Wiki du LAMA (UMR 5127) - Contributions [fr]

Algorithmes de multiplications d'entiers et de matrices

2026-05-12T04:21:33Z

Mangala : /* A) Fonctionnement */

= Introduction =

Depuis l'apparition des ordinateurs modernes, une quantité faramineuse de calculs a dû être effectuée. Les progressions technologiques nous poussent à envisager la puissance de calcul comme une ressource qu'il faut optimiser dans les moindres détails. C'est ainsi que l'optimisation des algorithmes de calcul est devenue cruciale, surtout lorsqu'il nous faut effectuer des opérations sur de très grands entiers par exemple.

= Objectif =

L'objectif majeur de ce projet est de comprendre de manière plus approfondie ce qu'est la '''complexité algorithmique'''.
Pour atteindre cet objectif, nous implémenterons plusieurs algorithmes de multiplication qui auront pour but de calculer le produit de grands entiers ou de matrices.

= Point important : complexité =

=== Définition ===
La complexité d'un algorithme est la quantité des ressources qu'il utilise en fonction de la taille des entrées qu'on lui demande de traiter. On peut par exemple se concentrer sur le temps qu'un algorithme prend pour renvoyer un résultat ou sur la mémoire dont il a besoin. Dans le cadre de notre projet, nous nous attarderons plus particulièrement sur la quantité de calcul effectuée en fonction de la taille des entrées, ce qui est par ailleurs étroitement liée à la notion de temps. De manière générale, plus un algorithme doit faire de calcul, plus il est lent. (Attention, toutes les opérations arithmétiques de base ne se valent pas)

De manière plus familière, on dira que la complexité d'un algorithme pourrait s'apparenter à son comportement lorsqu'il doit traiter des données plus ou moins grandes.
Chaque algorithme a une complexité, et on l'exprime par une fonction qui adopte un comportement similaire au nombre de calculs nécessaires en fonction de la taille des entrées.

=== Notation ===
La complexité réelle d'un algorithme peut être décrite par une fonction <math> f(n) </math> représentant le nombre d'opérations effectuées en fonction de la taille <math>n</math> des données d'entrée.

Cependant, afin de simplifier l'étude de cette croissance, on utilise généralement une borne asymptotique notée <math>\mathcal{O}(g(n))</math>, où <math>g(n)</math> est une fonction ayant le même ordre de grandeur que <math>f(n)</math> lorsque <math>n</math> devient grand.

On dit alors que :

<math>
f(n)\in\mathcal{O}(g(n))
</math>

si et seulement s'il existe une constante <math>C>0</math> et un entier <math>n_0</math> tels que :

<math>
\forall n\ge n_0,\ f(n)\le Cg(n)
</math>

Cette notation <math>\mathcal{O}(g(n))</math> permettra de comparer beaucoup plus facilement les algorithmes entre eux.

=== Master Theorem ===

Afin de déterminer la complexité de certains algorithmes récursifs, nous utiliserons le "Master Theorem".

Ce théorème permet d'obtenir directement l'ordre de grandeur de nombreuses relations de récurrence apparaissant dans l'analyse d'algorithmes de type « diviser pour régner », comme l'algorithme de Karatsuba ou celui de Strassen.

La démonstration complète de ce théorème dépasse le cadre de notre projet et nécessite des connaissances mathématiques plus avancées. Nous l'utiliserons donc principalement comme un outil nous permettant de déterminer efficacement la complexité asymptotique des algorithmes étudiés.

=== Graphiques ===

Les complexités étant des fonctions, nous pouvons les représenter par un graphique qui affichera le temps d'exécution (ou nombre d'opérations) en fonction de la taille des entrées.

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:30px; text-align:center;">
[[Fichier:complexite.webp|500px]]
<div><b>Graphiques des complexités</b></div>
</div>
<div style="max-width:800px;">
<p>Ce graphique ci-contre compare les complexités en fonction de la taille des d'entrées.</p>
<p>On comprend ainsi que certaines complexités ne sont pas raisonnable dans la cadre de la multiplication de grands entiers.</p>
<p>C'est pourquoi l'étude de ces algorithmes s'avère nécessaire.</p>
</div>
</div>

=== Exemple ===
L'algorithme naïf d'addition que nous avons tous appris à l'école a une complexité de <math>\mathcal{O}(n)</math>.
Soit n la taille des nombres en entrée, l'algorithme doit faire environ n addition pour arriver au résultat demandé.

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Addition.gif|220px]]
<div><b>Addition naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Comme le montre l'exemple ci-contre, 786 et 467 font 3 chiffres de long donc n sera de 3.</p>
<p>Il nous faudra 3 opérations pour additionner ces entiers.</p>
<p>C'est ainsi qu'avec une taille d'entrée n, l'algorithme de l'addition naïve va devoir faire n opérations.</p>
<p>Cet algorithme a donc une complexité <math>f(n) = n</math> qui n'a pas besoin d'être approximée.</p>
<p>Ainsi sa complexité finale sera <math>\mathcal{O}(n)</math>.</p>
</div>
</div>

= Problématique =

Le calcul du produit de deux entiers de manière naïve a une complexité de <math> \mathcal{O}(n^2)</math>, et celui de deux matrices une complexité de <math> \mathcal{O}(n^3)</math>. Afin de mieux comprendre ce qu'est la complexité algorithmique, nous devrons implémenter des algorithmes ayant le même objectif, mais étant plus efficaces. Ces algorithmes s'avèreront plus complexes mais devrait aboutir à un calcul plus rapide du produit demandé.

Nous séparerons notre wiki en deux grandes parties, la première concernera nos recherche sur [[#I - Produit d'entiers|la multiplication d'entiers]], la deuxième sur [[#II - Produit de matrices|la multiplication de matrices]].

= I - Produit d'entiers =

Notre départ commence avec l'algorithme de multiplication d'entier naïf.
En effet il s'agit de l'algorithme de multiplication le plus connu, et nous l'utiliserons comme référence pour le comparer aux futurs algorithmes plus efficaces.
Intéressons nous à sa complexité.

== 1) Nos implémentations des grands entiers ==

Qui dit produit de grands entiers dit implémentation de grands entiers.

Dans le cadre de nos recherches, nous allons devoir implémenter des algorithmes qui vont manipuler des grands entiers.

Nous avons donc choisi de créer deux représentations différentes de ceux-ci (car nous travaillons sur différents langages de programmation), nous permettant à la fois une implémentation simplifié, mais aussi de nous rapprocher d'une implémentation bas niveau.

=== A) En python ===
En python, l'utilisation des "bytes" m'a grandement servi à comprendre comment les entiers étaient manipulés à bas niveau. En effet, un des objectifs secondaires de nos recherches était de manipuler des entiers directement avec leur formes stockées sur l'ordinateur, et non pas avec des int python.
En effet l'utilisation des int python nous aurait permit de passer les étapes de retenues, de signes... D'autant plus que les bytes permettent de stocker un nombre en base 256, ce qui permet de visualiser plus facilement les grands entiers.

La forme finale de la représentation des grands entiers en python sera donc la suivante :

[ signe , bytes , bytes , (...) , bytes ]

Le signe est représenté par un entier, 1 si le nombre est positif, 0 sinon.
Cette configuration rendra plus simple la gestion des signes.

=== B) En C++ ===

En C++, pour avoir une représentation de grand entiers j'ai du définir ma propre structure pour m'affranchir de la limite de taille imposé par les entiers standards: (int32 ou int64). Pour cela, j'ai une structure qui possède l'équivalent d'un array de byte (ce qui nous permet d'être en base 256 au lieu de la base 10 habituelle), et pour traiter le signe j'utilise un booléen, ainsi en mémoire j'ai une structure de n*Octets + 1 octet en taille.

[ bytes , bytes , (...) , bytes ] [ signe ]

Le booléen prend 1 octet de place mais ne touche pas aux octets qui encode le grand entier.
Cette configuration rendra plus simple la gestion des signes dans le cadre des multiplication.

== 2) La multiplication naïve ==

=== A) Fonctionnement ===
Dans le cas de la multiplication d'entiers, nous allons prendre deux nombres qui n'ont pas nécessairement la même longueur. Soit les nombre a et b, de longueur respective <math> n </math> et <math> m </math>.
<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Multiplication.png|220px]]
<div><b>Multiplication naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Prenons deux nombres de longueur 3 et 2, et cherchons combien d'opérations l'algorithme de multiplication naïve va devoir faire pour nous renvoyer leur produit.</p>
<p>Dans un premier temps, on remarque que l'on va devoir multiplier chaque chiffre du nombre du haut par le chiffre des unités du bas, qui est 6. Cela va représenter <math>n</math> opérations. (6x5, 6x1 et 6x4)</p>
<p>Dans un deuxième temps nous constatons que nous allons devoir faire la même chose avec le chiffre des dizaines du nombre du bas. Cela nous ajoute de nouveau <math>n</math> opérations.</p>
<p>On arrive assez facilement à la conclusion que pour faire notre produit, il va nous falloir faire <math>n</math> fois <math>m</math> opérations.</p>
</div>
</div>

Ainsi, la complexité de la multiplication naïve est <math>\mathcal{O}(n^2)</math>.
Il est en de même avec la multiplication naïve récursive.

=== B) Graphique ===
Montrons maintenant sa courbe sur un graphique :

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Multiplicationnaive.png|500px]]
<div><b>Multiplication naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Les points noirs sont des repères pour que les autres courbes aient une forme cohérente.</p>
<p>Ils sont tous sur l'axe des abscisses.</p>
<p>La courbe rouge représente la complexité de la multiplication naïve.</p>
<p>On remarque que la courbe a un visuel très similaire à la fonction <math> f(x) = x^2 </math> </p>
</div>
</div>

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Naif_recursif.png|500px]]
<div><b>Multiplication naïve récursive</b></div>
</div>
<div style="max-width:800px;">
<p>Cette courbe rouge représente la complexité de la multiplication naïve récursive.</p>
<p>Elle sera utilisé pour comparer les complexités entre algorithmes car, comme tous récursifs, elle a été codé avec les mêmes biais d'implémentation qu'eux.</p>
<p>Théoriquement les deux courbes ci-contre ont la même complexité, mais encore une fois, notre implémentation n'est pas parfaitement optimale et donc ne respecte pas de manière minutieuse le Master Theorem.</p>
</div>
</div>

== 3) La multiplication karatsuba ==

=== A) Fonctionnement ===

L'algorithme de karatsuba est un algorithme récursif de type diviser pour régner.

L'idée générale de l'algorithme est de passer de 4 multiplication à 3. En effet ces opérations étant moins couteuses, il est préférable d'en ajouter si cela permet d'enlever des multiplications.

L'algorithme de multiplication naif récursif utilise la segmentation des facteurs en deux de manière successive.

Soit <math> x </math> et <math>y</math> deux facteurs, nous avons les égalités suivantes :

<div style="font-size: 15px;">
<math>x = a \times B^{n/2} + b</math>
<math>y = c \times B^{n/2} + d</math>
</div>

Avec <math>a</math> et <math>c</math> les premières moitiés des facteurs <math>x</math> et <math>y</math>,
et <math> b </math> et <math>d</math> les dernières moitiés de ces facteurs ainsi que <math>B</math> la base d'écriture du nombre (Nous sommes en base 256 avec les bytes).

Cette présentation des deux facteurs de notre multiplication n'est que la résultante d'un découpage.
Le [[#Master Theorem|Master Theorem]] nous montre que :

<div style="font-size: 15px;">
<math>T(n) = 4T(n/2) + O(n)</math>
</div>

Puisque nous avons après découpage 4 entiers de longueur <math>n/2</math>.

Ainsi, ce découpage ne permet pas de gagner du temps d'après le [[#Master Theorem|Master Theorem]].

Cependant, l'algorithme de Karatsuba réutilise ce principe en le modifiant, ce qui nous permet de baisser la complexité globale de la multiplication dans son entièreté.

Avec l'écriture ci-dessus des nombres <math>x</math> et <math>y</math>, on peut facilement en déduire l'égalité suivante :

<div style="font-size: 15px;">
<math>x \times y = (ac) \times B^n + (ad + bc) \times B^{n/2} + bd</math>
</div>

On remarque 4 multiplications longues à faire dans cette expression. Les multiplications dont <math>B</math> est l'un des facteurs sont très rapides puisqu'il s'agit de la base dans laquelle nous travaillons. De cela en résulte un décalage plutôt qu'un vrai calcul à faire.

Karatsuba développe une partie de cette expression pour pouvoir négocier une multiplication au prix d'additions et soustractions.

En effet, nous savons déjà que :

<div style="font-size: 15px;">
<math>(a + b)(c + d) = ac + ad + bc + bd</math>
</div>

En manipulant l'égalité nous obtenons :

<div style="font-size: 15px;">
<math>ad + bc = (a + b)(c + d) - ac - bd</math>
</div>

ac et bd ayant déjà été calculé précédemment, il nous reste uniquement la multiplication <math>(a + b)(c + d)</math>.

Nous venons ainsi de calculer <math>ad + bc</math> en seulement une multiplication. C'est la que repose le gain de temps de la méthode Karatsuba par rapport à la multiplication naïve.

En effet, l'algorithme n'effectuera alors plus que 3 multiplications :
<div style="font-size: 15px;">
<math>ac</math>
<math>bd</math>
<math>(a + b)(c + d)</math>
</div>

La relation de récurrence devient donc :
<div style="font-size: 15px;">
<math>T(n)=3T(n/2)+O(n)</math>
</div>

Et le Master Theorem nous dit que :
<div style="font-size: 15px;">
<math>T(n)\in O(n^{\log_2(3)})</math>
</div>

Or <math>\log_2(3)\approx 1.585</math>, donc la complexité de l'algorithme de Karatsuba est de <math> \mathcal{O}(n^{1.585})</math>. Ce qui est bien plus efficace que la multiplication classique, surtout lorsque les facteurs deviennent très grands.

=== B) Graphique ===
<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Karatsuba.png|500px]]
<div><b>Karatsuba</b></div>
</div>
<div style="max-width:800px;">
<p>Sur le graphique ci-contre nous avons utilisé la courbe de la multiplication naïve récursive (rouge) à titre de comparaison.</p>
<p>On remarque graphiquement que Karatsuba (jaune) prend moins de temps à chaque calcul de produit.</p>
<p>On en déduit donc expérimentalement que Karatsuba à une meilleure complexité que la multiplication naïve.</p>
<p>Ainsi nous vérifions donc ce que le Master Theorem prouve, c'est à dire que la complexité de karatsuba est de <math> \mathcal{O}(n^{1.585})</math> </p>
</div>
</div>

== 4) La multiplication toom-cook-3 ==

=== A) Fonctionnement ===

L'objectif est de diviser les grands entiers X et Y en trois blocs de taille égale k.
On les traite alors comme des polynômes de degré 2:

<math> P(z) = X_2 \cdot z^2 + X_1 \cdot z + X_0 </math>
<math> Q(z) = Y_2 \cdot z^2 + Y_1 \cdot z + Y_0 </math>

On choisit 5 points distincts pour évaluer nos polynômes.
Ce choix de 5 points est crucial car le produit de deux polynômes de degré 2 est un polynôme de degré 4, qui nécessite 5 points pour être défini.
Les points standards sont :

P(0) = X0
P(1) = X0 + X1 + X2
P(-1) = X0 - X1 + X2
P(2) = X0 + 2*X1 + 4*X2
P(inf) = X2

(On procède de manière similaire pour Q.)

Ensuite nous multiplions récursivement chaque points de P et de Q ensemble.
On effectue ainsi 5 multiplications de nombres plus petits au lieu des 9 multiplications requises par la méthode classique.

Après, nous effectuons une interpolation, cela permet de retrouver les 5 coefficients (w_0, w_1, w_2, w_3, w_4) du polynôme produit R(z) à partir des valeurs évaluées calculées précédemment.
On résout un système d'équations linéaires : <math> R(z) = w_4 z^4 + w_3 z^3 + w_2 z^2 + w_1 z + w_0 </math>
Finalement nous pouvons recomposer notre grand entier en positionnant les coefficients w_i aux bons rangs (en les décalant) et à gérer les retenues lors de l'addition finale:
Résultat <math>= w_4 B^{4k} + w_3 B^{3k} + w_2 B^{2k} + w_1 B^k + w_0</math>

=== B) Graphique ===

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Toomcook.png|500px]]
<div><b>Karatsuba</b></div>
</div>
<div style="max-width:800px;">
<p>Nous avons réutilisé le graphique précédant, cela nous permettra de comparer Toom-Cook avec les autres algorithmes.</p>
<p>On remarque que Toom-Cook 3 est plus performant que karatsuba et ainsi que la multiplication classique.</p>
<p>Toom-cook est par conséquent un algorithme qui repousse encore une fois la complexité minimum du produit d’entiers.</p>
</div>
</div>

== 5) La transformée de Fourier rapide ==

=== A) Fonctionnement ===

La transformation de Fourier rapide étant plus complexe que les autres algorithmes, nous allons essayer d'expliquer son fonctionnement malgré ne pas avoir réussi à l'implémenter.

Il faut comprendre que cet algorithme va considérer les facteurs comme des polynômes.

D'après le théorème de l'unisolvance, il n'existe qu'un seul polynôme de degré inférieur ou égal à <math> n </math> défini par <math>n + 1</math> points distincts. Cela implique non seulement que nous pouvons représenter chaque entier par un polynôme, mais également que si nous pouvons retrouver <math>n + m + 1</math> points (avec <math>n</math> et <math>m</math> la longueur des facteurs) du polynômes issue du produit entre deux facteurs, nous pourrons le retrouver.

Soit un entier quelconque, de forme :

<math>a_n a_{n-1} (...) a_1 a_0</math>

Avec <math>a_i</math>, un chiffre composant le nombre en base 10, qui vaut en réalité dans le nombre : <math>a_i \times 10^i</math>. On peut ainsi l'écrire sous la forme :

<math> P(x) = a_0 + a_1x + a_2x^2 + \dots + a_{n-1}x^{n-1} + a_nx^n </math>

Avec <math>x = 10</math> car nous sommes en base 10, nous obtenons :

<math>P(10) = a_0 + a_1 \times 10 + \dots + a_{n-1}10^{n-1} + a_n10^n </math>

Nous venons ainsi d'écrire notre nombre sous la forme d'un polynôme unique. Pour nous permettre d'évaluer en un nombre suffisant de points, nous allons devoir ajouter des 0 pour la récursion. Il nous faudra ajouter assez de 0 pour atteindre la prochaine puissance de 2 qui sera supérieure ou égale à <math>2n + 1</math>. L'ajout de 0 ne change pas le nombre car <math>0 \times x^n</math> n'ajoute pas de coefficient.

Cet algorithme est récursif et va segmenter en deux parties nos polynômes à chaque récursion. D'un coté les indice pairs et d'un coté les impaires.

Ainsi prenons les nombres 1234 et 5678, ces nombres sont respectivement représentés par les polynômes <math> P(x) = 4 + 3x + 2x^2 + x^3 </math> et <math> P(x) = 8 + 7x + 6x^2 + 5^3 </math>. Ce sont des polynômes de degré 3, ainsi leur produit donnera lieu à un polynôme de degré 6. Il nous faudra donc au minimum 7 points d'évaluation pour retrouve ce produit. De ce fait, en les représentant de la manière suivante :

<math>[4, 3, 2, 1, 0, 0, 0, 0]</math>
<math>[8, 7, 6, 5, 0, 0, 0, 0]</math>

Nous aurons assez de récursions possible pour les évaluer en un nombre suffisant de points différents car nous auront 3 récursions à faire pour atteindre notre cas de base. A chaque récursion, nous allons diviser nos polynômes en deux parties ce qui nous fait 8 feuilles à la dernière récursion.

En effet à chaque étape de la récursion nous allons séparer nos polynômes en deux tel que :

<math>P(x)=P_{\text{pair}}(x^2) + x \cdot P_{\text{impair}}(x^2)</math>

Durant les récursions, nous segmentons les polynômes mais ne les évaluons pas. C'est à la remonté des récursions que nous allons réellement évaluer nos polynômes. Lorsque l'on atteint notre cas de base, c'est à dire des polynômes de degré 0, nous remarquons qu'ils sont constants, nous n'avons donc pas besoin de les évaluer. En effet, peut importe le point en lequel nous voudrons l'évaluer, le polynôme renverra la constante. Nous la renvoyons donc seule.
Ensuite commence la remontée des récursions. A l'étape 1 de notre remontée nous allons reformer le polynôme précédemment séparé pour obtenir un polynôme de degré 1. Puis, nous évaluons ce polynôme avec les racines seconde de l'unité. Nous faisons à nouveau remonté les évaluations et recombinons à nouveau le polynôme qui sera ainsi de degré 2.
Nous l'évaluons maintenant avec les racines 4eme de l'unité. A chaque évaluation, nous réutilisons les résultats précédents, cela nous est permit par les racines de l'unité qui ont une structure récursive exploitable.

Finalement, nous arrivons à la fin de notre FFT, avec une représentation fréquentielle de la forme :

<math> [P(W_0), P(W_1), (...), P(W_n-1), P(W_n)] </math>

Cette représentation fréquentielle n'est autre que les évaluations du polynôme P aux racines nièmes de l'unité. Nous avons donc maintenant au minimum <math>2n+1</math> évaluations des polynômes facteurs. Il nous faut maintenant trouver les évaluations du produit final, c'est à dire les évaluations concernant le polynôme qui sera issue de la multiplication. On pourra ainsi le retrouver.

Soit <math>C</math> un polynome tel que <math> C = A \times B </math>, alors on a :

<math> C(x) = A(x) \times B(x) </math>

Ainsi on en déduit que <math> C(W_n^k) = A(W_n^k) \times B(W_n^k) </math>

On comprend donc que <math>FFT(C) = FFT(A) \times FFT(B)</math>

Il faut préciser que l'on fait le produit de FFT(A) et FFT(B) terme à terme, soit évaluation par évaluation.

Une fois en possession de <math>FFT(C)</math>, qui n'est autre que l'évaluation de notre polynôme final en un nombre suffisant de points pour le retrouver, nous pouvons faire l'<math> IFFT(FFT(C)) </math>, qui va nous permettre de retrouver les coefficients de notre polynôme en faisant l'exacte inverse de la FFT.

Une fois les coefficients retrouvés, il nous suffit de gérer les retenues, et nous retrouvons un entier de la forme : <math>a_0 a_1 (...) a_{n-1} a_n</math>

=== B) Graphique ===

Intéressons nous maintenant à la complexité de l'algorithme utilisant la transformée de Fourier rapide. On sait que l'algorithme passe par 5 étapes importantes :

<ul>
<li>Etape 1 : Ecrire les deux facteurs sous la forme de polynômes</li>
<li>Etape 2 : Effectuer la <math>FFT</math> des deux polynômes</li>
<li>Etape 3 : Faire le produit terme à terme des <math>FFT</math> obtenues</li>
<li>Etape 4 : Faire l'<math>IFFT</math> du produit</li>
<li>Etape 5 : Gérer les retenues et écrire le nombre qui en découle</li>
</ul>

Or, parmi toutes ces étapes, certaines sont négligeable comme l'étape 1 et 5.

Pour connaitre la complexité de l'algorithme, additionnons les complexités des étapes restantes :

Une <math>FFT</math> a une complexité de <math>\mathcal{O}(n\times logn)</math> car elle fait <math>n</math> évaluation sur <math> log(n)</math> récursions. Dans le cadre de notre algorithme, nous devons faire la <math>FFT</math> de nos deux facteurs. Soit <math>2\times \mathcal{O}(n\times logn)</math>.

Pour le produit terme à terme, nous faisons naturellement <math>n</math> opérations.

Pour finir, l'<math>IFFT</math> a la même complexité que la <math>FFT</math>. Dans le cadre de notre algorithme nous l'emploierons qu'une seule fois, ce qui fait une complexité de <math>\mathcal{O}(n\times logn)</math>.

Après addition de toutes ces complexités, nous obtenons la complexité réelle de <math>3\mathcal{O}(n\times logn) + \mathcal{O}(n)</math>.

D'après le Master Theorem, nous avons donc <math> f(n) = 3(n\times logn)+n </math>, cherchons <math>f(n)\in\mathcal{O}(g(n))</math> :

Nous pouvons ignorer les expressions linéaires ainsi que les constantes multiplicatrices, nous obtenons donc <math>\mathcal{O}(g(n)) = \mathcal{O}(n \times log n)</math>.

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:30px; text-align:center;">
[[Fichier:FFT complexite.png|500px]]
<div><b>Graphiques des complexités</b></div>
</div>
<div style="max-width:800px;">
<p>Ce graphique ci-contre ne provient pas du fruit de nos recherches personnelles mais illustre bien la comparaison entre la complexité de la FFT et des autres algorithmes.</p>
<p>On remarque que la FFT est très efficace et devance de loin les autres algorithmes en terme de complexité. </p>
<p>Les algorithmes les plus efficaces pour calculer le produit de grands entiers reposent aujourd'hui sur des variantes de la transformée de Fourier rapide.</p>
</div>
</div>

= II - Produit de matrices =

== 1.1) naïve ==

La multiplication naïve de matrice requiert d'avoir des tailles de lignes/colonne semblable, ensuite pour chaque membre de la matrice résultat, on doit multiplier les composantes ligne de la première matrice par les composantes colonne de la deuxième et le tout sommé.

On en déduit la formule suivante:
<math>C_{i,j} = \sum_{k=1}^{n} (A_{i,k} \times B_{k,j})</math>

Et visuellement:

[[Fichier:Matricenaive.jpeg]]

On a donc un algorithme d'ordre de complexité <math>\mathcal{O}(g(n))</math>

== 1.2) naïve récursive ==

Dans un premier temps on doit découper nos deux matrices en quatres sous matrices de plus petite taille.
<math>A = \begin{pmatrix} A_{11} & A_{12} \ A_{21} & A_{22} \end{pmatrix}</math>
<math>B = \begin{pmatrix} B_{11} & B_{12} \ B_{21} & B_{22} \end{pmatrix}</math>

Ensuite on vient calculer la matrice résultat.
<math>C_{11} = (A_{11} \times B_{11}) + (A_{12} \times B_{21})</math>
<math>C_{12} = (A_{11} \times B_{12}) + (A_{12} \times B_{22})</math>
<math>C_{21} = (A_{21} \times B_{11}) + (A_{22} \times B_{21})</math>
<math>C_{22} = (A_{21} \times B_{12}) + (A_{22} \times B_{22})</math>

Le côté récursif est utile que pour les matrices de tailles <= 32 (32 valeurs stockées dedans),
si on est au dessus de cette taille alors on divisera à nouveau nos matrices en quatres.
On aura 8 multiplications mais de plus petite taille au final.

== 2) strassen ==

=== A) Fonctionnement ===

Strassen consiste à définir 7 produits intermédiaires qui, par des jeux de sommes et de différences, permettent de reconstruire les quadrants de la matrice résultante. On passe ainsi d'une complexité de O(n^3) à environ O(n^2.81)

=== B) Graphique ===

On voit bien la différence de complexité sur la multiplication de grande matrice entre l'approche naïve et l'approche récursive qui est beaucoup plus rapide.

[[Fichier:Analyse matrices.png]]

= Conclusion =

L'étude de ces algorithmes de multiplication nous a clairement montré l'évolution de la complexité algorithmique permettant de gagner en efficacité lorsque la taille des données augmente.

La multiplication classiqe, en <math>\mathcal{O}(n^2)</math>, résulte d'une approche naïve qui devient rapidement inefficace pour les grands entiers ou les grandes matrices. L'algorithme de Karatsuba nous montre qu'organiser de manière intelligente ses calculs algébrique permet parfois de gagner beaucoup de multiplications, et donc de temps. Nous avons ainsi réussi à passer d'une complexité de <math>\mathcal{O}(n^2)</math> à <math> \mathcal{O}(n^{log_2(3)}) </math>, soit environ <math>\mathcal{O}(n^{1/585})</math>.

Des méthodes encore plus avancées comme utilise l'algorithme de Toom-Cook-3 continue dans cette idées de divisions d'entiers en blocs plus petits, tandis que la transformée de Fourier rapide change complètement de point de vue. En effet la FFT n'utilise pas la représentation classique des entiers mais fait appel à une vision polynomiale, ce qui transforme la convolution classique en multiplication terme à terme, ce qui lui permet d'atteindre une complexité de <math>\mathcal{O}(n \times log n)</math>.

Dans le cas des matrices, les mêmes logiques apparaissent comme par exemple avec l'algorithme de Strassen qui se rapproche très fortement de Karatsuba en combinant de manière astucieuse les parties d'entiers qui avaient été précédemment découpée.

On remarque néanmoins que la majorité des algorithmes efficaces s'orientent vers une approche récursive et non itérative. Néanmoins, nous avons pu trouver certaines de ces implémentations (comme par exemple la FFT) en itérative.

Avec ces recherches, nous comprenons que la réorganisations des calculs algébriques peuvent aider à gagner en complexité mais que pour faire de réels progrès, il nous faudra surement changer notre point de vue une nouvelle fois, et aborder le problème sous un angle nouveau comme le font dors et déjà les algorithmes les plus performants.

= Mentions =

Le premier gif est le résultat du travail de 'Walké', licence ci-contre : https://fr.wikipedia.org/wiki/Fichier:Addition.gif

Utilisation du site de production graphique "Desmos" : https://www.desmos.com/calculator?lang=fr

= Sources =

Pour karatsuba :
<ul>
<li> https://www.youtube.com/watch?v=PZ2gdWdKHAA </li>
</ul>

Pour mieux comprendre la FFT, nous avons utilisé plusieurs sources d'informations :
<ul>
<li> https://www.youtube.com/watch?v=h7apO7q16V0&list=WL&index=1&t=886s </li>
<li> https://fr.wikipedia.org/wiki/Interpolation_polynomiale </li>
</ul>

Algorithmes de multiplications d'entiers et de matrices

2026-05-11T22:05:56Z

Mangala : /* A) Fonctionnement */

= Introduction =

Depuis l'apparition des ordinateurs modernes, une quantité faramineuse de calculs a dû être effectuée. Les progressions technologiques nous poussent à envisager la puissance de calcul comme une ressource qu'il faut optimiser dans les moindres détails. C'est ainsi que l'optimisation des algorithmes de calcul est devenue cruciale, surtout lorsqu'il nous faut effectuer des opérations sur de très grands entiers par exemple.

= Objectif =

L'objectif majeur de ce projet est de comprendre de manière plus approfondie ce qu'est la '''complexité algorithmique'''.
Pour atteindre cet objectif, nous implémenterons plusieurs algorithmes de multiplication qui auront pour but de calculer le produit de grands entiers ou de matrices.

= Point important : complexité =

=== Définition ===
La complexité d'un algorithme est la quantité des ressources qu'il utilise en fonction de la taille des entrées qu'on lui demande de traiter. On peut par exemple se concentrer sur le temps qu'un algorithme prend pour renvoyer un résultat ou sur la mémoire dont il a besoin. Dans le cadre de notre projet, nous nous attarderons plus particulièrement sur la quantité de calcul effectuée en fonction de la taille des entrées, ce qui est par ailleurs étroitement liée à la notion de temps. De manière générale, plus un algorithme doit faire de calcul, plus il est lent. (Attention, toutes les opérations arithmétiques de base ne se valent pas)

De manière plus familière, on dira que la complexité d'un algorithme pourrait s'apparenter à son comportement lorsqu'il doit traiter des données plus ou moins grandes.
Chaque algorithme a une complexité, et on l'exprime par une fonction qui adopte un comportement similaire au nombre de calculs nécessaires en fonction de la taille des entrées.

=== Notation ===
La complexité réelle d'un algorithme peut être décrite par une fonction <math> f(n) </math> représentant le nombre d'opérations effectuées en fonction de la taille <math>n</math> des données d'entrée.

Cependant, afin de simplifier l'étude de cette croissance, on utilise généralement une borne asymptotique notée <math>\mathcal{O}(g(n))</math>, où <math>g(n)</math> est une fonction ayant le même ordre de grandeur que <math>f(n)</math> lorsque <math>n</math> devient grand.

On dit alors que :

<math>
f(n)\in\mathcal{O}(g(n))
</math>

si et seulement s'il existe une constante <math>C>0</math> et un entier <math>n_0</math> tels que :

<math>
\forall n\ge n_0,\ f(n)\le Cg(n)
</math>

Cette notation <math>\mathcal{O}(g(n))</math> permettra de comparer beaucoup plus facilement les algorithmes entre eux.

=== Master Theorem ===

Afin de déterminer la complexité de certains algorithmes récursifs, nous utiliserons le "Master Theorem".

Ce théorème permet d'obtenir directement l'ordre de grandeur de nombreuses relations de récurrence apparaissant dans l'analyse d'algorithmes de type « diviser pour régner », comme l'algorithme de Karatsuba ou celui de Strassen.

La démonstration complète de ce théorème dépasse le cadre de notre projet et nécessite des connaissances mathématiques plus avancées. Nous l'utiliserons donc principalement comme un outil nous permettant de déterminer efficacement la complexité asymptotique des algorithmes étudiés.

=== Graphiques ===

Les complexités étant des fonctions, nous pouvons les représenter par un graphique qui affichera le temps d'exécution (ou nombre d'opérations) en fonction de la taille des entrées.

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:30px; text-align:center;">
[[Fichier:complexite.webp|500px]]
<div><b>Graphiques des complexités</b></div>
</div>
<div style="max-width:800px;">
<p>Ce graphique ci-contre compare les complexités en fonction de la taille des d'entrées.</p>
<p>On comprend ainsi que certaines complexités ne sont pas raisonnable dans la cadre de la multiplication de grands entiers.</p>
<p>C'est pourquoi l'étude de ces algorithmes s'avère nécessaire.</p>
</div>
</div>

=== Exemple ===
L'algorithme naïf d'addition que nous avons tous appris à l'école a une complexité de <math>\mathcal{O}(n)</math>.
Soit n la taille des nombres en entrée, l'algorithme doit faire environ n addition pour arriver au résultat demandé.

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Addition.gif|220px]]
<div><b>Addition naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Comme le montre l'exemple ci-contre, 786 et 467 font 3 chiffres de long donc n sera de 3.</p>
<p>Il nous faudra 3 opérations pour additionner ces entiers.</p>
<p>C'est ainsi qu'avec une taille d'entrée n, l'algorithme de l'addition naïve va devoir faire n opérations.</p>
<p>Cet algorithme a donc une complexité <math>f(n) = n</math> qui n'a pas besoin d'être approximée.</p>
<p>Ainsi sa complexité finale sera <math>\mathcal{O}(n)</math>.</p>
</div>
</div>

= Problématique =

Le calcul du produit de deux entiers de manière naïve a une complexité de <math> \mathcal{O}(n^2)</math>, et celui de deux matrices une complexité de <math> \mathcal{O}(n^3)</math>. Afin de mieux comprendre ce qu'est la complexité algorithmique, nous devrons implémenter des algorithmes ayant le même objectif, mais étant plus efficaces. Ces algorithmes s'avèreront plus complexes mais devrait aboutir à un calcul plus rapide du produit demandé.

Nous séparerons notre wiki en deux grandes parties, la première concernera nos recherche sur [[#I - Produit d'entiers|la multiplication d'entiers]], la deuxième sur [[#II - Produit de matrices|la multiplication de matrices]].

= I - Produit d'entiers =

Notre départ commence avec l'algorithme de multiplication d'entier naïf.
En effet il s'agit de l'algorithme de multiplication le plus connu, et nous l'utiliserons comme référence pour le comparer aux futurs algorithmes plus efficaces.
Intéressons nous à sa complexité.

== 1) Nos implémentations des grands entiers ==

Qui dit produit de grands entiers dit implémentation de grands entiers.

Dans le cadre de nos recherches, nous allons devoir implémenter des algorithmes qui vont manipuler des grands entiers.

Nous avons donc choisi de créer deux représentations différentes de ceux-ci (car nous travaillons sur différents langages de programmation), nous permettant à la fois une implémentation simplifié, mais aussi de nous rapprocher d'une implémentation bas niveau.

=== A) En python ===
En python, l'utilisation des "bytes" m'a grandement servi à comprendre comment les entiers étaient manipulés à bas niveau. En effet, un des objectifs secondaires de nos recherches était de manipuler des entiers directement avec leur formes stockées sur l'ordinateur, et non pas avec des int python.
En effet l'utilisation des int python nous aurait permit de passer les étapes de retenues, de signes... D'autant plus que les bytes permettent de stocker un nombre en base 256, ce qui permet de visualiser plus facilement les grands entiers.

La forme finale de la représentation des grands entiers en python sera donc la suivante :

[ signe , bytes , bytes , (...) , bytes ]

Le signe est représenté par un entier, 1 si le nombre est positif, 0 sinon.
Cette configuration rendra plus simple la gestion des signes.

=== B) En C++ ===

En C++, pour avoir une représentation de grand entiers j'ai du définir ma propre structure pour m'affranchir de la limite de taille imposé par les entiers standards: (int32 ou int64). Pour cela, j'ai une structure qui possède l'équivalent d'un array de byte (ce qui nous permet d'être en base 256 au lieu de la base 10 habituelle), et pour traiter le signe j'utilise un booléen, ainsi en mémoire j'ai une structure de n*Octets + 1 octet en taille.

[ bytes , bytes , (...) , bytes ] [ signe ]

Le booléen prend 1 octet de place mais ne touche pas aux octets qui encode le grand entier.
Cette configuration rendra plus simple la gestion des signes dans le cadre des multiplication.

== 2) La multiplication naïve ==

=== A) Fonctionnement ===
Dans le cas de la multiplication d'entiers, nous allons prendre deux nombres qui n'ont pas nécessairement la même longueur. Soit les nombre a et b, de longueur respective <math> n </math> et <math> m </math>.
<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Multiplication.png|220px]]
<div><b>Multiplication naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Prenons deux nombres de longueur 3 et 2, et cherchons combien d'opérations l'algorithme de multiplication naïve va devoir faire pour nous renvoyer leur produit.</p>
<p>Dans un premier temps, on remarque que l'on va devoir multiplier chaque chiffre du nombre du haut par le chiffre des unités du bas, qui est 6. Cela va représenter <math>n</math> opérations. (6x5, 6x1 et 6x4)</p>
<p>Dans un deuxième temps nous constatons que nous allons devoir faire la même chose avec le chiffre des dizaines du nombre du bas. Cela nous ajoute de nouveau <math>n</math> opérations.</p>
<p>On arrive assez facilement à la conclusion que pour faire notre produit, il va nous falloir faire <math>n</math> fois <math>m</math> opérations.</p>
</div>
</div>

Ainsi, la complexité de la multiplication naïve est <math>\mathcal{O}(n^2)</math>.
Il est en de même avec la multiplication naïve récursive.

=== B) Graphique ===
Montrons maintenant sa courbe sur un graphique :

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Multiplicationnaive.png|500px]]
<div><b>Multiplication naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Les points noirs sont des repères pour que les autres courbes aient une forme cohérente.</p>
<p>Ils sont tous sur l'axe des abscisses.</p>
<p>La courbe rouge représente la complexité de la multiplication naïve.</p>
<p>On remarque que la courbe a un visuel très similaire à la fonction <math> f(x) = x^2 </math> </p>
</div>
</div>

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Naif_recursif.png|500px]]
<div><b>Multiplication naïve récursive</b></div>
</div>
<div style="max-width:800px;">
<p>Cette courbe rouge représente la complexité de la multiplication naïve récursive.</p>
<p>Elle sera utilisé pour comparer les complexités entre algorithmes car, comme tous récursifs, elle a été codé avec les mêmes biais d'implémentation qu'eux.</p>
<p>Théoriquement les deux courbes ci-contre ont la même complexité, mais encore une fois, notre implémentation n'est pas parfaitement optimale et donc ne respecte pas de manière minutieuse le Master Theorem.</p>
</div>
</div>

== 3) La multiplication karatsuba ==

=== A) Fonctionnement ===

L'algorithme de karatsuba est un algorithme récursif de type diviser pour régner.

L'idée générale de l'algorithme est de passer de 4 multiplication à 3. En effet ces opérations étant moins couteuses, il est préférable d'en ajouter si cela permet d'enlever des multiplications.

L'algorithme de multiplication naif récursif utilise la segmentation des facteurs en deux de manière successive.

Soit <math> x </math> et <math>y</math> deux facteurs, nous avons les égalités suivantes :

<div style="font-size: 15px;">
<math>x = a \times B^{n/2} + b</math>
<math>y = c \times B^{n/2} + d</math>
</div>

Avec <math>a</math> et <math>c</math> les premières moitiés des facteurs <math>x</math> et <math>y</math>,
et <math> b </math> et <math>d</math> les dernières moitiés de ces facteurs ainsi que <math>B</math> la base d'écriture du nombre (Nous sommes en base 256 avec les bytes).

Cette présentation des deux facteurs de notre multiplication n'est que la résultante d'un découpage.
Le [[#Master Theorem|Master Theorem]] nous montre que :

<div style="font-size: 15px;">
<math>T(n) = 4T(n/2) + O(n)</math>
</div>

Puisque nous avons après découpage 4 entiers de longueur <math>n/2</math>.

Ainsi, ce découpage ne permet pas de gagner du temps d'après le [[#Master Theorem|Master Theorem]].

Cependant, l'algorithme de Karatsuba réutilise ce principe en le modifiant, ce qui nous permet de baisser la complexité globale de la multiplication dans son entièreté.

Avec l'écriture ci-dessus des nombres <math>x</math> et <math>y</math>, on peut facilement en déduire l'égalité suivante :

<div style="font-size: 15px;">
<math>x \times y = (ac) \times B^n + (ad + bc) \times B^{n/2} + bd</math>
</div>

On remarque 4 multiplications longues à faire dans cette expression. Les multiplications dont <math>B</math> est l'un des facteurs sont très rapides puisqu'il s'agit de la base dans laquelle nous travaillons. De cela en résulte un décalage plutôt qu'un vrai calcul à faire.

Karatsuba développe une partie de cette expression pour pouvoir négocier une multiplication au prix d'additions et soustractions.

En effet, nous savons déjà que :

<div style="font-size: 15px;">
<math>(a + b)(c + d) = ac + ad + bc + bd</math>
</div>

En manipulant l'égalité nous obtenons :

<div style="font-size: 15px;">
<math>ad + bc = (a + b)(c + d) - ac - bd</math>
</div>

ac et bd ayant déjà été calculé précédemment, il nous reste uniquement la multiplication <math>(a + b)(c + d)</math>.

Nous venons ainsi de calculer <math>ad + bc</math> en seulement une multiplication. C'est la que repose le gain de temps de la méthode Karatsuba par rapport à la multiplication naïve.

En effet, l'algorithme n'effectuera alors plus que 3 multiplications :
<div style="font-size: 15px;">
<math>ac</math>
<math>bd</math>
<math>(a + b)(c + d)</math>
</div>

La relation de récurrence devient donc :
<div style="font-size: 15px;">
<math>T(n)=3T(n/2)+O(n)</math>
</div>

Et le Master Theorem nous dit que :
<div style="font-size: 15px;">
<math>T(n)\in O(n^{\log_2(3)})</math>
</div>

Or <math>\log_2(3)\approx 1.585</math>, donc la complexité de l'algorithme de Karatsuba est de <math> \mathcal{O}(n^{1.585})</math>. Ce qui est bien plus efficace que la multiplication classique, surtout lorsque les facteurs deviennent très grands.

=== B) Graphique ===
<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Karatsuba.png|500px]]
<div><b>Karatsuba</b></div>
</div>
<div style="max-width:800px;">
<p>Sur le graphique ci-contre nous avons utilisé la courbe de la multiplication naïve récursive (rouge) à titre de comparaison.</p>
<p>On remarque graphiquement que Karatsuba (jaune) prend moins de temps à chaque calcul de produit.</p>
<p>On en déduit donc expérimentalement que Karatsuba à une meilleure complexité que la multiplication naïve.</p>
<p>Ainsi nous vérifions donc ce que le Master Theorem prouve, c'est à dire que la complexité de karatsuba est de <math> \mathcal{O}(n^{1.585})</math> </p>
</div>
</div>

== 4) La multiplication toom-cook-3 ==

=== A) Fonctionnement ===

L'objectif est de diviser les grands entiers X et Y en trois blocs de taille égale k.
On les traite alors comme des polynômes de degré 2:

<math> P(z) = X_2 \cdot z^2 + X_1 \cdot z + X_0 </math>
<math> Q(z) = Y_2 \cdot z^2 + Y_1 \cdot z + Y_0 </math>

On choisit 5 points distincts pour évaluer nos polynômes.
Ce choix de 5 points est crucial car le produit de deux polynômes de degré 2 est un polynôme de degré 4, qui nécessite 5 points pour être défini.
Les points standards sont :

P(0) = X0
P(1) = X0 + X1 + X2
P(-1) = X0 - X1 + X2
P(2) = X0 + 2*X1 + 4*X2
P(inf) = X2

(On procède de manière similaire pour Q.)

Ensuite nous multiplions récursivement chaque points de P et de Q ensemble.
On effectue ainsi 5 multiplications de nombres plus petits au lieu des 9 multiplications requises par la méthode classique.

Après, nous effectuons une interpolation, cela permet de retrouver les 5 coefficients (w_0, w_1, w_2, w_3, w_4) du polynôme produit R(z) à partir des valeurs évaluées calculées précédemment.
On résout un système d'équations linéaires : <math> R(z) = w_4 z^4 + w_3 z^3 + w_2 z^2 + w_1 z + w_0 </math>
Finalement nous pouvons recomposer notre grand entier en positionnant les coefficients w_i aux bons rangs (en les décalant) et à gérer les retenues lors de l'addition finale:
Résultat <math>= w_4 B^{4k} + w_3 B^{3k} + w_2 B^{2k} + w_1 B^k + w_0</math>

=== B) Graphique ===

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Toomcook.png|500px]]
<div><b>Karatsuba</b></div>
</div>
<div style="max-width:800px;">
<p>Nous avons réutilisé le graphique précédant, cela nous permettra de comparer Toom-Cook avec les autres algorithmes.</p>
<p>On remarque que Toom-Cook 3 est plus performant que karatsuba et ainsi que la multiplication classique.</p>
<p>Toom-cook est par conséquent un algorithme qui repousse encore une fois la complexité minimum du produit d’entiers.</p>
</div>
</div>

== 5) La transformée de Fourier rapide ==

=== A) Fonctionnement ===

La transformation de Fourier rapide étant plus complexe que les autres algorithmes, nous allons essayer d'expliquer son fonctionnement malgré ne pas avoir réussi à l'implémenter.

Il faut comprendre que cet algorithme va considérer les facteurs comme des polynômes.

D'après le théorème de l'unisolvance, il n'existe qu'un seul polynôme de degré inférieur ou égal à <math> n </math> défini par <math>n + 1</math> points distincts. Cela implique non seulement que nous pouvons représenter chaque entier par un polynôme, mais également que si nous pouvons retrouver <math>n + m + 1</math> points (avec <math>n</math> et <math>m</math> la longueur des facteurs) du polynômes issue du produit entre deux facteurs, nous pourrons le retrouver.

Soit un entier quelconque, de forme :

<math>a_n a_{n-1} (...) a_1 a_0</math>

Avec <math>a_i</math>, un chiffre composant le nombre en base 10, qui vaut en réalité dans le nombre : <math>a_i \times 10^i</math>. On peut ainsi l'écrire sous la forme :

<math> P(x) = a_0 + a_1x + a_2x^2 + \dots + a_{n-1}x^{n-1} + a_nx^n </math>

Avec <math>x = 10</math> car nous sommes en base 10, nous obtenons :

<math>P(10) = a_0 + a_1 \times 10 + \dots + a_{n-1}10^{n-1} + a_n10^n </math>

Nous venons ainsi d'écrire notre nombre sous la forme d'un polynôme unique. Pour nous permettre d'évaluer en un nombre suffisant de points, nous allons devoir ajouter des 0 pour la récursion. Il nous faudra ajouter assez de 0 pour atteindre la prochaine puissance de 2 qui sera supérieure ou égale à <math>2n + 1</math>. L'ajout de 0 ne change pas le nombre car <math>0 \times x^n</math> n'ajoute pas de coefficient.

Cet algorithme est récursif et va segmenter en deux parties nos polynômes à chaque récursion. D'un coté les indice pairs et d'un coté les impaires.

Ainsi prenons les nombres 1234 et 5678, ces nombres sont respectivement représentés par les polynômes <math> P(x) = 4 + 3x + 2x^2 + x^3 </math> et <math> P(x) = 8 + 7x + 6x^2 + 5^3 </math>. Ce sont des polynômes de degré 3, ainsi leur produit donnera lieu à un polynôme de degré 6. Il nous faudra donc au minimum 7 points d'évaluation pour retrouve ce produit. De ce fait, en les représentant de la manière suivante :

<math>[4, 3, 2, 1, 0, 0, 0, 0]</math>
<math>[8, 7, 6, 5, 0, 0, 0, 0]</math>

Nous aurons assez de récursions possible pour les évaluer en un nombre suffisant de points différents car nous auront 3 récursions à faire pour atteindre notre cas de base. A chaque récursion, nous allons diviser nos polynômes en deux parties ce qui nous fait 8 feuilles à la dernière récursion.

En effet à chaque étape de la récursion nous allons séparer nos polynômes en deux tel que :

<math>P(x)=P_{\text{pair}}(x^2) + x \cdot P_{\text{impair}}(x^2)</math>

Durant les récursions, nous segmentons les polynômes mais ne les évaluons pas. C'est à la remonté des récursions que nous allons réellement évaluer nos polynômes. Lorsque l'on atteint notre cas de base, c'est à dire des polynômes de degré 0, nous remarquons qu'ils sont constants, nous n'avons donc pas besoin de les évaluer. En effet, peut importe le point en lequel nous voudrons l'évaluer, le polynôme renverra la constante. Nous la renvoyons donc seule.
Ensuite commence la remontée des récursions. A l'étape 1 de notre remontée nous allons reformer le polynôme précédemment séparé pour obtenir un polynôme de degré 1. Puis, nous évaluons ce polynôme avec les racines seconde de l'unité. Nous faisons à nouveau remonté les évaluations et recombinons à nouveau le polynôme qui sera ainsi de degré 2.
Nous l'évaluons maintenant avec les racines 4eme de l'unité. A chaque évaluation, nous réutilisons les résultats précédents, cela nous est permit par les racines de l'unité qui ont une structure récursive exploitable.

Finalement, nous arrivons à la fin de notre FFT, avec une représentation fréquentielle de la forme :

<math> [P(W_0), P(W_1), (...), P(W_n-1), P(W_n)] </math>

Cette représentation fréquentielle n'est autre que les évaluations du polynôme P aux racines nièmes de l'unité. Nous avons donc maintenant au minimum <math>2n+1</math> évaluations des polynômes facteurs. Il nous faut maintenant trouver les évaluations du produit final, c'est à dire les évaluations concernant le polynôme qui sera issue de la multiplication. On pourra ainsi le retrouver.

Soit <math>C</math> un polynome tel que <math> C = A \times B </math>, alors on a :

<math> C(x) = A(x) \times B(x) </math>

Ainsi on en déduit que <math> C(W_n^k) = A(W_n^k) \times B(W_n^k) </math>

On comprend donc que <math>FFT(C) = FFT(A) \times FFT(B)</math>

Il faut préciser que l'on fait le produit de FFT(A) et FFT(B) terme à terme, soit évaluation par évaluation.

Une fois en possession de <math>FFT(C)</math>, qui n'est autre que l'évaluation de notre polynôme final en un nombre suffisant de points pour le retrouver, nous pouvons faire l'<math>IFFT(FFT(C))</math>, qui va nous permettre de retrouver les coefficients de notre polynôme en faisant l'exacte inverse de la FFT.

Une fois les coefficients retrouvés, il nous suffit de gérer les retenues, et nous retrouvons un entier de la forme : <math>a_0 a_1 (...) a_{n-1} a_n</math>

=== B) Graphique ===

Intéressons nous maintenant à la complexité de l'algorithme utilisant la transformée de Fourier rapide. On sait que l'algorithme passe par 5 étapes importantes :

<ul>
<li>Etape 1 : Ecrire les deux facteurs sous la forme de polynômes</li>
<li>Etape 2 : Effectuer la <math>FFT</math> des deux polynômes</li>
<li>Etape 3 : Faire le produit terme à terme des <math>FFT</math> obtenues</li>
<li>Etape 4 : Faire l'<math>IFFT</math> du produit</li>
<li>Etape 5 : Gérer les retenues et écrire le nombre qui en découle</li>
</ul>

Or, parmi toutes ces étapes, certaines sont négligeable comme l'étape 1 et 5.

Pour connaitre la complexité de l'algorithme, additionnons les complexités des étapes restantes :

Une <math>FFT</math> a une complexité de <math>\mathcal{O}(n\times logn)</math> car elle fait <math>n</math> évaluation sur <math> log(n)</math> récursions. Dans le cadre de notre algorithme, nous devons faire la <math>FFT</math> de nos deux facteurs. Soit <math>2\times \mathcal{O}(n\times logn)</math>.

Pour le produit terme à terme, nous faisons naturellement <math>n</math> opérations.

Pour finir, l'<math>IFFT</math> a la même complexité que la <math>FFT</math>. Dans le cadre de notre algorithme nous l'emploierons qu'une seule fois, ce qui fait une complexité de <math>\mathcal{O}(n\times logn)</math>.

Après addition de toutes ces complexités, nous obtenons la complexité réelle de <math>3\mathcal{O}(n\times logn) + \mathcal{O}(n)</math>.

D'après le Master Theorem, nous avons donc <math> f(n) = 3(n\times logn)+n </math>, cherchons <math>f(n)\in\mathcal{O}(g(n))</math> :

Nous pouvons ignorer les expressions linéaires ainsi que les constantes multiplicatrices, nous obtenons donc <math>\mathcal{O}(g(n)) = \mathcal{O}(n \times log n)</math>.

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:30px; text-align:center;">
[[Fichier:FFT complexite.png|500px]]
<div><b>Graphiques des complexités</b></div>
</div>
<div style="max-width:800px;">
<p>Ce graphique ci-contre ne provient pas du fruit de nos recherches personnelles mais illustre bien la comparaison entre la complexité de la FFT et des autres algorithmes.</p>
<p>On remarque que la FFT est très efficace et devance de loin les autres algorithmes en terme de complexité. </p>
<p>Les algorithmes les plus efficaces pour calculer le produit de grands entiers reposent aujourd'hui sur des variantes de la transformée de Fourier rapide.</p>
</div>
</div>

= II - Produit de matrices =

== 1.1) naïve ==

La multiplication naïve de matrice requiert d'avoir des tailles de lignes/colonne semblable, ensuite pour chaque membre de la matrice résultat, on doit multiplier les composantes ligne de la première matrice par les composantes colonne de la deuxième et le tout sommé.

On en déduit la formule suivante:
<math>C_{i,j} = \sum_{k=1}^{n} (A_{i,k} \times B_{k,j})</math>

Et visuellement:

[[Fichier:Matricenaive.jpeg]]

On a donc un algorithme d'ordre de complexité <math>\mathcal{O}(g(n))</math>

== 1.2) naïve récursive ==

Dans un premier temps on doit découper nos deux matrices en quatres sous matrices de plus petite taille.
<math>A = \begin{pmatrix} A_{11} & A_{12} \ A_{21} & A_{22} \end{pmatrix}</math>
<math>B = \begin{pmatrix} B_{11} & B_{12} \ B_{21} & B_{22} \end{pmatrix}</math>

Ensuite on vient calculer la matrice résultat.
<math>C_{11} = (A_{11} \times B_{11}) + (A_{12} \times B_{21})</math>
<math>C_{12} = (A_{11} \times B_{12}) + (A_{12} \times B_{22})</math>
<math>C_{21} = (A_{21} \times B_{11}) + (A_{22} \times B_{21})</math>
<math>C_{22} = (A_{21} \times B_{12}) + (A_{22} \times B_{22})</math>

Le côté récursif est utile que pour les matrices de tailles <= 32 (32 valeurs stockées dedans),
si on est au dessus de cette taille alors on divisera à nouveau nos matrices en quatres.
On aura 8 multiplications mais de plus petite taille au final.

== 2) strassen ==

=== A) Fonctionnement ===

Strassen consiste à définir 7 produits intermédiaires qui, par des jeux de sommes et de différences, permettent de reconstruire les quadrants de la matrice résultante. On passe ainsi d'une complexité de O(n^3) à environ O(n^2.81)

=== B) Graphique ===

On voit bien la différence de complexité sur la multiplication de grande matrice entre l'approche naïve et l'approche récursive qui est beaucoup plus rapide.

[[Fichier:Analyse matrices.png]]

= Conclusion =

L'étude de ces algorithmes de multiplication nous a clairement montré l'évolution de la complexité algorithmique permettant de gagner en efficacité lorsque la taille des données augmente.

La multiplication classiqe, en <math>\mathcal{O}(n^2)</math>, résulte d'une approche naïve qui devient rapidement inefficace pour les grands entiers ou les grandes matrices. L'algorithme de Karatsuba nous montre qu'organiser de manière intelligente ses calculs algébrique permet parfois de gagner beaucoup de multiplications, et donc de temps. Nous avons ainsi réussi à passer d'une complexité de <math>\mathcal{O}(n^2)</math> à <math> \mathcal{O}(n^{log_2(3)}) </math>, soit environ <math>\mathcal{O}(n^{1/585})</math>.

Des méthodes encore plus avancées comme utilise l'algorithme de Toom-Cook-3 continue dans cette idées de divisions d'entiers en blocs plus petits, tandis que la transformée de Fourier rapide change complètement de point de vue. En effet la FFT n'utilise pas la représentation classique des entiers mais fait appel à une vision polynomiale, ce qui transforme la convolution classique en multiplication terme à terme, ce qui lui permet d'atteindre une complexité de <math>\mathcal{O}(n \times log n)</math>.

Dans le cas des matrices, les mêmes logiques apparaissent comme par exemple avec l'algorithme de Strassen qui se rapproche très fortement de Karatsuba en combinant de manière astucieuse les parties d'entiers qui avaient été précédemment découpée.

On remarque néanmoins que la majorité des algorithmes efficaces s'orientent vers une approche récursive et non itérative. Néanmoins, nous avons pu trouver certaines de ces implémentations (comme par exemple la FFT) en itérative.

Avec ces recherches, nous comprenons que la réorganisations des calculs algébriques peuvent aider à gagner en complexité mais que pour faire de réels progrès, il nous faudra surement changer notre point de vue une nouvelle fois, et aborder le problème sous un angle nouveau comme le font dors et déjà les algorithmes les plus performants.

= Mentions =

Le premier gif est le résultat du travail de 'Walké', licence ci-contre : https://fr.wikipedia.org/wiki/Fichier:Addition.gif

Utilisation du site de production graphique "Desmos" : https://www.desmos.com/calculator?lang=fr

= Sources =

Pour karatsuba :
<ul>
<li> https://www.youtube.com/watch?v=PZ2gdWdKHAA </li>
</ul>

Pour mieux comprendre la FFT, nous avons utilisé plusieurs sources d'informations :
<ul>
<li> https://www.youtube.com/watch?v=h7apO7q16V0&list=WL&index=1&t=886s </li>
<li> https://fr.wikipedia.org/wiki/Interpolation_polynomiale </li>
</ul>

Algorithmes de multiplications d'entiers et de matrices

2026-05-11T22:03:01Z

Mangala : /* Conclusion */

= Introduction =

Depuis l'apparition des ordinateurs modernes, une quantité faramineuse de calculs a dû être effectuée. Les progressions technologiques nous poussent à envisager la puissance de calcul comme une ressource qu'il faut optimiser dans les moindres détails. C'est ainsi que l'optimisation des algorithmes de calcul est devenue cruciale, surtout lorsqu'il nous faut effectuer des opérations sur de très grands entiers par exemple.

= Objectif =

L'objectif majeur de ce projet est de comprendre de manière plus approfondie ce qu'est la '''complexité algorithmique'''.
Pour atteindre cet objectif, nous implémenterons plusieurs algorithmes de multiplication qui auront pour but de calculer le produit de grands entiers ou de matrices.

= Point important : complexité =

=== Définition ===
La complexité d'un algorithme est la quantité des ressources qu'il utilise en fonction de la taille des entrées qu'on lui demande de traiter. On peut par exemple se concentrer sur le temps qu'un algorithme prend pour renvoyer un résultat ou sur la mémoire dont il a besoin. Dans le cadre de notre projet, nous nous attarderons plus particulièrement sur la quantité de calcul effectuée en fonction de la taille des entrées, ce qui est par ailleurs étroitement liée à la notion de temps. De manière générale, plus un algorithme doit faire de calcul, plus il est lent. (Attention, toutes les opérations arithmétiques de base ne se valent pas)

De manière plus familière, on dira que la complexité d'un algorithme pourrait s'apparenter à son comportement lorsqu'il doit traiter des données plus ou moins grandes.
Chaque algorithme a une complexité, et on l'exprime par une fonction qui adopte un comportement similaire au nombre de calculs nécessaires en fonction de la taille des entrées.

=== Notation ===
La complexité réelle d'un algorithme peut être décrite par une fonction <math> f(n) </math> représentant le nombre d'opérations effectuées en fonction de la taille <math>n</math> des données d'entrée.

Cependant, afin de simplifier l'étude de cette croissance, on utilise généralement une borne asymptotique notée <math>\mathcal{O}(g(n))</math>, où <math>g(n)</math> est une fonction ayant le même ordre de grandeur que <math>f(n)</math> lorsque <math>n</math> devient grand.

On dit alors que :

<math>
f(n)\in\mathcal{O}(g(n))
</math>

si et seulement s'il existe une constante <math>C>0</math> et un entier <math>n_0</math> tels que :

<math>
\forall n\ge n_0,\ f(n)\le Cg(n)
</math>

Cette notation <math>\mathcal{O}(g(n))</math> permettra de comparer beaucoup plus facilement les algorithmes entre eux.

=== Master Theorem ===

Afin de déterminer la complexité de certains algorithmes récursifs, nous utiliserons le "Master Theorem".

Ce théorème permet d'obtenir directement l'ordre de grandeur de nombreuses relations de récurrence apparaissant dans l'analyse d'algorithmes de type « diviser pour régner », comme l'algorithme de Karatsuba ou celui de Strassen.

La démonstration complète de ce théorème dépasse le cadre de notre projet et nécessite des connaissances mathématiques plus avancées. Nous l'utiliserons donc principalement comme un outil nous permettant de déterminer efficacement la complexité asymptotique des algorithmes étudiés.

=== Graphiques ===

Les complexités étant des fonctions, nous pouvons les représenter par un graphique qui affichera le temps d'exécution (ou nombre d'opérations) en fonction de la taille des entrées.

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:30px; text-align:center;">
[[Fichier:complexite.webp|500px]]
<div><b>Graphiques des complexités</b></div>
</div>
<div style="max-width:800px;">
<p>Ce graphique ci-contre compare les complexités en fonction de la taille des d'entrées.</p>
<p>On comprend ainsi que certaines complexités ne sont pas raisonnable dans la cadre de la multiplication de grands entiers.</p>
<p>C'est pourquoi l'étude de ces algorithmes s'avère nécessaire.</p>
</div>
</div>

=== Exemple ===
L'algorithme naïf d'addition que nous avons tous appris à l'école a une complexité de <math>\mathcal{O}(n)</math>.
Soit n la taille des nombres en entrée, l'algorithme doit faire environ n addition pour arriver au résultat demandé.

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Addition.gif|220px]]
<div><b>Addition naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Comme le montre l'exemple ci-contre, 786 et 467 font 3 chiffres de long donc n sera de 3.</p>
<p>Il nous faudra 3 opérations pour additionner ces entiers.</p>
<p>C'est ainsi qu'avec une taille d'entrée n, l'algorithme de l'addition naïve va devoir faire n opérations.</p>
<p>Cet algorithme a donc une complexité <math>f(n) = n</math> qui n'a pas besoin d'être approximée.</p>
<p>Ainsi sa complexité finale sera <math>\mathcal{O}(n)</math>.</p>
</div>
</div>

= Problématique =

Le calcul du produit de deux entiers de manière naïve a une complexité de <math> \mathcal{O}(n^2)</math>, et celui de deux matrices une complexité de <math> \mathcal{O}(n^3)</math>. Afin de mieux comprendre ce qu'est la complexité algorithmique, nous devrons implémenter des algorithmes ayant le même objectif, mais étant plus efficaces. Ces algorithmes s'avèreront plus complexes mais devrait aboutir à un calcul plus rapide du produit demandé.

Nous séparerons notre wiki en deux grandes parties, la première concernera nos recherche sur [[#I - Produit d'entiers|la multiplication d'entiers]], la deuxième sur [[#II - Produit de matrices|la multiplication de matrices]].

= I - Produit d'entiers =

Notre départ commence avec l'algorithme de multiplication d'entier naïf.
En effet il s'agit de l'algorithme de multiplication le plus connu, et nous l'utiliserons comme référence pour le comparer aux futurs algorithmes plus efficaces.
Intéressons nous à sa complexité.

== 1) Nos implémentations des grands entiers ==

Qui dit produit de grands entiers dit implémentation de grands entiers.

Dans le cadre de nos recherches, nous allons devoir implémenter des algorithmes qui vont manipuler des grands entiers.

Nous avons donc choisi de créer deux représentations différentes de ceux-ci (car nous travaillons sur différents langages de programmation), nous permettant à la fois une implémentation simplifié, mais aussi de nous rapprocher d'une implémentation bas niveau.

=== A) En python ===
En python, l'utilisation des "bytes" m'a grandement servi à comprendre comment les entiers étaient manipulés à bas niveau. En effet, un des objectifs secondaires de nos recherches était de manipuler des entiers directement avec leur formes stockées sur l'ordinateur, et non pas avec des int python.
En effet l'utilisation des int python nous aurait permit de passer les étapes de retenues, de signes... D'autant plus que les bytes permettent de stocker un nombre en base 256, ce qui permet de visualiser plus facilement les grands entiers.

La forme finale de la représentation des grands entiers en python sera donc la suivante :

[ signe , bytes , bytes , (...) , bytes ]

Le signe est représenté par un entier, 1 si le nombre est positif, 0 sinon.
Cette configuration rendra plus simple la gestion des signes.

=== B) En C++ ===

En C++, pour avoir une représentation de grand entiers j'ai du définir ma propre structure pour m'affranchir de la limite de taille imposé par les entiers standards: (int32 ou int64). Pour cela, j'ai une structure qui possède l'équivalent d'un array de byte (ce qui nous permet d'être en base 256 au lieu de la base 10 habituelle), et pour traiter le signe j'utilise un booléen, ainsi en mémoire j'ai une structure de n*Octets + 1 octet en taille.

[ bytes , bytes , (...) , bytes ] [ signe ]

Le booléen prend 1 octet de place mais ne touche pas aux octets qui encode le grand entier.
Cette configuration rendra plus simple la gestion des signes dans le cadre des multiplication.

== 2) La multiplication naïve ==

=== A) Fonctionnement ===
Dans le cas de la multiplication d'entiers, nous allons prendre deux nombres qui n'ont pas nécessairement la même longueur. Soit les nombre a et b, de longueur respective <math> n </math> et <math> m </math>.
<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Multiplication.png|220px]]
<div><b>Multiplication naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Prenons deux nombres de longueur 3 et 2, et cherchons combien d'opérations l'algorithme de multiplication naïve va devoir faire pour nous renvoyer leur produit.</p>
<p>Dans un premier temps, on remarque que l'on va devoir multiplier chaque chiffre du nombre du haut par le chiffre des unités du bas, qui est 6. Cela va représenter <math>n</math> opérations. (6x5, 6x1 et 6x4)</p>
<p>Dans un deuxième temps nous constatons que nous allons devoir faire la même chose avec le chiffre des dizaines du nombre du bas. Cela nous ajoute de nouveau <math>n</math> opérations.</p>
<p>On arrive assez facilement à la conclusion que pour faire notre produit, il va nous falloir faire <math>n</math> fois <math>m</math> opérations.</p>
</div>
</div>

Ainsi, la complexité de la multiplication naïve est <math>\mathcal{O}(n^2)</math>.
Il est en de même avec la multiplication naïve récursive.

=== B) Graphique ===
Montrons maintenant sa courbe sur un graphique :

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Multiplicationnaive.png|500px]]
<div><b>Multiplication naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Les points noirs sont des repères pour que les autres courbes aient une forme cohérente.</p>
<p>Ils sont tous sur l'axe des abscisses.</p>
<p>La courbe rouge représente la complexité de la multiplication naïve.</p>
<p>On remarque que la courbe a un visuel très similaire à la fonction <math> f(x) = x^2 </math> </p>
</div>
</div>

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Naif_recursif.png|500px]]
<div><b>Multiplication naïve récursive</b></div>
</div>
<div style="max-width:800px;">
<p>Cette courbe rouge représente la complexité de la multiplication naïve récursive.</p>
<p>Elle sera utilisé pour comparer les complexités entre algorithmes car, comme tous récursifs, elle a été codé avec les mêmes biais d'implémentation qu'eux.</p>
<p>Théoriquement les deux courbes ci-contre ont la même complexité, mais encore une fois, notre implémentation n'est pas parfaitement optimale et donc ne respecte pas de manière minutieuse le Master Theorem.</p>
</div>
</div>

== 3) La multiplication karatsuba ==

=== A) Fonctionnement ===

L'algorithme de karatsuba est un algorithme récursif de type diviser pour régner.

L'idée générale de l'algorithme est de passer de 4 multiplication à 3. En effet ces opérations étant moins couteuses, il est préférable d'en ajouter si cela permet d'enlever des multiplications.

L'algorithme de multiplication naif récursif utilise la segmentation des facteurs en deux de manière successive.

Soit <math> x </math> et <math>y</math> deux facteurs, nous avons les égalités suivantes :

<div style="font-size: 15px;">
<math>x = a \times B^{n/2} + b</math>
<math>y = c \times B^{n/2} + d</math>
</div>

Avec <math>a</math> et <math>c</math> les premières moitiés des facteurs <math>x</math> et <math>y</math>,
et <math> b </math> et <math>d</math> les dernières moitiés de ces facteurs ainsi que <math>B</math> la base d'écriture du nombre (Nous sommes en base 256 avec les bytes).

Cette présentation des deux facteurs de notre multiplication n'est que la résultante d'un découpage.
Le [[#Master Theorem|Master Theorem]] nous montre que :

<div style="font-size: 15px;">
<math>T(n) = 4T(n/2) + O(n)</math>
</div>

Puisque nous avons après découpage 4 entiers de longueur <math>n/2</math>.

Ainsi, ce découpage ne permet pas de gagner du temps d'après le [[#Master Theorem|Master Theorem]].

Cependant, l'algorithme de Karatsuba réutilise ce principe en le modifiant, ce qui nous permet de baisser la complexité globale de la multiplication dans son entièreté.

Avec l'écriture ci-dessus des nombres <math>x</math> et <math>y</math>, on peut facilement en déduire l'égalité suivante :

<div style="font-size: 15px;">
<math>x \times y = (ac) \times B^n + (ad + bc) \times B^{n/2} + bd</math>
</div>

On remarque 4 multiplications longues à faire dans cette expression. Les multiplications dont <math>B</math> est l'un des facteurs sont très rapides puisqu'il s'agit de la base dans laquelle nous travaillons. De cela en résulte un décalage plutôt qu'un vrai calcul à faire.

Karatsuba développe une partie de cette expression pour pouvoir négocier une multiplication au prix d'additions et soustractions.

En effet, nous savons déjà que :

<div style="font-size: 15px;">
<math>(a + b)(c + d) = ac + ad + bc + bd</math>
</div>

En manipulant l'égalité nous obtenons :

<div style="font-size: 15px;">
<math>ad + bc = (a + b)(c + d) - ac - bd</math>
</div>

ac et bd ayant déjà été calculé précédemment, il nous reste uniquement la multiplication <math>(a + b)(c + d)</math>.

Nous venons ainsi de calculer <math>ad + bc</math> en seulement une multiplication. C'est la que repose le gain de temps de la méthode Karatsuba par rapport à la multiplication naïve.

En effet, l'algorithme n'effectuera alors plus que 3 multiplications :
<div style="font-size: 15px;">
<math>ac</math>
<math>bd</math>
<math>(a + b)(c + d)</math>
</div>

La relation de récurrence devient donc :
<div style="font-size: 15px;">
<math>T(n)=3T(n/2)+O(n)</math>
</div>

Et le Master Theorem nous dit que :
<div style="font-size: 15px;">
<math>T(n)\in O(n^{\log_2(3)})</math>
</div>

Or <math>\log_2(3)\approx 1.585</math>, donc la complexité de l'algorithme de Karatsuba est de <math> \mathcal{O}(n^{1.585})</math>. Ce qui est bien plus efficace que la multiplication classique, surtout lorsque les facteurs deviennent très grands.

=== B) Graphique ===
<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Karatsuba.png|500px]]
<div><b>Karatsuba</b></div>
</div>
<div style="max-width:800px;">
<p>Sur le graphique ci-contre nous avons utilisé la courbe de la multiplication naïve récursive (rouge) à titre de comparaison.</p>
<p>On remarque graphiquement que Karatsuba (jaune) prend moins de temps à chaque calcul de produit.</p>
<p>On en déduit donc expérimentalement que Karatsuba à une meilleure complexité que la multiplication naïve.</p>
<p>Ainsi nous vérifions donc ce que le Master Theorem prouve, c'est à dire que la complexité de karatsuba est de <math> \mathcal{O}(n^{1.585})</math> </p>
</div>
</div>

== 4) La multiplication toom-cook-3 ==

=== A) Fonctionnement ===

L'objectif est de diviser les grands entiers X et Y en trois blocs de taille égale k.
On les traite alors comme des polynômes de degré 2:

<math> P(z) = X_2 \cdot z^2 + X_1 \cdot z + X_0 </math>
<math> Q(z) = Y_2 \cdot z^2 + Y_1 \cdot z + Y_0 </math>

On choisit 5 points distincts pour évaluer nos polynômes.
Ce choix de 5 points est crucial car le produit de deux polynômes de degré 2 est un polynôme de degré 4, qui nécessite 5 points pour être défini.
Les points standards sont :

P(0) = X0
P(1) = X0 + X1 + X2
P(-1) = X0 - X1 + X2
P(2) = X0 + 2*X1 + 4*X2
P(inf) = X2

(On procède de manière similaire pour Q.)

Ensuite nous multiplions récursivement chaque points de P et de Q ensemble.
On effectue ainsi 5 multiplications de nombres plus petits au lieu des 9 multiplications requises par la méthode classique.

Après, nous effectuons une interpolation, cela permet de retrouver les 5 coefficients (w_0, w_1, w_2, w_3, w_4) du polynôme produit R(z) à partir des valeurs évaluées calculées précédemment.
On résout un système d'équations linéaires : <math> R(z) = w_4 z^4 + w_3 z^3 + w_2 z^2 + w_1 z + w_0 </math>
Finalement nous pouvons recomposer notre grand entier en positionnant les coefficients w_i aux bons rangs (en les décalant) et à gérer les retenues lors de l'addition finale:
Résultat <math>= w_4 B^{4k} + w_3 B^{3k} + w_2 B^{2k} + w_1 B^k + w_0</math>

=== B) Graphique ===

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Toomcook.png|500px]]
<div><b>Karatsuba</b></div>
</div>
<div style="max-width:800px;">
<p>Nous avons réutilisé le graphique précédant, cela nous permettra de comparer Toom-Cook avec les autres algorithmes.</p>
<p>On remarque que Toom-Cook 3 est plus performant que karatsuba et ainsi que la multiplication classique.</p>
<p>Toom-cook est par conséquent un algorithme qui repousse encore une fois la complexité minimum du produit d’entiers.</p>
</div>
</div>

== 5) La transformée de Fourier rapide ==

=== A) Fonctionnement ===

La transformation de Fourier rapide étant plus complexe que les autres algorithmes, nous allons essayer d'expliquer son fonctionnement malgré ne pas avoir réussi à l'implémenter.

Il faut comprendre que cet algorithme va considérer les facteurs comme des polynômes.

D'après le théorème de l'unisolvance, il n'existe qu'un seul polynôme de degré inférieur ou égal à <math> n </math> défini par <math>n + 1</math> points distincts. Cela implique non seulement que nous pouvons représenter chaque entier par un polynôme, mais également que si nous pouvons retrouver <math>n + m + 1</math> points (avec <math>n</math> et <math>m</math> la longueur des facteurs) du polynômes issue du produit entre deux facteurs, nous pourrons le retrouver.

Soit un entier quelconque, de forme :

<math>a_n a_{n-1} (...) a_1 a_0</math>

Avec <math>a_i</math>, un chiffre composant le nombre en base 10, qui vaut en réalité dans le nombre : <math>a_i \times 10^i</math>. On peut ainsi l'écrire sous la forme :

<math> P(x) = a_0 + a_1x + a_2x^2 + \dots + a_{n-1}x^{n-1} + a_nx^n </math>

Avec <math>x = 10</math> car nous sommes en base 10, nous obtenons :

<math>P(10) = a_0 + a_1 \times 10 + \dots + a_{n-1}10^{n-1} + a_n10^n </math>

Nous venons ainsi d'écrire notre nombre sous la forme d'un polynôme unique. Pour nous permettre d'évaluer en un nombre suffisant de points, nous allons devoir ajouter des 0 pour la récursion. Il nous faudra ajouter assez de 0 pour atteindre la prochaine puissance de 2 qui sera supérieure ou égale à <math>2n + 1</math>. L'ajout de 0 ne change pas le nombre car <math>0 \times x^n</math> n'ajoute pas de coefficient.

Cet algorithme est récursif et va segmenter en deux parties nos polynômes à chaque récursion. D'un coté les indice pairs et d'un coté les impaires.

Ainsi prenons les nombres 1234 et 5678, ces nombres sont respectivement représentés par les polynômes <math> P(x) = 4 + 3x + 2x^2 + x^3 </math> et <math> P(x) = 8 + 7x + 6x^2 + 5^3 </math>. Ce sont des polynômes de degré 3, ainsi leur produit donnera lieu à un polynôme de degré 6. Il nous faudra donc au minimum 7 points d'évaluation pour retrouve ce produit. De ce fait, en les représentant de la manière suivante :

<math>[4, 3, 2, 1, 0, 0, 0, 0]</math>
<math>[8, 7, 6, 5, 0, 0, 0, 0]</math>

Nous aurons assez de récursions possible pour les évaluer en un nombre suffisant de points différents car nous auront 3 récursions à faire pour atteindre notre cas de base. A chaque récursion, nous allons diviser nos polynômes en deux parties ce qui nous fait 8 feuilles à la dernière récursion.

En effet à chaque étape de la récursion nous allons séparer nos polynômes en deux tel que :

<math>P(x)=P_{\text{pair}}(x^2) + x \cdot P_{\text{impair}}(x^2)</math>

Durant les récursions, nous segmentons les polynômes mais ne les évaluons pas. C'est à la remonté des récursions que nous allons réellement évaluer nos polynômes. Lorsque l'on atteint notre cas de base, c'est à dire des polynômes de degré 0, nous remarquons qu'ils sont constants, nous n'avons donc pas besoin de les évaluer. En effet, peut importe le point en lequel nous voudrons l'évaluer, le polynôme renverra la constante. Nous la renvoyons donc seule.
Ensuite commence la remontée des récursions. A l'étape 1 de notre remontée nous allons reformer le polynôme précédemment séparé pour obtenir un polynôme de degré 1. Puis, nous évaluons ce polynôme avec les racines seconde de l'unité. Nous faisons à nouveau remonté les évaluations et recombinons à nouveau le polynôme qui sera ainsi de degré 2.
Nous l'évaluons maintenant avec les racines 4eme de l'unité. A chaque évaluation, nous réutilisons les résultats précédents, cela nous est permit par les racines de l'unité qui ont une structure récursive exploitable.

Finalement, nous arrivons à la fin de notre FFT, avec une représentation fréquentielle de la forme :

<math> [P(W_0), P(W_1), (...), P(W_n-1), P(W_n)] </math>

Cette représentation fréquentielle n'est autre que les évaluations du polynôme P aux racines nièmes de l'unité. Nous avons donc maintenant au minimum <math>2n+1</math> évaluations des polynômes facteurs. Il nous faut maintenant trouver les évaluations du produit final, c'est à dire les évaluations concernant le polynôme qui sera issue de la multiplication. On pourra ainsi le retrouver.

Soit <math>C</math> un polynome tel que <math> C = A \times B </math>, alors on a :

<math> C(x) = A(x) \times B(x) </math>

Ainsi on en déduit que <math> C(W_n^k) = A(W_n^k) \times B(W_n^k) </math>

On comprend donc que <math>FFT(C) = FFT(A) \times FFT(B)</math>

Il faut préciser que l'on fait le produit de FFT(A) et FFT(B) terme à terme, soit évaluation par évaluation.

Une fois en possession de <math>FFT(C)</math>, qui n'est autre que l'évaluation de notre polynôme final en un nombre suffisant de points pour le retrouver, nous pouvons faire l'<math>IFFT(FFT(C))</math>, qui va nous permettre de retrouver les coefficients de notre polynôme en faisant l'exacte inverse de la FFT.

Une fois les coefficients retrouvés, il nous suffit de gérer les retenues, et nous retrouvons un entier de la forme : <math>a_0 a_1 (...) a_{n-1} a_n</math>

=== B) Graphique ===

Intéressons nous maintenant à la complexité de l'algorithme utilisant la transformée de Fourier rapide. On sait que l'algorithme passe par 5 étapes importantes :

<ul>
<li>Etape 1 : Ecrire les deux facteurs sous la forme de polynômes</li>
<li>Etape 2 : Effectuer la <math>FFT</math> des deux polynômes</li>
<li>Etape 3 : Faire le produit terme à terme des <math>FFT</math> obtenues</li>
<li>Etape 4 : Faire l'<math>IFFT</math> du produit</li>
<li>Etape 5 : Gérer les retenues et écrire le nombre qui en découle</li>
</ul>

Or, parmi toutes ces étapes, certaines sont négligeable comme l'étape 1 et 5.

Pour connaitre la complexité de l'algorithme, additionnons les complexités des étapes restantes :

Une <math>FFT</math> a une complexité de <math>\mathcal{O}(n\times logn)</math> car elle fait <math>n</math> évaluation sur <math> log(n)</math> récursions. Dans le cadre de notre algorithme, nous devons faire la <math>FFT</math> de nos deux facteurs. Soit <math>2\times \mathcal{O}(n\times logn)</math>.

Pour le produit terme à terme, nous faisons naturellement <math>n</math> opérations.

Pour finir, l'<math>IFFT</math> a la même complexité que la <math>FFT</math>. Dans le cadre de notre algorithme nous l'emploierons qu'une seule fois, ce qui fait une complexité de <math>\mathcal{O}(n\times logn)</math>.

Après addition de toutes ces complexités, nous obtenons la complexité réelle de <math>3\mathcal{O}(n\times logn) + \mathcal{O}(n)</math>.

D'après le Master Theorem, nous avons donc <math> f(n) = 3(n\times logn)+n </math>, cherchons <math>f(n)\in\mathcal{O}(g(n))</math> :

Nous pouvons ignorer les expressions linéaires ainsi que les constantes multiplicatrices, nous obtenons donc <math>\mathcal{O}(g(n)) = \mathcal{O}(n \times log n)</math>.

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:30px; text-align:center;">
[[Fichier:FFT complexite.png|500px]]
<div><b>Graphiques des complexités</b></div>
</div>
<div style="max-width:800px;">
<p>Ce graphique ci-contre ne provient pas du fruit de nos recherches personnelles mais illustre bien la comparaison entre la complexité de la FFT et des autres algorithmes.</p>
<p>On remarque que la FFT est très efficace et devance de loin les autres algorithmes en terme de complexité. </p>
<p>Les algorithmes les plus efficaces pour calculer le produit de grands entiers reposent aujourd'hui sur des variantes de la transformée de Fourier rapide.</p>
</div>
</div>

= II - Produit de matrices =

== 1.1) naïve ==

La multiplication naïve de matrice requiert d'avoir des tailles de lignes/colonne semblable, ensuite pour chaque membre de la matrice résultat, on doit multiplier les composantes ligne de la première matrice par les composantes colonne de la deuxième et le tout sommé.

On en déduit la formule suivante:
<math>C_{i,j} = \sum_{k=1}^{n} (A_{i,k} \times B_{k,j})</math>

Et visuellement:

[[Fichier:Matricenaive.jpeg]]

On a donc un algorithme d'ordre de complexité <math>\mathcal{O}(g(n))</math>

== 1.2) naïve récursive ==

Dans un premier temps on doit découper nos deux matrices en quatres sous matrices de plus petite taille.
<math>A = \begin{pmatrix} A_{11} & A_{12} \ A_{21} & A_{22} \end{pmatrix}</math>
<math>B = \begin{pmatrix} B_{11} & B_{12} \ B_{21} & B_{22} \end{pmatrix}</math>

Ensuite on vient calculer la matrice résultat.
<math>C_{11} = (A_{11} \times B_{11}) + (A_{12} \times B_{21})</math>
<math>C_{12} = (A_{11} \times B_{12}) + (A_{12} \times B_{22})</math>
<math>C_{21} = (A_{21} \times B_{11}) + (A_{22} \times B_{21})</math>
<math>C_{22} = (A_{21} \times B_{12}) + (A_{22} \times B_{22})</math>

Le côté récursif est utile que pour les matrices de tailles <= 32 (32 valeurs stockées dedans),
si on est au dessus de cette taille alors on divisera à nouveau nos matrices en quatres.
On aura 8 multiplications mais de plus petite taille au final.

== 2) strassen ==

=== A) Fonctionnement ===

Strassen consiste à définir 7 produits intermédiaires qui, par des jeux de sommes et de différences, permettent de reconstruire les quadrants de la matrice résultante. On passe ainsi d'une complexité de O(n^3) à environ O(n^2.81)

=== B) Graphique ===

On voit bien la différence de complexité sur la multiplication de grande matrice entre l'approche naïve et l'approche récursive qui est beaucoup plus rapide.

[[Fichier:Analyse matrices.png]]

= Conclusion =

L'étude de ces algorithmes de multiplication nous a clairement montré l'évolution de la complexité algorithmique permettant de gagner en efficacité lorsque la taille des données augmente.

La multiplication classiqe, en <math>\mathcal{O}(n^2)</math>, résulte d'une approche naïve qui devient rapidement inefficace pour les grands entiers ou les grandes matrices. L'algorithme de Karatsuba nous montre qu'organiser de manière intelligente ses calculs algébrique permet parfois de gagner beaucoup de multiplications, et donc de temps. Nous avons ainsi réussi à passer d'une complexité de <math>\mathcal{O}(n^2)</math> à <math> \mathcal{O}(n^{log_2(3)}) </math>, soit environ <math>\mathcal{O}(n^{1/585})</math>.

Des méthodes encore plus avancées comme utilise l'algorithme de Toom-Cook-3 continue dans cette idées de divisions d'entiers en blocs plus petits, tandis que la transformée de Fourier rapide change complètement de point de vue. En effet la FFT n'utilise pas la représentation classique des entiers mais fait appel à une vision polynomiale, ce qui transforme la convolution classique en multiplication terme à terme, ce qui lui permet d'atteindre une complexité de <math>\mathcal{O}(n \times log n)</math>.

Dans le cas des matrices, les mêmes logiques apparaissent comme par exemple avec l'algorithme de Strassen qui se rapproche très fortement de Karatsuba en combinant de manière astucieuse les parties d'entiers qui avaient été précédemment découpée.

On remarque néanmoins que la majorité des algorithmes efficaces s'orientent vers une approche récursive et non itérative. Néanmoins, nous avons pu trouver certaines de ces implémentations (comme par exemple la FFT) en itérative.

Avec ces recherches, nous comprenons que la réorganisations des calculs algébriques peuvent aider à gagner en complexité mais que pour faire de réels progrès, il nous faudra surement changer notre point de vue une nouvelle fois, et aborder le problème sous un angle nouveau comme le font dors et déjà les algorithmes les plus performants.

= Mentions =

Le premier gif est le résultat du travail de 'Walké', licence ci-contre : https://fr.wikipedia.org/wiki/Fichier:Addition.gif

Utilisation du site de production graphique "Desmos" : https://www.desmos.com/calculator?lang=fr

= Sources =

Pour karatsuba :
<ul>
<li> https://www.youtube.com/watch?v=PZ2gdWdKHAA </li>
</ul>

Pour mieux comprendre la FFT, nous avons utilisé plusieurs sources d'informations :
<ul>
<li> https://www.youtube.com/watch?v=h7apO7q16V0&list=WL&index=1&t=886s </li>
<li> https://fr.wikipedia.org/wiki/Interpolation_polynomiale </li>
</ul>

Algorithmes de multiplications d'entiers et de matrices

2026-05-11T21:44:31Z

Mangala : /* B) Graphique */

= Introduction =

Depuis l'apparition des ordinateurs modernes, une quantité faramineuse de calculs a dû être effectuée. Les progressions technologiques nous poussent à envisager la puissance de calcul comme une ressource qu'il faut optimiser dans les moindres détails. C'est ainsi que l'optimisation des algorithmes de calcul est devenue cruciale, surtout lorsqu'il nous faut effectuer des opérations sur de très grands entiers par exemple.

= Objectif =

L'objectif majeur de ce projet est de comprendre de manière plus approfondie ce qu'est la '''complexité algorithmique'''.
Pour atteindre cet objectif, nous implémenterons plusieurs algorithmes de multiplication qui auront pour but de calculer le produit de grands entiers ou de matrices.

= Point important : complexité =

=== Définition ===
La complexité d'un algorithme est la quantité des ressources qu'il utilise en fonction de la taille des entrées qu'on lui demande de traiter. On peut par exemple se concentrer sur le temps qu'un algorithme prend pour renvoyer un résultat ou sur la mémoire dont il a besoin. Dans le cadre de notre projet, nous nous attarderons plus particulièrement sur la quantité de calcul effectuée en fonction de la taille des entrées, ce qui est par ailleurs étroitement liée à la notion de temps. De manière générale, plus un algorithme doit faire de calcul, plus il est lent. (Attention, toutes les opérations arithmétiques de base ne se valent pas)

De manière plus familière, on dira que la complexité d'un algorithme pourrait s'apparenter à son comportement lorsqu'il doit traiter des données plus ou moins grandes.
Chaque algorithme a une complexité, et on l'exprime par une fonction qui adopte un comportement similaire au nombre de calculs nécessaires en fonction de la taille des entrées.

=== Notation ===
La complexité réelle d'un algorithme peut être décrite par une fonction <math> f(n) </math> représentant le nombre d'opérations effectuées en fonction de la taille <math>n</math> des données d'entrée.

Cependant, afin de simplifier l'étude de cette croissance, on utilise généralement une borne asymptotique notée <math>\mathcal{O}(g(n))</math>, où <math>g(n)</math> est une fonction ayant le même ordre de grandeur que <math>f(n)</math> lorsque <math>n</math> devient grand.

On dit alors que :

<math>
f(n)\in\mathcal{O}(g(n))
</math>

si et seulement s'il existe une constante <math>C>0</math> et un entier <math>n_0</math> tels que :

<math>
\forall n\ge n_0,\ f(n)\le Cg(n)
</math>

Cette notation <math>\mathcal{O}(g(n))</math> permettra de comparer beaucoup plus facilement les algorithmes entre eux.

=== Master Theorem ===

Afin de déterminer la complexité de certains algorithmes récursifs, nous utiliserons le "Master Theorem".

Ce théorème permet d'obtenir directement l'ordre de grandeur de nombreuses relations de récurrence apparaissant dans l'analyse d'algorithmes de type « diviser pour régner », comme l'algorithme de Karatsuba ou celui de Strassen.

La démonstration complète de ce théorème dépasse le cadre de notre projet et nécessite des connaissances mathématiques plus avancées. Nous l'utiliserons donc principalement comme un outil nous permettant de déterminer efficacement la complexité asymptotique des algorithmes étudiés.

=== Graphiques ===

Les complexités étant des fonctions, nous pouvons les représenter par un graphique qui affichera le temps d'exécution (ou nombre d'opérations) en fonction de la taille des entrées.

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:30px; text-align:center;">
[[Fichier:complexite.webp|500px]]
<div><b>Graphiques des complexités</b></div>
</div>
<div style="max-width:800px;">
<p>Ce graphique ci-contre compare les complexités en fonction de la taille des d'entrées.</p>
<p>On comprend ainsi que certaines complexités ne sont pas raisonnable dans la cadre de la multiplication de grands entiers.</p>
<p>C'est pourquoi l'étude de ces algorithmes s'avère nécessaire.</p>
</div>
</div>

=== Exemple ===
L'algorithme naïf d'addition que nous avons tous appris à l'école a une complexité de <math>\mathcal{O}(n)</math>.
Soit n la taille des nombres en entrée, l'algorithme doit faire environ n addition pour arriver au résultat demandé.

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Addition.gif|220px]]
<div><b>Addition naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Comme le montre l'exemple ci-contre, 786 et 467 font 3 chiffres de long donc n sera de 3.</p>
<p>Il nous faudra 3 opérations pour additionner ces entiers.</p>
<p>C'est ainsi qu'avec une taille d'entrée n, l'algorithme de l'addition naïve va devoir faire n opérations.</p>
<p>Cet algorithme a donc une complexité <math>f(n) = n</math> qui n'a pas besoin d'être approximée.</p>
<p>Ainsi sa complexité finale sera <math>\mathcal{O}(n)</math>.</p>
</div>
</div>

= Problématique =

Le calcul du produit de deux entiers de manière naïve a une complexité de <math> \mathcal{O}(n^2)</math>, et celui de deux matrices une complexité de <math> \mathcal{O}(n^3)</math>. Afin de mieux comprendre ce qu'est la complexité algorithmique, nous devrons implémenter des algorithmes ayant le même objectif, mais étant plus efficaces. Ces algorithmes s'avèreront plus complexes mais devrait aboutir à un calcul plus rapide du produit demandé.

Nous séparerons notre wiki en deux grandes parties, la première concernera nos recherche sur [[#I - Produit d'entiers|la multiplication d'entiers]], la deuxième sur [[#II - Produit de matrices|la multiplication de matrices]].

= I - Produit d'entiers =

Notre départ commence avec l'algorithme de multiplication d'entier naïf.
En effet il s'agit de l'algorithme de multiplication le plus connu, et nous l'utiliserons comme référence pour le comparer aux futurs algorithmes plus efficaces.
Intéressons nous à sa complexité.

== 1) Nos implémentations des grands entiers ==

Qui dit produit de grands entiers dit implémentation de grands entiers.

Dans le cadre de nos recherches, nous allons devoir implémenter des algorithmes qui vont manipuler des grands entiers.

Nous avons donc choisi de créer deux représentations différentes de ceux-ci (car nous travaillons sur différents langages de programmation), nous permettant à la fois une implémentation simplifié, mais aussi de nous rapprocher d'une implémentation bas niveau.

=== A) En python ===
En python, l'utilisation des "bytes" m'a grandement servi à comprendre comment les entiers étaient manipulés à bas niveau. En effet, un des objectifs secondaires de nos recherches était de manipuler des entiers directement avec leur formes stockées sur l'ordinateur, et non pas avec des int python.
En effet l'utilisation des int python nous aurait permit de passer les étapes de retenues, de signes... D'autant plus que les bytes permettent de stocker un nombre en base 256, ce qui permet de visualiser plus facilement les grands entiers.

La forme finale de la représentation des grands entiers en python sera donc la suivante :

[ signe , bytes , bytes , (...) , bytes ]

Le signe est représenté par un entier, 1 si le nombre est positif, 0 sinon.
Cette configuration rendra plus simple la gestion des signes.

=== B) En C++ ===

En C++, pour avoir une représentation de grand entiers j'ai du définir ma propre structure pour m'affranchir de la limite de taille imposé par les entiers standards: (int32 ou int64). Pour cela, j'ai une structure qui possède l'équivalent d'un array de byte (ce qui nous permet d'être en base 256 au lieu de la base 10 habituelle), et pour traiter le signe j'utilise un booléen, ainsi en mémoire j'ai une structure de n*Octets + 1 octet en taille.

[ bytes , bytes , (...) , bytes ] [ signe ]

Le booléen prend 1 octet de place mais ne touche pas aux octets qui encode le grand entier.
Cette configuration rendra plus simple la gestion des signes dans le cadre des multiplication.

== 2) La multiplication naïve ==

=== A) Fonctionnement ===
Dans le cas de la multiplication d'entiers, nous allons prendre deux nombres qui n'ont pas nécessairement la même longueur. Soit les nombre a et b, de longueur respective <math> n </math> et <math> m </math>.
<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Multiplication.png|220px]]
<div><b>Multiplication naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Prenons deux nombres de longueur 3 et 2, et cherchons combien d'opérations l'algorithme de multiplication naïve va devoir faire pour nous renvoyer leur produit.</p>
<p>Dans un premier temps, on remarque que l'on va devoir multiplier chaque chiffre du nombre du haut par le chiffre des unités du bas, qui est 6. Cela va représenter <math>n</math> opérations. (6x5, 6x1 et 6x4)</p>
<p>Dans un deuxième temps nous constatons que nous allons devoir faire la même chose avec le chiffre des dizaines du nombre du bas. Cela nous ajoute de nouveau <math>n</math> opérations.</p>
<p>On arrive assez facilement à la conclusion que pour faire notre produit, il va nous falloir faire <math>n</math> fois <math>m</math> opérations.</p>
</div>
</div>

Ainsi, la complexité de la multiplication naïve est <math>\mathcal{O}(n^2)</math>.
Il est en de même avec la multiplication naïve récursive.

=== B) Graphique ===
Montrons maintenant sa courbe sur un graphique :

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Multiplicationnaive.png|500px]]
<div><b>Multiplication naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Les points noirs sont des repères pour que les autres courbes aient une forme cohérente.</p>
<p>Ils sont tous sur l'axe des abscisses.</p>
<p>La courbe rouge représente la complexité de la multiplication naïve.</p>
<p>On remarque que la courbe a un visuel très similaire à la fonction <math> f(x) = x^2 </math> </p>
</div>
</div>

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Naif_recursif.png|500px]]
<div><b>Multiplication naïve récursive</b></div>
</div>
<div style="max-width:800px;">
<p>Cette courbe rouge représente la complexité de la multiplication naïve récursive.</p>
<p>Elle sera utilisé pour comparer les complexités entre algorithmes car, comme tous récursifs, elle a été codé avec les mêmes biais d'implémentation qu'eux.</p>
<p>Théoriquement les deux courbes ci-contre ont la même complexité, mais encore une fois, notre implémentation n'est pas parfaitement optimale et donc ne respecte pas de manière minutieuse le Master Theorem.</p>
</div>
</div>

== 3) La multiplication karatsuba ==

=== A) Fonctionnement ===

L'algorithme de karatsuba est un algorithme récursif de type diviser pour régner.

L'idée générale de l'algorithme est de passer de 4 multiplication à 3. En effet ces opérations étant moins couteuses, il est préférable d'en ajouter si cela permet d'enlever des multiplications.

L'algorithme de multiplication naif récursif utilise la segmentation des facteurs en deux de manière successive.

Soit <math> x </math> et <math>y</math> deux facteurs, nous avons les égalités suivantes :

<div style="font-size: 15px;">
<math>x = a \times B^{n/2} + b</math>
<math>y = c \times B^{n/2} + d</math>
</div>

Avec <math>a</math> et <math>c</math> les premières moitiés des facteurs <math>x</math> et <math>y</math>,
et <math> b </math> et <math>d</math> les dernières moitiés de ces facteurs ainsi que <math>B</math> la base d'écriture du nombre (Nous sommes en base 256 avec les bytes).

Cette présentation des deux facteurs de notre multiplication n'est que la résultante d'un découpage.
Le [[#Master Theorem|Master Theorem]] nous montre que :

<div style="font-size: 15px;">
<math>T(n) = 4T(n/2) + O(n)</math>
</div>

Puisque nous avons après découpage 4 entiers de longueur <math>n/2</math>.

Ainsi, ce découpage ne permet pas de gagner du temps d'après le [[#Master Theorem|Master Theorem]].

Cependant, l'algorithme de Karatsuba réutilise ce principe en le modifiant, ce qui nous permet de baisser la complexité globale de la multiplication dans son entièreté.

Avec l'écriture ci-dessus des nombres <math>x</math> et <math>y</math>, on peut facilement en déduire l'égalité suivante :

<div style="font-size: 15px;">
<math>x \times y = (ac) \times B^n + (ad + bc) \times B^{n/2} + bd</math>
</div>

On remarque 4 multiplications longues à faire dans cette expression. Les multiplications dont <math>B</math> est l'un des facteurs sont très rapides puisqu'il s'agit de la base dans laquelle nous travaillons. De cela en résulte un décalage plutôt qu'un vrai calcul à faire.

Karatsuba développe une partie de cette expression pour pouvoir négocier une multiplication au prix d'additions et soustractions.

En effet, nous savons déjà que :

<div style="font-size: 15px;">
<math>(a + b)(c + d) = ac + ad + bc + bd</math>
</div>

En manipulant l'égalité nous obtenons :

<div style="font-size: 15px;">
<math>ad + bc = (a + b)(c + d) - ac - bd</math>
</div>

ac et bd ayant déjà été calculé précédemment, il nous reste uniquement la multiplication <math>(a + b)(c + d)</math>.

Nous venons ainsi de calculer <math>ad + bc</math> en seulement une multiplication. C'est la que repose le gain de temps de la méthode Karatsuba par rapport à la multiplication naïve.

En effet, l'algorithme n'effectuera alors plus que 3 multiplications :
<div style="font-size: 15px;">
<math>ac</math>
<math>bd</math>
<math>(a + b)(c + d)</math>
</div>

La relation de récurrence devient donc :
<div style="font-size: 15px;">
<math>T(n)=3T(n/2)+O(n)</math>
</div>

Et le Master Theorem nous dit que :
<div style="font-size: 15px;">
<math>T(n)\in O(n^{\log_2(3)})</math>
</div>

Or <math>\log_2(3)\approx 1.585</math>, donc la complexité de l'algorithme de Karatsuba est de <math> \mathcal{O}(n^{1.585})</math>. Ce qui est bien plus efficace que la multiplication classique, surtout lorsque les facteurs deviennent très grands.

=== B) Graphique ===
<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Karatsuba.png|500px]]
<div><b>Karatsuba</b></div>
</div>
<div style="max-width:800px;">
<p>Sur le graphique ci-contre nous avons utilisé la courbe de la multiplication naïve récursive (rouge) à titre de comparaison.</p>
<p>On remarque graphiquement que Karatsuba (jaune) prend moins de temps à chaque calcul de produit.</p>
<p>On en déduit donc expérimentalement que Karatsuba à une meilleure complexité que la multiplication naïve.</p>
<p>Ainsi nous vérifions donc ce que le Master Theorem prouve, c'est à dire que la complexité de karatsuba est de <math> \mathcal{O}(n^{1.585})</math> </p>
</div>
</div>

== 4) La multiplication toom-cook-3 ==

=== A) Fonctionnement ===

L'objectif est de diviser les grands entiers X et Y en trois blocs de taille égale k.
On les traite alors comme des polynômes de degré 2:

<math> P(z) = X_2 \cdot z^2 + X_1 \cdot z + X_0 </math>
<math> Q(z) = Y_2 \cdot z^2 + Y_1 \cdot z + Y_0 </math>

On choisit 5 points distincts pour évaluer nos polynômes.
Ce choix de 5 points est crucial car le produit de deux polynômes de degré 2 est un polynôme de degré 4, qui nécessite 5 points pour être défini.
Les points standards sont :

P(0) = X0
P(1) = X0 + X1 + X2
P(-1) = X0 - X1 + X2
P(2) = X0 + 2*X1 + 4*X2
P(inf) = X2

(On procède de manière similaire pour Q.)

Ensuite nous multiplions récursivement chaque points de P et de Q ensemble.
On effectue ainsi 5 multiplications de nombres plus petits au lieu des 9 multiplications requises par la méthode classique.

Après, nous effectuons une interpolation, cela permet de retrouver les 5 coefficients (w_0, w_1, w_2, w_3, w_4) du polynôme produit R(z) à partir des valeurs évaluées calculées précédemment.
On résout un système d'équations linéaires : <math> R(z) = w_4 z^4 + w_3 z^3 + w_2 z^2 + w_1 z + w_0 </math>
Finalement nous pouvons recomposer notre grand entier en positionnant les coefficients w_i aux bons rangs (en les décalant) et à gérer les retenues lors de l'addition finale:
Résultat <math>= w_4 B^{4k} + w_3 B^{3k} + w_2 B^{2k} + w_1 B^k + w_0</math>

=== B) Graphique ===

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Toomcook.png|500px]]
<div><b>Karatsuba</b></div>
</div>
<div style="max-width:800px;">
<p>Nous avons réutilisé le graphique précédant, cela nous permettra de comparer Toom-Cook avec les autres algorithmes.</p>
<p>On remarque que Toom-Cook 3 est plus performant que karatsuba et ainsi que la multiplication classique.</p>
<p>Toom-cook est par conséquent un algorithme qui repousse encore une fois la complexité minimum du produit d’entiers.</p>
</div>
</div>

== 5) La transformée de Fourier rapide ==

=== A) Fonctionnement ===

La transformation de Fourier rapide étant plus complexe que les autres algorithmes, nous allons essayer d'expliquer son fonctionnement malgré ne pas avoir réussi à l'implémenter.

Il faut comprendre que cet algorithme va considérer les facteurs comme des polynômes.

D'après le théorème de l'unisolvance, il n'existe qu'un seul polynôme de degré inférieur ou égal à <math> n </math> défini par <math>n + 1</math> points distincts. Cela implique non seulement que nous pouvons représenter chaque entier par un polynôme, mais également que si nous pouvons retrouver <math>n + m + 1</math> points (avec <math>n</math> et <math>m</math> la longueur des facteurs) du polynômes issue du produit entre deux facteurs, nous pourrons le retrouver.

Soit un entier quelconque, de forme :

<math>a_n a_{n-1} (...) a_1 a_0</math>

Avec <math>a_i</math>, un chiffre composant le nombre en base 10, qui vaut en réalité dans le nombre : <math>a_i \times 10^i</math>. On peut ainsi l'écrire sous la forme :

<math> P(x) = a_0 + a_1x + a_2x^2 + \dots + a_{n-1}x^{n-1} + a_nx^n </math>

Avec <math>x = 10</math> car nous sommes en base 10, nous obtenons :

<math>P(10) = a_0 + a_1 \times 10 + \dots + a_{n-1}10^{n-1} + a_n10^n </math>

Nous venons ainsi d'écrire notre nombre sous la forme d'un polynôme unique. Pour nous permettre d'évaluer en un nombre suffisant de points, nous allons devoir ajouter des 0 pour la récursion. Il nous faudra ajouter assez de 0 pour atteindre la prochaine puissance de 2 qui sera supérieure ou égale à <math>2n + 1</math>. L'ajout de 0 ne change pas le nombre car <math>0 \times x^n</math> n'ajoute pas de coefficient.

Cet algorithme est récursif et va segmenter en deux parties nos polynômes à chaque récursion. D'un coté les indice pairs et d'un coté les impaires.

Ainsi prenons les nombres 1234 et 5678, ces nombres sont respectivement représentés par les polynômes <math> P(x) = 4 + 3x + 2x^2 + x^3 </math> et <math> P(x) = 8 + 7x + 6x^2 + 5^3 </math>. Ce sont des polynômes de degré 3, ainsi leur produit donnera lieu à un polynôme de degré 6. Il nous faudra donc au minimum 7 points d'évaluation pour retrouve ce produit. De ce fait, en les représentant de la manière suivante :

<math>[4, 3, 2, 1, 0, 0, 0, 0]</math>
<math>[8, 7, 6, 5, 0, 0, 0, 0]</math>

Nous aurons assez de récursions possible pour les évaluer en un nombre suffisant de points différents car nous auront 3 récursions à faire pour atteindre notre cas de base. A chaque récursion, nous allons diviser nos polynômes en deux parties ce qui nous fait 8 feuilles à la dernière récursion.

En effet à chaque étape de la récursion nous allons séparer nos polynômes en deux tel que :

<math>P(x)=P_{\text{pair}}(x^2) + x \cdot P_{\text{impair}}(x^2)</math>

Durant les récursions, nous segmentons les polynômes mais ne les évaluons pas. C'est à la remonté des récursions que nous allons réellement évaluer nos polynômes. Lorsque l'on atteint notre cas de base, c'est à dire des polynômes de degré 0, nous remarquons qu'ils sont constants, nous n'avons donc pas besoin de les évaluer. En effet, peut importe le point en lequel nous voudrons l'évaluer, le polynôme renverra la constante. Nous la renvoyons donc seule.
Ensuite commence la remontée des récursions. A l'étape 1 de notre remontée nous allons reformer le polynôme précédemment séparé pour obtenir un polynôme de degré 1. Puis, nous évaluons ce polynôme avec les racines seconde de l'unité. Nous faisons à nouveau remonté les évaluations et recombinons à nouveau le polynôme qui sera ainsi de degré 2.
Nous l'évaluons maintenant avec les racines 4eme de l'unité. A chaque évaluation, nous réutilisons les résultats précédents, cela nous est permit par les racines de l'unité qui ont une structure récursive exploitable.

Finalement, nous arrivons à la fin de notre FFT, avec une représentation fréquentielle de la forme :

<math> [P(W_0), P(W_1), (...), P(W_n-1), P(W_n)] </math>

Cette représentation fréquentielle n'est autre que les évaluations du polynôme P aux racines nièmes de l'unité. Nous avons donc maintenant au minimum <math>2n+1</math> évaluations des polynômes facteurs. Il nous faut maintenant trouver les évaluations du produit final, c'est à dire les évaluations concernant le polynôme qui sera issue de la multiplication. On pourra ainsi le retrouver.

Soit <math>C</math> un polynome tel que <math> C = A \times B </math>, alors on a :

<math> C(x) = A(x) \times B(x) </math>

Ainsi on en déduit que <math> C(W_n^k) = A(W_n^k) \times B(W_n^k) </math>

On comprend donc que <math>FFT(C) = FFT(A) \times FFT(B)</math>

Il faut préciser que l'on fait le produit de FFT(A) et FFT(B) terme à terme, soit évaluation par évaluation.

Une fois en possession de <math>FFT(C)</math>, qui n'est autre que l'évaluation de notre polynôme final en un nombre suffisant de points pour le retrouver, nous pouvons faire l'<math>IFFT(FFT(C))</math>, qui va nous permettre de retrouver les coefficients de notre polynôme en faisant l'exacte inverse de la FFT.

Une fois les coefficients retrouvés, il nous suffit de gérer les retenues, et nous retrouvons un entier de la forme : <math>a_0 a_1 (...) a_{n-1} a_n</math>

=== B) Graphique ===

Intéressons nous maintenant à la complexité de l'algorithme utilisant la transformée de Fourier rapide. On sait que l'algorithme passe par 5 étapes importantes :

<ul>
<li>Etape 1 : Ecrire les deux facteurs sous la forme de polynômes</li>
<li>Etape 2 : Effectuer la <math>FFT</math> des deux polynômes</li>
<li>Etape 3 : Faire le produit terme à terme des <math>FFT</math> obtenues</li>
<li>Etape 4 : Faire l'<math>IFFT</math> du produit</li>
<li>Etape 5 : Gérer les retenues et écrire le nombre qui en découle</li>
</ul>

Or, parmi toutes ces étapes, certaines sont négligeable comme l'étape 1 et 5.

Pour connaitre la complexité de l'algorithme, additionnons les complexités des étapes restantes :

Une <math>FFT</math> a une complexité de <math>\mathcal{O}(n\times logn)</math> car elle fait <math>n</math> évaluation sur <math> log(n)</math> récursions. Dans le cadre de notre algorithme, nous devons faire la <math>FFT</math> de nos deux facteurs. Soit <math>2\times \mathcal{O}(n\times logn)</math>.

Pour le produit terme à terme, nous faisons naturellement <math>n</math> opérations.

Pour finir, l'<math>IFFT</math> a la même complexité que la <math>FFT</math>. Dans le cadre de notre algorithme nous l'emploierons qu'une seule fois, ce qui fait une complexité de <math>\mathcal{O}(n\times logn)</math>.

Après addition de toutes ces complexités, nous obtenons la complexité réelle de <math>3\mathcal{O}(n\times logn) + \mathcal{O}(n)</math>.

D'après le Master Theorem, nous avons donc <math> f(n) = 3(n\times logn)+n </math>, cherchons <math>f(n)\in\mathcal{O}(g(n))</math> :

Nous pouvons ignorer les expressions linéaires ainsi que les constantes multiplicatrices, nous obtenons donc <math>\mathcal{O}(g(n)) = \mathcal{O}(n \times log n)</math>.

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:30px; text-align:center;">
[[Fichier:FFT complexite.png|500px]]
<div><b>Graphiques des complexités</b></div>
</div>
<div style="max-width:800px;">
<p>Ce graphique ci-contre ne provient pas du fruit de nos recherches personnelles mais illustre bien la comparaison entre la complexité de la FFT et des autres algorithmes.</p>
<p>On remarque que la FFT est très efficace et devance de loin les autres algorithmes en terme de complexité. </p>
<p>Les algorithmes les plus efficaces pour calculer le produit de grands entiers reposent aujourd'hui sur des variantes de la transformée de Fourier rapide.</p>
</div>
</div>

= II - Produit de matrices =

== 1.1) naïve ==

La multiplication naïve de matrice requiert d'avoir des tailles de lignes/colonne semblable, ensuite pour chaque membre de la matrice résultat, on doit multiplier les composantes ligne de la première matrice par les composantes colonne de la deuxième et le tout sommé.

On en déduit la formule suivante:
<math>C_{i,j} = \sum_{k=1}^{n} (A_{i,k} \times B_{k,j})</math>

Et visuellement:

[[Fichier:Matricenaive.jpeg]]

On a donc un algorithme d'ordre de complexité <math>\mathcal{O}(g(n))</math>

== 1.2) naïve récursive ==

Dans un premier temps on doit découper nos deux matrices en quatres sous matrices de plus petite taille.
<math>A = \begin{pmatrix} A_{11} & A_{12} \ A_{21} & A_{22} \end{pmatrix}</math>
<math>B = \begin{pmatrix} B_{11} & B_{12} \ B_{21} & B_{22} \end{pmatrix}</math>

Ensuite on vient calculer la matrice résultat.
<math>C_{11} = (A_{11} \times B_{11}) + (A_{12} \times B_{21})</math>
<math>C_{12} = (A_{11} \times B_{12}) + (A_{12} \times B_{22})</math>
<math>C_{21} = (A_{21} \times B_{11}) + (A_{22} \times B_{21})</math>
<math>C_{22} = (A_{21} \times B_{12}) + (A_{22} \times B_{22})</math>

Le côté récursif est utile que pour les matrices de tailles <= 32 (32 valeurs stockées dedans),
si on est au dessus de cette taille alors on divisera à nouveau nos matrices en quatres.
On aura 8 multiplications mais de plus petite taille au final.

== 2) strassen ==

=== A) Fonctionnement ===

Strassen consiste à définir 7 produits intermédiaires qui, par des jeux de sommes et de différences, permettent de reconstruire les quadrants de la matrice résultante. On passe ainsi d'une complexité de O(n^3) à environ O(n^2.81)

=== B) Graphique ===

On voit bien la différence de complexité sur la multiplication de grande matrice entre l'approche naïve et l'approche récursive qui est beaucoup plus rapide.

[[Fichier:Analyse matrices.png]]

= Conclusion =

L'étude de ces algorithmes de multiplication nous a clairement montré l'évolution de la complexité algorithmique permettant de gagner en efficacité lorsque la taille des données augmente.

La multiplication classiqe, en <math> \mathcal{O}(n^2) </math>, résulte d'une approche naïve qui devient rapidement inefficace pour les grands entiers ou les grandes matrices. L'algorithme de Karatsuba nous montre qu'organiser de manière intelligente ses calculs algébrique permet parfois de gagner beaucoup de multiplications, et donc de temps. Nous avons ainsi réussi à passer d'une complexité de <math>\mathcal{O}(n^2)</math> à <math> \mathcal{O}(n^{log_2(3)}) </math>, soit environ <math>\mathcal{O}(n^{1/585})</math>.

Des méthodes encore plus avancées comme utilise l'algorithme de Toom-Cook-3 continue dans cette idées de divisions d'entiers en blocs plus petits, tandis que la transformée de Fourier rapide change complètement de point de vue. En effet la FFT n'utilise pas la représentation classique des entiers mais fait appel à une vision polynomiale, ce qui transforme la convolution classique en multiplication terme à terme, ce qui lui permet d'atteindre une complexité de <math>\mathcal{O}(n \times log n)</math>.

Dans le cas des matrices, les mêmes logiques apparaissent comme par exemple avec l'algorithme de Strassen qui se rapproche très fortement de Karatsuba en combinant de manière astucieuse les parties d'entiers qui avaient été précédemment découpée.

On remarque néanmoins que la majorité des algorithmes efficaces s'orientent vers une approche récursive et non itérative. Néanmoins, nous avons pu trouver certaines de ces implémentations (comme par exemple la FFT) en itérative.

Avec ces recherches, nous comprenons que la réorganisations des calculs algébriques peuvent aider à gagner en complexité mais que pour faire de réels progrès, il nous faudra surement changer notre point de vue une nouvelle fois, et aborder le problème sous un angle nouveau comme le font dors et déjà les algorithmes les plus performants.

= Mentions =

Le premier gif est le résultat du travail de 'Walké', licence ci-contre : https://fr.wikipedia.org/wiki/Fichier:Addition.gif

Utilisation du site de production graphique "Desmos" : https://www.desmos.com/calculator?lang=fr

= Sources =

Pour karatsuba :
<ul>
<li> https://www.youtube.com/watch?v=PZ2gdWdKHAA </li>
</ul>

Pour mieux comprendre la FFT, nous avons utilisé plusieurs sources d'informations :
<ul>
<li> https://www.youtube.com/watch?v=h7apO7q16V0&list=WL&index=1&t=886s </li>
<li> https://fr.wikipedia.org/wiki/Interpolation_polynomiale </li>
</ul>

Algorithmes de multiplications d'entiers et de matrices

2026-05-11T21:27:33Z

Mangala : /* Conclusion */

= Introduction =

Depuis l'apparition des ordinateurs modernes, une quantité faramineuse de calculs a dû être effectuée. Les progressions technologiques nous poussent à envisager la puissance de calcul comme une ressource qu'il faut optimiser dans les moindres détails. C'est ainsi que l'optimisation des algorithmes de calcul est devenue cruciale, surtout lorsqu'il nous faut effectuer des opérations sur de très grands entiers par exemple.

= Objectif =

L'objectif majeur de ce projet est de comprendre de manière plus approfondie ce qu'est la '''complexité algorithmique'''.
Pour atteindre cet objectif, nous implémenterons plusieurs algorithmes de multiplication qui auront pour but de calculer le produit de grands entiers ou de matrices.

= Point important : complexité =

=== Définition ===
La complexité d'un algorithme est la quantité des ressources qu'il utilise en fonction de la taille des entrées qu'on lui demande de traiter. On peut par exemple se concentrer sur le temps qu'un algorithme prend pour renvoyer un résultat ou sur la mémoire dont il a besoin. Dans le cadre de notre projet, nous nous attarderons plus particulièrement sur la quantité de calcul effectuée en fonction de la taille des entrées, ce qui est par ailleurs étroitement liée à la notion de temps. De manière générale, plus un algorithme doit faire de calcul, plus il est lent. (Attention, toutes les opérations arithmétiques de base ne se valent pas)

De manière plus familière, on dira que la complexité d'un algorithme pourrait s'apparenter à son comportement lorsqu'il doit traiter des données plus ou moins grandes.
Chaque algorithme a une complexité, et on l'exprime par une fonction qui adopte un comportement similaire au nombre de calculs nécessaires en fonction de la taille des entrées.

=== Notation ===
La complexité réelle d'un algorithme peut être décrite par une fonction <math> f(n) </math> représentant le nombre d'opérations effectuées en fonction de la taille <math>n</math> des données d'entrée.

Cependant, afin de simplifier l'étude de cette croissance, on utilise généralement une borne asymptotique notée <math>\mathcal{O}(g(n))</math>, où <math>g(n)</math> est une fonction ayant le même ordre de grandeur que <math>f(n)</math> lorsque <math>n</math> devient grand.

On dit alors que :

<math>
f(n)\in\mathcal{O}(g(n))
</math>

si et seulement s'il existe une constante <math>C>0</math> et un entier <math>n_0</math> tels que :

<math>
\forall n\ge n_0,\ f(n)\le Cg(n)
</math>

Cette notation <math>\mathcal{O}(g(n))</math> permettra de comparer beaucoup plus facilement les algorithmes entre eux.

=== Master Theorem ===

Afin de déterminer la complexité de certains algorithmes récursifs, nous utiliserons le "Master Theorem".

Ce théorème permet d'obtenir directement l'ordre de grandeur de nombreuses relations de récurrence apparaissant dans l'analyse d'algorithmes de type « diviser pour régner », comme l'algorithme de Karatsuba ou celui de Strassen.

La démonstration complète de ce théorème dépasse le cadre de notre projet et nécessite des connaissances mathématiques plus avancées. Nous l'utiliserons donc principalement comme un outil nous permettant de déterminer efficacement la complexité asymptotique des algorithmes étudiés.

=== Graphiques ===

Les complexités étant des fonctions, nous pouvons les représenter par un graphique qui affichera le temps d'exécution (ou nombre d'opérations) en fonction de la taille des entrées.

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:30px; text-align:center;">
[[Fichier:complexite.webp|500px]]
<div><b>Graphiques des complexités</b></div>
</div>
<div style="max-width:800px;">
<p>Ce graphique ci-contre compare les complexités en fonction de la taille des d'entrées.</p>
<p>On comprend ainsi que certaines complexités ne sont pas raisonnable dans la cadre de la multiplication de grands entiers.</p>
<p>C'est pourquoi l'étude de ces algorithmes s'avère nécessaire.</p>
</div>
</div>

=== Exemple ===
L'algorithme naïf d'addition que nous avons tous appris à l'école a une complexité de <math>\mathcal{O}(n)</math>.
Soit n la taille des nombres en entrée, l'algorithme doit faire environ n addition pour arriver au résultat demandé.

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Addition.gif|220px]]
<div><b>Addition naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Comme le montre l'exemple ci-contre, 786 et 467 font 3 chiffres de long donc n sera de 3.</p>
<p>Il nous faudra 3 opérations pour additionner ces entiers.</p>
<p>C'est ainsi qu'avec une taille d'entrée n, l'algorithme de l'addition naïve va devoir faire n opérations.</p>
<p>Cet algorithme a donc une complexité <math>f(n) = n</math> qui n'a pas besoin d'être approximée.</p>
<p>Ainsi sa complexité finale sera <math>\mathcal{O}(n)</math>.</p>
</div>
</div>

= Problématique =

Le calcul du produit de deux entiers de manière naïve a une complexité de <math> \mathcal{O}(n^2)</math>, et celui de deux matrices une complexité de <math> \mathcal{O}(n^3)</math>. Afin de mieux comprendre ce qu'est la complexité algorithmique, nous devrons implémenter des algorithmes ayant le même objectif, mais étant plus efficaces. Ces algorithmes s'avèreront plus complexes mais devrait aboutir à un calcul plus rapide du produit demandé.

Nous séparerons notre wiki en deux grandes parties, la première concernera nos recherche sur [[#I - Produit d'entiers|la multiplication d'entiers]], la deuxième sur [[#II - Produit de matrices|la multiplication de matrices]].

= I - Produit d'entiers =

Notre départ commence avec l'algorithme de multiplication d'entier naïf.
En effet il s'agit de l'algorithme de multiplication le plus connu, et nous l'utiliserons comme référence pour le comparer aux futurs algorithmes plus efficaces.
Intéressons nous à sa complexité.

== 1) Nos implémentations des grands entiers ==

Qui dit produit de grands entiers dit implémentation de grands entiers.

Dans le cadre de nos recherches, nous allons devoir implémenter des algorithmes qui vont manipuler des grands entiers.

Nous avons donc choisi de créer deux représentations différentes de ceux-ci (car nous travaillons sur différents langages de programmation), nous permettant à la fois une implémentation simplifié, mais aussi de nous rapprocher d'une implémentation bas niveau.

=== A) En python ===
En python, l'utilisation des "bytes" m'a grandement servi à comprendre comment les entiers étaient manipulés à bas niveau. En effet, un des objectifs secondaires de nos recherches était de manipuler des entiers directement avec leur formes stockées sur l'ordinateur, et non pas avec des int python.
En effet l'utilisation des int python nous aurait permit de passer les étapes de retenues, de signes... D'autant plus que les bytes permettent de stocker un nombre en base 256, ce qui permet de visualiser plus facilement les grands entiers.

La forme finale de la représentation des grands entiers en python sera donc la suivante :

[ signe , bytes , bytes , (...) , bytes ]

Le signe est représenté par un entier, 1 si le nombre est positif, 0 sinon.
Cette configuration rendra plus simple la gestion des signes.

=== B) En C++ ===

En C++, pour avoir une représentation de grand entiers j'ai du définir ma propre structure pour m'affranchir de la limite de taille imposé par les entiers standards: (int32 ou int64). Pour cela, j'ai une structure qui possède l'équivalent d'un array de byte (ce qui nous permet d'être en base 256 au lieu de la base 10 habituelle), et pour traiter le signe j'utilise un booléen, ainsi en mémoire j'ai une structure de n*Octets + 1 octet en taille.

[ bytes , bytes , (...) , bytes ] [ signe ]

Le booléen prend 1 octet de place mais ne touche pas aux octets qui encode le grand entier.
Cette configuration rendra plus simple la gestion des signes dans le cadre des multiplication.

== 2) La multiplication naïve ==

=== A) Fonctionnement ===
Dans le cas de la multiplication d'entiers, nous allons prendre deux nombres qui n'ont pas nécessairement la même longueur. Soit les nombre a et b, de longueur respective <math> n </math> et <math> m </math>.
<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Multiplication.png|220px]]
<div><b>Multiplication naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Prenons deux nombres de longueur 3 et 2, et cherchons combien d'opérations l'algorithme de multiplication naïve va devoir faire pour nous renvoyer leur produit.</p>
<p>Dans un premier temps, on remarque que l'on va devoir multiplier chaque chiffre du nombre du haut par le chiffre des unités du bas, qui est 6. Cela va représenter <math>n</math> opérations. (6x5, 6x1 et 6x4)</p>
<p>Dans un deuxième temps nous constatons que nous allons devoir faire la même chose avec le chiffre des dizaines du nombre du bas. Cela nous ajoute de nouveau <math>n</math> opérations.</p>
<p>On arrive assez facilement à la conclusion que pour faire notre produit, il va nous falloir faire <math>n</math> fois <math>m</math> opérations.</p>
</div>
</div>

Ainsi, la complexité de la multiplication naïve est <math>\mathcal{O}(n^2)</math>.
Il est en de même avec la multiplication naïve récursive.

=== B) Graphique ===
Montrons maintenant sa courbe sur un graphique :

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Multiplicationnaive.png|500px]]
<div><b>Multiplication naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Les points noirs sont des repères pour que les autres courbes aient une forme cohérente.</p>
<p>Ils sont tous sur l'axe des abscisses.</p>
<p>La courbe rouge représente la complexité de la multiplication naïve.</p>
<p>On remarque que la courbe a un visuel très similaire à la fonction <math> f(x) = x^2 </math> </p>
</div>
</div>

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Naif_recursif.png|500px]]
<div><b>Multiplication naïve récursive</b></div>
</div>
<div style="max-width:800px;">
<p>Cette courbe rouge représente la complexité de la multiplication naïve récursive.</p>
<p>Elle sera utilisé pour comparer les complexités entre algorithmes car, comme tous récursifs, elle a été codé avec les mêmes biais d'implémentation qu'eux.</p>
<p>Théoriquement les deux courbes ci-contre ont la même complexité, mais encore une fois, notre implémentation n'est pas parfaitement optimale et donc ne respecte pas de manière minutieuse le Master Theorem.</p>
</div>
</div>

== 3) La multiplication karatsuba ==

=== A) Fonctionnement ===

L'algorithme de karatsuba est un algorithme récursif de type diviser pour régner.

L'idée générale de l'algorithme est de passer de 4 multiplication à 3. En effet ces opérations étant moins couteuses, il est préférable d'en ajouter si cela permet d'enlever des multiplications.

L'algorithme de multiplication naif récursif utilise la segmentation des facteurs en deux de manière successive.

Soit <math> x </math> et <math>y</math> deux facteurs, nous avons les égalités suivantes :

<div style="font-size: 15px;">
<math>x = a \times B^{n/2} + b</math>
<math>y = c \times B^{n/2} + d</math>
</div>

Avec <math>a</math> et <math>c</math> les premières moitiés des facteurs <math>x</math> et <math>y</math>,
et <math> b </math> et <math>d</math> les dernières moitiés de ces facteurs ainsi que <math>B</math> la base d'écriture du nombre (Nous sommes en base 256 avec les bytes).

Cette présentation des deux facteurs de notre multiplication n'est que la résultante d'un découpage.
Le [[#Master Theorem|Master Theorem]] nous montre que :

<div style="font-size: 15px;">
<math>T(n) = 4T(n/2) + O(n)</math>
</div>

Puisque nous avons après découpage 4 entiers de longueur <math>n/2</math>.

Ainsi, ce découpage ne permet pas de gagner du temps d'après le [[#Master Theorem|Master Theorem]].

Cependant, l'algorithme de Karatsuba réutilise ce principe en le modifiant, ce qui nous permet de baisser la complexité globale de la multiplication dans son entièreté.

Avec l'écriture ci-dessus des nombres <math>x</math> et <math>y</math>, on peut facilement en déduire l'égalité suivante :

<div style="font-size: 15px;">
<math>x \times y = (ac) \times B^n + (ad + bc) \times B^{n/2} + bd</math>
</div>

On remarque 4 multiplications longues à faire dans cette expression. Les multiplications dont <math>B</math> est l'un des facteurs sont très rapides puisqu'il s'agit de la base dans laquelle nous travaillons. De cela en résulte un décalage plutôt qu'un vrai calcul à faire.

Karatsuba développe une partie de cette expression pour pouvoir négocier une multiplication au prix d'additions et soustractions.

En effet, nous savons déjà que :

<div style="font-size: 15px;">
<math>(a + b)(c + d) = ac + ad + bc + bd</math>
</div>

En manipulant l'égalité nous obtenons :

<div style="font-size: 15px;">
<math>ad + bc = (a + b)(c + d) - ac - bd</math>
</div>

ac et bd ayant déjà été calculé précédemment, il nous reste uniquement la multiplication <math>(a + b)(c + d)</math>.

Nous venons ainsi de calculer <math>ad + bc</math> en seulement une multiplication. C'est la que repose le gain de temps de la méthode Karatsuba par rapport à la multiplication naïve.

En effet, l'algorithme n'effectuera alors plus que 3 multiplications :
<div style="font-size: 15px;">
<math>ac</math>
<math>bd</math>
<math>(a + b)(c + d)</math>
</div>

La relation de récurrence devient donc :
<div style="font-size: 15px;">
<math>T(n)=3T(n/2)+O(n)</math>
</div>

Et le Master Theorem nous dit que :
<div style="font-size: 15px;">
<math>T(n)\in O(n^{\log_2(3)})</math>
</div>

Or <math>\log_2(3)\approx 1.585</math>, donc la complexité de l'algorithme de Karatsuba est de <math> \mathcal{O}(n^{1.585})</math>. Ce qui est bien plus efficace que la multiplication classique, surtout lorsque les facteurs deviennent très grands.

=== B) Graphique ===
<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Karatsuba.png|500px]]
<div><b>Karatsuba</b></div>
</div>
<div style="max-width:800px;">
<p>Sur le graphique ci-contre nous avons utilisé la courbe de la multiplication naïve récursive (rouge) à titre de comparaison.</p>
<p>On remarque graphiquement que Karatsuba (jaune) prend moins de temps à chaque calcul de produit.</p>
<p>On en déduit donc expérimentalement que Karatsuba à une meilleure complexité que la multiplication naïve.</p>
<p>Ainsi nous vérifions donc ce que le Master Theorem prouve, c'est à dire que la complexité de karatsuba est de <math> \mathcal{O}(n^{1.585})</math> </p>
</div>
</div>

== 4) La multiplication toom-cook-3 ==

=== A) Fonctionnement ===

L'objectif est de diviser les grands entiers X et Y en trois blocs de taille égale k.
On les traite alors comme des polynômes de degré 2:

<math> P(z) = X_2 \cdot z^2 + X_1 \cdot z + X_0 </math>
<math> Q(z) = Y_2 \cdot z^2 + Y_1 \cdot z + Y_0 </math>

On choisit 5 points distincts pour évaluer nos polynômes.
Ce choix de 5 points est crucial car le produit de deux polynômes de degré 2 est un polynôme de degré 4, qui nécessite 5 points pour être défini.
Les points standards sont :

P(0) = X0
P(1) = X0 + X1 + X2
P(-1) = X0 - X1 + X2
P(2) = X0 + 2*X1 + 4*X2
P(inf) = X2

(On procède de manière similaire pour Q.)

Ensuite nous multiplions récursivement chaque points de P et de Q ensemble.
On effectue ainsi 5 multiplications de nombres plus petits au lieu des 9 multiplications requises par la méthode classique.

Après, nous effectuons une interpolation, cela permet de retrouver les 5 coefficients (w_0, w_1, w_2, w_3, w_4) du polynôme produit R(z) à partir des valeurs évaluées calculées précédemment.
On résout un système d'équations linéaires : <math> R(z) = w_4 z^4 + w_3 z^3 + w_2 z^2 + w_1 z + w_0 </math>
Finalement nous pouvons recomposer notre grand entier en positionnant les coefficients w_i aux bons rangs (en les décalant) et à gérer les retenues lors de l'addition finale:
Résultat <math>= w_4 B^{4k} + w_3 B^{3k} + w_2 B^{2k} + w_1 B^k + w_0</math>

=== B) Graphique ===

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Toomcook.png|500px]]
<div><b>Karatsuba</b></div>
</div>
<div style="max-width:800px;">
<p>on a reprit multi récursive (rouge)</p>
<p>on voit que Toom (vert) en dessous de karatsuba (jaune) en dessous de multi classique (rouge)</p>
<p>meilleur complexité</p>
</div>
</div>

== 5) La transformée de Fourier rapide ==

=== A) Fonctionnement ===

La transformation de Fourier rapide étant plus complexe que les autres algorithmes, nous allons essayer d'expliquer son fonctionnement malgré ne pas avoir réussi à l'implémenter.

Il faut comprendre que cet algorithme va considérer les facteurs comme des polynômes.

D'après le théorème de l'unisolvance, il n'existe qu'un seul polynôme de degré inférieur ou égal à <math> n </math> défini par <math>n + 1</math> points distincts. Cela implique non seulement que nous pouvons représenter chaque entier par un polynôme, mais également que si nous pouvons retrouver <math>n + m + 1</math> points (avec <math>n</math> et <math>m</math> la longueur des facteurs) du polynômes issue du produit entre deux facteurs, nous pourrons le retrouver.

Soit un entier quelconque, de forme :

<math>a_n a_{n-1} (...) a_1 a_0</math>

Avec <math>a_i</math>, un chiffre composant le nombre en base 10, qui vaut en réalité dans le nombre : <math>a_i \times 10^i</math>. On peut ainsi l'écrire sous la forme :

<math> P(x) = a_0 + a_1x + a_2x^2 + \dots + a_{n-1}x^{n-1} + a_nx^n </math>

Avec <math>x = 10</math> car nous sommes en base 10, nous obtenons :

<math>P(10) = a_0 + a_1 \times 10 + \dots + a_{n-1}10^{n-1} + a_n10^n </math>

Nous venons ainsi d'écrire notre nombre sous la forme d'un polynôme unique. Pour nous permettre d'évaluer en un nombre suffisant de points, nous allons devoir ajouter des 0 pour la récursion. Il nous faudra ajouter assez de 0 pour atteindre la prochaine puissance de 2 qui sera supérieure ou égale à <math>2n + 1</math>. L'ajout de 0 ne change pas le nombre car <math>0 \times x^n</math> n'ajoute pas de coefficient.

Cet algorithme est récursif et va segmenter en deux parties nos polynômes à chaque récursion. D'un coté les indice pairs et d'un coté les impaires.

Ainsi prenons les nombres 1234 et 5678, ces nombres sont respectivement représentés par les polynômes <math> P(x) = 4 + 3x + 2x^2 + x^3 </math> et <math> P(x) = 8 + 7x + 6x^2 + 5^3 </math>. Ce sont des polynômes de degré 3, ainsi leur produit donnera lieu à un polynôme de degré 6. Il nous faudra donc au minimum 7 points d'évaluation pour retrouve ce produit. De ce fait, en les représentant de la manière suivante :

<math>[4, 3, 2, 1, 0, 0, 0, 0]</math>
<math>[8, 7, 6, 5, 0, 0, 0, 0]</math>

Nous aurons assez de récursions possible pour les évaluer en un nombre suffisant de points différents car nous auront 3 récursions à faire pour atteindre notre cas de base. A chaque récursion, nous allons diviser nos polynômes en deux parties ce qui nous fait 8 feuilles à la dernière récursion.

En effet à chaque étape de la récursion nous allons séparer nos polynômes en deux tel que :

<math>P(x)=P_{\text{pair}}(x^2) + x \cdot P_{\text{impair}}(x^2)</math>

Durant les récursions, nous segmentons les polynômes mais ne les évaluons pas. C'est à la remonté des récursions que nous allons réellement évaluer nos polynômes. Lorsque l'on atteint notre cas de base, c'est à dire des polynômes de degré 0, nous remarquons qu'ils sont constants, nous n'avons donc pas besoin de les évaluer. En effet, peut importe le point en lequel nous voudrons l'évaluer, le polynôme renverra la constante. Nous la renvoyons donc seule.
Ensuite commence la remontée des récursions. A l'étape 1 de notre remontée nous allons reformer le polynôme précédemment séparé pour obtenir un polynôme de degré 1. Puis, nous évaluons ce polynôme avec les racines seconde de l'unité. Nous faisons à nouveau remonté les évaluations et recombinons à nouveau le polynôme qui sera ainsi de degré 2.
Nous l'évaluons maintenant avec les racines 4eme de l'unité. A chaque évaluation, nous réutilisons les résultats précédents, cela nous est permit par les racines de l'unité qui ont une structure récursive exploitable.

Finalement, nous arrivons à la fin de notre FFT, avec une représentation fréquentielle de la forme :

<math> [P(W_0), P(W_1), (...), P(W_n-1), P(W_n)] </math>

Cette représentation fréquentielle n'est autre que les évaluations du polynôme P aux racines nièmes de l'unité. Nous avons donc maintenant au minimum <math>2n+1</math> évaluations des polynômes facteurs. Il nous faut maintenant trouver les évaluations du produit final, c'est à dire les évaluations concernant le polynôme qui sera issue de la multiplication. On pourra ainsi le retrouver.

Soit <math>C</math> un polynome tel que <math> C = A \times B </math>, alors on a :

<math> C(x) = A(x) \times B(x) </math>

Ainsi on en déduit que <math> C(W_n^k) = A(W_n^k) \times B(W_n^k) </math>

On comprend donc que <math>FFT(C) = FFT(A) \times FFT(B)</math>

Il faut préciser que l'on fait le produit de FFT(A) et FFT(B) terme à terme, soit évaluation par évaluation.

Une fois en possession de <math>FFT(C)</math>, qui n'est autre que l'évaluation de notre polynôme final en un nombre suffisant de points pour le retrouver, nous pouvons faire l'<math>IFFT(FFT(C))</math>, qui va nous permettre de retrouver les coefficients de notre polynôme en faisant l'exacte inverse de la FFT.

Une fois les coefficients retrouvés, il nous suffit de gérer les retenues, et nous retrouvons un entier de la forme : <math>a_0 a_1 (...) a_{n-1} a_n</math>

=== B) Graphique ===

Intéressons nous maintenant à la complexité de l'algorithme utilisant la transformée de Fourier rapide. On sait que l'algorithme passe par 5 étapes importantes :

<ul>
<li>Etape 1 : Ecrire les deux facteurs sous la forme de polynômes</li>
<li>Etape 2 : Effectuer la <math>FFT</math> des deux polynômes</li>
<li>Etape 3 : Faire le produit terme à terme des <math>FFT</math> obtenues</li>
<li>Etape 4 : Faire l'<math>IFFT</math> du produit</li>
<li>Etape 5 : Gérer les retenues et écrire le nombre qui en découle</li>
</ul>

Or, parmi toutes ces étapes, certaines sont négligeable comme l'étape 1 et 5.

Pour connaitre la complexité de l'algorithme, additionnons les complexités des étapes restantes :

Une <math>FFT</math> a une complexité de <math>\mathcal{O}(n\times logn)</math> car elle fait <math>n</math> évaluation sur <math> log(n)</math> récursions. Dans le cadre de notre algorithme, nous devons faire la <math>FFT</math> de nos deux facteurs. Soit <math>2\times \mathcal{O}(n\times logn)</math>.

Pour le produit terme à terme, nous faisons naturellement <math>n</math> opérations.

Pour finir, l'<math>IFFT</math> a la même complexité que la <math>FFT</math>. Dans le cadre de notre algorithme nous l'emploierons qu'une seule fois, ce qui fait une complexité de <math>\mathcal{O}(n\times logn)</math>.

Après addition de toutes ces complexités, nous obtenons la complexité réelle de <math>3\mathcal{O}(n\times logn) + \mathcal{O}(n)</math>.

D'après le Master Theorem, nous avons donc <math> f(n) = 3(n\times logn)+n </math>, cherchons <math>f(n)\in\mathcal{O}(g(n))</math> :

Nous pouvons ignorer les expressions linéaires ainsi que les constantes multiplicatrices, nous obtenons donc <math>\mathcal{O}(g(n)) = \mathcal{O}(n \times log n)</math>.

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:30px; text-align:center;">
[[Fichier:FFT complexite.png|500px]]
<div><b>Graphiques des complexités</b></div>
</div>
<div style="max-width:800px;">
<p>Ce graphique ci-contre ne provient pas du fruit de nos recherches personnelles mais illustre bien la comparaison entre la complexité de la FFT et des autres algorithmes.</p>
<p>On remarque que la FFT est très efficace et devance de loin les autres algorithmes en terme de complexité. </p>
<p>Les algorithmes les plus efficaces pour calculer le produit de grands entiers reposent aujourd'hui sur des variantes de la transformée de Fourier rapide.</p>
</div>
</div>

= II - Produit de matrices =

== 1.1) naïve ==

La multiplication naïve de matrice requiert d'avoir des tailles de lignes/colonne semblable, ensuite pour chaque membre de la matrice résultat, on doit multiplier les composantes ligne de la première matrice par les composantes colonne de la deuxième et le tout sommé.

On en déduit la formule suivante:
<math>C_{i,j} = \sum_{k=1}^{n} (A_{i,k} \times B_{k,j})</math>

Et visuellement:

[[Fichier:Matricenaive.jpeg]]

On a donc un algorithme d'ordre de complexité <math>\mathcal{O}(g(n))</math>

== 1.2) naïve récursive ==

Dans un premier temps on doit découper nos deux matrices en quatres sous matrices de plus petite taille.
<math>A = \begin{pmatrix} A_{11} & A_{12} \ A_{21} & A_{22} \end{pmatrix}</math>
<math>B = \begin{pmatrix} B_{11} & B_{12} \ B_{21} & B_{22} \end{pmatrix}</math>

Ensuite on vient calculer la matrice résultat.
<math>C_{11} = (A_{11} \times B_{11}) + (A_{12} \times B_{21})</math>
<math>C_{12} = (A_{11} \times B_{12}) + (A_{12} \times B_{22})</math>
<math>C_{21} = (A_{21} \times B_{11}) + (A_{22} \times B_{21})</math>
<math>C_{22} = (A_{21} \times B_{12}) + (A_{22} \times B_{22})</math>

Le côté récursif est utile que pour les matrices de tailles <= 32 (32 valeurs stockées dedans),
si on est au dessus de cette taille alors on divisera à nouveau nos matrices en quatres.
On aura 8 multiplications mais de plus petite taille au final.

== 2) strassen ==

=== A) Fonctionnement ===

Strassen consiste à définir 7 produits intermédiaires qui, par des jeux de sommes et de différences, permettent de reconstruire les quadrants de la matrice résultante. On passe ainsi d'une complexité de O(n^3) à environ O(n^2.81)

=== B) Graphique ===

On voit bien la différence de complexité sur la multiplication de grande matrice entre l'approche naïve et l'approche récursive qui est beaucoup plus rapide.

[[Fichier:Analyse matrices.png]]

= Conclusion =

L'étude de ces algorithmes de multiplication nous a clairement montré l'évolution de la complexité algorithmique permettant de gagner en efficacité lorsque la taille des données augmente.

La multiplication classiqe, en <math> \mathcal{O}(n^2) </math>, résulte d'une approche naïve qui devient rapidement inefficace pour les grands entiers ou les grandes matrices. L'algorithme de Karatsuba nous montre qu'organiser de manière intelligente ses calculs algébrique permet parfois de gagner beaucoup de multiplications, et donc de temps. Nous avons ainsi réussi à passer d'une complexité de <math>\mathcal{O}(n^2)</math> à <math> \mathcal{O}(n^{log_2(3)}) </math>, soit environ <math>\mathcal{O}(n^{1/585})</math>.

Des méthodes encore plus avancées comme utilise l'algorithme de Toom-Cook-3 continue dans cette idées de divisions d'entiers en blocs plus petits, tandis que la transformée de Fourier rapide change complètement de point de vue. En effet la FFT n'utilise pas la représentation classique des entiers mais fait appel à une vision polynomiale, ce qui transforme la convolution classique en multiplication terme à terme, ce qui lui permet d'atteindre une complexité de <math>\mathcal{O}(n \times log n)</math>.

Dans le cas des matrices, les mêmes logiques apparaissent comme par exemple avec l'algorithme de Strassen qui se rapproche très fortement de Karatsuba en combinant de manière astucieuse les parties d'entiers qui avaient été précédemment découpée.

On remarque néanmoins que la majorité des algorithmes efficaces s'orientent vers une approche récursive et non itérative. Néanmoins, nous avons pu trouver certaines de ces implémentations (comme par exemple la FFT) en itérative.

Avec ces recherches, nous comprenons que la réorganisations des calculs algébriques peuvent aider à gagner en complexité mais que pour faire de réels progrès, il nous faudra surement changer notre point de vue une nouvelle fois, et aborder le problème sous un angle nouveau comme le font dors et déjà les algorithmes les plus performants.

= Mentions =

Le premier gif est le résultat du travail de 'Walké', licence ci-contre : https://fr.wikipedia.org/wiki/Fichier:Addition.gif

Utilisation du site de production graphique "Desmos" : https://www.desmos.com/calculator?lang=fr

= Sources =

Pour karatsuba :
<ul>
<li> https://www.youtube.com/watch?v=PZ2gdWdKHAA </li>
</ul>

Pour mieux comprendre la FFT, nous avons utilisé plusieurs sources d'informations :
<ul>
<li> https://www.youtube.com/watch?v=h7apO7q16V0&list=WL&index=1&t=886s </li>
<li> https://fr.wikipedia.org/wiki/Interpolation_polynomiale </li>
</ul>

Algorithmes de multiplications d'entiers et de matrices

2026-05-11T21:27:21Z

Mangala : /* Conclusion */

= Introduction =

Depuis l'apparition des ordinateurs modernes, une quantité faramineuse de calculs a dû être effectuée. Les progressions technologiques nous poussent à envisager la puissance de calcul comme une ressource qu'il faut optimiser dans les moindres détails. C'est ainsi que l'optimisation des algorithmes de calcul est devenue cruciale, surtout lorsqu'il nous faut effectuer des opérations sur de très grands entiers par exemple.

= Objectif =

L'objectif majeur de ce projet est de comprendre de manière plus approfondie ce qu'est la '''complexité algorithmique'''.
Pour atteindre cet objectif, nous implémenterons plusieurs algorithmes de multiplication qui auront pour but de calculer le produit de grands entiers ou de matrices.

= Point important : complexité =

=== Définition ===
La complexité d'un algorithme est la quantité des ressources qu'il utilise en fonction de la taille des entrées qu'on lui demande de traiter. On peut par exemple se concentrer sur le temps qu'un algorithme prend pour renvoyer un résultat ou sur la mémoire dont il a besoin. Dans le cadre de notre projet, nous nous attarderons plus particulièrement sur la quantité de calcul effectuée en fonction de la taille des entrées, ce qui est par ailleurs étroitement liée à la notion de temps. De manière générale, plus un algorithme doit faire de calcul, plus il est lent. (Attention, toutes les opérations arithmétiques de base ne se valent pas)

De manière plus familière, on dira que la complexité d'un algorithme pourrait s'apparenter à son comportement lorsqu'il doit traiter des données plus ou moins grandes.
Chaque algorithme a une complexité, et on l'exprime par une fonction qui adopte un comportement similaire au nombre de calculs nécessaires en fonction de la taille des entrées.

=== Notation ===
La complexité réelle d'un algorithme peut être décrite par une fonction <math> f(n) </math> représentant le nombre d'opérations effectuées en fonction de la taille <math>n</math> des données d'entrée.

Cependant, afin de simplifier l'étude de cette croissance, on utilise généralement une borne asymptotique notée <math>\mathcal{O}(g(n))</math>, où <math>g(n)</math> est une fonction ayant le même ordre de grandeur que <math>f(n)</math> lorsque <math>n</math> devient grand.

On dit alors que :

<math>
f(n)\in\mathcal{O}(g(n))
</math>

si et seulement s'il existe une constante <math>C>0</math> et un entier <math>n_0</math> tels que :

<math>
\forall n\ge n_0,\ f(n)\le Cg(n)
</math>

Cette notation <math>\mathcal{O}(g(n))</math> permettra de comparer beaucoup plus facilement les algorithmes entre eux.

=== Master Theorem ===

Afin de déterminer la complexité de certains algorithmes récursifs, nous utiliserons le "Master Theorem".

Ce théorème permet d'obtenir directement l'ordre de grandeur de nombreuses relations de récurrence apparaissant dans l'analyse d'algorithmes de type « diviser pour régner », comme l'algorithme de Karatsuba ou celui de Strassen.

La démonstration complète de ce théorème dépasse le cadre de notre projet et nécessite des connaissances mathématiques plus avancées. Nous l'utiliserons donc principalement comme un outil nous permettant de déterminer efficacement la complexité asymptotique des algorithmes étudiés.

=== Graphiques ===

Les complexités étant des fonctions, nous pouvons les représenter par un graphique qui affichera le temps d'exécution (ou nombre d'opérations) en fonction de la taille des entrées.

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:30px; text-align:center;">
[[Fichier:complexite.webp|500px]]
<div><b>Graphiques des complexités</b></div>
</div>
<div style="max-width:800px;">
<p>Ce graphique ci-contre compare les complexités en fonction de la taille des d'entrées.</p>
<p>On comprend ainsi que certaines complexités ne sont pas raisonnable dans la cadre de la multiplication de grands entiers.</p>
<p>C'est pourquoi l'étude de ces algorithmes s'avère nécessaire.</p>
</div>
</div>

=== Exemple ===
L'algorithme naïf d'addition que nous avons tous appris à l'école a une complexité de <math>\mathcal{O}(n)</math>.
Soit n la taille des nombres en entrée, l'algorithme doit faire environ n addition pour arriver au résultat demandé.

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Addition.gif|220px]]
<div><b>Addition naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Comme le montre l'exemple ci-contre, 786 et 467 font 3 chiffres de long donc n sera de 3.</p>
<p>Il nous faudra 3 opérations pour additionner ces entiers.</p>
<p>C'est ainsi qu'avec une taille d'entrée n, l'algorithme de l'addition naïve va devoir faire n opérations.</p>
<p>Cet algorithme a donc une complexité <math>f(n) = n</math> qui n'a pas besoin d'être approximée.</p>
<p>Ainsi sa complexité finale sera <math>\mathcal{O}(n)</math>.</p>
</div>
</div>

= Problématique =

Le calcul du produit de deux entiers de manière naïve a une complexité de <math> \mathcal{O}(n^2)</math>, et celui de deux matrices une complexité de <math> \mathcal{O}(n^3)</math>. Afin de mieux comprendre ce qu'est la complexité algorithmique, nous devrons implémenter des algorithmes ayant le même objectif, mais étant plus efficaces. Ces algorithmes s'avèreront plus complexes mais devrait aboutir à un calcul plus rapide du produit demandé.

Nous séparerons notre wiki en deux grandes parties, la première concernera nos recherche sur [[#I - Produit d'entiers|la multiplication d'entiers]], la deuxième sur [[#II - Produit de matrices|la multiplication de matrices]].

= I - Produit d'entiers =

Notre départ commence avec l'algorithme de multiplication d'entier naïf.
En effet il s'agit de l'algorithme de multiplication le plus connu, et nous l'utiliserons comme référence pour le comparer aux futurs algorithmes plus efficaces.
Intéressons nous à sa complexité.

== 1) Nos implémentations des grands entiers ==

Qui dit produit de grands entiers dit implémentation de grands entiers.

Dans le cadre de nos recherches, nous allons devoir implémenter des algorithmes qui vont manipuler des grands entiers.

Nous avons donc choisi de créer deux représentations différentes de ceux-ci (car nous travaillons sur différents langages de programmation), nous permettant à la fois une implémentation simplifié, mais aussi de nous rapprocher d'une implémentation bas niveau.

=== A) En python ===
En python, l'utilisation des "bytes" m'a grandement servi à comprendre comment les entiers étaient manipulés à bas niveau. En effet, un des objectifs secondaires de nos recherches était de manipuler des entiers directement avec leur formes stockées sur l'ordinateur, et non pas avec des int python.
En effet l'utilisation des int python nous aurait permit de passer les étapes de retenues, de signes... D'autant plus que les bytes permettent de stocker un nombre en base 256, ce qui permet de visualiser plus facilement les grands entiers.

La forme finale de la représentation des grands entiers en python sera donc la suivante :

[ signe , bytes , bytes , (...) , bytes ]

Le signe est représenté par un entier, 1 si le nombre est positif, 0 sinon.
Cette configuration rendra plus simple la gestion des signes.

=== B) En C++ ===

En C++, pour avoir une représentation de grand entiers j'ai du définir ma propre structure pour m'affranchir de la limite de taille imposé par les entiers standards: (int32 ou int64). Pour cela, j'ai une structure qui possède l'équivalent d'un array de byte (ce qui nous permet d'être en base 256 au lieu de la base 10 habituelle), et pour traiter le signe j'utilise un booléen, ainsi en mémoire j'ai une structure de n*Octets + 1 octet en taille.

[ bytes , bytes , (...) , bytes ] [ signe ]

Le booléen prend 1 octet de place mais ne touche pas aux octets qui encode le grand entier.
Cette configuration rendra plus simple la gestion des signes dans le cadre des multiplication.

== 2) La multiplication naïve ==

=== A) Fonctionnement ===
Dans le cas de la multiplication d'entiers, nous allons prendre deux nombres qui n'ont pas nécessairement la même longueur. Soit les nombre a et b, de longueur respective <math> n </math> et <math> m </math>.
<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Multiplication.png|220px]]
<div><b>Multiplication naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Prenons deux nombres de longueur 3 et 2, et cherchons combien d'opérations l'algorithme de multiplication naïve va devoir faire pour nous renvoyer leur produit.</p>
<p>Dans un premier temps, on remarque que l'on va devoir multiplier chaque chiffre du nombre du haut par le chiffre des unités du bas, qui est 6. Cela va représenter <math>n</math> opérations. (6x5, 6x1 et 6x4)</p>
<p>Dans un deuxième temps nous constatons que nous allons devoir faire la même chose avec le chiffre des dizaines du nombre du bas. Cela nous ajoute de nouveau <math>n</math> opérations.</p>
<p>On arrive assez facilement à la conclusion que pour faire notre produit, il va nous falloir faire <math>n</math> fois <math>m</math> opérations.</p>
</div>
</div>

Ainsi, la complexité de la multiplication naïve est <math>\mathcal{O}(n^2)</math>.
Il est en de même avec la multiplication naïve récursive.

=== B) Graphique ===
Montrons maintenant sa courbe sur un graphique :

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Multiplicationnaive.png|500px]]
<div><b>Multiplication naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Les points noirs sont des repères pour que les autres courbes aient une forme cohérente.</p>
<p>Ils sont tous sur l'axe des abscisses.</p>
<p>La courbe rouge représente la complexité de la multiplication naïve.</p>
<p>On remarque que la courbe a un visuel très similaire à la fonction <math> f(x) = x^2 </math> </p>
</div>
</div>

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Naif_recursif.png|500px]]
<div><b>Multiplication naïve récursive</b></div>
</div>
<div style="max-width:800px;">
<p>Cette courbe rouge représente la complexité de la multiplication naïve récursive.</p>
<p>Elle sera utilisé pour comparer les complexités entre algorithmes car, comme tous récursifs, elle a été codé avec les mêmes biais d'implémentation qu'eux.</p>
<p>Théoriquement les deux courbes ci-contre ont la même complexité, mais encore une fois, notre implémentation n'est pas parfaitement optimale et donc ne respecte pas de manière minutieuse le Master Theorem.</p>
</div>
</div>

== 3) La multiplication karatsuba ==

=== A) Fonctionnement ===

L'algorithme de karatsuba est un algorithme récursif de type diviser pour régner.

L'idée générale de l'algorithme est de passer de 4 multiplication à 3. En effet ces opérations étant moins couteuses, il est préférable d'en ajouter si cela permet d'enlever des multiplications.

L'algorithme de multiplication naif récursif utilise la segmentation des facteurs en deux de manière successive.

Soit <math> x </math> et <math>y</math> deux facteurs, nous avons les égalités suivantes :

<div style="font-size: 15px;">
<math>x = a \times B^{n/2} + b</math>
<math>y = c \times B^{n/2} + d</math>
</div>

Avec <math>a</math> et <math>c</math> les premières moitiés des facteurs <math>x</math> et <math>y</math>,
et <math> b </math> et <math>d</math> les dernières moitiés de ces facteurs ainsi que <math>B</math> la base d'écriture du nombre (Nous sommes en base 256 avec les bytes).

Cette présentation des deux facteurs de notre multiplication n'est que la résultante d'un découpage.
Le [[#Master Theorem|Master Theorem]] nous montre que :

<div style="font-size: 15px;">
<math>T(n) = 4T(n/2) + O(n)</math>
</div>

Puisque nous avons après découpage 4 entiers de longueur <math>n/2</math>.

Ainsi, ce découpage ne permet pas de gagner du temps d'après le [[#Master Theorem|Master Theorem]].

Cependant, l'algorithme de Karatsuba réutilise ce principe en le modifiant, ce qui nous permet de baisser la complexité globale de la multiplication dans son entièreté.

Avec l'écriture ci-dessus des nombres <math>x</math> et <math>y</math>, on peut facilement en déduire l'égalité suivante :

<div style="font-size: 15px;">
<math>x \times y = (ac) \times B^n + (ad + bc) \times B^{n/2} + bd</math>
</div>

On remarque 4 multiplications longues à faire dans cette expression. Les multiplications dont <math>B</math> est l'un des facteurs sont très rapides puisqu'il s'agit de la base dans laquelle nous travaillons. De cela en résulte un décalage plutôt qu'un vrai calcul à faire.

Karatsuba développe une partie de cette expression pour pouvoir négocier une multiplication au prix d'additions et soustractions.

En effet, nous savons déjà que :

<div style="font-size: 15px;">
<math>(a + b)(c + d) = ac + ad + bc + bd</math>
</div>

En manipulant l'égalité nous obtenons :

<div style="font-size: 15px;">
<math>ad + bc = (a + b)(c + d) - ac - bd</math>
</div>

ac et bd ayant déjà été calculé précédemment, il nous reste uniquement la multiplication <math>(a + b)(c + d)</math>.

Nous venons ainsi de calculer <math>ad + bc</math> en seulement une multiplication. C'est la que repose le gain de temps de la méthode Karatsuba par rapport à la multiplication naïve.

En effet, l'algorithme n'effectuera alors plus que 3 multiplications :
<div style="font-size: 15px;">
<math>ac</math>
<math>bd</math>
<math>(a + b)(c + d)</math>
</div>

La relation de récurrence devient donc :
<div style="font-size: 15px;">
<math>T(n)=3T(n/2)+O(n)</math>
</div>

Et le Master Theorem nous dit que :
<div style="font-size: 15px;">
<math>T(n)\in O(n^{\log_2(3)})</math>
</div>

Or <math>\log_2(3)\approx 1.585</math>, donc la complexité de l'algorithme de Karatsuba est de <math> \mathcal{O}(n^{1.585})</math>. Ce qui est bien plus efficace que la multiplication classique, surtout lorsque les facteurs deviennent très grands.

=== B) Graphique ===
<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Karatsuba.png|500px]]
<div><b>Karatsuba</b></div>
</div>
<div style="max-width:800px;">
<p>Sur le graphique ci-contre nous avons utilisé la courbe de la multiplication naïve récursive (rouge) à titre de comparaison.</p>
<p>On remarque graphiquement que Karatsuba (jaune) prend moins de temps à chaque calcul de produit.</p>
<p>On en déduit donc expérimentalement que Karatsuba à une meilleure complexité que la multiplication naïve.</p>
<p>Ainsi nous vérifions donc ce que le Master Theorem prouve, c'est à dire que la complexité de karatsuba est de <math> \mathcal{O}(n^{1.585})</math> </p>
</div>
</div>

== 4) La multiplication toom-cook-3 ==

=== A) Fonctionnement ===

L'objectif est de diviser les grands entiers X et Y en trois blocs de taille égale k.
On les traite alors comme des polynômes de degré 2:

<math> P(z) = X_2 \cdot z^2 + X_1 \cdot z + X_0 </math>
<math> Q(z) = Y_2 \cdot z^2 + Y_1 \cdot z + Y_0 </math>

On choisit 5 points distincts pour évaluer nos polynômes.
Ce choix de 5 points est crucial car le produit de deux polynômes de degré 2 est un polynôme de degré 4, qui nécessite 5 points pour être défini.
Les points standards sont :

P(0) = X0
P(1) = X0 + X1 + X2
P(-1) = X0 - X1 + X2
P(2) = X0 + 2*X1 + 4*X2
P(inf) = X2

(On procède de manière similaire pour Q.)

Ensuite nous multiplions récursivement chaque points de P et de Q ensemble.
On effectue ainsi 5 multiplications de nombres plus petits au lieu des 9 multiplications requises par la méthode classique.

Après, nous effectuons une interpolation, cela permet de retrouver les 5 coefficients (w_0, w_1, w_2, w_3, w_4) du polynôme produit R(z) à partir des valeurs évaluées calculées précédemment.
On résout un système d'équations linéaires : <math> R(z) = w_4 z^4 + w_3 z^3 + w_2 z^2 + w_1 z + w_0 </math>
Finalement nous pouvons recomposer notre grand entier en positionnant les coefficients w_i aux bons rangs (en les décalant) et à gérer les retenues lors de l'addition finale:
Résultat <math>= w_4 B^{4k} + w_3 B^{3k} + w_2 B^{2k} + w_1 B^k + w_0</math>

=== B) Graphique ===

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Toomcook.png|500px]]
<div><b>Karatsuba</b></div>
</div>
<div style="max-width:800px;">
<p>on a reprit multi récursive (rouge)</p>
<p>on voit que Toom (vert) en dessous de karatsuba (jaune) en dessous de multi classique (rouge)</p>
<p>meilleur complexité</p>
</div>
</div>

== 5) La transformée de Fourier rapide ==

=== A) Fonctionnement ===

La transformation de Fourier rapide étant plus complexe que les autres algorithmes, nous allons essayer d'expliquer son fonctionnement malgré ne pas avoir réussi à l'implémenter.

Il faut comprendre que cet algorithme va considérer les facteurs comme des polynômes.

D'après le théorème de l'unisolvance, il n'existe qu'un seul polynôme de degré inférieur ou égal à <math> n </math> défini par <math>n + 1</math> points distincts. Cela implique non seulement que nous pouvons représenter chaque entier par un polynôme, mais également que si nous pouvons retrouver <math>n + m + 1</math> points (avec <math>n</math> et <math>m</math> la longueur des facteurs) du polynômes issue du produit entre deux facteurs, nous pourrons le retrouver.

Soit un entier quelconque, de forme :

<math>a_n a_{n-1} (...) a_1 a_0</math>

Avec <math>a_i</math>, un chiffre composant le nombre en base 10, qui vaut en réalité dans le nombre : <math>a_i \times 10^i</math>. On peut ainsi l'écrire sous la forme :

<math> P(x) = a_0 + a_1x + a_2x^2 + \dots + a_{n-1}x^{n-1} + a_nx^n </math>

Avec <math>x = 10</math> car nous sommes en base 10, nous obtenons :

<math>P(10) = a_0 + a_1 \times 10 + \dots + a_{n-1}10^{n-1} + a_n10^n </math>

Nous venons ainsi d'écrire notre nombre sous la forme d'un polynôme unique. Pour nous permettre d'évaluer en un nombre suffisant de points, nous allons devoir ajouter des 0 pour la récursion. Il nous faudra ajouter assez de 0 pour atteindre la prochaine puissance de 2 qui sera supérieure ou égale à <math>2n + 1</math>. L'ajout de 0 ne change pas le nombre car <math>0 \times x^n</math> n'ajoute pas de coefficient.

Cet algorithme est récursif et va segmenter en deux parties nos polynômes à chaque récursion. D'un coté les indice pairs et d'un coté les impaires.

Ainsi prenons les nombres 1234 et 5678, ces nombres sont respectivement représentés par les polynômes <math> P(x) = 4 + 3x + 2x^2 + x^3 </math> et <math> P(x) = 8 + 7x + 6x^2 + 5^3 </math>. Ce sont des polynômes de degré 3, ainsi leur produit donnera lieu à un polynôme de degré 6. Il nous faudra donc au minimum 7 points d'évaluation pour retrouve ce produit. De ce fait, en les représentant de la manière suivante :

<math>[4, 3, 2, 1, 0, 0, 0, 0]</math>
<math>[8, 7, 6, 5, 0, 0, 0, 0]</math>

Nous aurons assez de récursions possible pour les évaluer en un nombre suffisant de points différents car nous auront 3 récursions à faire pour atteindre notre cas de base. A chaque récursion, nous allons diviser nos polynômes en deux parties ce qui nous fait 8 feuilles à la dernière récursion.

En effet à chaque étape de la récursion nous allons séparer nos polynômes en deux tel que :

<math>P(x)=P_{\text{pair}}(x^2) + x \cdot P_{\text{impair}}(x^2)</math>

Durant les récursions, nous segmentons les polynômes mais ne les évaluons pas. C'est à la remonté des récursions que nous allons réellement évaluer nos polynômes. Lorsque l'on atteint notre cas de base, c'est à dire des polynômes de degré 0, nous remarquons qu'ils sont constants, nous n'avons donc pas besoin de les évaluer. En effet, peut importe le point en lequel nous voudrons l'évaluer, le polynôme renverra la constante. Nous la renvoyons donc seule.
Ensuite commence la remontée des récursions. A l'étape 1 de notre remontée nous allons reformer le polynôme précédemment séparé pour obtenir un polynôme de degré 1. Puis, nous évaluons ce polynôme avec les racines seconde de l'unité. Nous faisons à nouveau remonté les évaluations et recombinons à nouveau le polynôme qui sera ainsi de degré 2.
Nous l'évaluons maintenant avec les racines 4eme de l'unité. A chaque évaluation, nous réutilisons les résultats précédents, cela nous est permit par les racines de l'unité qui ont une structure récursive exploitable.

Finalement, nous arrivons à la fin de notre FFT, avec une représentation fréquentielle de la forme :

<math> [P(W_0), P(W_1), (...), P(W_n-1), P(W_n)] </math>

Cette représentation fréquentielle n'est autre que les évaluations du polynôme P aux racines nièmes de l'unité. Nous avons donc maintenant au minimum <math>2n+1</math> évaluations des polynômes facteurs. Il nous faut maintenant trouver les évaluations du produit final, c'est à dire les évaluations concernant le polynôme qui sera issue de la multiplication. On pourra ainsi le retrouver.

Soit <math>C</math> un polynome tel que <math> C = A \times B </math>, alors on a :

<math> C(x) = A(x) \times B(x) </math>

Ainsi on en déduit que <math> C(W_n^k) = A(W_n^k) \times B(W_n^k) </math>

On comprend donc que <math>FFT(C) = FFT(A) \times FFT(B)</math>

Il faut préciser que l'on fait le produit de FFT(A) et FFT(B) terme à terme, soit évaluation par évaluation.

Une fois en possession de <math>FFT(C)</math>, qui n'est autre que l'évaluation de notre polynôme final en un nombre suffisant de points pour le retrouver, nous pouvons faire l'<math>IFFT(FFT(C))</math>, qui va nous permettre de retrouver les coefficients de notre polynôme en faisant l'exacte inverse de la FFT.

Une fois les coefficients retrouvés, il nous suffit de gérer les retenues, et nous retrouvons un entier de la forme : <math>a_0 a_1 (...) a_{n-1} a_n</math>

=== B) Graphique ===

Intéressons nous maintenant à la complexité de l'algorithme utilisant la transformée de Fourier rapide. On sait que l'algorithme passe par 5 étapes importantes :

<ul>
<li>Etape 1 : Ecrire les deux facteurs sous la forme de polynômes</li>
<li>Etape 2 : Effectuer la <math>FFT</math> des deux polynômes</li>
<li>Etape 3 : Faire le produit terme à terme des <math>FFT</math> obtenues</li>
<li>Etape 4 : Faire l'<math>IFFT</math> du produit</li>
<li>Etape 5 : Gérer les retenues et écrire le nombre qui en découle</li>
</ul>

Or, parmi toutes ces étapes, certaines sont négligeable comme l'étape 1 et 5.

Pour connaitre la complexité de l'algorithme, additionnons les complexités des étapes restantes :

Une <math>FFT</math> a une complexité de <math>\mathcal{O}(n\times logn)</math> car elle fait <math>n</math> évaluation sur <math> log(n)</math> récursions. Dans le cadre de notre algorithme, nous devons faire la <math>FFT</math> de nos deux facteurs. Soit <math>2\times \mathcal{O}(n\times logn)</math>.

Pour le produit terme à terme, nous faisons naturellement <math>n</math> opérations.

Pour finir, l'<math>IFFT</math> a la même complexité que la <math>FFT</math>. Dans le cadre de notre algorithme nous l'emploierons qu'une seule fois, ce qui fait une complexité de <math>\mathcal{O}(n\times logn)</math>.

Après addition de toutes ces complexités, nous obtenons la complexité réelle de <math>3\mathcal{O}(n\times logn) + \mathcal{O}(n)</math>.

D'après le Master Theorem, nous avons donc <math> f(n) = 3(n\times logn)+n </math>, cherchons <math>f(n)\in\mathcal{O}(g(n))</math> :

Nous pouvons ignorer les expressions linéaires ainsi que les constantes multiplicatrices, nous obtenons donc <math>\mathcal{O}(g(n)) = \mathcal{O}(n \times log n)</math>.

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:30px; text-align:center;">
[[Fichier:FFT complexite.png|500px]]
<div><b>Graphiques des complexités</b></div>
</div>
<div style="max-width:800px;">
<p>Ce graphique ci-contre ne provient pas du fruit de nos recherches personnelles mais illustre bien la comparaison entre la complexité de la FFT et des autres algorithmes.</p>
<p>On remarque que la FFT est très efficace et devance de loin les autres algorithmes en terme de complexité. </p>
<p>Les algorithmes les plus efficaces pour calculer le produit de grands entiers reposent aujourd'hui sur des variantes de la transformée de Fourier rapide.</p>
</div>
</div>

= II - Produit de matrices =

== 1.1) naïve ==

La multiplication naïve de matrice requiert d'avoir des tailles de lignes/colonne semblable, ensuite pour chaque membre de la matrice résultat, on doit multiplier les composantes ligne de la première matrice par les composantes colonne de la deuxième et le tout sommé.

On en déduit la formule suivante:
<math>C_{i,j} = \sum_{k=1}^{n} (A_{i,k} \times B_{k,j})</math>

Et visuellement:

[[Fichier:Matricenaive.jpeg]]

On a donc un algorithme d'ordre de complexité <math>\mathcal{O}(g(n))</math>

== 1.2) naïve récursive ==

Dans un premier temps on doit découper nos deux matrices en quatres sous matrices de plus petite taille.
<math>A = \begin{pmatrix} A_{11} & A_{12} \ A_{21} & A_{22} \end{pmatrix}</math>
<math>B = \begin{pmatrix} B_{11} & B_{12} \ B_{21} & B_{22} \end{pmatrix}</math>

Ensuite on vient calculer la matrice résultat.
<math>C_{11} = (A_{11} \times B_{11}) + (A_{12} \times B_{21})</math>
<math>C_{12} = (A_{11} \times B_{12}) + (A_{12} \times B_{22})</math>
<math>C_{21} = (A_{21} \times B_{11}) + (A_{22} \times B_{21})</math>
<math>C_{22} = (A_{21} \times B_{12}) + (A_{22} \times B_{22})</math>

Le côté récursif est utile que pour les matrices de tailles <= 32 (32 valeurs stockées dedans),
si on est au dessus de cette taille alors on divisera à nouveau nos matrices en quatres.
On aura 8 multiplications mais de plus petite taille au final.

== 2) strassen ==

=== A) Fonctionnement ===

Strassen consiste à définir 7 produits intermédiaires qui, par des jeux de sommes et de différences, permettent de reconstruire les quadrants de la matrice résultante. On passe ainsi d'une complexité de O(n^3) à environ O(n^2.81)

=== B) Graphique ===

On voit bien la différence de complexité sur la multiplication de grande matrice entre l'approche naïve et l'approche récursive qui est beaucoup plus rapide.

[[Fichier:Analyse matrices.png]]

= Conclusion =

L'étude de ces algorithmes de multiplication nous a clairement montré l'évolution de la complexité algorithmique permettant de gagner en efficacité lorsque la taille des données augmente.

La multiplication classiqe, en <math>\mathcal{O}(n^2)</math>, résulte d'une approche naïve qui devient rapidement inefficace pour les grands entiers ou les grandes matrices. L'algorithme de Karatsuba nous montre qu'organiser de manière intelligente ses calculs algébrique permet parfois de gagner beaucoup de multiplications, et donc de temps. Nous avons ainsi réussi à passer d'une complexité de <math>\mathcal{O}(n^2)</math> à <math> \mathcal{O}(n^{log_2(3)}) </math>, soit environ <math>\mathcal{O}(n^{1/585})</math>.

Des méthodes encore plus avancées comme utilise l'algorithme de Toom-Cook-3 continue dans cette idées de divisions d'entiers en blocs plus petits, tandis que la transformée de Fourier rapide change complètement de point de vue. En effet la FFT n'utilise pas la représentation classique des entiers mais fait appel à une vision polynomiale, ce qui transforme la convolution classique en multiplication terme à terme, ce qui lui permet d'atteindre une complexité de <math>\mathcal{O}(n \times log n)</math>.

Dans le cas des matrices, les mêmes logiques apparaissent comme par exemple avec l'algorithme de Strassen qui se rapproche très fortement de Karatsuba en combinant de manière astucieuse les parties d'entiers qui avaient été précédemment découpée.

On remarque néanmoins que la majorité des algorithmes efficaces s'orientent vers une approche récursive et non itérative. Néanmoins, nous avons pu trouver certaines de ces implémentations (comme par exemple la FFT) en itérative.

Avec ces recherches, nous comprenons que la réorganisations des calculs algébriques peuvent aider à gagner en complexité mais que pour faire de réels progrès, il nous faudra surement changer notre point de vue une nouvelle fois, et aborder le problème sous un angle nouveau comme le font dors et déjà les algorithmes les plus performants.

= Mentions =

Le premier gif est le résultat du travail de 'Walké', licence ci-contre : https://fr.wikipedia.org/wiki/Fichier:Addition.gif

Utilisation du site de production graphique "Desmos" : https://www.desmos.com/calculator?lang=fr

= Sources =

Pour karatsuba :
<ul>
<li> https://www.youtube.com/watch?v=PZ2gdWdKHAA </li>
</ul>

Pour mieux comprendre la FFT, nous avons utilisé plusieurs sources d'informations :
<ul>
<li> https://www.youtube.com/watch?v=h7apO7q16V0&list=WL&index=1&t=886s </li>
<li> https://fr.wikipedia.org/wiki/Interpolation_polynomiale </li>
</ul>

Algorithmes de multiplications d'entiers et de matrices

2026-05-11T21:22:27Z

Mangala : /* B) Graphique */

= Introduction =

Depuis l'apparition des ordinateurs modernes, une quantité faramineuse de calculs a dû être effectuée. Les progressions technologiques nous poussent à envisager la puissance de calcul comme une ressource qu'il faut optimiser dans les moindres détails. C'est ainsi que l'optimisation des algorithmes de calcul est devenue cruciale, surtout lorsqu'il nous faut effectuer des opérations sur de très grands entiers par exemple.

= Objectif =

L'objectif majeur de ce projet est de comprendre de manière plus approfondie ce qu'est la '''complexité algorithmique'''.
Pour atteindre cet objectif, nous implémenterons plusieurs algorithmes de multiplication qui auront pour but de calculer le produit de grands entiers ou de matrices.

= Point important : complexité =

=== Définition ===
La complexité d'un algorithme est la quantité des ressources qu'il utilise en fonction de la taille des entrées qu'on lui demande de traiter. On peut par exemple se concentrer sur le temps qu'un algorithme prend pour renvoyer un résultat ou sur la mémoire dont il a besoin. Dans le cadre de notre projet, nous nous attarderons plus particulièrement sur la quantité de calcul effectuée en fonction de la taille des entrées, ce qui est par ailleurs étroitement liée à la notion de temps. De manière générale, plus un algorithme doit faire de calcul, plus il est lent. (Attention, toutes les opérations arithmétiques de base ne se valent pas)

De manière plus familière, on dira que la complexité d'un algorithme pourrait s'apparenter à son comportement lorsqu'il doit traiter des données plus ou moins grandes.
Chaque algorithme a une complexité, et on l'exprime par une fonction qui adopte un comportement similaire au nombre de calculs nécessaires en fonction de la taille des entrées.

=== Notation ===
La complexité réelle d'un algorithme peut être décrite par une fonction <math> f(n) </math> représentant le nombre d'opérations effectuées en fonction de la taille <math>n</math> des données d'entrée.

Cependant, afin de simplifier l'étude de cette croissance, on utilise généralement une borne asymptotique notée <math>\mathcal{O}(g(n))</math>, où <math>g(n)</math> est une fonction ayant le même ordre de grandeur que <math>f(n)</math> lorsque <math>n</math> devient grand.

On dit alors que :

<math>
f(n)\in\mathcal{O}(g(n))
</math>

si et seulement s'il existe une constante <math>C>0</math> et un entier <math>n_0</math> tels que :

<math>
\forall n\ge n_0,\ f(n)\le Cg(n)
</math>

Cette notation <math>\mathcal{O}(g(n))</math> permettra de comparer beaucoup plus facilement les algorithmes entre eux.

=== Master Theorem ===

Afin de déterminer la complexité de certains algorithmes récursifs, nous utiliserons le "Master Theorem".

Ce théorème permet d'obtenir directement l'ordre de grandeur de nombreuses relations de récurrence apparaissant dans l'analyse d'algorithmes de type « diviser pour régner », comme l'algorithme de Karatsuba ou celui de Strassen.

La démonstration complète de ce théorème dépasse le cadre de notre projet et nécessite des connaissances mathématiques plus avancées. Nous l'utiliserons donc principalement comme un outil nous permettant de déterminer efficacement la complexité asymptotique des algorithmes étudiés.

=== Graphiques ===

Les complexités étant des fonctions, nous pouvons les représenter par un graphique qui affichera le temps d'exécution (ou nombre d'opérations) en fonction de la taille des entrées.

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:30px; text-align:center;">
[[Fichier:complexite.webp|500px]]
<div><b>Graphiques des complexités</b></div>
</div>
<div style="max-width:800px;">
<p>Ce graphique ci-contre compare les complexités en fonction de la taille des d'entrées.</p>
<p>On comprend ainsi que certaines complexités ne sont pas raisonnable dans la cadre de la multiplication de grands entiers.</p>
<p>C'est pourquoi l'étude de ces algorithmes s'avère nécessaire.</p>
</div>
</div>

=== Exemple ===
L'algorithme naïf d'addition que nous avons tous appris à l'école a une complexité de <math>\mathcal{O}(n)</math>.
Soit n la taille des nombres en entrée, l'algorithme doit faire environ n addition pour arriver au résultat demandé.

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Addition.gif|220px]]
<div><b>Addition naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Comme le montre l'exemple ci-contre, 786 et 467 font 3 chiffres de long donc n sera de 3.</p>
<p>Il nous faudra 3 opérations pour additionner ces entiers.</p>
<p>C'est ainsi qu'avec une taille d'entrée n, l'algorithme de l'addition naïve va devoir faire n opérations.</p>
<p>Cet algorithme a donc une complexité <math>f(n) = n</math> qui n'a pas besoin d'être approximée.</p>
<p>Ainsi sa complexité finale sera <math>\mathcal{O}(n)</math>.</p>
</div>
</div>

= Problématique =

Le calcul du produit de deux entiers de manière naïve a une complexité de <math> \mathcal{O}(n^2)</math>, et celui de deux matrices une complexité de <math> \mathcal{O}(n^3)</math>. Afin de mieux comprendre ce qu'est la complexité algorithmique, nous devrons implémenter des algorithmes ayant le même objectif, mais étant plus efficaces. Ces algorithmes s'avèreront plus complexes mais devrait aboutir à un calcul plus rapide du produit demandé.

Nous séparerons notre wiki en deux grandes parties, la première concernera nos recherche sur [[#I - Produit d'entiers|la multiplication d'entiers]], la deuxième sur [[#II - Produit de matrices|la multiplication de matrices]].

= I - Produit d'entiers =

Notre départ commence avec l'algorithme de multiplication d'entier naïf.
En effet il s'agit de l'algorithme de multiplication le plus connu, et nous l'utiliserons comme référence pour le comparer aux futurs algorithmes plus efficaces.
Intéressons nous à sa complexité.

== 1) Nos implémentations des grands entiers ==

Qui dit produit de grands entiers dit implémentation de grands entiers.

Dans le cadre de nos recherches, nous allons devoir implémenter des algorithmes qui vont manipuler des grands entiers.

Nous avons donc choisi de créer deux représentations différentes de ceux-ci (car nous travaillons sur différents langages de programmation), nous permettant à la fois une implémentation simplifié, mais aussi de nous rapprocher d'une implémentation bas niveau.

=== A) En python ===
En python, l'utilisation des "bytes" m'a grandement servi à comprendre comment les entiers étaient manipulés à bas niveau. En effet, un des objectifs secondaires de nos recherches était de manipuler des entiers directement avec leur formes stockées sur l'ordinateur, et non pas avec des int python.
En effet l'utilisation des int python nous aurait permit de passer les étapes de retenues, de signes... D'autant plus que les bytes permettent de stocker un nombre en base 256, ce qui permet de visualiser plus facilement les grands entiers.

La forme finale de la représentation des grands entiers en python sera donc la suivante :

[ signe , bytes , bytes , (...) , bytes ]

Le signe est représenté par un entier, 1 si le nombre est positif, 0 sinon.
Cette configuration rendra plus simple la gestion des signes.

=== B) En C++ ===

En C++, pour avoir une représentation de grand entiers j'ai du définir ma propre structure pour m'affranchir de la limite de taille imposé par les entiers standards: (int32 ou int64). Pour cela, j'ai une structure qui possède l'équivalent d'un array de byte (ce qui nous permet d'être en base 256 au lieu de la base 10 habituelle), et pour traiter le signe j'utilise un booléen, ainsi en mémoire j'ai une structure de n*Octets + 1 octet en taille.

[ bytes , bytes , (...) , bytes ] [ signe ]

Le booléen prend 1 octet de place mais ne touche pas aux octets qui encode le grand entier.
Cette configuration rendra plus simple la gestion des signes dans le cadre des multiplication.

== 2) La multiplication naïve ==

=== A) Fonctionnement ===
Dans le cas de la multiplication d'entiers, nous allons prendre deux nombres qui n'ont pas nécessairement la même longueur. Soit les nombre a et b, de longueur respective <math> n </math> et <math> m </math>.
<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Multiplication.png|220px]]
<div><b>Multiplication naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Prenons deux nombres de longueur 3 et 2, et cherchons combien d'opérations l'algorithme de multiplication naïve va devoir faire pour nous renvoyer leur produit.</p>
<p>Dans un premier temps, on remarque que l'on va devoir multiplier chaque chiffre du nombre du haut par le chiffre des unités du bas, qui est 6. Cela va représenter <math>n</math> opérations. (6x5, 6x1 et 6x4)</p>
<p>Dans un deuxième temps nous constatons que nous allons devoir faire la même chose avec le chiffre des dizaines du nombre du bas. Cela nous ajoute de nouveau <math>n</math> opérations.</p>
<p>On arrive assez facilement à la conclusion que pour faire notre produit, il va nous falloir faire <math>n</math> fois <math>m</math> opérations.</p>
</div>
</div>

Ainsi, la complexité de la multiplication naïve est <math>\mathcal{O}(n^2)</math>.
Il est en de même avec la multiplication naïve récursive.

=== B) Graphique ===
Montrons maintenant sa courbe sur un graphique :

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Multiplicationnaive.png|500px]]
<div><b>Multiplication naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Les points noirs sont des repères pour que les autres courbes aient une forme cohérente.</p>
<p>Ils sont tous sur l'axe des abscisses.</p>
<p>La courbe rouge représente la complexité de la multiplication naïve.</p>
<p>On remarque que la courbe a un visuel très similaire à la fonction <math> f(x) = x^2 </math> </p>
</div>
</div>

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Naif_recursif.png|500px]]
<div><b>Multiplication naïve récursive</b></div>
</div>
<div style="max-width:800px;">
<p>Cette courbe rouge représente la complexité de la multiplication naïve récursive.</p>
<p>Elle sera utilisé pour comparer les complexités entre algorithmes car, comme tous récursifs, elle a été codé avec les mêmes biais d'implémentation qu'eux.</p>
<p>Théoriquement les deux courbes ci-contre ont la même complexité, mais encore une fois, notre implémentation n'est pas parfaitement optimale et donc ne respecte pas de manière minutieuse le Master Theorem.</p>
</div>
</div>

== 3) La multiplication karatsuba ==

=== A) Fonctionnement ===

L'algorithme de karatsuba est un algorithme récursif de type diviser pour régner.

L'idée générale de l'algorithme est de passer de 4 multiplication à 3. En effet ces opérations étant moins couteuses, il est préférable d'en ajouter si cela permet d'enlever des multiplications.

L'algorithme de multiplication naif récursif utilise la segmentation des facteurs en deux de manière successive.

Soit <math> x </math> et <math>y</math> deux facteurs, nous avons les égalités suivantes :

<div style="font-size: 15px;">
<math>x = a \times B^{n/2} + b</math>
<math>y = c \times B^{n/2} + d</math>
</div>

Avec <math>a</math> et <math>c</math> les premières moitiés des facteurs <math>x</math> et <math>y</math>,
et <math> b </math> et <math>d</math> les dernières moitiés de ces facteurs ainsi que <math>B</math> la base d'écriture du nombre (Nous sommes en base 256 avec les bytes).

Cette présentation des deux facteurs de notre multiplication n'est que la résultante d'un découpage.
Le [[#Master Theorem|Master Theorem]] nous montre que :

<div style="font-size: 15px;">
<math>T(n) = 4T(n/2) + O(n)</math>
</div>

Puisque nous avons après découpage 4 entiers de longueur <math>n/2</math>.

Ainsi, ce découpage ne permet pas de gagner du temps d'après le [[#Master Theorem|Master Theorem]].

Cependant, l'algorithme de Karatsuba réutilise ce principe en le modifiant, ce qui nous permet de baisser la complexité globale de la multiplication dans son entièreté.

Avec l'écriture ci-dessus des nombres <math>x</math> et <math>y</math>, on peut facilement en déduire l'égalité suivante :

<div style="font-size: 15px;">
<math>x \times y = (ac) \times B^n + (ad + bc) \times B^{n/2} + bd</math>
</div>

On remarque 4 multiplications longues à faire dans cette expression. Les multiplications dont <math>B</math> est l'un des facteurs sont très rapides puisqu'il s'agit de la base dans laquelle nous travaillons. De cela en résulte un décalage plutôt qu'un vrai calcul à faire.

Karatsuba développe une partie de cette expression pour pouvoir négocier une multiplication au prix d'additions et soustractions.

En effet, nous savons déjà que :

<div style="font-size: 15px;">
<math>(a + b)(c + d) = ac + ad + bc + bd</math>
</div>

En manipulant l'égalité nous obtenons :

<div style="font-size: 15px;">
<math>ad + bc = (a + b)(c + d) - ac - bd</math>
</div>

ac et bd ayant déjà été calculé précédemment, il nous reste uniquement la multiplication <math>(a + b)(c + d)</math>.

Nous venons ainsi de calculer <math>ad + bc</math> en seulement une multiplication. C'est la que repose le gain de temps de la méthode Karatsuba par rapport à la multiplication naïve.

En effet, l'algorithme n'effectuera alors plus que 3 multiplications :
<div style="font-size: 15px;">
<math>ac</math>
<math>bd</math>
<math>(a + b)(c + d)</math>
</div>

La relation de récurrence devient donc :
<div style="font-size: 15px;">
<math>T(n)=3T(n/2)+O(n)</math>
</div>

Et le Master Theorem nous dit que :
<div style="font-size: 15px;">
<math>T(n)\in O(n^{\log_2(3)})</math>
</div>

Or <math>\log_2(3)\approx 1.585</math>, donc la complexité de l'algorithme de Karatsuba est de <math> \mathcal{O}(n^{1.585})</math>. Ce qui est bien plus efficace que la multiplication classique, surtout lorsque les facteurs deviennent très grands.

=== B) Graphique ===
<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Karatsuba.png|500px]]
<div><b>Karatsuba</b></div>
</div>
<div style="max-width:800px;">
<p>Sur le graphique ci-contre nous avons utilisé la courbe de la multiplication naïve récursive (rouge) à titre de comparaison.</p>
<p>On remarque graphiquement que Karatsuba (jaune) prend moins de temps à chaque calcul de produit.</p>
<p>On en déduit donc expérimentalement que Karatsuba à une meilleure complexité que la multiplication naïve.</p>
<p>Ainsi nous vérifions donc ce que le Master Theorem prouve, c'est à dire que la complexité de karatsuba est de <math> \mathcal{O}(n^{1.585})</math> </p>
</div>
</div>

== 4) La multiplication toom-cook-3 ==

=== A) Fonctionnement ===

L'objectif est de diviser les grands entiers X et Y en trois blocs de taille égale k.
On les traite alors comme des polynômes de degré 2:

<math> P(z) = X_2 \cdot z^2 + X_1 \cdot z + X_0 </math>
<math> Q(z) = Y_2 \cdot z^2 + Y_1 \cdot z + Y_0 </math>

On choisit 5 points distincts pour évaluer nos polynômes.
Ce choix de 5 points est crucial car le produit de deux polynômes de degré 2 est un polynôme de degré 4, qui nécessite 5 points pour être défini.
Les points standards sont :

P(0) = X0
P(1) = X0 + X1 + X2
P(-1) = X0 - X1 + X2
P(2) = X0 + 2*X1 + 4*X2
P(inf) = X2

(On procède de manière similaire pour Q.)

Ensuite nous multiplions récursivement chaque points de P et de Q ensemble.
On effectue ainsi 5 multiplications de nombres plus petits au lieu des 9 multiplications requises par la méthode classique.

Après, nous effectuons une interpolation, cela permet de retrouver les 5 coefficients (w_0, w_1, w_2, w_3, w_4) du polynôme produit R(z) à partir des valeurs évaluées calculées précédemment.
On résout un système d'équations linéaires : <math> R(z) = w_4 z^4 + w_3 z^3 + w_2 z^2 + w_1 z + w_0 </math>
Finalement nous pouvons recomposer notre grand entier en positionnant les coefficients w_i aux bons rangs (en les décalant) et à gérer les retenues lors de l'addition finale:
Résultat <math>= w_4 B^{4k} + w_3 B^{3k} + w_2 B^{2k} + w_1 B^k + w_0</math>

=== B) Graphique ===

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Toomcook.png|500px]]
<div><b>Karatsuba</b></div>
</div>
<div style="max-width:800px;">
<p>on a reprit multi récursive (rouge)</p>
<p>on voit que Toom (vert) en dessous de karatsuba (jaune) en dessous de multi classique (rouge)</p>
<p>meilleur complexité</p>
</div>
</div>

== 5) La transformée de Fourier rapide ==

=== A) Fonctionnement ===

La transformation de Fourier rapide étant plus complexe que les autres algorithmes, nous allons essayer d'expliquer son fonctionnement malgré ne pas avoir réussi à l'implémenter.

Il faut comprendre que cet algorithme va considérer les facteurs comme des polynômes.

D'après le théorème de l'unisolvance, il n'existe qu'un seul polynôme de degré inférieur ou égal à <math> n </math> défini par <math>n + 1</math> points distincts. Cela implique non seulement que nous pouvons représenter chaque entier par un polynôme, mais également que si nous pouvons retrouver <math>n + m + 1</math> points (avec <math>n</math> et <math>m</math> la longueur des facteurs) du polynômes issue du produit entre deux facteurs, nous pourrons le retrouver.

Soit un entier quelconque, de forme :

<math>a_n a_{n-1} (...) a_1 a_0</math>

Avec <math>a_i</math>, un chiffre composant le nombre en base 10, qui vaut en réalité dans le nombre : <math>a_i \times 10^i</math>. On peut ainsi l'écrire sous la forme :

<math> P(x) = a_0 + a_1x + a_2x^2 + \dots + a_{n-1}x^{n-1} + a_nx^n </math>

Avec <math>x = 10</math> car nous sommes en base 10, nous obtenons :

<math>P(10) = a_0 + a_1 \times 10 + \dots + a_{n-1}10^{n-1} + a_n10^n </math>

Nous venons ainsi d'écrire notre nombre sous la forme d'un polynôme unique. Pour nous permettre d'évaluer en un nombre suffisant de points, nous allons devoir ajouter des 0 pour la récursion. Il nous faudra ajouter assez de 0 pour atteindre la prochaine puissance de 2 qui sera supérieure ou égale à <math>2n + 1</math>. L'ajout de 0 ne change pas le nombre car <math>0 \times x^n</math> n'ajoute pas de coefficient.

Cet algorithme est récursif et va segmenter en deux parties nos polynômes à chaque récursion. D'un coté les indice pairs et d'un coté les impaires.

Ainsi prenons les nombres 1234 et 5678, ces nombres sont respectivement représentés par les polynômes <math> P(x) = 4 + 3x + 2x^2 + x^3 </math> et <math> P(x) = 8 + 7x + 6x^2 + 5^3 </math>. Ce sont des polynômes de degré 3, ainsi leur produit donnera lieu à un polynôme de degré 6. Il nous faudra donc au minimum 7 points d'évaluation pour retrouve ce produit. De ce fait, en les représentant de la manière suivante :

<math>[4, 3, 2, 1, 0, 0, 0, 0]</math>
<math>[8, 7, 6, 5, 0, 0, 0, 0]</math>

Nous aurons assez de récursions possible pour les évaluer en un nombre suffisant de points différents car nous auront 3 récursions à faire pour atteindre notre cas de base. A chaque récursion, nous allons diviser nos polynômes en deux parties ce qui nous fait 8 feuilles à la dernière récursion.

En effet à chaque étape de la récursion nous allons séparer nos polynômes en deux tel que :

<math>P(x)=P_{\text{pair}}(x^2) + x \cdot P_{\text{impair}}(x^2)</math>

Durant les récursions, nous segmentons les polynômes mais ne les évaluons pas. C'est à la remonté des récursions que nous allons réellement évaluer nos polynômes. Lorsque l'on atteint notre cas de base, c'est à dire des polynômes de degré 0, nous remarquons qu'ils sont constants, nous n'avons donc pas besoin de les évaluer. En effet, peut importe le point en lequel nous voudrons l'évaluer, le polynôme renverra la constante. Nous la renvoyons donc seule.
Ensuite commence la remontée des récursions. A l'étape 1 de notre remontée nous allons reformer le polynôme précédemment séparé pour obtenir un polynôme de degré 1. Puis, nous évaluons ce polynôme avec les racines seconde de l'unité. Nous faisons à nouveau remonté les évaluations et recombinons à nouveau le polynôme qui sera ainsi de degré 2.
Nous l'évaluons maintenant avec les racines 4eme de l'unité. A chaque évaluation, nous réutilisons les résultats précédents, cela nous est permit par les racines de l'unité qui ont une structure récursive exploitable.

Finalement, nous arrivons à la fin de notre FFT, avec une représentation fréquentielle de la forme :

<math> [P(W_0), P(W_1), (...), P(W_n-1), P(W_n)] </math>

Cette représentation fréquentielle n'est autre que les évaluations du polynôme P aux racines nièmes de l'unité. Nous avons donc maintenant au minimum <math>2n+1</math> évaluations des polynômes facteurs. Il nous faut maintenant trouver les évaluations du produit final, c'est à dire les évaluations concernant le polynôme qui sera issue de la multiplication. On pourra ainsi le retrouver.

Soit <math>C</math> un polynome tel que <math> C = A \times B </math>, alors on a :

<math> C(x) = A(x) \times B(x) </math>

Ainsi on en déduit que <math> C(W_n^k) = A(W_n^k) \times B(W_n^k) </math>

On comprend donc que <math>FFT(C) = FFT(A) \times FFT(B)</math>

Il faut préciser que l'on fait le produit de FFT(A) et FFT(B) terme à terme, soit évaluation par évaluation.

Une fois en possession de <math>FFT(C)</math>, qui n'est autre que l'évaluation de notre polynôme final en un nombre suffisant de points pour le retrouver, nous pouvons faire l'<math>IFFT(FFT(C))</math>, qui va nous permettre de retrouver les coefficients de notre polynôme en faisant l'exacte inverse de la FFT.

Une fois les coefficients retrouvés, il nous suffit de gérer les retenues, et nous retrouvons un entier de la forme : <math>a_0 a_1 (...) a_{n-1} a_n</math>

=== B) Graphique ===

Intéressons nous maintenant à la complexité de l'algorithme utilisant la transformée de Fourier rapide. On sait que l'algorithme passe par 5 étapes importantes :

<ul>
<li>Etape 1 : Ecrire les deux facteurs sous la forme de polynômes</li>
<li>Etape 2 : Effectuer la <math>FFT</math> des deux polynômes</li>
<li>Etape 3 : Faire le produit terme à terme des <math>FFT</math> obtenues</li>
<li>Etape 4 : Faire l'<math>IFFT</math> du produit</li>
<li>Etape 5 : Gérer les retenues et écrire le nombre qui en découle</li>
</ul>

Or, parmi toutes ces étapes, certaines sont négligeable comme l'étape 1 et 5.

Pour connaitre la complexité de l'algorithme, additionnons les complexités des étapes restantes :

Une <math>FFT</math> a une complexité de <math>\mathcal{O}(n\times logn)</math> car elle fait <math>n</math> évaluation sur <math> log(n)</math> récursions. Dans le cadre de notre algorithme, nous devons faire la <math>FFT</math> de nos deux facteurs. Soit <math>2\times \mathcal{O}(n\times logn)</math>.

Pour le produit terme à terme, nous faisons naturellement <math>n</math> opérations.

Pour finir, l'<math>IFFT</math> a la même complexité que la <math>FFT</math>. Dans le cadre de notre algorithme nous l'emploierons qu'une seule fois, ce qui fait une complexité de <math>\mathcal{O}(n\times logn)</math>.

Après addition de toutes ces complexités, nous obtenons la complexité réelle de <math>3\mathcal{O}(n\times logn) + \mathcal{O}(n)</math>.

D'après le Master Theorem, nous avons donc <math> f(n) = 3(n\times logn)+n </math>, cherchons <math>f(n)\in\mathcal{O}(g(n))</math> :

Nous pouvons ignorer les expressions linéaires ainsi que les constantes multiplicatrices, nous obtenons donc <math>\mathcal{O}(g(n)) = \mathcal{O}(n \times log n)</math>.

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:30px; text-align:center;">
[[Fichier:FFT complexite.png|500px]]
<div><b>Graphiques des complexités</b></div>
</div>
<div style="max-width:800px;">
<p>Ce graphique ci-contre ne provient pas du fruit de nos recherches personnelles mais illustre bien la comparaison entre la complexité de la FFT et des autres algorithmes.</p>
<p>On remarque que la FFT est très efficace et devance de loin les autres algorithmes en terme de complexité. </p>
<p>Les algorithmes les plus efficaces pour calculer le produit de grands entiers reposent aujourd'hui sur des variantes de la transformée de Fourier rapide.</p>
</div>
</div>

= II - Produit de matrices =

== 1.1) naïve ==

La multiplication naïve de matrice requiert d'avoir des tailles de lignes/colonne semblable, ensuite pour chaque membre de la matrice résultat, on doit multiplier les composantes ligne de la première matrice par les composantes colonne de la deuxième et le tout sommé.

On en déduit la formule suivante:
<math>C_{i,j} = \sum_{k=1}^{n} (A_{i,k} \times B_{k,j})</math>

Et visuellement:

[[Fichier:Matricenaive.jpeg]]

On a donc un algorithme d'ordre de complexité <math>\mathcal{O}(g(n))</math>

== 1.2) naïve récursive ==

Dans un premier temps on doit découper nos deux matrices en quatres sous matrices de plus petite taille.
<math>A = \begin{pmatrix} A_{11} & A_{12} \ A_{21} & A_{22} \end{pmatrix}</math>
<math>B = \begin{pmatrix} B_{11} & B_{12} \ B_{21} & B_{22} \end{pmatrix}</math>

Ensuite on vient calculer la matrice résultat.
<math>C_{11} = (A_{11} \times B_{11}) + (A_{12} \times B_{21})</math>
<math>C_{12} = (A_{11} \times B_{12}) + (A_{12} \times B_{22})</math>
<math>C_{21} = (A_{21} \times B_{11}) + (A_{22} \times B_{21})</math>
<math>C_{22} = (A_{21} \times B_{12}) + (A_{22} \times B_{22})</math>

Le côté récursif est utile que pour les matrices de tailles <= 32 (32 valeurs stockées dedans),
si on est au dessus de cette taille alors on divisera à nouveau nos matrices en quatres.
On aura 8 multiplications mais de plus petite taille au final.

== 2) strassen ==

=== A) Fonctionnement ===

Strassen consiste à définir 7 produits intermédiaires qui, par des jeux de sommes et de différences, permettent de reconstruire les quadrants de la matrice résultante. On passe ainsi d'une complexité de O(n^3) à environ O(n^2.81)

=== B) Graphique ===

On voit bien la différence de complexité sur la multiplication de grande matrice entre l'approche naïve et l'approche récursive qui est beaucoup plus rapide.

[[Fichier:Analyse matrices.png]]

= Conclusion =

L'étude de ces algorithmes de multiplication nous a clairement montré l'évolution de la complexité algorithmique permettant de gagner en efficacité lorsque la taille des données augmente.

La multiplication classiqe, en <math>\mathcal{O}(n^2)</math>, résulte d'une approche naïve qui devient rapidement inefficace pour les grands entiers ou les grandes matrices. L'algorithme de Karatsuba nous montre qu'organiser de manière intelligente ses calculs algébrique permet parfois de gagner beaucoup de multiplications, et donc de temps. Nous avons ainsi réussi à passer d'une complexité de <math>\mathcal{O}(n^2)</math> à <math>\mathcal{O}(n^{log_2(3)})</math>, soit environ <math>\mathcal{O}(n^{1/585})</math>.

Des méthodes encore plus avancées comme utilise l'algorithme de Toom-Cook-3 continue dans cette idées de divisions d'entiers en blocs plus petits, tandis que la transformée de Fourier rapide change complètement de point de vue. En effet la FFT n'utilise pas la représentation classique des entiers mais fait appel à une vision polynomiale, ce qui transforme la convolution classique en multiplication terme à terme, ce qui lui permet d'atteindre une complexité de <math>\mathcal{O}(n \times log n)</math>.

Dans le cas des matrices, les mêmes logiques apparaissent comme par exemple avec l'algorithme de Strassen qui se rapproche très fortement de Karatsuba en combinant de manière astucieuse les parties d'entiers qui avaient été précédemment découpée.

On remarque néanmoins que la majorité des algorithmes efficaces s'orientent vers une approche récursive et non itérative. Néanmoins, nous avons pu trouver certaines de ces implémentations (comme par exemple la FFT) en itérative.

Avec ces recherches, nous comprenons que la réorganisations des calculs algébriques peuvent aider à gagner en complexité mais que pour faire de réels progrès, il nous faudra surement changer notre point de vue une nouvelle fois, et aborder le problème sous un angle nouveau comme le font dors et déjà les algorithmes les plus performants.

= Mentions =

Le premier gif est le résultat du travail de 'Walké', licence ci-contre : https://fr.wikipedia.org/wiki/Fichier:Addition.gif

Utilisation du site de production graphique "Desmos" : https://www.desmos.com/calculator?lang=fr

= Sources =

Pour karatsuba :
<ul>
<li> https://www.youtube.com/watch?v=PZ2gdWdKHAA </li>
</ul>

Pour mieux comprendre la FFT, nous avons utilisé plusieurs sources d'informations :
<ul>
<li> https://www.youtube.com/watch?v=h7apO7q16V0&list=WL&index=1&t=886s </li>
<li> https://fr.wikipedia.org/wiki/Interpolation_polynomiale </li>
</ul>

Algorithmes de multiplications d'entiers et de matrices

2026-05-11T21:22:05Z

Mangala : /* A) Fonctionnement */

= Introduction =

Depuis l'apparition des ordinateurs modernes, une quantité faramineuse de calculs a dû être effectuée. Les progressions technologiques nous poussent à envisager la puissance de calcul comme une ressource qu'il faut optimiser dans les moindres détails. C'est ainsi que l'optimisation des algorithmes de calcul est devenue cruciale, surtout lorsqu'il nous faut effectuer des opérations sur de très grands entiers par exemple.

= Objectif =

L'objectif majeur de ce projet est de comprendre de manière plus approfondie ce qu'est la '''complexité algorithmique'''.
Pour atteindre cet objectif, nous implémenterons plusieurs algorithmes de multiplication qui auront pour but de calculer le produit de grands entiers ou de matrices.

= Point important : complexité =

=== Définition ===
La complexité d'un algorithme est la quantité des ressources qu'il utilise en fonction de la taille des entrées qu'on lui demande de traiter. On peut par exemple se concentrer sur le temps qu'un algorithme prend pour renvoyer un résultat ou sur la mémoire dont il a besoin. Dans le cadre de notre projet, nous nous attarderons plus particulièrement sur la quantité de calcul effectuée en fonction de la taille des entrées, ce qui est par ailleurs étroitement liée à la notion de temps. De manière générale, plus un algorithme doit faire de calcul, plus il est lent. (Attention, toutes les opérations arithmétiques de base ne se valent pas)

De manière plus familière, on dira que la complexité d'un algorithme pourrait s'apparenter à son comportement lorsqu'il doit traiter des données plus ou moins grandes.
Chaque algorithme a une complexité, et on l'exprime par une fonction qui adopte un comportement similaire au nombre de calculs nécessaires en fonction de la taille des entrées.

=== Notation ===
La complexité réelle d'un algorithme peut être décrite par une fonction <math> f(n) </math> représentant le nombre d'opérations effectuées en fonction de la taille <math>n</math> des données d'entrée.

Cependant, afin de simplifier l'étude de cette croissance, on utilise généralement une borne asymptotique notée <math>\mathcal{O}(g(n))</math>, où <math>g(n)</math> est une fonction ayant le même ordre de grandeur que <math>f(n)</math> lorsque <math>n</math> devient grand.

On dit alors que :

<math>
f(n)\in\mathcal{O}(g(n))
</math>

si et seulement s'il existe une constante <math>C>0</math> et un entier <math>n_0</math> tels que :

<math>
\forall n\ge n_0,\ f(n)\le Cg(n)
</math>

Cette notation <math>\mathcal{O}(g(n))</math> permettra de comparer beaucoup plus facilement les algorithmes entre eux.

=== Master Theorem ===

Afin de déterminer la complexité de certains algorithmes récursifs, nous utiliserons le "Master Theorem".

Ce théorème permet d'obtenir directement l'ordre de grandeur de nombreuses relations de récurrence apparaissant dans l'analyse d'algorithmes de type « diviser pour régner », comme l'algorithme de Karatsuba ou celui de Strassen.

La démonstration complète de ce théorème dépasse le cadre de notre projet et nécessite des connaissances mathématiques plus avancées. Nous l'utiliserons donc principalement comme un outil nous permettant de déterminer efficacement la complexité asymptotique des algorithmes étudiés.

=== Graphiques ===

Les complexités étant des fonctions, nous pouvons les représenter par un graphique qui affichera le temps d'exécution (ou nombre d'opérations) en fonction de la taille des entrées.

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:30px; text-align:center;">
[[Fichier:complexite.webp|500px]]
<div><b>Graphiques des complexités</b></div>
</div>
<div style="max-width:800px;">
<p>Ce graphique ci-contre compare les complexités en fonction de la taille des d'entrées.</p>
<p>On comprend ainsi que certaines complexités ne sont pas raisonnable dans la cadre de la multiplication de grands entiers.</p>
<p>C'est pourquoi l'étude de ces algorithmes s'avère nécessaire.</p>
</div>
</div>

=== Exemple ===
L'algorithme naïf d'addition que nous avons tous appris à l'école a une complexité de <math>\mathcal{O}(n)</math>.
Soit n la taille des nombres en entrée, l'algorithme doit faire environ n addition pour arriver au résultat demandé.

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Addition.gif|220px]]
<div><b>Addition naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Comme le montre l'exemple ci-contre, 786 et 467 font 3 chiffres de long donc n sera de 3.</p>
<p>Il nous faudra 3 opérations pour additionner ces entiers.</p>
<p>C'est ainsi qu'avec une taille d'entrée n, l'algorithme de l'addition naïve va devoir faire n opérations.</p>
<p>Cet algorithme a donc une complexité <math>f(n) = n</math> qui n'a pas besoin d'être approximée.</p>
<p>Ainsi sa complexité finale sera <math>\mathcal{O}(n)</math>.</p>
</div>
</div>

= Problématique =

Le calcul du produit de deux entiers de manière naïve a une complexité de <math> \mathcal{O}(n^2)</math>, et celui de deux matrices une complexité de <math> \mathcal{O}(n^3)</math>. Afin de mieux comprendre ce qu'est la complexité algorithmique, nous devrons implémenter des algorithmes ayant le même objectif, mais étant plus efficaces. Ces algorithmes s'avèreront plus complexes mais devrait aboutir à un calcul plus rapide du produit demandé.

Nous séparerons notre wiki en deux grandes parties, la première concernera nos recherche sur [[#I - Produit d'entiers|la multiplication d'entiers]], la deuxième sur [[#II - Produit de matrices|la multiplication de matrices]].

= I - Produit d'entiers =

Notre départ commence avec l'algorithme de multiplication d'entier naïf.
En effet il s'agit de l'algorithme de multiplication le plus connu, et nous l'utiliserons comme référence pour le comparer aux futurs algorithmes plus efficaces.
Intéressons nous à sa complexité.

== 1) Nos implémentations des grands entiers ==

Qui dit produit de grands entiers dit implémentation de grands entiers.

Dans le cadre de nos recherches, nous allons devoir implémenter des algorithmes qui vont manipuler des grands entiers.

Nous avons donc choisi de créer deux représentations différentes de ceux-ci (car nous travaillons sur différents langages de programmation), nous permettant à la fois une implémentation simplifié, mais aussi de nous rapprocher d'une implémentation bas niveau.

=== A) En python ===
En python, l'utilisation des "bytes" m'a grandement servi à comprendre comment les entiers étaient manipulés à bas niveau. En effet, un des objectifs secondaires de nos recherches était de manipuler des entiers directement avec leur formes stockées sur l'ordinateur, et non pas avec des int python.
En effet l'utilisation des int python nous aurait permit de passer les étapes de retenues, de signes... D'autant plus que les bytes permettent de stocker un nombre en base 256, ce qui permet de visualiser plus facilement les grands entiers.

La forme finale de la représentation des grands entiers en python sera donc la suivante :

[ signe , bytes , bytes , (...) , bytes ]

Le signe est représenté par un entier, 1 si le nombre est positif, 0 sinon.
Cette configuration rendra plus simple la gestion des signes.

=== B) En C++ ===

En C++, pour avoir une représentation de grand entiers j'ai du définir ma propre structure pour m'affranchir de la limite de taille imposé par les entiers standards: (int32 ou int64). Pour cela, j'ai une structure qui possède l'équivalent d'un array de byte (ce qui nous permet d'être en base 256 au lieu de la base 10 habituelle), et pour traiter le signe j'utilise un booléen, ainsi en mémoire j'ai une structure de n*Octets + 1 octet en taille.

[ bytes , bytes , (...) , bytes ] [ signe ]

Le booléen prend 1 octet de place mais ne touche pas aux octets qui encode le grand entier.
Cette configuration rendra plus simple la gestion des signes dans le cadre des multiplication.

== 2) La multiplication naïve ==

=== A) Fonctionnement ===
Dans le cas de la multiplication d'entiers, nous allons prendre deux nombres qui n'ont pas nécessairement la même longueur. Soit les nombre a et b, de longueur respective <math> n </math> et <math> m </math>.
<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Multiplication.png|220px]]
<div><b>Multiplication naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Prenons deux nombres de longueur 3 et 2, et cherchons combien d'opérations l'algorithme de multiplication naïve va devoir faire pour nous renvoyer leur produit.</p>
<p>Dans un premier temps, on remarque que l'on va devoir multiplier chaque chiffre du nombre du haut par le chiffre des unités du bas, qui est 6. Cela va représenter <math>n</math> opérations. (6x5, 6x1 et 6x4)</p>
<p>Dans un deuxième temps nous constatons que nous allons devoir faire la même chose avec le chiffre des dizaines du nombre du bas. Cela nous ajoute de nouveau <math>n</math> opérations.</p>
<p>On arrive assez facilement à la conclusion que pour faire notre produit, il va nous falloir faire <math>n</math> fois <math>m</math> opérations.</p>
</div>
</div>

Ainsi, la complexité de la multiplication naïve est <math>\mathcal{O}(n^2)</math>.
Il est en de même avec la multiplication naïve récursive.

=== B) Graphique ===
Montrons maintenant sa courbe sur un graphique :

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Multiplicationnaive.png|500px]]
<div><b>Multiplication naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Les points noirs sont des repères pour que les autres courbes aient une forme cohérente.</p>
<p>Ils sont tous sur l'axe des abscisses.</p>
<p>La courbe rouge représente la complexité de la multiplication naïve.</p>
<p>On remarque que la courbe a un visuel très similaire à la fonction <math> f(x) = x^2 </math> </p>
</div>
</div>

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Naif_recursif.png|500px]]
<div><b>Multiplication naïve récursive</b></div>
</div>
<div style="max-width:800px;">
<p>La courbe rouge représente la complexité de la multiplication naïve récursive.</p>
<p>Elle sera utilisé pour comparer les complexités entre algorithmes car, comme tous récursifs, elle a été codé avec les mêmes biais d'implémentation qu'eux.</p>
<p>Théoriquement les deux courbes ci-contre ont la même complexité, mais encore une fois, notre implémentation n'est pas parfaitement optimale et donc ne respecte pas de manière minutieuse le Master Theorem.</p>
</div>
</div>

== 3) La multiplication karatsuba ==

=== A) Fonctionnement ===

L'algorithme de karatsuba est un algorithme récursif de type diviser pour régner.

L'idée générale de l'algorithme est de passer de 4 multiplication à 3. En effet ces opérations étant moins couteuses, il est préférable d'en ajouter si cela permet d'enlever des multiplications.

L'algorithme de multiplication naif récursif utilise la segmentation des facteurs en deux de manière successive.

Soit <math> x </math> et <math>y</math> deux facteurs, nous avons les égalités suivantes :

<div style="font-size: 15px;">
<math>x = a \times B^{n/2} + b</math>
<math>y = c \times B^{n/2} + d</math>
</div>

Avec <math>a</math> et <math>c</math> les premières moitiés des facteurs <math>x</math> et <math>y</math>,
et <math> b </math> et <math>d</math> les dernières moitiés de ces facteurs ainsi que <math>B</math> la base d'écriture du nombre (Nous sommes en base 256 avec les bytes).

Cette présentation des deux facteurs de notre multiplication n'est que la résultante d'un découpage.
Le [[#Master Theorem|Master Theorem]] nous montre que :

<div style="font-size: 15px;">
<math>T(n) = 4T(n/2) + O(n)</math>
</div>

Puisque nous avons après découpage 4 entiers de longueur <math>n/2</math>.

Ainsi, ce découpage ne permet pas de gagner du temps d'après le [[#Master Theorem|Master Theorem]].

Cependant, l'algorithme de Karatsuba réutilise ce principe en le modifiant, ce qui nous permet de baisser la complexité globale de la multiplication dans son entièreté.

Avec l'écriture ci-dessus des nombres <math>x</math> et <math>y</math>, on peut facilement en déduire l'égalité suivante :

<div style="font-size: 15px;">
<math>x \times y = (ac) \times B^n + (ad + bc) \times B^{n/2} + bd</math>
</div>

On remarque 4 multiplications longues à faire dans cette expression. Les multiplications dont <math>B</math> est l'un des facteurs sont très rapides puisqu'il s'agit de la base dans laquelle nous travaillons. De cela en résulte un décalage plutôt qu'un vrai calcul à faire.

Karatsuba développe une partie de cette expression pour pouvoir négocier une multiplication au prix d'additions et soustractions.

En effet, nous savons déjà que :

<div style="font-size: 15px;">
<math>(a + b)(c + d) = ac + ad + bc + bd</math>
</div>

En manipulant l'égalité nous obtenons :

<div style="font-size: 15px;">
<math>ad + bc = (a + b)(c + d) - ac - bd</math>
</div>

ac et bd ayant déjà été calculé précédemment, il nous reste uniquement la multiplication <math>(a + b)(c + d)</math>.

Nous venons ainsi de calculer <math>ad + bc</math> en seulement une multiplication. C'est la que repose le gain de temps de la méthode Karatsuba par rapport à la multiplication naïve.

En effet, l'algorithme n'effectuera alors plus que 3 multiplications :
<div style="font-size: 15px;">
<math>ac</math>
<math>bd</math>
<math>(a + b)(c + d)</math>
</div>

La relation de récurrence devient donc :
<div style="font-size: 15px;">
<math>T(n)=3T(n/2)+O(n)</math>
</div>

Et le Master Theorem nous dit que :
<div style="font-size: 15px;">
<math>T(n)\in O(n^{\log_2(3)})</math>
</div>

Or <math>\log_2(3)\approx 1.585</math>, donc la complexité de l'algorithme de Karatsuba est de <math> \mathcal{O}(n^{1.585})</math>. Ce qui est bien plus efficace que la multiplication classique, surtout lorsque les facteurs deviennent très grands.

=== B) Graphique ===
<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Karatsuba.png|500px]]
<div><b>Karatsuba</b></div>
</div>
<div style="max-width:800px;">
<p>Sur le graphique ci-contre nous avons utilisé la courbe de la multiplication naïve récursive (rouge) à titre de comparaison.</p>
<p>On remarque graphiquement que Karatsuba (jaune) prend moins de temps à chaque calcul de produit.</p>
<p>On en déduit donc expérimentalement que Karatsuba à une meilleure complexité que la multiplication naïve.</p>
<p>Ainsi nous vérifions donc ce que le Master Theorem prouve, c'est à dire que la complexité de karatsuba est de <math> \mathcal{O}(n^{1.585})</math> </p>
</div>
</div>

== 4) La multiplication toom-cook-3 ==

=== A) Fonctionnement ===

L'objectif est de diviser les grands entiers X et Y en trois blocs de taille égale k.
On les traite alors comme des polynômes de degré 2:

<math> P(z) = X_2 \cdot z^2 + X_1 \cdot z + X_0 </math>
<math> Q(z) = Y_2 \cdot z^2 + Y_1 \cdot z + Y_0 </math>

On choisit 5 points distincts pour évaluer nos polynômes.
Ce choix de 5 points est crucial car le produit de deux polynômes de degré 2 est un polynôme de degré 4, qui nécessite 5 points pour être défini.
Les points standards sont :

P(0) = X0
P(1) = X0 + X1 + X2
P(-1) = X0 - X1 + X2
P(2) = X0 + 2*X1 + 4*X2
P(inf) = X2

(On procède de manière similaire pour Q.)

Ensuite nous multiplions récursivement chaque points de P et de Q ensemble.
On effectue ainsi 5 multiplications de nombres plus petits au lieu des 9 multiplications requises par la méthode classique.

Après, nous effectuons une interpolation, cela permet de retrouver les 5 coefficients (w_0, w_1, w_2, w_3, w_4) du polynôme produit R(z) à partir des valeurs évaluées calculées précédemment.
On résout un système d'équations linéaires : <math> R(z) = w_4 z^4 + w_3 z^3 + w_2 z^2 + w_1 z + w_0 </math>
Finalement nous pouvons recomposer notre grand entier en positionnant les coefficients w_i aux bons rangs (en les décalant) et à gérer les retenues lors de l'addition finale:
Résultat <math>= w_4 B^{4k} + w_3 B^{3k} + w_2 B^{2k} + w_1 B^k + w_0</math>

=== B) Graphique ===

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Toomcook.png|500px]]
<div><b>Karatsuba</b></div>
</div>
<div style="max-width:800px;">
<p>on a reprit multi récursive (rouge)</p>
<p>on voit que Toom (vert) en dessous de karatsuba (jaune) en dessous de multi classique (rouge)</p>
<p>meilleur complexité</p>
</div>
</div>

== 5) La transformée de Fourier rapide ==

=== A) Fonctionnement ===

La transformation de Fourier rapide étant plus complexe que les autres algorithmes, nous allons essayer d'expliquer son fonctionnement malgré ne pas avoir réussi à l'implémenter.

Il faut comprendre que cet algorithme va considérer les facteurs comme des polynômes.

D'après le théorème de l'unisolvance, il n'existe qu'un seul polynôme de degré inférieur ou égal à <math> n </math> défini par <math>n + 1</math> points distincts. Cela implique non seulement que nous pouvons représenter chaque entier par un polynôme, mais également que si nous pouvons retrouver <math>n + m + 1</math> points (avec <math>n</math> et <math>m</math> la longueur des facteurs) du polynômes issue du produit entre deux facteurs, nous pourrons le retrouver.

Soit un entier quelconque, de forme :

<math>a_n a_{n-1} (...) a_1 a_0</math>

Avec <math>a_i</math>, un chiffre composant le nombre en base 10, qui vaut en réalité dans le nombre : <math>a_i \times 10^i</math>. On peut ainsi l'écrire sous la forme :

<math> P(x) = a_0 + a_1x + a_2x^2 + \dots + a_{n-1}x^{n-1} + a_nx^n </math>

Avec <math>x = 10</math> car nous sommes en base 10, nous obtenons :

<math>P(10) = a_0 + a_1 \times 10 + \dots + a_{n-1}10^{n-1} + a_n10^n </math>

Nous venons ainsi d'écrire notre nombre sous la forme d'un polynôme unique. Pour nous permettre d'évaluer en un nombre suffisant de points, nous allons devoir ajouter des 0 pour la récursion. Il nous faudra ajouter assez de 0 pour atteindre la prochaine puissance de 2 qui sera supérieure ou égale à <math>2n + 1</math>. L'ajout de 0 ne change pas le nombre car <math>0 \times x^n</math> n'ajoute pas de coefficient.

Cet algorithme est récursif et va segmenter en deux parties nos polynômes à chaque récursion. D'un coté les indice pairs et d'un coté les impaires.

Ainsi prenons les nombres 1234 et 5678, ces nombres sont respectivement représentés par les polynômes <math> P(x) = 4 + 3x + 2x^2 + x^3 </math> et <math> P(x) = 8 + 7x + 6x^2 + 5^3 </math>. Ce sont des polynômes de degré 3, ainsi leur produit donnera lieu à un polynôme de degré 6. Il nous faudra donc au minimum 7 points d'évaluation pour retrouve ce produit. De ce fait, en les représentant de la manière suivante :

<math>[4, 3, 2, 1, 0, 0, 0, 0]</math>
<math>[8, 7, 6, 5, 0, 0, 0, 0]</math>

Nous aurons assez de récursions possible pour les évaluer en un nombre suffisant de points différents car nous auront 3 récursions à faire pour atteindre notre cas de base. A chaque récursion, nous allons diviser nos polynômes en deux parties ce qui nous fait 8 feuilles à la dernière récursion.

En effet à chaque étape de la récursion nous allons séparer nos polynômes en deux tel que :

<math>P(x)=P_{\text{pair}}(x^2) + x \cdot P_{\text{impair}}(x^2)</math>

Durant les récursions, nous segmentons les polynômes mais ne les évaluons pas. C'est à la remonté des récursions que nous allons réellement évaluer nos polynômes. Lorsque l'on atteint notre cas de base, c'est à dire des polynômes de degré 0, nous remarquons qu'ils sont constants, nous n'avons donc pas besoin de les évaluer. En effet, peut importe le point en lequel nous voudrons l'évaluer, le polynôme renverra la constante. Nous la renvoyons donc seule.
Ensuite commence la remontée des récursions. A l'étape 1 de notre remontée nous allons reformer le polynôme précédemment séparé pour obtenir un polynôme de degré 1. Puis, nous évaluons ce polynôme avec les racines seconde de l'unité. Nous faisons à nouveau remonté les évaluations et recombinons à nouveau le polynôme qui sera ainsi de degré 2.
Nous l'évaluons maintenant avec les racines 4eme de l'unité. A chaque évaluation, nous réutilisons les résultats précédents, cela nous est permit par les racines de l'unité qui ont une structure récursive exploitable.

Finalement, nous arrivons à la fin de notre FFT, avec une représentation fréquentielle de la forme :

<math> [P(W_0), P(W_1), (...), P(W_n-1), P(W_n)] </math>

Cette représentation fréquentielle n'est autre que les évaluations du polynôme P aux racines nièmes de l'unité. Nous avons donc maintenant au minimum <math>2n+1</math> évaluations des polynômes facteurs. Il nous faut maintenant trouver les évaluations du produit final, c'est à dire les évaluations concernant le polynôme qui sera issue de la multiplication. On pourra ainsi le retrouver.

Soit <math>C</math> un polynome tel que <math> C = A \times B </math>, alors on a :

<math> C(x) = A(x) \times B(x) </math>

Ainsi on en déduit que <math> C(W_n^k) = A(W_n^k) \times B(W_n^k) </math>

On comprend donc que <math>FFT(C) = FFT(A) \times FFT(B)</math>

Il faut préciser que l'on fait le produit de FFT(A) et FFT(B) terme à terme, soit évaluation par évaluation.

Une fois en possession de <math>FFT(C)</math>, qui n'est autre que l'évaluation de notre polynôme final en un nombre suffisant de points pour le retrouver, nous pouvons faire l'<math>IFFT(FFT(C))</math>, qui va nous permettre de retrouver les coefficients de notre polynôme en faisant l'exacte inverse de la FFT.

Une fois les coefficients retrouvés, il nous suffit de gérer les retenues, et nous retrouvons un entier de la forme : <math>a_0 a_1 (...) a_{n-1} a_n</math>

=== B) Graphique ===

Intéressons nous maintenant à la complexité de l'algorithme utilisant la transformée de Fourier rapide. On sait que l'algorithme passe par 5 étapes importantes :

<ul>
<li>Etape 1 : Ecrire les deux facteurs sous la forme de polynômes</li>
<li>Etape 2 : Effectuer la <math>FFT</math> des deux polynômes</li>
<li>Etape 3 : Faire le produit terme à terme des <math>FFT</math> obtenues</li>
<li>Etape 4 : Faire l'<math>IFFT</math> du produit</li>
<li>Etape 5 : Gérer les retenues et écrire le nombre qui en découle</li>
</ul>

Or, parmi toutes ces étapes, certaines sont négligeable comme l'étape 1 et 5.

Pour connaitre la complexité de l'algorithme, additionnons les complexités des étapes restantes :

Une <math>FFT</math> a une complexité de <math>\mathcal{O}(n\times logn)</math> car elle fait <math>n</math> évaluation sur <math> log(n)</math> récursions. Dans le cadre de notre algorithme, nous devons faire la <math>FFT</math> de nos deux facteurs. Soit <math>2\times \mathcal{O}(n\times logn)</math>.

Pour le produit terme à terme, nous faisons naturellement <math>n</math> opérations.

Pour finir, l'<math>IFFT</math> a la même complexité que la <math>FFT</math>. Dans le cadre de notre algorithme nous l'emploierons qu'une seule fois, ce qui fait une complexité de <math>\mathcal{O}(n\times logn)</math>.

Après addition de toutes ces complexités, nous obtenons la complexité réelle de <math>3\mathcal{O}(n\times logn) + \mathcal{O}(n)</math>.

D'après le Master Theorem, nous avons donc <math> f(n) = 3(n\times logn)+n </math>, cherchons <math>f(n)\in\mathcal{O}(g(n))</math> :

Nous pouvons ignorer les expressions linéaires ainsi que les constantes multiplicatrices, nous obtenons donc <math>\mathcal{O}(g(n)) = \mathcal{O}(n \times log n)</math>.

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:30px; text-align:center;">
[[Fichier:FFT complexite.png|500px]]
<div><b>Graphiques des complexités</b></div>
</div>
<div style="max-width:800px;">
<p>Ce graphique ci-contre ne provient pas du fruit de nos recherches personnelles mais illustre bien la comparaison entre la complexité de la FFT et des autres algorithmes.</p>
<p>On remarque que la FFT est très efficace et devance de loin les autres algorithmes en terme de complexité. </p>
<p>Les algorithmes les plus efficaces pour calculer le produit de grands entiers reposent aujourd'hui sur des variantes de la transformée de Fourier rapide.</p>
</div>
</div>

= II - Produit de matrices =

== 1.1) naïve ==

La multiplication naïve de matrice requiert d'avoir des tailles de lignes/colonne semblable, ensuite pour chaque membre de la matrice résultat, on doit multiplier les composantes ligne de la première matrice par les composantes colonne de la deuxième et le tout sommé.

On en déduit la formule suivante:
<math>C_{i,j} = \sum_{k=1}^{n} (A_{i,k} \times B_{k,j})</math>

Et visuellement:

[[Fichier:Matricenaive.jpeg]]

On a donc un algorithme d'ordre de complexité <math>\mathcal{O}(g(n))</math>

== 1.2) naïve récursive ==

Dans un premier temps on doit découper nos deux matrices en quatres sous matrices de plus petite taille.
<math>A = \begin{pmatrix} A_{11} & A_{12} \ A_{21} & A_{22} \end{pmatrix}</math>
<math>B = \begin{pmatrix} B_{11} & B_{12} \ B_{21} & B_{22} \end{pmatrix}</math>

Ensuite on vient calculer la matrice résultat.
<math>C_{11} = (A_{11} \times B_{11}) + (A_{12} \times B_{21})</math>
<math>C_{12} = (A_{11} \times B_{12}) + (A_{12} \times B_{22})</math>
<math>C_{21} = (A_{21} \times B_{11}) + (A_{22} \times B_{21})</math>
<math>C_{22} = (A_{21} \times B_{12}) + (A_{22} \times B_{22})</math>

Le côté récursif est utile que pour les matrices de tailles <= 32 (32 valeurs stockées dedans),
si on est au dessus de cette taille alors on divisera à nouveau nos matrices en quatres.
On aura 8 multiplications mais de plus petite taille au final.

== 2) strassen ==

=== A) Fonctionnement ===

Strassen consiste à définir 7 produits intermédiaires qui, par des jeux de sommes et de différences, permettent de reconstruire les quadrants de la matrice résultante. On passe ainsi d'une complexité de O(n^3) à environ O(n^2.81)

=== B) Graphique ===

On voit bien la différence de complexité sur la multiplication de grande matrice entre l'approche naïve et l'approche récursive qui est beaucoup plus rapide.

[[Fichier:Analyse matrices.png]]

= Conclusion =

L'étude de ces algorithmes de multiplication nous a clairement montré l'évolution de la complexité algorithmique permettant de gagner en efficacité lorsque la taille des données augmente.

La multiplication classiqe, en <math>\mathcal{O}(n^2)</math>, résulte d'une approche naïve qui devient rapidement inefficace pour les grands entiers ou les grandes matrices. L'algorithme de Karatsuba nous montre qu'organiser de manière intelligente ses calculs algébrique permet parfois de gagner beaucoup de multiplications, et donc de temps. Nous avons ainsi réussi à passer d'une complexité de <math>\mathcal{O}(n^2)</math> à <math>\mathcal{O}(n^{log_2(3)})</math>, soit environ <math>\mathcal{O}(n^{1/585})</math>.

Des méthodes encore plus avancées comme utilise l'algorithme de Toom-Cook-3 continue dans cette idées de divisions d'entiers en blocs plus petits, tandis que la transformée de Fourier rapide change complètement de point de vue. En effet la FFT n'utilise pas la représentation classique des entiers mais fait appel à une vision polynomiale, ce qui transforme la convolution classique en multiplication terme à terme, ce qui lui permet d'atteindre une complexité de <math>\mathcal{O}(n \times log n)</math>.

Dans le cas des matrices, les mêmes logiques apparaissent comme par exemple avec l'algorithme de Strassen qui se rapproche très fortement de Karatsuba en combinant de manière astucieuse les parties d'entiers qui avaient été précédemment découpée.

On remarque néanmoins que la majorité des algorithmes efficaces s'orientent vers une approche récursive et non itérative. Néanmoins, nous avons pu trouver certaines de ces implémentations (comme par exemple la FFT) en itérative.

Avec ces recherches, nous comprenons que la réorganisations des calculs algébriques peuvent aider à gagner en complexité mais que pour faire de réels progrès, il nous faudra surement changer notre point de vue une nouvelle fois, et aborder le problème sous un angle nouveau comme le font dors et déjà les algorithmes les plus performants.

= Mentions =

Le premier gif est le résultat du travail de 'Walké', licence ci-contre : https://fr.wikipedia.org/wiki/Fichier:Addition.gif

Utilisation du site de production graphique "Desmos" : https://www.desmos.com/calculator?lang=fr

= Sources =

Pour karatsuba :
<ul>
<li> https://www.youtube.com/watch?v=PZ2gdWdKHAA </li>
</ul>

Pour mieux comprendre la FFT, nous avons utilisé plusieurs sources d'informations :
<ul>
<li> https://www.youtube.com/watch?v=h7apO7q16V0&list=WL&index=1&t=886s </li>
<li> https://fr.wikipedia.org/wiki/Interpolation_polynomiale </li>
</ul>

Algorithmes de multiplications d'entiers et de matrices

2026-05-11T21:21:43Z

Mangala : /* A) Fonctionnement */

= Introduction =

Depuis l'apparition des ordinateurs modernes, une quantité faramineuse de calculs a dû être effectuée. Les progressions technologiques nous poussent à envisager la puissance de calcul comme une ressource qu'il faut optimiser dans les moindres détails. C'est ainsi que l'optimisation des algorithmes de calcul est devenue cruciale, surtout lorsqu'il nous faut effectuer des opérations sur de très grands entiers par exemple.

= Objectif =

L'objectif majeur de ce projet est de comprendre de manière plus approfondie ce qu'est la '''complexité algorithmique'''.
Pour atteindre cet objectif, nous implémenterons plusieurs algorithmes de multiplication qui auront pour but de calculer le produit de grands entiers ou de matrices.

= Point important : complexité =

=== Définition ===
La complexité d'un algorithme est la quantité des ressources qu'il utilise en fonction de la taille des entrées qu'on lui demande de traiter. On peut par exemple se concentrer sur le temps qu'un algorithme prend pour renvoyer un résultat ou sur la mémoire dont il a besoin. Dans le cadre de notre projet, nous nous attarderons plus particulièrement sur la quantité de calcul effectuée en fonction de la taille des entrées, ce qui est par ailleurs étroitement liée à la notion de temps. De manière générale, plus un algorithme doit faire de calcul, plus il est lent. (Attention, toutes les opérations arithmétiques de base ne se valent pas)

De manière plus familière, on dira que la complexité d'un algorithme pourrait s'apparenter à son comportement lorsqu'il doit traiter des données plus ou moins grandes.
Chaque algorithme a une complexité, et on l'exprime par une fonction qui adopte un comportement similaire au nombre de calculs nécessaires en fonction de la taille des entrées.

=== Notation ===
La complexité réelle d'un algorithme peut être décrite par une fonction <math> f(n) </math> représentant le nombre d'opérations effectuées en fonction de la taille <math>n</math> des données d'entrée.

Cependant, afin de simplifier l'étude de cette croissance, on utilise généralement une borne asymptotique notée <math>\mathcal{O}(g(n))</math>, où <math>g(n)</math> est une fonction ayant le même ordre de grandeur que <math>f(n)</math> lorsque <math>n</math> devient grand.

On dit alors que :

<math>
f(n)\in\mathcal{O}(g(n))
</math>

si et seulement s'il existe une constante <math>C>0</math> et un entier <math>n_0</math> tels que :

<math>
\forall n\ge n_0,\ f(n)\le Cg(n)
</math>

Cette notation <math>\mathcal{O}(g(n))</math> permettra de comparer beaucoup plus facilement les algorithmes entre eux.

=== Master Theorem ===

Afin de déterminer la complexité de certains algorithmes récursifs, nous utiliserons le "Master Theorem".

Ce théorème permet d'obtenir directement l'ordre de grandeur de nombreuses relations de récurrence apparaissant dans l'analyse d'algorithmes de type « diviser pour régner », comme l'algorithme de Karatsuba ou celui de Strassen.

La démonstration complète de ce théorème dépasse le cadre de notre projet et nécessite des connaissances mathématiques plus avancées. Nous l'utiliserons donc principalement comme un outil nous permettant de déterminer efficacement la complexité asymptotique des algorithmes étudiés.

=== Graphiques ===

Les complexités étant des fonctions, nous pouvons les représenter par un graphique qui affichera le temps d'exécution (ou nombre d'opérations) en fonction de la taille des entrées.

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:30px; text-align:center;">
[[Fichier:complexite.webp|500px]]
<div><b>Graphiques des complexités</b></div>
</div>
<div style="max-width:800px;">
<p>Ce graphique ci-contre compare les complexités en fonction de la taille des d'entrées.</p>
<p>On comprend ainsi que certaines complexités ne sont pas raisonnable dans la cadre de la multiplication de grands entiers.</p>
<p>C'est pourquoi l'étude de ces algorithmes s'avère nécessaire.</p>
</div>
</div>

=== Exemple ===
L'algorithme naïf d'addition que nous avons tous appris à l'école a une complexité de <math>\mathcal{O}(n)</math>.
Soit n la taille des nombres en entrée, l'algorithme doit faire environ n addition pour arriver au résultat demandé.

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Addition.gif|220px]]
<div><b>Addition naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Comme le montre l'exemple ci-contre, 786 et 467 font 3 chiffres de long donc n sera de 3.</p>
<p>Il nous faudra 3 opérations pour additionner ces entiers.</p>
<p>C'est ainsi qu'avec une taille d'entrée n, l'algorithme de l'addition naïve va devoir faire n opérations.</p>
<p>Cet algorithme a donc une complexité <math>f(n) = n</math> qui n'a pas besoin d'être approximée.</p>
<p>Ainsi sa complexité finale sera <math>\mathcal{O}(n)</math>.</p>
</div>
</div>

= Problématique =

Le calcul du produit de deux entiers de manière naïve a une complexité de <math> \mathcal{O}(n^2)</math>, et celui de deux matrices une complexité de <math> \mathcal{O}(n^3)</math>. Afin de mieux comprendre ce qu'est la complexité algorithmique, nous devrons implémenter des algorithmes ayant le même objectif, mais étant plus efficaces. Ces algorithmes s'avèreront plus complexes mais devrait aboutir à un calcul plus rapide du produit demandé.

Nous séparerons notre wiki en deux grandes parties, la première concernera nos recherche sur [[#I - Produit d'entiers|la multiplication d'entiers]], la deuxième sur [[#II - Produit de matrices|la multiplication de matrices]].

= I - Produit d'entiers =

Notre départ commence avec l'algorithme de multiplication d'entier naïf.
En effet il s'agit de l'algorithme de multiplication le plus connu, et nous l'utiliserons comme référence pour le comparer aux futurs algorithmes plus efficaces.
Intéressons nous à sa complexité.

== 1) Nos implémentations des grands entiers ==

Qui dit produit de grands entiers dit implémentation de grands entiers.

Dans le cadre de nos recherches, nous allons devoir implémenter des algorithmes qui vont manipuler des grands entiers.

Nous avons donc choisi de créer deux représentations différentes de ceux-ci (car nous travaillons sur différents langages de programmation), nous permettant à la fois une implémentation simplifié, mais aussi de nous rapprocher d'une implémentation bas niveau.

=== A) En python ===
En python, l'utilisation des "bytes" m'a grandement servi à comprendre comment les entiers étaient manipulés à bas niveau. En effet, un des objectifs secondaires de nos recherches était de manipuler des entiers directement avec leur formes stockées sur l'ordinateur, et non pas avec des int python.
En effet l'utilisation des int python nous aurait permit de passer les étapes de retenues, de signes... D'autant plus que les bytes permettent de stocker un nombre en base 256, ce qui permet de visualiser plus facilement les grands entiers.

La forme finale de la représentation des grands entiers en python sera donc la suivante :

[ signe , bytes , bytes , (...) , bytes ]

Le signe est représenté par un entier, 1 si le nombre est positif, 0 sinon.
Cette configuration rendra plus simple la gestion des signes.

=== B) En C++ ===

En C++, pour avoir une représentation de grand entiers j'ai du définir ma propre structure pour m'affranchir de la limite de taille imposé par les entiers standards: (int32 ou int64). Pour cela, j'ai une structure qui possède l'équivalent d'un array de byte (ce qui nous permet d'être en base 256 au lieu de la base 10 habituelle), et pour traiter le signe j'utilise un booléen, ainsi en mémoire j'ai une structure de n*Octets + 1 octet en taille.

[ bytes , bytes , (...) , bytes ] [ signe ]

Le booléen prend 1 octet de place mais ne touche pas aux octets qui encode le grand entier.
Cette configuration rendra plus simple la gestion des signes dans le cadre des multiplication.

== 2) La multiplication naïve ==

=== A) Fonctionnement ===
Dans le cas de la multiplication d'entiers, nous allons prendre deux nombres qui n'ont pas nécessairement la même longueur. Soit les nombre a et b, de longueur respective <math> n </math> et <math> m </math>.
<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Multiplication.png|220px]]
<div><b>Multiplication naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Prenons deux nombres de longueur 3 et 2, et cherchons combien d'opérations l'algorithme de multiplication naïve va devoir faire pour nous renvoyer leur produit.</p>
<p>Dans un premier temps, on remarque que l'on va devoir multiplier chaque chiffre du nombre du haut par le chiffre des unités du bas, qui est 6. Cela va représenter <math>n</math> opérations. (6x5, 6x1 et 6x4)</p>
<p>Dans un deuxième temps nous constatons que nous allons devoir faire la même chose avec le chiffre des dizaines du nombre du bas. Cela nous ajoute de nouveau <math>n</math> opérations.</p>
<p>On arrive assez facilement à la conclusion que pour faire notre produit, il va nous falloir faire <math>n</math> fois <math>m</math> opérations.</p>
</div>
</div>

Ainsi, la complexité de la multiplication naïve est <math>\mathcal{O}(n^2)</math>.
Il est en de même avec la multiplication naïve récursive.

=== B) Graphique ===
Montrons maintenant sa courbe sur un graphique :

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Multiplicationnaive.png|500px]]
<div><b>Multiplication naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Les points noirs sont des repères pour que les autres courbes aient une forme cohérente.</p>
<p>Ils sont tous sur l'axe des abscisses.</p>
<p>La courbe rouge représente la complexité de la multiplication naïve.</p>
<p>On remarque que la courbe a un visuel très similaire à la fonction <math> f(x) = x^2 </math> </p>
</div>
</div>

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Naif_recursif.png|500px]]
<div><b>Multiplication naïve récursive</b></div>
</div>
<div style="max-width:800px;">
<p>La courbe rouge représente la complexité de la multiplication naïve récursive.</p>
<p>Elle sera utilisé pour comparer les complexités entre algorithmes car, comme tous récursifs, elle a été codé avec les mêmes biais d'implémentation qu'eux.</p>
<p>Théoriquement les deux courbes ci-contre ont la même complexité, mais encore une fois, notre implémentation n'est pas parfaitement optimale et donc ne respecte pas de manière minutieuse le Master Theorem.</p>
</div>
</div>

== 3) La multiplication karatsuba ==

=== A) Fonctionnement ===

L'algorithme de karatsuba est un algorithme récursif de type diviser pour régner.

L'idée générale de l'algorithme est de passer de 4 multiplication à 3. En effet ces opérations étant moins couteuses, il est préférable d'en ajouter si cela permet d'enlever des multiplications.

L'algorithme de multiplication naif récursif utilise la segmentation des facteurs en deux de manière successive.

Soit <math> x </math> et <math>y</math> deux facteurs, nous avons les égalités suivantes :

<div style="font-size: 15px;">
<math>x = a \times B^{n/2} + b</math>
<math>y = c \times B^{n/2} + d</math>
</div>

Avec <math>a</math> et <math>c</math> les premières moitiés des facteurs <math>x</math> et <math>y</math>,
et <math> b </math> et <math>d</math> les dernières moitiés de ces facteurs ainsi que <math>B</math> la base d'écriture du nombre (Nous sommes en base 256 avec les bytes).

Cette présentation des deux facteurs de notre multiplication n'est que la résultante d'un découpage.
Le [[#Master Theorem|Master Theorem]] nous montre que :

<div style="font-size: 15px;">
<math>T(n) = 4T(n/2) + O(n)</math>
</div>

Puisque nous avons après découpage 4 entiers de longueur <math>n/2</math>.

Ainsi, ce découpage ne permet pas de gagner du temps d'après le [[#Master Theorem|Master Theorem]].

Cependant, l'algorithme de Karatsuba réutilise ce principe en le modifiant, ce qui nous permet de baisser la complexité globale de la multiplication dans son entièreté.

Avec l'écriture ci-dessus des nombres <math>x</math> et <math>y</math>, on peut facilement en déduire l'égalité suivante :

<div style="font-size: 15px;">
<math>x \times y = (ac) \times B^n + (ad + bc) \times B^{n/2} + bd</math>
</div>

On remarque 4 multiplications longues à faire dans cette expression. Les multiplications dont <math>B</math> est l'un des facteurs sont très rapides puisqu'il s'agit de la base dans laquelle nous travaillons. De cela en résulte un décalage plutôt qu'un vrai calcul à faire.

Karatsuba développe une partie de cette expression pour pouvoir négocier une multiplication au prix d'additions et soustractions.

En effet, nous savons déjà que :

<div style="font-size: 15px;">
<math>(a + b)(c + d) = ac + ad + bc + bd</math>
</div>

En manipulant l'égalité nous obtenons :

<div style="font-size: 15px;">
<math>ad + bc = (a + b)(c + d) - ac - bd</math>
</div>

ac et bd ayant déjà été calculé précédemment, il nous reste uniquement la multiplication <math>(a + b)(c + d)</math>.

Nous venons ainsi de calculer <math>ad + bc</math> en seulement une multiplication. C'est la que repose le gain de temps de la méthode Karatsuba par rapport à la multiplication naïve.

En effet, l'algorithme n'effectuera alors plus que 3 multiplications :
<div style="font-size: 15px;">
<math>ac</math>
<math>bd</math>
<math>(a + b)(c + d)</math>
</div>

La relation de récurrence devient donc :
<div style="font-size: 15px;">
<math>T(n)=3T(n/2)+O(n)</math>
</div>

Et le Master Theorem nous dit que :
<div style="font-size: 15px;">
<math>T(n)\in O(n^{\log_2(3)})</math>
</div>

Or <math>\log_2(3)\approx 1.585</math>, donc la complexité de l'algorithme de Karatsuba est de <math> \mathcal{O}(n^{1.585})</math>. Ce qui est bien plus efficace que la multiplication classique, surtout lorsque les facteurs deviennent très grands.

=== B) Graphique ===
<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Karatsuba.png|500px]]
<div><b>Karatsuba</b></div>
</div>
<div style="max-width:800px;">
<p>Sur le graphique ci-contre nous avons utilisé la courbe de la multiplication naïve récursive (rouge) à titre de comparaison.</p>
<p>On remarque graphiquement que Karatsuba (jaune) prend moins de temps à chaque calcul de produit.</p>
<p>On en déduit donc expérimentalement que Karatsuba à une meilleure complexité que la multiplication naïve.</p>
<p>Ainsi nous vérifions donc ce que le Master Theorem prouve, c'est à dire que la complexité de karatsuba est de <math> \mathcal{O}(n^{1.585})</math> </p>
</div>
</div>

== 4) La multiplication toom-cook-3 ==

=== A) Fonctionnement ===

L'objectif est de diviser les grands entiers X et Y en trois blocs de taille égale k.
On les traite alors comme des polynômes de degré 2:

<math>P(z) = X_2 \cdot z^2 + X_1 \cdot z + X_0</math>
<math>Q(z) = Y_2 \cdot z^2 + Y_1 \cdot z + Y_0</math>

On choisit 5 points distincts pour évaluer nos polynômes.
Ce choix de 5 points est crucial car le produit de deux polynômes de degré 2 est un polynôme de degré 4, qui nécessite 5 points pour être défini.
Les points standards sont :

P(0) = X0
P(1) = X0 + X1 + X2
P(-1) = X0 - X1 + X2
P(2) = X0 + 2*X1 + 4*X2
P(inf) = X2

(On procède de manière similaire pour Q.)

Ensuite nous multiplions récursivement chaque points de P et de Q ensemble.
On effectue ainsi 5 multiplications de nombres plus petits au lieu des 9 multiplications requises par la méthode classique.

Après, nous effectuons une interpolation, cela permet de retrouver les 5 coefficients (w_0, w_1, w_2, w_3, w_4) du polynôme produit R(z) à partir des valeurs évaluées calculées précédemment.
On résout un système d'équations linéaires : <math> R(z) = w_4 z^4 + w_3 z^3 + w_2 z^2 + w_1 z + w_0 </math>
Finalement nous pouvons recomposer notre grand entier en positionnant les coefficients w_i aux bons rangs (en les décalant) et à gérer les retenues lors de l'addition finale:
Résultat <math>= w_4 B^{4k} + w_3 B^{3k} + w_2 B^{2k} + w_1 B^k + w_0</math>

=== B) Graphique ===

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Toomcook.png|500px]]
<div><b>Karatsuba</b></div>
</div>
<div style="max-width:800px;">
<p>on a reprit multi récursive (rouge)</p>
<p>on voit que Toom (vert) en dessous de karatsuba (jaune) en dessous de multi classique (rouge)</p>
<p>meilleur complexité</p>
</div>
</div>

== 5) La transformée de Fourier rapide ==

=== A) Fonctionnement ===

La transformation de Fourier rapide étant plus complexe que les autres algorithmes, nous allons essayer d'expliquer son fonctionnement malgré ne pas avoir réussi à l'implémenter.

Il faut comprendre que cet algorithme va considérer les facteurs comme des polynômes.

D'après le théorème de l'unisolvance, il n'existe qu'un seul polynôme de degré inférieur ou égal à <math> n </math> défini par <math>n + 1</math> points distincts. Cela implique non seulement que nous pouvons représenter chaque entier par un polynôme, mais également que si nous pouvons retrouver <math>n + m + 1</math> points (avec <math>n</math> et <math>m</math> la longueur des facteurs) du polynômes issue du produit entre deux facteurs, nous pourrons le retrouver.

Soit un entier quelconque, de forme :

<math>a_n a_{n-1} (...) a_1 a_0</math>

Avec <math>a_i</math>, un chiffre composant le nombre en base 10, qui vaut en réalité dans le nombre : <math>a_i \times 10^i</math>. On peut ainsi l'écrire sous la forme :

<math> P(x) = a_0 + a_1x + a_2x^2 + \dots + a_{n-1}x^{n-1} + a_nx^n </math>

Avec <math>x = 10</math> car nous sommes en base 10, nous obtenons :

<math>P(10) = a_0 + a_1 \times 10 + \dots + a_{n-1}10^{n-1} + a_n10^n </math>

Nous venons ainsi d'écrire notre nombre sous la forme d'un polynôme unique. Pour nous permettre d'évaluer en un nombre suffisant de points, nous allons devoir ajouter des 0 pour la récursion. Il nous faudra ajouter assez de 0 pour atteindre la prochaine puissance de 2 qui sera supérieure ou égale à <math>2n + 1</math>. L'ajout de 0 ne change pas le nombre car <math>0 \times x^n</math> n'ajoute pas de coefficient.

Cet algorithme est récursif et va segmenter en deux parties nos polynômes à chaque récursion. D'un coté les indice pairs et d'un coté les impaires.

Ainsi prenons les nombres 1234 et 5678, ces nombres sont respectivement représentés par les polynômes <math> P(x) = 4 + 3x + 2x^2 + x^3 </math> et <math> P(x) = 8 + 7x + 6x^2 + 5^3 </math>. Ce sont des polynômes de degré 3, ainsi leur produit donnera lieu à un polynôme de degré 6. Il nous faudra donc au minimum 7 points d'évaluation pour retrouve ce produit. De ce fait, en les représentant de la manière suivante :

<math>[4, 3, 2, 1, 0, 0, 0, 0]</math>
<math>[8, 7, 6, 5, 0, 0, 0, 0]</math>

Nous aurons assez de récursions possible pour les évaluer en un nombre suffisant de points différents car nous auront 3 récursions à faire pour atteindre notre cas de base. A chaque récursion, nous allons diviser nos polynômes en deux parties ce qui nous fait 8 feuilles à la dernière récursion.

En effet à chaque étape de la récursion nous allons séparer nos polynômes en deux tel que :

<math>P(x)=P_{\text{pair}}(x^2) + x \cdot P_{\text{impair}}(x^2)</math>

Durant les récursions, nous segmentons les polynômes mais ne les évaluons pas. C'est à la remonté des récursions que nous allons réellement évaluer nos polynômes. Lorsque l'on atteint notre cas de base, c'est à dire des polynômes de degré 0, nous remarquons qu'ils sont constants, nous n'avons donc pas besoin de les évaluer. En effet, peut importe le point en lequel nous voudrons l'évaluer, le polynôme renverra la constante. Nous la renvoyons donc seule.
Ensuite commence la remontée des récursions. A l'étape 1 de notre remontée nous allons reformer le polynôme précédemment séparé pour obtenir un polynôme de degré 1. Puis, nous évaluons ce polynôme avec les racines seconde de l'unité. Nous faisons à nouveau remonté les évaluations et recombinons à nouveau le polynôme qui sera ainsi de degré 2.
Nous l'évaluons maintenant avec les racines 4eme de l'unité. A chaque évaluation, nous réutilisons les résultats précédents, cela nous est permit par les racines de l'unité qui ont une structure récursive exploitable.

Finalement, nous arrivons à la fin de notre FFT, avec une représentation fréquentielle de la forme :

<math> [P(W_0), P(W_1), (...), P(W_n-1), P(W_n)] </math>

Cette représentation fréquentielle n'est autre que les évaluations du polynôme P aux racines nièmes de l'unité. Nous avons donc maintenant au minimum <math>2n+1</math> évaluations des polynômes facteurs. Il nous faut maintenant trouver les évaluations du produit final, c'est à dire les évaluations concernant le polynôme qui sera issue de la multiplication. On pourra ainsi le retrouver.

Soit <math>C</math> un polynome tel que <math> C = A \times B </math>, alors on a :

<math> C(x) = A(x) \times B(x) </math>

Ainsi on en déduit que <math> C(W_n^k) = A(W_n^k) \times B(W_n^k) </math>

On comprend donc que <math>FFT(C) = FFT(A) \times FFT(B)</math>

Il faut préciser que l'on fait le produit de FFT(A) et FFT(B) terme à terme, soit évaluation par évaluation.

Une fois en possession de <math>FFT(C)</math>, qui n'est autre que l'évaluation de notre polynôme final en un nombre suffisant de points pour le retrouver, nous pouvons faire l'<math>IFFT(FFT(C))</math>, qui va nous permettre de retrouver les coefficients de notre polynôme en faisant l'exacte inverse de la FFT.

Une fois les coefficients retrouvés, il nous suffit de gérer les retenues, et nous retrouvons un entier de la forme : <math>a_0 a_1 (...) a_{n-1} a_n</math>

=== B) Graphique ===

Intéressons nous maintenant à la complexité de l'algorithme utilisant la transformée de Fourier rapide. On sait que l'algorithme passe par 5 étapes importantes :

<ul>
<li>Etape 1 : Ecrire les deux facteurs sous la forme de polynômes</li>
<li>Etape 2 : Effectuer la <math>FFT</math> des deux polynômes</li>
<li>Etape 3 : Faire le produit terme à terme des <math>FFT</math> obtenues</li>
<li>Etape 4 : Faire l'<math>IFFT</math> du produit</li>
<li>Etape 5 : Gérer les retenues et écrire le nombre qui en découle</li>
</ul>

Or, parmi toutes ces étapes, certaines sont négligeable comme l'étape 1 et 5.

Pour connaitre la complexité de l'algorithme, additionnons les complexités des étapes restantes :

Une <math>FFT</math> a une complexité de <math>\mathcal{O}(n\times logn)</math> car elle fait <math>n</math> évaluation sur <math> log(n)</math> récursions. Dans le cadre de notre algorithme, nous devons faire la <math>FFT</math> de nos deux facteurs. Soit <math>2\times \mathcal{O}(n\times logn)</math>.

Pour le produit terme à terme, nous faisons naturellement <math>n</math> opérations.

Pour finir, l'<math>IFFT</math> a la même complexité que la <math>FFT</math>. Dans le cadre de notre algorithme nous l'emploierons qu'une seule fois, ce qui fait une complexité de <math>\mathcal{O}(n\times logn)</math>.

Après addition de toutes ces complexités, nous obtenons la complexité réelle de <math>3\mathcal{O}(n\times logn) + \mathcal{O}(n)</math>.

D'après le Master Theorem, nous avons donc <math> f(n) = 3(n\times logn)+n </math>, cherchons <math>f(n)\in\mathcal{O}(g(n))</math> :

Nous pouvons ignorer les expressions linéaires ainsi que les constantes multiplicatrices, nous obtenons donc <math>\mathcal{O}(g(n)) = \mathcal{O}(n \times log n)</math>.

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:30px; text-align:center;">
[[Fichier:FFT complexite.png|500px]]
<div><b>Graphiques des complexités</b></div>
</div>
<div style="max-width:800px;">
<p>Ce graphique ci-contre ne provient pas du fruit de nos recherches personnelles mais illustre bien la comparaison entre la complexité de la FFT et des autres algorithmes.</p>
<p>On remarque que la FFT est très efficace et devance de loin les autres algorithmes en terme de complexité. </p>
<p>Les algorithmes les plus efficaces pour calculer le produit de grands entiers reposent aujourd'hui sur des variantes de la transformée de Fourier rapide.</p>
</div>
</div>

= II - Produit de matrices =

== 1.1) naïve ==

La multiplication naïve de matrice requiert d'avoir des tailles de lignes/colonne semblable, ensuite pour chaque membre de la matrice résultat, on doit multiplier les composantes ligne de la première matrice par les composantes colonne de la deuxième et le tout sommé.

On en déduit la formule suivante:
<math>C_{i,j} = \sum_{k=1}^{n} (A_{i,k} \times B_{k,j})</math>

Et visuellement:

[[Fichier:Matricenaive.jpeg]]

On a donc un algorithme d'ordre de complexité <math>\mathcal{O}(g(n))</math>

== 1.2) naïve récursive ==

Dans un premier temps on doit découper nos deux matrices en quatres sous matrices de plus petite taille.
<math>A = \begin{pmatrix} A_{11} & A_{12} \ A_{21} & A_{22} \end{pmatrix}</math>
<math>B = \begin{pmatrix} B_{11} & B_{12} \ B_{21} & B_{22} \end{pmatrix}</math>

Ensuite on vient calculer la matrice résultat.
<math>C_{11} = (A_{11} \times B_{11}) + (A_{12} \times B_{21})</math>
<math>C_{12} = (A_{11} \times B_{12}) + (A_{12} \times B_{22})</math>
<math>C_{21} = (A_{21} \times B_{11}) + (A_{22} \times B_{21})</math>
<math>C_{22} = (A_{21} \times B_{12}) + (A_{22} \times B_{22})</math>

Le côté récursif est utile que pour les matrices de tailles <= 32 (32 valeurs stockées dedans),
si on est au dessus de cette taille alors on divisera à nouveau nos matrices en quatres.
On aura 8 multiplications mais de plus petite taille au final.

== 2) strassen ==

=== A) Fonctionnement ===

Strassen consiste à définir 7 produits intermédiaires qui, par des jeux de sommes et de différences, permettent de reconstruire les quadrants de la matrice résultante. On passe ainsi d'une complexité de O(n^3) à environ O(n^2.81)

=== B) Graphique ===

On voit bien la différence de complexité sur la multiplication de grande matrice entre l'approche naïve et l'approche récursive qui est beaucoup plus rapide.

[[Fichier:Analyse matrices.png]]

= Conclusion =

L'étude de ces algorithmes de multiplication nous a clairement montré l'évolution de la complexité algorithmique permettant de gagner en efficacité lorsque la taille des données augmente.

La multiplication classiqe, en <math>\mathcal{O}(n^2)</math>, résulte d'une approche naïve qui devient rapidement inefficace pour les grands entiers ou les grandes matrices. L'algorithme de Karatsuba nous montre qu'organiser de manière intelligente ses calculs algébrique permet parfois de gagner beaucoup de multiplications, et donc de temps. Nous avons ainsi réussi à passer d'une complexité de <math>\mathcal{O}(n^2)</math> à <math>\mathcal{O}(n^{log_2(3)})</math>, soit environ <math>\mathcal{O}(n^{1/585})</math>.

Des méthodes encore plus avancées comme utilise l'algorithme de Toom-Cook-3 continue dans cette idées de divisions d'entiers en blocs plus petits, tandis que la transformée de Fourier rapide change complètement de point de vue. En effet la FFT n'utilise pas la représentation classique des entiers mais fait appel à une vision polynomiale, ce qui transforme la convolution classique en multiplication terme à terme, ce qui lui permet d'atteindre une complexité de <math>\mathcal{O}(n \times log n)</math>.

Dans le cas des matrices, les mêmes logiques apparaissent comme par exemple avec l'algorithme de Strassen qui se rapproche très fortement de Karatsuba en combinant de manière astucieuse les parties d'entiers qui avaient été précédemment découpée.

On remarque néanmoins que la majorité des algorithmes efficaces s'orientent vers une approche récursive et non itérative. Néanmoins, nous avons pu trouver certaines de ces implémentations (comme par exemple la FFT) en itérative.

Avec ces recherches, nous comprenons que la réorganisations des calculs algébriques peuvent aider à gagner en complexité mais que pour faire de réels progrès, il nous faudra surement changer notre point de vue une nouvelle fois, et aborder le problème sous un angle nouveau comme le font dors et déjà les algorithmes les plus performants.

= Mentions =

Le premier gif est le résultat du travail de 'Walké', licence ci-contre : https://fr.wikipedia.org/wiki/Fichier:Addition.gif

Utilisation du site de production graphique "Desmos" : https://www.desmos.com/calculator?lang=fr

= Sources =

Pour karatsuba :
<ul>
<li> https://www.youtube.com/watch?v=PZ2gdWdKHAA </li>
</ul>

Pour mieux comprendre la FFT, nous avons utilisé plusieurs sources d'informations :
<ul>
<li> https://www.youtube.com/watch?v=h7apO7q16V0&list=WL&index=1&t=886s </li>
<li> https://fr.wikipedia.org/wiki/Interpolation_polynomiale </li>
</ul>

Algorithmes de multiplications d'entiers et de matrices

2026-05-11T21:21:26Z

Mangala : /* B) Graphique */

= Introduction =

Depuis l'apparition des ordinateurs modernes, une quantité faramineuse de calculs a dû être effectuée. Les progressions technologiques nous poussent à envisager la puissance de calcul comme une ressource qu'il faut optimiser dans les moindres détails. C'est ainsi que l'optimisation des algorithmes de calcul est devenue cruciale, surtout lorsqu'il nous faut effectuer des opérations sur de très grands entiers par exemple.

= Objectif =

L'objectif majeur de ce projet est de comprendre de manière plus approfondie ce qu'est la '''complexité algorithmique'''.
Pour atteindre cet objectif, nous implémenterons plusieurs algorithmes de multiplication qui auront pour but de calculer le produit de grands entiers ou de matrices.

= Point important : complexité =

=== Définition ===
La complexité d'un algorithme est la quantité des ressources qu'il utilise en fonction de la taille des entrées qu'on lui demande de traiter. On peut par exemple se concentrer sur le temps qu'un algorithme prend pour renvoyer un résultat ou sur la mémoire dont il a besoin. Dans le cadre de notre projet, nous nous attarderons plus particulièrement sur la quantité de calcul effectuée en fonction de la taille des entrées, ce qui est par ailleurs étroitement liée à la notion de temps. De manière générale, plus un algorithme doit faire de calcul, plus il est lent. (Attention, toutes les opérations arithmétiques de base ne se valent pas)

De manière plus familière, on dira que la complexité d'un algorithme pourrait s'apparenter à son comportement lorsqu'il doit traiter des données plus ou moins grandes.
Chaque algorithme a une complexité, et on l'exprime par une fonction qui adopte un comportement similaire au nombre de calculs nécessaires en fonction de la taille des entrées.

=== Notation ===
La complexité réelle d'un algorithme peut être décrite par une fonction <math> f(n) </math> représentant le nombre d'opérations effectuées en fonction de la taille <math>n</math> des données d'entrée.

Cependant, afin de simplifier l'étude de cette croissance, on utilise généralement une borne asymptotique notée <math>\mathcal{O}(g(n))</math>, où <math>g(n)</math> est une fonction ayant le même ordre de grandeur que <math>f(n)</math> lorsque <math>n</math> devient grand.

On dit alors que :

<math>
f(n)\in\mathcal{O}(g(n))
</math>

si et seulement s'il existe une constante <math>C>0</math> et un entier <math>n_0</math> tels que :

<math>
\forall n\ge n_0,\ f(n)\le Cg(n)
</math>

Cette notation <math>\mathcal{O}(g(n))</math> permettra de comparer beaucoup plus facilement les algorithmes entre eux.

=== Master Theorem ===

Afin de déterminer la complexité de certains algorithmes récursifs, nous utiliserons le "Master Theorem".

Ce théorème permet d'obtenir directement l'ordre de grandeur de nombreuses relations de récurrence apparaissant dans l'analyse d'algorithmes de type « diviser pour régner », comme l'algorithme de Karatsuba ou celui de Strassen.

La démonstration complète de ce théorème dépasse le cadre de notre projet et nécessite des connaissances mathématiques plus avancées. Nous l'utiliserons donc principalement comme un outil nous permettant de déterminer efficacement la complexité asymptotique des algorithmes étudiés.

=== Graphiques ===

Les complexités étant des fonctions, nous pouvons les représenter par un graphique qui affichera le temps d'exécution (ou nombre d'opérations) en fonction de la taille des entrées.

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:30px; text-align:center;">
[[Fichier:complexite.webp|500px]]
<div><b>Graphiques des complexités</b></div>
</div>
<div style="max-width:800px;">
<p>Ce graphique ci-contre compare les complexités en fonction de la taille des d'entrées.</p>
<p>On comprend ainsi que certaines complexités ne sont pas raisonnable dans la cadre de la multiplication de grands entiers.</p>
<p>C'est pourquoi l'étude de ces algorithmes s'avère nécessaire.</p>
</div>
</div>

=== Exemple ===
L'algorithme naïf d'addition que nous avons tous appris à l'école a une complexité de <math>\mathcal{O}(n)</math>.
Soit n la taille des nombres en entrée, l'algorithme doit faire environ n addition pour arriver au résultat demandé.

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Addition.gif|220px]]
<div><b>Addition naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Comme le montre l'exemple ci-contre, 786 et 467 font 3 chiffres de long donc n sera de 3.</p>
<p>Il nous faudra 3 opérations pour additionner ces entiers.</p>
<p>C'est ainsi qu'avec une taille d'entrée n, l'algorithme de l'addition naïve va devoir faire n opérations.</p>
<p>Cet algorithme a donc une complexité <math>f(n) = n</math> qui n'a pas besoin d'être approximée.</p>
<p>Ainsi sa complexité finale sera <math>\mathcal{O}(n)</math>.</p>
</div>
</div>

= Problématique =

Le calcul du produit de deux entiers de manière naïve a une complexité de <math> \mathcal{O}(n^2)</math>, et celui de deux matrices une complexité de <math> \mathcal{O}(n^3)</math>. Afin de mieux comprendre ce qu'est la complexité algorithmique, nous devrons implémenter des algorithmes ayant le même objectif, mais étant plus efficaces. Ces algorithmes s'avèreront plus complexes mais devrait aboutir à un calcul plus rapide du produit demandé.

Nous séparerons notre wiki en deux grandes parties, la première concernera nos recherche sur [[#I - Produit d'entiers|la multiplication d'entiers]], la deuxième sur [[#II - Produit de matrices|la multiplication de matrices]].

= I - Produit d'entiers =

Notre départ commence avec l'algorithme de multiplication d'entier naïf.
En effet il s'agit de l'algorithme de multiplication le plus connu, et nous l'utiliserons comme référence pour le comparer aux futurs algorithmes plus efficaces.
Intéressons nous à sa complexité.

== 1) Nos implémentations des grands entiers ==

Qui dit produit de grands entiers dit implémentation de grands entiers.

Dans le cadre de nos recherches, nous allons devoir implémenter des algorithmes qui vont manipuler des grands entiers.

Nous avons donc choisi de créer deux représentations différentes de ceux-ci (car nous travaillons sur différents langages de programmation), nous permettant à la fois une implémentation simplifié, mais aussi de nous rapprocher d'une implémentation bas niveau.

=== A) En python ===
En python, l'utilisation des "bytes" m'a grandement servi à comprendre comment les entiers étaient manipulés à bas niveau. En effet, un des objectifs secondaires de nos recherches était de manipuler des entiers directement avec leur formes stockées sur l'ordinateur, et non pas avec des int python.
En effet l'utilisation des int python nous aurait permit de passer les étapes de retenues, de signes... D'autant plus que les bytes permettent de stocker un nombre en base 256, ce qui permet de visualiser plus facilement les grands entiers.

La forme finale de la représentation des grands entiers en python sera donc la suivante :

[ signe , bytes , bytes , (...) , bytes ]

Le signe est représenté par un entier, 1 si le nombre est positif, 0 sinon.
Cette configuration rendra plus simple la gestion des signes.

=== B) En C++ ===

En C++, pour avoir une représentation de grand entiers j'ai du définir ma propre structure pour m'affranchir de la limite de taille imposé par les entiers standards: (int32 ou int64). Pour cela, j'ai une structure qui possède l'équivalent d'un array de byte (ce qui nous permet d'être en base 256 au lieu de la base 10 habituelle), et pour traiter le signe j'utilise un booléen, ainsi en mémoire j'ai une structure de n*Octets + 1 octet en taille.

[ bytes , bytes , (...) , bytes ] [ signe ]

Le booléen prend 1 octet de place mais ne touche pas aux octets qui encode le grand entier.
Cette configuration rendra plus simple la gestion des signes dans le cadre des multiplication.

== 2) La multiplication naïve ==

=== A) Fonctionnement ===
Dans le cas de la multiplication d'entiers, nous allons prendre deux nombres qui n'ont pas nécessairement la même longueur. Soit les nombre a et b, de longueur respective <math> n </math> et <math> m </math>.
<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Multiplication.png|220px]]
<div><b>Multiplication naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Prenons deux nombres de longueur 3 et 2, et cherchons combien d'opérations l'algorithme de multiplication naïve va devoir faire pour nous renvoyer leur produit.</p>
<p>Dans un premier temps, on remarque que l'on va devoir multiplier chaque chiffre du nombre du haut par le chiffre des unités du bas, qui est 6. Cela va représenter <math>n</math> opérations. (6x5, 6x1 et 6x4)</p>
<p>Dans un deuxième temps nous constatons que nous allons devoir faire la même chose avec le chiffre des dizaines du nombre du bas. Cela nous ajoute de nouveau <math>n</math> opérations.</p>
<p>On arrive assez facilement à la conclusion que pour faire notre produit, il va nous falloir faire <math>n</math> fois <math>m</math> opérations.</p>
</div>
</div>

Ainsi, la complexité de la multiplication naïve est <math>\mathcal{O}(n^2)</math>.
Il est en de même avec la multiplication naïve récursive.

=== B) Graphique ===
Montrons maintenant sa courbe sur un graphique :

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Multiplicationnaive.png|500px]]
<div><b>Multiplication naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Les points noirs sont des repères pour que les autres courbes aient une forme cohérente.</p>
<p>Ils sont tous sur l'axe des abscisses.</p>
<p>La courbe rouge représente la complexité de la multiplication naïve.</p>
<p>On remarque que la courbe a un visuel très similaire à la fonction <math> f(x) = x^2 </math> </p>
</div>
</div>

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Naif_recursif.png|500px]]
<div><b>Multiplication naïve récursive</b></div>
</div>
<div style="max-width:800px;">
<p>La courbe rouge représente la complexité de la multiplication naïve récursive.</p>
<p>Elle sera utilisé pour comparer les complexités entre algorithmes car, comme tous récursifs, elle a été codé avec les mêmes biais d'implémentation qu'eux.</p>
<p>Théoriquement les deux courbes ci-contre ont la même complexité, mais encore une fois, notre implémentation n'est pas parfaitement optimale et donc ne respecte pas de manière minutieuse le Master Theorem.</p>
</div>
</div>

== 3) La multiplication karatsuba ==

=== A) Fonctionnement ===

L'algorithme de karatsuba est un algorithme récursif de type diviser pour régner.

L'idée générale de l'algorithme est de passer de 4 multiplication à 3. En effet ces opérations étant moins couteuses, il est préférable d'en ajouter si cela permet d'enlever des multiplications.

L'algorithme de multiplication naif récursif utilise la segmentation des facteurs en deux de manière successive.

Soit <math>x</math> et <math>y</math> deux facteurs, nous avons les égalités suivantes :

<div style="font-size: 15px;">
<math>x = a \times B^{n/2} + b</math>
<math>y = c \times B^{n/2} + d</math>
</div>

Avec <math>a</math> et <math>c</math> les premières moitiés des facteurs <math>x</math> et <math>y</math>,
et <math> b </math> et <math>d</math> les dernières moitiés de ces facteurs ainsi que <math>B</math> la base d'écriture du nombre (Nous sommes en base 256 avec les bytes).

Cette présentation des deux facteurs de notre multiplication n'est que la résultante d'un découpage.
Le [[#Master Theorem|Master Theorem]] nous montre que :

<div style="font-size: 15px;">
<math>T(n) = 4T(n/2) + O(n)</math>
</div>

Puisque nous avons après découpage 4 entiers de longueur <math>n/2</math>.

Ainsi, ce découpage ne permet pas de gagner du temps d'après le [[#Master Theorem|Master Theorem]].

Cependant, l'algorithme de Karatsuba réutilise ce principe en le modifiant, ce qui nous permet de baisser la complexité globale de la multiplication dans son entièreté.

Avec l'écriture ci-dessus des nombres <math>x</math> et <math>y</math>, on peut facilement en déduire l'égalité suivante :

<div style="font-size: 15px;">
<math>x \times y = (ac) \times B^n + (ad + bc) \times B^{n/2} + bd</math>
</div>

On remarque 4 multiplications longues à faire dans cette expression. Les multiplications dont <math>B</math> est l'un des facteurs sont très rapides puisqu'il s'agit de la base dans laquelle nous travaillons. De cela en résulte un décalage plutôt qu'un vrai calcul à faire.

Karatsuba développe une partie de cette expression pour pouvoir négocier une multiplication au prix d'additions et soustractions.

En effet, nous savons déjà que :

<div style="font-size: 15px;">
<math>(a + b)(c + d) = ac + ad + bc + bd</math>
</div>

En manipulant l'égalité nous obtenons :

<div style="font-size: 15px;">
<math>ad + bc = (a + b)(c + d) - ac - bd</math>
</div>

ac et bd ayant déjà été calculé précédemment, il nous reste uniquement la multiplication <math>(a + b)(c + d)</math>.

Nous venons ainsi de calculer <math>ad + bc</math> en seulement une multiplication. C'est la que repose le gain de temps de la méthode Karatsuba par rapport à la multiplication naïve.

En effet, l'algorithme n'effectuera alors plus que 3 multiplications :
<div style="font-size: 15px;">
<math>ac</math>
<math>bd</math>
<math>(a + b)(c + d)</math>
</div>

La relation de récurrence devient donc :
<div style="font-size: 15px;">
<math>T(n)=3T(n/2)+O(n)</math>
</div>

Et le Master Theorem nous dit que :
<div style="font-size: 15px;">
<math>T(n)\in O(n^{\log_2(3)})</math>
</div>

Or <math>\log_2(3)\approx 1.585</math>, donc la complexité de l'algorithme de Karatsuba est de <math> \mathcal{O}(n^{1.585})</math>. Ce qui est bien plus efficace que la multiplication classique, surtout lorsque les facteurs deviennent très grands.

=== B) Graphique ===
<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Karatsuba.png|500px]]
<div><b>Karatsuba</b></div>
</div>
<div style="max-width:800px;">
<p>Sur le graphique ci-contre nous avons utilisé la courbe de la multiplication naïve récursive (rouge) à titre de comparaison.</p>
<p>On remarque graphiquement que Karatsuba (jaune) prend moins de temps à chaque calcul de produit.</p>
<p>On en déduit donc expérimentalement que Karatsuba à une meilleure complexité que la multiplication naïve.</p>
<p>Ainsi nous vérifions donc ce que le Master Theorem prouve, c'est à dire que la complexité de karatsuba est de <math> \mathcal{O}(n^{1.585})</math> </p>
</div>
</div>

== 4) La multiplication toom-cook-3 ==

=== A) Fonctionnement ===

L'objectif est de diviser les grands entiers X et Y en trois blocs de taille égale k.
On les traite alors comme des polynômes de degré 2:

<math>P(z) = X_2 \cdot z^2 + X_1 \cdot z + X_0</math>
<math>Q(z) = Y_2 \cdot z^2 + Y_1 \cdot z + Y_0</math>

On choisit 5 points distincts pour évaluer nos polynômes.
Ce choix de 5 points est crucial car le produit de deux polynômes de degré 2 est un polynôme de degré 4, qui nécessite 5 points pour être défini.
Les points standards sont :

P(0) = X0
P(1) = X0 + X1 + X2
P(-1) = X0 - X1 + X2
P(2) = X0 + 2*X1 + 4*X2
P(inf) = X2

(On procède de manière similaire pour Q.)

Ensuite nous multiplions récursivement chaque points de P et de Q ensemble.
On effectue ainsi 5 multiplications de nombres plus petits au lieu des 9 multiplications requises par la méthode classique.

Après, nous effectuons une interpolation, cela permet de retrouver les 5 coefficients (w_0, w_1, w_2, w_3, w_4) du polynôme produit R(z) à partir des valeurs évaluées calculées précédemment.
On résout un système d'équations linéaires : <math> R(z) = w_4 z^4 + w_3 z^3 + w_2 z^2 + w_1 z + w_0 </math>
Finalement nous pouvons recomposer notre grand entier en positionnant les coefficients w_i aux bons rangs (en les décalant) et à gérer les retenues lors de l'addition finale:
Résultat <math>= w_4 B^{4k} + w_3 B^{3k} + w_2 B^{2k} + w_1 B^k + w_0</math>

=== B) Graphique ===

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Toomcook.png|500px]]
<div><b>Karatsuba</b></div>
</div>
<div style="max-width:800px;">
<p>on a reprit multi récursive (rouge)</p>
<p>on voit que Toom (vert) en dessous de karatsuba (jaune) en dessous de multi classique (rouge)</p>
<p>meilleur complexité</p>
</div>
</div>

== 5) La transformée de Fourier rapide ==

=== A) Fonctionnement ===

La transformation de Fourier rapide étant plus complexe que les autres algorithmes, nous allons essayer d'expliquer son fonctionnement malgré ne pas avoir réussi à l'implémenter.

Il faut comprendre que cet algorithme va considérer les facteurs comme des polynômes.

D'après le théorème de l'unisolvance, il n'existe qu'un seul polynôme de degré inférieur ou égal à <math> n </math> défini par <math>n + 1</math> points distincts. Cela implique non seulement que nous pouvons représenter chaque entier par un polynôme, mais également que si nous pouvons retrouver <math>n + m + 1</math> points (avec <math>n</math> et <math>m</math> la longueur des facteurs) du polynômes issue du produit entre deux facteurs, nous pourrons le retrouver.

Soit un entier quelconque, de forme :

<math>a_n a_{n-1} (...) a_1 a_0</math>

Avec <math>a_i</math>, un chiffre composant le nombre en base 10, qui vaut en réalité dans le nombre : <math>a_i \times 10^i</math>. On peut ainsi l'écrire sous la forme :

<math> P(x) = a_0 + a_1x + a_2x^2 + \dots + a_{n-1}x^{n-1} + a_nx^n </math>

Avec <math>x = 10</math> car nous sommes en base 10, nous obtenons :

<math>P(10) = a_0 + a_1 \times 10 + \dots + a_{n-1}10^{n-1} + a_n10^n </math>

Nous venons ainsi d'écrire notre nombre sous la forme d'un polynôme unique. Pour nous permettre d'évaluer en un nombre suffisant de points, nous allons devoir ajouter des 0 pour la récursion. Il nous faudra ajouter assez de 0 pour atteindre la prochaine puissance de 2 qui sera supérieure ou égale à <math>2n + 1</math>. L'ajout de 0 ne change pas le nombre car <math>0 \times x^n</math> n'ajoute pas de coefficient.

Cet algorithme est récursif et va segmenter en deux parties nos polynômes à chaque récursion. D'un coté les indice pairs et d'un coté les impaires.

Ainsi prenons les nombres 1234 et 5678, ces nombres sont respectivement représentés par les polynômes <math> P(x) = 4 + 3x + 2x^2 + x^3 </math> et <math> P(x) = 8 + 7x + 6x^2 + 5^3 </math>. Ce sont des polynômes de degré 3, ainsi leur produit donnera lieu à un polynôme de degré 6. Il nous faudra donc au minimum 7 points d'évaluation pour retrouve ce produit. De ce fait, en les représentant de la manière suivante :

<math>[4, 3, 2, 1, 0, 0, 0, 0]</math>
<math>[8, 7, 6, 5, 0, 0, 0, 0]</math>

Nous aurons assez de récursions possible pour les évaluer en un nombre suffisant de points différents car nous auront 3 récursions à faire pour atteindre notre cas de base. A chaque récursion, nous allons diviser nos polynômes en deux parties ce qui nous fait 8 feuilles à la dernière récursion.

En effet à chaque étape de la récursion nous allons séparer nos polynômes en deux tel que :

<math>P(x)=P_{\text{pair}}(x^2) + x \cdot P_{\text{impair}}(x^2)</math>

Durant les récursions, nous segmentons les polynômes mais ne les évaluons pas. C'est à la remonté des récursions que nous allons réellement évaluer nos polynômes. Lorsque l'on atteint notre cas de base, c'est à dire des polynômes de degré 0, nous remarquons qu'ils sont constants, nous n'avons donc pas besoin de les évaluer. En effet, peut importe le point en lequel nous voudrons l'évaluer, le polynôme renverra la constante. Nous la renvoyons donc seule.
Ensuite commence la remontée des récursions. A l'étape 1 de notre remontée nous allons reformer le polynôme précédemment séparé pour obtenir un polynôme de degré 1. Puis, nous évaluons ce polynôme avec les racines seconde de l'unité. Nous faisons à nouveau remonté les évaluations et recombinons à nouveau le polynôme qui sera ainsi de degré 2.
Nous l'évaluons maintenant avec les racines 4eme de l'unité. A chaque évaluation, nous réutilisons les résultats précédents, cela nous est permit par les racines de l'unité qui ont une structure récursive exploitable.

Finalement, nous arrivons à la fin de notre FFT, avec une représentation fréquentielle de la forme :

<math> [P(W_0), P(W_1), (...), P(W_n-1), P(W_n)] </math>

Cette représentation fréquentielle n'est autre que les évaluations du polynôme P aux racines nièmes de l'unité. Nous avons donc maintenant au minimum <math>2n+1</math> évaluations des polynômes facteurs. Il nous faut maintenant trouver les évaluations du produit final, c'est à dire les évaluations concernant le polynôme qui sera issue de la multiplication. On pourra ainsi le retrouver.

Soit <math>C</math> un polynome tel que <math> C = A \times B </math>, alors on a :

<math> C(x) = A(x) \times B(x) </math>

Ainsi on en déduit que <math> C(W_n^k) = A(W_n^k) \times B(W_n^k) </math>

On comprend donc que <math>FFT(C) = FFT(A) \times FFT(B)</math>

Il faut préciser que l'on fait le produit de FFT(A) et FFT(B) terme à terme, soit évaluation par évaluation.

Une fois en possession de <math>FFT(C)</math>, qui n'est autre que l'évaluation de notre polynôme final en un nombre suffisant de points pour le retrouver, nous pouvons faire l'<math>IFFT(FFT(C))</math>, qui va nous permettre de retrouver les coefficients de notre polynôme en faisant l'exacte inverse de la FFT.

Une fois les coefficients retrouvés, il nous suffit de gérer les retenues, et nous retrouvons un entier de la forme : <math>a_0 a_1 (...) a_{n-1} a_n</math>

=== B) Graphique ===

Intéressons nous maintenant à la complexité de l'algorithme utilisant la transformée de Fourier rapide. On sait que l'algorithme passe par 5 étapes importantes :

<ul>
<li>Etape 1 : Ecrire les deux facteurs sous la forme de polynômes</li>
<li>Etape 2 : Effectuer la <math>FFT</math> des deux polynômes</li>
<li>Etape 3 : Faire le produit terme à terme des <math>FFT</math> obtenues</li>
<li>Etape 4 : Faire l'<math>IFFT</math> du produit</li>
<li>Etape 5 : Gérer les retenues et écrire le nombre qui en découle</li>
</ul>

Or, parmi toutes ces étapes, certaines sont négligeable comme l'étape 1 et 5.

Pour connaitre la complexité de l'algorithme, additionnons les complexités des étapes restantes :

Une <math>FFT</math> a une complexité de <math>\mathcal{O}(n\times logn)</math> car elle fait <math>n</math> évaluation sur <math> log(n)</math> récursions. Dans le cadre de notre algorithme, nous devons faire la <math>FFT</math> de nos deux facteurs. Soit <math>2\times \mathcal{O}(n\times logn)</math>.

Pour le produit terme à terme, nous faisons naturellement <math>n</math> opérations.

Pour finir, l'<math>IFFT</math> a la même complexité que la <math>FFT</math>. Dans le cadre de notre algorithme nous l'emploierons qu'une seule fois, ce qui fait une complexité de <math>\mathcal{O}(n\times logn)</math>.

Après addition de toutes ces complexités, nous obtenons la complexité réelle de <math>3\mathcal{O}(n\times logn) + \mathcal{O}(n)</math>.

D'après le Master Theorem, nous avons donc <math> f(n) = 3(n\times logn)+n </math>, cherchons <math>f(n)\in\mathcal{O}(g(n))</math> :

Nous pouvons ignorer les expressions linéaires ainsi que les constantes multiplicatrices, nous obtenons donc <math>\mathcal{O}(g(n)) = \mathcal{O}(n \times log n)</math>.

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:30px; text-align:center;">
[[Fichier:FFT complexite.png|500px]]
<div><b>Graphiques des complexités</b></div>
</div>
<div style="max-width:800px;">
<p>Ce graphique ci-contre ne provient pas du fruit de nos recherches personnelles mais illustre bien la comparaison entre la complexité de la FFT et des autres algorithmes.</p>
<p>On remarque que la FFT est très efficace et devance de loin les autres algorithmes en terme de complexité. </p>
<p>Les algorithmes les plus efficaces pour calculer le produit de grands entiers reposent aujourd'hui sur des variantes de la transformée de Fourier rapide.</p>
</div>
</div>

= II - Produit de matrices =

== 1.1) naïve ==

La multiplication naïve de matrice requiert d'avoir des tailles de lignes/colonne semblable, ensuite pour chaque membre de la matrice résultat, on doit multiplier les composantes ligne de la première matrice par les composantes colonne de la deuxième et le tout sommé.

On en déduit la formule suivante:
<math>C_{i,j} = \sum_{k=1}^{n} (A_{i,k} \times B_{k,j})</math>

Et visuellement:

[[Fichier:Matricenaive.jpeg]]

On a donc un algorithme d'ordre de complexité <math>\mathcal{O}(g(n))</math>

== 1.2) naïve récursive ==

Dans un premier temps on doit découper nos deux matrices en quatres sous matrices de plus petite taille.
<math>A = \begin{pmatrix} A_{11} & A_{12} \ A_{21} & A_{22} \end{pmatrix}</math>
<math>B = \begin{pmatrix} B_{11} & B_{12} \ B_{21} & B_{22} \end{pmatrix}</math>

Ensuite on vient calculer la matrice résultat.
<math>C_{11} = (A_{11} \times B_{11}) + (A_{12} \times B_{21})</math>
<math>C_{12} = (A_{11} \times B_{12}) + (A_{12} \times B_{22})</math>
<math>C_{21} = (A_{21} \times B_{11}) + (A_{22} \times B_{21})</math>
<math>C_{22} = (A_{21} \times B_{12}) + (A_{22} \times B_{22})</math>

Le côté récursif est utile que pour les matrices de tailles <= 32 (32 valeurs stockées dedans),
si on est au dessus de cette taille alors on divisera à nouveau nos matrices en quatres.
On aura 8 multiplications mais de plus petite taille au final.

== 2) strassen ==

=== A) Fonctionnement ===

Strassen consiste à définir 7 produits intermédiaires qui, par des jeux de sommes et de différences, permettent de reconstruire les quadrants de la matrice résultante. On passe ainsi d'une complexité de O(n^3) à environ O(n^2.81)

=== B) Graphique ===

On voit bien la différence de complexité sur la multiplication de grande matrice entre l'approche naïve et l'approche récursive qui est beaucoup plus rapide.

[[Fichier:Analyse matrices.png]]

= Conclusion =

L'étude de ces algorithmes de multiplication nous a clairement montré l'évolution de la complexité algorithmique permettant de gagner en efficacité lorsque la taille des données augmente.

La multiplication classiqe, en <math>\mathcal{O}(n^2)</math>, résulte d'une approche naïve qui devient rapidement inefficace pour les grands entiers ou les grandes matrices. L'algorithme de Karatsuba nous montre qu'organiser de manière intelligente ses calculs algébrique permet parfois de gagner beaucoup de multiplications, et donc de temps. Nous avons ainsi réussi à passer d'une complexité de <math>\mathcal{O}(n^2)</math> à <math>\mathcal{O}(n^{log_2(3)})</math>, soit environ <math>\mathcal{O}(n^{1/585})</math>.

Des méthodes encore plus avancées comme utilise l'algorithme de Toom-Cook-3 continue dans cette idées de divisions d'entiers en blocs plus petits, tandis que la transformée de Fourier rapide change complètement de point de vue. En effet la FFT n'utilise pas la représentation classique des entiers mais fait appel à une vision polynomiale, ce qui transforme la convolution classique en multiplication terme à terme, ce qui lui permet d'atteindre une complexité de <math>\mathcal{O}(n \times log n)</math>.

Dans le cas des matrices, les mêmes logiques apparaissent comme par exemple avec l'algorithme de Strassen qui se rapproche très fortement de Karatsuba en combinant de manière astucieuse les parties d'entiers qui avaient été précédemment découpée.

On remarque néanmoins que la majorité des algorithmes efficaces s'orientent vers une approche récursive et non itérative. Néanmoins, nous avons pu trouver certaines de ces implémentations (comme par exemple la FFT) en itérative.

Avec ces recherches, nous comprenons que la réorganisations des calculs algébriques peuvent aider à gagner en complexité mais que pour faire de réels progrès, il nous faudra surement changer notre point de vue une nouvelle fois, et aborder le problème sous un angle nouveau comme le font dors et déjà les algorithmes les plus performants.

= Mentions =

Le premier gif est le résultat du travail de 'Walké', licence ci-contre : https://fr.wikipedia.org/wiki/Fichier:Addition.gif

Utilisation du site de production graphique "Desmos" : https://www.desmos.com/calculator?lang=fr

= Sources =

Pour karatsuba :
<ul>
<li> https://www.youtube.com/watch?v=PZ2gdWdKHAA </li>
</ul>

Pour mieux comprendre la FFT, nous avons utilisé plusieurs sources d'informations :
<ul>
<li> https://www.youtube.com/watch?v=h7apO7q16V0&list=WL&index=1&t=886s </li>
<li> https://fr.wikipedia.org/wiki/Interpolation_polynomiale </li>
</ul>

Algorithmes de multiplications d'entiers et de matrices

2026-05-11T21:19:50Z

Mangala : /* B) Graphique */

= Introduction =

Depuis l'apparition des ordinateurs modernes, une quantité faramineuse de calculs a dû être effectuée. Les progressions technologiques nous poussent à envisager la puissance de calcul comme une ressource qu'il faut optimiser dans les moindres détails. C'est ainsi que l'optimisation des algorithmes de calcul est devenue cruciale, surtout lorsqu'il nous faut effectuer des opérations sur de très grands entiers par exemple.

= Objectif =

L'objectif majeur de ce projet est de comprendre de manière plus approfondie ce qu'est la '''complexité algorithmique'''.
Pour atteindre cet objectif, nous implémenterons plusieurs algorithmes de multiplication qui auront pour but de calculer le produit de grands entiers ou de matrices.

= Point important : complexité =

=== Définition ===
La complexité d'un algorithme est la quantité des ressources qu'il utilise en fonction de la taille des entrées qu'on lui demande de traiter. On peut par exemple se concentrer sur le temps qu'un algorithme prend pour renvoyer un résultat ou sur la mémoire dont il a besoin. Dans le cadre de notre projet, nous nous attarderons plus particulièrement sur la quantité de calcul effectuée en fonction de la taille des entrées, ce qui est par ailleurs étroitement liée à la notion de temps. De manière générale, plus un algorithme doit faire de calcul, plus il est lent. (Attention, toutes les opérations arithmétiques de base ne se valent pas)

De manière plus familière, on dira que la complexité d'un algorithme pourrait s'apparenter à son comportement lorsqu'il doit traiter des données plus ou moins grandes.
Chaque algorithme a une complexité, et on l'exprime par une fonction qui adopte un comportement similaire au nombre de calculs nécessaires en fonction de la taille des entrées.

=== Notation ===
La complexité réelle d'un algorithme peut être décrite par une fonction <math> f(n) </math> représentant le nombre d'opérations effectuées en fonction de la taille <math>n</math> des données d'entrée.

Cependant, afin de simplifier l'étude de cette croissance, on utilise généralement une borne asymptotique notée <math>\mathcal{O}(g(n))</math>, où <math>g(n)</math> est une fonction ayant le même ordre de grandeur que <math>f(n)</math> lorsque <math>n</math> devient grand.

On dit alors que :

<math>
f(n)\in\mathcal{O}(g(n))
</math>

si et seulement s'il existe une constante <math>C>0</math> et un entier <math>n_0</math> tels que :

<math>
\forall n\ge n_0,\ f(n)\le Cg(n)
</math>

Cette notation <math>\mathcal{O}(g(n))</math> permettra de comparer beaucoup plus facilement les algorithmes entre eux.

=== Master Theorem ===

Afin de déterminer la complexité de certains algorithmes récursifs, nous utiliserons le "Master Theorem".

Ce théorème permet d'obtenir directement l'ordre de grandeur de nombreuses relations de récurrence apparaissant dans l'analyse d'algorithmes de type « diviser pour régner », comme l'algorithme de Karatsuba ou celui de Strassen.

La démonstration complète de ce théorème dépasse le cadre de notre projet et nécessite des connaissances mathématiques plus avancées. Nous l'utiliserons donc principalement comme un outil nous permettant de déterminer efficacement la complexité asymptotique des algorithmes étudiés.

=== Graphiques ===

Les complexités étant des fonctions, nous pouvons les représenter par un graphique qui affichera le temps d'exécution (ou nombre d'opérations) en fonction de la taille des entrées.

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:30px; text-align:center;">
[[Fichier:complexite.webp|500px]]
<div><b>Graphiques des complexités</b></div>
</div>
<div style="max-width:800px;">
<p>Ce graphique ci-contre compare les complexités en fonction de la taille des d'entrées.</p>
<p>On comprend ainsi que certaines complexités ne sont pas raisonnable dans la cadre de la multiplication de grands entiers.</p>
<p>C'est pourquoi l'étude de ces algorithmes s'avère nécessaire.</p>
</div>
</div>

=== Exemple ===
L'algorithme naïf d'addition que nous avons tous appris à l'école a une complexité de <math>\mathcal{O}(n)</math>.
Soit n la taille des nombres en entrée, l'algorithme doit faire environ n addition pour arriver au résultat demandé.

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Addition.gif|220px]]
<div><b>Addition naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Comme le montre l'exemple ci-contre, 786 et 467 font 3 chiffres de long donc n sera de 3.</p>
<p>Il nous faudra 3 opérations pour additionner ces entiers.</p>
<p>C'est ainsi qu'avec une taille d'entrée n, l'algorithme de l'addition naïve va devoir faire n opérations.</p>
<p>Cet algorithme a donc une complexité <math>f(n) = n</math> qui n'a pas besoin d'être approximée.</p>
<p>Ainsi sa complexité finale sera <math>\mathcal{O}(n)</math>.</p>
</div>
</div>

= Problématique =

Le calcul du produit de deux entiers de manière naïve a une complexité de <math> \mathcal{O}(n^2)</math>, et celui de deux matrices une complexité de <math> \mathcal{O}(n^3)</math>. Afin de mieux comprendre ce qu'est la complexité algorithmique, nous devrons implémenter des algorithmes ayant le même objectif, mais étant plus efficaces. Ces algorithmes s'avèreront plus complexes mais devrait aboutir à un calcul plus rapide du produit demandé.

Nous séparerons notre wiki en deux grandes parties, la première concernera nos recherche sur [[#I - Produit d'entiers|la multiplication d'entiers]], la deuxième sur [[#II - Produit de matrices|la multiplication de matrices]].

= I - Produit d'entiers =

Notre départ commence avec l'algorithme de multiplication d'entier naïf.
En effet il s'agit de l'algorithme de multiplication le plus connu, et nous l'utiliserons comme référence pour le comparer aux futurs algorithmes plus efficaces.
Intéressons nous à sa complexité.

== 1) Nos implémentations des grands entiers ==

Qui dit produit de grands entiers dit implémentation de grands entiers.

Dans le cadre de nos recherches, nous allons devoir implémenter des algorithmes qui vont manipuler des grands entiers.

Nous avons donc choisi de créer deux représentations différentes de ceux-ci (car nous travaillons sur différents langages de programmation), nous permettant à la fois une implémentation simplifié, mais aussi de nous rapprocher d'une implémentation bas niveau.

=== A) En python ===
En python, l'utilisation des "bytes" m'a grandement servi à comprendre comment les entiers étaient manipulés à bas niveau. En effet, un des objectifs secondaires de nos recherches était de manipuler des entiers directement avec leur formes stockées sur l'ordinateur, et non pas avec des int python.
En effet l'utilisation des int python nous aurait permit de passer les étapes de retenues, de signes... D'autant plus que les bytes permettent de stocker un nombre en base 256, ce qui permet de visualiser plus facilement les grands entiers.

La forme finale de la représentation des grands entiers en python sera donc la suivante :

[ signe , bytes , bytes , (...) , bytes ]

Le signe est représenté par un entier, 1 si le nombre est positif, 0 sinon.
Cette configuration rendra plus simple la gestion des signes.

=== B) En C++ ===

En C++, pour avoir une représentation de grand entiers j'ai du définir ma propre structure pour m'affranchir de la limite de taille imposé par les entiers standards: (int32 ou int64). Pour cela, j'ai une structure qui possède l'équivalent d'un array de byte (ce qui nous permet d'être en base 256 au lieu de la base 10 habituelle), et pour traiter le signe j'utilise un booléen, ainsi en mémoire j'ai une structure de n*Octets + 1 octet en taille.

[ bytes , bytes , (...) , bytes ] [ signe ]

Le booléen prend 1 octet de place mais ne touche pas aux octets qui encode le grand entier.
Cette configuration rendra plus simple la gestion des signes dans le cadre des multiplication.

== 2) La multiplication naïve ==

=== A) Fonctionnement ===
Dans le cas de la multiplication d'entiers, nous allons prendre deux nombres qui n'ont pas nécessairement la même longueur. Soit les nombre a et b, de longueur respective <math> n </math> et <math> m </math>.
<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Multiplication.png|220px]]
<div><b>Multiplication naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Prenons deux nombres de longueur 3 et 2, et cherchons combien d'opérations l'algorithme de multiplication naïve va devoir faire pour nous renvoyer leur produit.</p>
<p>Dans un premier temps, on remarque que l'on va devoir multiplier chaque chiffre du nombre du haut par le chiffre des unités du bas, qui est 6. Cela va représenter <math>n</math> opérations. (6x5, 6x1 et 6x4)</p>
<p>Dans un deuxième temps nous constatons que nous allons devoir faire la même chose avec le chiffre des dizaines du nombre du bas. Cela nous ajoute de nouveau <math>n</math> opérations.</p>
<p>On arrive assez facilement à la conclusion que pour faire notre produit, il va nous falloir faire <math>n</math> fois <math>m</math> opérations.</p>
</div>
</div>

Ainsi, la complexité de la multiplication naïve est <math>\mathcal{O}(n^2)</math>.
Il est en de même avec la multiplication naïve récursive.

=== B) Graphique ===
Montrons maintenant sa courbe sur un graphique :

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Multiplicationnaive.png|500px]]
<div><b>Multiplication naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Les points noirs sont des repères pour que les autres courbes aient une forme cohérente.</p>
<p>Ils sont tous sur l'axe des abscisses.</p>
<p>La courbe rouge représente la complexité de la multiplication naïve.</p>
<p>On remarque que la courbe a un visuel très similaire à la fonction <math>f(x) = x^2</math> </p>
</div>
</div>

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Naif_recursif.png|500px]]
<div><b>Multiplication naïve récursive</b></div>
</div>
<div style="max-width:800px;">
<p>La courbe rouge représente la complexité de la multiplication naïve récursive.</p>
<p>Elle sera utilisé pour comparer les complexités entre algorithmes car, comme tous récursifs, elle a été codé avec les mêmes biais d'implémentation qu'eux.</p>
<p>Théoriquement les deux courbes ci-contre ont la même complexité, mais encore une fois, notre implémentation n'est pas parfaitement optimale et donc ne respecte pas de manière minutieuse le Master Theorem.</p>
</div>
</div>

== 3) La multiplication karatsuba ==

=== A) Fonctionnement ===

L'algorithme de karatsuba est un algorithme récursif de type diviser pour régner.

L'idée générale de l'algorithme est de passer de 4 multiplication à 3. En effet ces opérations étant moins couteuses, il est préférable d'en ajouter si cela permet d'enlever des multiplications.

L'algorithme de multiplication naif récursif utilise la segmentation des facteurs en deux de manière successive.

Soit <math>x</math> et <math>y</math> deux facteurs, nous avons les égalités suivantes :

<div style="font-size: 15px;">
<math>x = a \times B^{n/2} + b</math>
<math>y = c \times B^{n/2} + d</math>
</div>

Avec <math>a</math> et <math>c</math> les premières moitiés des facteurs <math>x</math> et <math>y</math>,
et <math> b </math> et <math>d</math> les dernières moitiés de ces facteurs ainsi que <math>B</math> la base d'écriture du nombre (Nous sommes en base 256 avec les bytes).

Cette présentation des deux facteurs de notre multiplication n'est que la résultante d'un découpage.
Le [[#Master Theorem|Master Theorem]] nous montre que :

<div style="font-size: 15px;">
<math>T(n) = 4T(n/2) + O(n)</math>
</div>

Puisque nous avons après découpage 4 entiers de longueur <math>n/2</math>.

Ainsi, ce découpage ne permet pas de gagner du temps d'après le [[#Master Theorem|Master Theorem]].

Cependant, l'algorithme de Karatsuba réutilise ce principe en le modifiant, ce qui nous permet de baisser la complexité globale de la multiplication dans son entièreté.

Avec l'écriture ci-dessus des nombres <math>x</math> et <math>y</math>, on peut facilement en déduire l'égalité suivante :

<div style="font-size: 15px;">
<math>x \times y = (ac) \times B^n + (ad + bc) \times B^{n/2} + bd</math>
</div>

On remarque 4 multiplications longues à faire dans cette expression. Les multiplications dont <math>B</math> est l'un des facteurs sont très rapides puisqu'il s'agit de la base dans laquelle nous travaillons. De cela en résulte un décalage plutôt qu'un vrai calcul à faire.

Karatsuba développe une partie de cette expression pour pouvoir négocier une multiplication au prix d'additions et soustractions.

En effet, nous savons déjà que :

<div style="font-size: 15px;">
<math>(a + b)(c + d) = ac + ad + bc + bd</math>
</div>

En manipulant l'égalité nous obtenons :

<div style="font-size: 15px;">
<math>ad + bc = (a + b)(c + d) - ac - bd</math>
</div>

ac et bd ayant déjà été calculé précédemment, il nous reste uniquement la multiplication <math>(a + b)(c + d)</math>.

Nous venons ainsi de calculer <math>ad + bc</math> en seulement une multiplication. C'est la que repose le gain de temps de la méthode Karatsuba par rapport à la multiplication naïve.

En effet, l'algorithme n'effectuera alors plus que 3 multiplications :
<div style="font-size: 15px;">
<math>ac</math>
<math>bd</math>
<math>(a + b)(c + d)</math>
</div>

La relation de récurrence devient donc :
<div style="font-size: 15px;">
<math>T(n)=3T(n/2)+O(n)</math>
</div>

Et le Master Theorem nous dit que :
<div style="font-size: 15px;">
<math>T(n)\in O(n^{\log_2(3)})</math>
</div>

Or <math>\log_2(3)\approx 1.585</math>, donc la complexité de l'algorithme de Karatsuba est de <math> \mathcal{O}(n^{1.585})</math>. Ce qui est bien plus efficace que la multiplication classique, surtout lorsque les facteurs deviennent très grands.

=== B) Graphique ===
<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Karatsuba.png|500px]]
<div><b>Karatsuba</b></div>
</div>
<div style="max-width:800px;">
<p>Sur le graphique ci-contre nous avons utilisé la courbe de la multiplication naïve récursive (rouge) à titre de comparaison.</p>
<p>On remarque graphiquement que Karatsuba (jaune) prend moins de temps à chaque calcul de produit.</p>
<p>On en déduit donc expérimentalement que Karatsuba à une meilleure complexité que la multiplication naïve.</p>
<p>Ainsi nous vérifions donc ce que le Master Theorem prouve, c'est à dire que la complexité de karatsuba est de <math> \mathcal{O}(n^{1.585})</math> </p>
</div>
</div>

== 4) La multiplication toom-cook-3 ==

=== A) Fonctionnement ===

L'objectif est de diviser les grands entiers X et Y en trois blocs de taille égale k.
On les traite alors comme des polynômes de degré 2:

<math>P(z) = X_2 \cdot z^2 + X_1 \cdot z + X_0</math>
<math>Q(z) = Y_2 \cdot z^2 + Y_1 \cdot z + Y_0</math>

On choisit 5 points distincts pour évaluer nos polynômes.
Ce choix de 5 points est crucial car le produit de deux polynômes de degré 2 est un polynôme de degré 4, qui nécessite 5 points pour être défini.
Les points standards sont :

P(0) = X0
P(1) = X0 + X1 + X2
P(-1) = X0 - X1 + X2
P(2) = X0 + 2*X1 + 4*X2
P(inf) = X2

(On procède de manière similaire pour Q.)

Ensuite nous multiplions récursivement chaque points de P et de Q ensemble.
On effectue ainsi 5 multiplications de nombres plus petits au lieu des 9 multiplications requises par la méthode classique.

Après, nous effectuons une interpolation, cela permet de retrouver les 5 coefficients (w_0, w_1, w_2, w_3, w_4) du polynôme produit R(z) à partir des valeurs évaluées calculées précédemment.
On résout un système d'équations linéaires : <math> R(z) = w_4 z^4 + w_3 z^3 + w_2 z^2 + w_1 z + w_0 </math>
Finalement nous pouvons recomposer notre grand entier en positionnant les coefficients w_i aux bons rangs (en les décalant) et à gérer les retenues lors de l'addition finale:
Résultat <math>= w_4 B^{4k} + w_3 B^{3k} + w_2 B^{2k} + w_1 B^k + w_0</math>

=== B) Graphique ===

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Toomcook.png|500px]]
<div><b>Karatsuba</b></div>
</div>
<div style="max-width:800px;">
<p>on a reprit multi récursive (rouge)</p>
<p>on voit que Toom (vert) en dessous de karatsuba (jaune) en dessous de multi classique (rouge)</p>
<p>meilleur complexité</p>
</div>
</div>

== 5) La transformée de Fourier rapide ==

=== A) Fonctionnement ===

La transformation de Fourier rapide étant plus complexe que les autres algorithmes, nous allons essayer d'expliquer son fonctionnement malgré ne pas avoir réussi à l'implémenter.

Il faut comprendre que cet algorithme va considérer les facteurs comme des polynômes.

D'après le théorème de l'unisolvance, il n'existe qu'un seul polynôme de degré inférieur ou égal à <math> n </math> défini par <math>n + 1</math> points distincts. Cela implique non seulement que nous pouvons représenter chaque entier par un polynôme, mais également que si nous pouvons retrouver <math>n + m + 1</math> points (avec <math>n</math> et <math>m</math> la longueur des facteurs) du polynômes issue du produit entre deux facteurs, nous pourrons le retrouver.

Soit un entier quelconque, de forme :

<math>a_n a_{n-1} (...) a_1 a_0</math>

Avec <math>a_i</math>, un chiffre composant le nombre en base 10, qui vaut en réalité dans le nombre : <math>a_i \times 10^i</math>. On peut ainsi l'écrire sous la forme :

<math> P(x) = a_0 + a_1x + a_2x^2 + \dots + a_{n-1}x^{n-1} + a_nx^n </math>

Avec <math>x = 10</math> car nous sommes en base 10, nous obtenons :

<math>P(10) = a_0 + a_1 \times 10 + \dots + a_{n-1}10^{n-1} + a_n10^n </math>

Nous venons ainsi d'écrire notre nombre sous la forme d'un polynôme unique. Pour nous permettre d'évaluer en un nombre suffisant de points, nous allons devoir ajouter des 0 pour la récursion. Il nous faudra ajouter assez de 0 pour atteindre la prochaine puissance de 2 qui sera supérieure ou égale à <math>2n + 1</math>. L'ajout de 0 ne change pas le nombre car <math>0 \times x^n</math> n'ajoute pas de coefficient.

Cet algorithme est récursif et va segmenter en deux parties nos polynômes à chaque récursion. D'un coté les indice pairs et d'un coté les impaires.

Ainsi prenons les nombres 1234 et 5678, ces nombres sont respectivement représentés par les polynômes <math> P(x) = 4 + 3x + 2x^2 + x^3 </math> et <math> P(x) = 8 + 7x + 6x^2 + 5^3 </math>. Ce sont des polynômes de degré 3, ainsi leur produit donnera lieu à un polynôme de degré 6. Il nous faudra donc au minimum 7 points d'évaluation pour retrouve ce produit. De ce fait, en les représentant de la manière suivante :

<math>[4, 3, 2, 1, 0, 0, 0, 0]</math>
<math>[8, 7, 6, 5, 0, 0, 0, 0]</math>

Nous aurons assez de récursions possible pour les évaluer en un nombre suffisant de points différents car nous auront 3 récursions à faire pour atteindre notre cas de base. A chaque récursion, nous allons diviser nos polynômes en deux parties ce qui nous fait 8 feuilles à la dernière récursion.

En effet à chaque étape de la récursion nous allons séparer nos polynômes en deux tel que :

<math>P(x)=P_{\text{pair}}(x^2) + x \cdot P_{\text{impair}}(x^2)</math>

Durant les récursions, nous segmentons les polynômes mais ne les évaluons pas. C'est à la remonté des récursions que nous allons réellement évaluer nos polynômes. Lorsque l'on atteint notre cas de base, c'est à dire des polynômes de degré 0, nous remarquons qu'ils sont constants, nous n'avons donc pas besoin de les évaluer. En effet, peut importe le point en lequel nous voudrons l'évaluer, le polynôme renverra la constante. Nous la renvoyons donc seule.
Ensuite commence la remontée des récursions. A l'étape 1 de notre remontée nous allons reformer le polynôme précédemment séparé pour obtenir un polynôme de degré 1. Puis, nous évaluons ce polynôme avec les racines seconde de l'unité. Nous faisons à nouveau remonté les évaluations et recombinons à nouveau le polynôme qui sera ainsi de degré 2.
Nous l'évaluons maintenant avec les racines 4eme de l'unité. A chaque évaluation, nous réutilisons les résultats précédents, cela nous est permit par les racines de l'unité qui ont une structure récursive exploitable.

Finalement, nous arrivons à la fin de notre FFT, avec une représentation fréquentielle de la forme :

<math> [P(W_0), P(W_1), (...), P(W_n-1), P(W_n)] </math>

Cette représentation fréquentielle n'est autre que les évaluations du polynôme P aux racines nièmes de l'unité. Nous avons donc maintenant au minimum <math>2n+1</math> évaluations des polynômes facteurs. Il nous faut maintenant trouver les évaluations du produit final, c'est à dire les évaluations concernant le polynôme qui sera issue de la multiplication. On pourra ainsi le retrouver.

Soit <math>C</math> un polynome tel que <math> C = A \times B </math>, alors on a :

<math> C(x) = A(x) \times B(x) </math>

Ainsi on en déduit que <math> C(W_n^k) = A(W_n^k) \times B(W_n^k) </math>

On comprend donc que <math>FFT(C) = FFT(A) \times FFT(B)</math>

Il faut préciser que l'on fait le produit de FFT(A) et FFT(B) terme à terme, soit évaluation par évaluation.

Une fois en possession de <math>FFT(C)</math>, qui n'est autre que l'évaluation de notre polynôme final en un nombre suffisant de points pour le retrouver, nous pouvons faire l'<math>IFFT(FFT(C))</math>, qui va nous permettre de retrouver les coefficients de notre polynôme en faisant l'exacte inverse de la FFT.

Une fois les coefficients retrouvés, il nous suffit de gérer les retenues, et nous retrouvons un entier de la forme : <math>a_0 a_1 (...) a_{n-1} a_n</math>

=== B) Graphique ===

Intéressons nous maintenant à la complexité de l'algorithme utilisant la transformée de Fourier rapide. On sait que l'algorithme passe par 5 étapes importantes :

<ul>
<li>Etape 1 : Ecrire les deux facteurs sous la forme de polynômes</li>
<li>Etape 2 : Effectuer la <math>FFT</math> des deux polynômes</li>
<li>Etape 3 : Faire le produit terme à terme des <math>FFT</math> obtenues</li>
<li>Etape 4 : Faire l'<math>IFFT</math> du produit</li>
<li>Etape 5 : Gérer les retenues et écrire le nombre qui en découle</li>
</ul>

Or, parmi toutes ces étapes, certaines sont négligeable comme l'étape 1 et 5.

Pour connaitre la complexité de l'algorithme, additionnons les complexités des étapes restantes :

Une <math>FFT</math> a une complexité de <math>\mathcal{O}(n\times logn)</math> car elle fait <math>n</math> évaluation sur <math> log(n)</math> récursions. Dans le cadre de notre algorithme, nous devons faire la <math>FFT</math> de nos deux facteurs. Soit <math>2\times \mathcal{O}(n\times logn)</math>.

Pour le produit terme à terme, nous faisons naturellement <math>n</math> opérations.

Pour finir, l'<math>IFFT</math> a la même complexité que la <math>FFT</math>. Dans le cadre de notre algorithme nous l'emploierons qu'une seule fois, ce qui fait une complexité de <math>\mathcal{O}(n\times logn)</math>.

Après addition de toutes ces complexités, nous obtenons la complexité réelle de <math>3\mathcal{O}(n\times logn) + \mathcal{O}(n)</math>.

D'après le Master Theorem, nous avons donc <math> f(n) = 3(n\times logn)+n </math>, cherchons <math>f(n)\in\mathcal{O}(g(n))</math> :

Nous pouvons ignorer les expressions linéaires ainsi que les constantes multiplicatrices, nous obtenons donc <math>\mathcal{O}(g(n)) = \mathcal{O}(n \times log n)</math>.

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:30px; text-align:center;">
[[Fichier:FFT complexite.png|500px]]
<div><b>Graphiques des complexités</b></div>
</div>
<div style="max-width:800px;">
<p>Ce graphique ci-contre ne provient pas du fruit de nos recherches personnelles mais illustre bien la comparaison entre la complexité de la FFT et des autres algorithmes.</p>
<p>On remarque que la FFT est très efficace et devance de loin les autres algorithmes en terme de complexité. </p>
<p>Les algorithmes les plus efficaces pour calculer le produit de grands entiers reposent aujourd'hui sur des variantes de la transformée de Fourier rapide.</p>
</div>
</div>

= II - Produit de matrices =

== 1.1) naïve ==

La multiplication naïve de matrice requiert d'avoir des tailles de lignes/colonne semblable, ensuite pour chaque membre de la matrice résultat, on doit multiplier les composantes ligne de la première matrice par les composantes colonne de la deuxième et le tout sommé.

On en déduit la formule suivante:
<math>C_{i,j} = \sum_{k=1}^{n} (A_{i,k} \times B_{k,j})</math>

Et visuellement:

[[Fichier:Matricenaive.jpeg]]

On a donc un algorithme d'ordre de complexité <math>\mathcal{O}(g(n))</math>

== 1.2) naïve récursive ==

Dans un premier temps on doit découper nos deux matrices en quatres sous matrices de plus petite taille.
<math>A = \begin{pmatrix} A_{11} & A_{12} \ A_{21} & A_{22} \end{pmatrix}</math>
<math>B = \begin{pmatrix} B_{11} & B_{12} \ B_{21} & B_{22} \end{pmatrix}</math>

Ensuite on vient calculer la matrice résultat.
<math>C_{11} = (A_{11} \times B_{11}) + (A_{12} \times B_{21})</math>
<math>C_{12} = (A_{11} \times B_{12}) + (A_{12} \times B_{22})</math>
<math>C_{21} = (A_{21} \times B_{11}) + (A_{22} \times B_{21})</math>
<math>C_{22} = (A_{21} \times B_{12}) + (A_{22} \times B_{22})</math>

Le côté récursif est utile que pour les matrices de tailles <= 32 (32 valeurs stockées dedans),
si on est au dessus de cette taille alors on divisera à nouveau nos matrices en quatres.
On aura 8 multiplications mais de plus petite taille au final.

== 2) strassen ==

=== A) Fonctionnement ===

Strassen consiste à définir 7 produits intermédiaires qui, par des jeux de sommes et de différences, permettent de reconstruire les quadrants de la matrice résultante. On passe ainsi d'une complexité de O(n^3) à environ O(n^2.81)

=== B) Graphique ===

On voit bien la différence de complexité sur la multiplication de grande matrice entre l'approche naïve et l'approche récursive qui est beaucoup plus rapide.

[[Fichier:Analyse matrices.png]]

= Conclusion =

L'étude de ces algorithmes de multiplication nous a clairement montré l'évolution de la complexité algorithmique permettant de gagner en efficacité lorsque la taille des données augmente.

La multiplication classiqe, en <math>\mathcal{O}(n^2)</math>, résulte d'une approche naïve qui devient rapidement inefficace pour les grands entiers ou les grandes matrices. L'algorithme de Karatsuba nous montre qu'organiser de manière intelligente ses calculs algébrique permet parfois de gagner beaucoup de multiplications, et donc de temps. Nous avons ainsi réussi à passer d'une complexité de <math>\mathcal{O}(n^2)</math> à <math>\mathcal{O}(n^{log_2(3)})</math>, soit environ <math>\mathcal{O}(n^{1/585})</math>.

Des méthodes encore plus avancées comme utilise l'algorithme de Toom-Cook-3 continue dans cette idées de divisions d'entiers en blocs plus petits, tandis que la transformée de Fourier rapide change complètement de point de vue. En effet la FFT n'utilise pas la représentation classique des entiers mais fait appel à une vision polynomiale, ce qui transforme la convolution classique en multiplication terme à terme, ce qui lui permet d'atteindre une complexité de <math>\mathcal{O}(n \times log n)</math>.

Dans le cas des matrices, les mêmes logiques apparaissent comme par exemple avec l'algorithme de Strassen qui se rapproche très fortement de Karatsuba en combinant de manière astucieuse les parties d'entiers qui avaient été précédemment découpée.

On remarque néanmoins que la majorité des algorithmes efficaces s'orientent vers une approche récursive et non itérative. Néanmoins, nous avons pu trouver certaines de ces implémentations (comme par exemple la FFT) en itérative.

Avec ces recherches, nous comprenons que la réorganisations des calculs algébriques peuvent aider à gagner en complexité mais que pour faire de réels progrès, il nous faudra surement changer notre point de vue une nouvelle fois, et aborder le problème sous un angle nouveau comme le font dors et déjà les algorithmes les plus performants.

= Mentions =

Le premier gif est le résultat du travail de 'Walké', licence ci-contre : https://fr.wikipedia.org/wiki/Fichier:Addition.gif

Utilisation du site de production graphique "Desmos" : https://www.desmos.com/calculator?lang=fr

= Sources =

Pour karatsuba :
<ul>
<li> https://www.youtube.com/watch?v=PZ2gdWdKHAA </li>
</ul>

Pour mieux comprendre la FFT, nous avons utilisé plusieurs sources d'informations :
<ul>
<li> https://www.youtube.com/watch?v=h7apO7q16V0&list=WL&index=1&t=886s </li>
<li> https://fr.wikipedia.org/wiki/Interpolation_polynomiale </li>
</ul>

Algorithmes de multiplications d'entiers et de matrices

2026-05-11T21:17:26Z

Mangala : /* B) Graphique */

= Introduction =

Depuis l'apparition des ordinateurs modernes, une quantité faramineuse de calculs a dû être effectuée. Les progressions technologiques nous poussent à envisager la puissance de calcul comme une ressource qu'il faut optimiser dans les moindres détails. C'est ainsi que l'optimisation des algorithmes de calcul est devenue cruciale, surtout lorsqu'il nous faut effectuer des opérations sur de très grands entiers par exemple.

= Objectif =

L'objectif majeur de ce projet est de comprendre de manière plus approfondie ce qu'est la '''complexité algorithmique'''.
Pour atteindre cet objectif, nous implémenterons plusieurs algorithmes de multiplication qui auront pour but de calculer le produit de grands entiers ou de matrices.

= Point important : complexité =

=== Définition ===
La complexité d'un algorithme est la quantité des ressources qu'il utilise en fonction de la taille des entrées qu'on lui demande de traiter. On peut par exemple se concentrer sur le temps qu'un algorithme prend pour renvoyer un résultat ou sur la mémoire dont il a besoin. Dans le cadre de notre projet, nous nous attarderons plus particulièrement sur la quantité de calcul effectuée en fonction de la taille des entrées, ce qui est par ailleurs étroitement liée à la notion de temps. De manière générale, plus un algorithme doit faire de calcul, plus il est lent. (Attention, toutes les opérations arithmétiques de base ne se valent pas)

De manière plus familière, on dira que la complexité d'un algorithme pourrait s'apparenter à son comportement lorsqu'il doit traiter des données plus ou moins grandes.
Chaque algorithme a une complexité, et on l'exprime par une fonction qui adopte un comportement similaire au nombre de calculs nécessaires en fonction de la taille des entrées.

=== Notation ===
La complexité réelle d'un algorithme peut être décrite par une fonction <math> f(n) </math> représentant le nombre d'opérations effectuées en fonction de la taille <math>n</math> des données d'entrée.

Cependant, afin de simplifier l'étude de cette croissance, on utilise généralement une borne asymptotique notée <math>\mathcal{O}(g(n))</math>, où <math>g(n)</math> est une fonction ayant le même ordre de grandeur que <math>f(n)</math> lorsque <math>n</math> devient grand.

On dit alors que :

<math>
f(n)\in\mathcal{O}(g(n))
</math>

si et seulement s'il existe une constante <math>C>0</math> et un entier <math>n_0</math> tels que :

<math>
\forall n\ge n_0,\ f(n)\le Cg(n)
</math>

Cette notation <math>\mathcal{O}(g(n))</math> permettra de comparer beaucoup plus facilement les algorithmes entre eux.

=== Master Theorem ===

Afin de déterminer la complexité de certains algorithmes récursifs, nous utiliserons le "Master Theorem".

Ce théorème permet d'obtenir directement l'ordre de grandeur de nombreuses relations de récurrence apparaissant dans l'analyse d'algorithmes de type « diviser pour régner », comme l'algorithme de Karatsuba ou celui de Strassen.

La démonstration complète de ce théorème dépasse le cadre de notre projet et nécessite des connaissances mathématiques plus avancées. Nous l'utiliserons donc principalement comme un outil nous permettant de déterminer efficacement la complexité asymptotique des algorithmes étudiés.

=== Graphiques ===

Les complexités étant des fonctions, nous pouvons les représenter par un graphique qui affichera le temps d'exécution (ou nombre d'opérations) en fonction de la taille des entrées.

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:30px; text-align:center;">
[[Fichier:complexite.webp|500px]]
<div><b>Graphiques des complexités</b></div>
</div>
<div style="max-width:800px;">
<p>Ce graphique ci-contre compare les complexités en fonction de la taille des d'entrées.</p>
<p>On comprend ainsi que certaines complexités ne sont pas raisonnable dans la cadre de la multiplication de grands entiers.</p>
<p>C'est pourquoi l'étude de ces algorithmes s'avère nécessaire.</p>
</div>
</div>

=== Exemple ===
L'algorithme naïf d'addition que nous avons tous appris à l'école a une complexité de <math>\mathcal{O}(n)</math>.
Soit n la taille des nombres en entrée, l'algorithme doit faire environ n addition pour arriver au résultat demandé.

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Addition.gif|220px]]
<div><b>Addition naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Comme le montre l'exemple ci-contre, 786 et 467 font 3 chiffres de long donc n sera de 3.</p>
<p>Il nous faudra 3 opérations pour additionner ces entiers.</p>
<p>C'est ainsi qu'avec une taille d'entrée n, l'algorithme de l'addition naïve va devoir faire n opérations.</p>
<p>Cet algorithme a donc une complexité <math>f(n) = n</math> qui n'a pas besoin d'être approximée.</p>
<p>Ainsi sa complexité finale sera <math>\mathcal{O}(n)</math>.</p>
</div>
</div>

= Problématique =

Le calcul du produit de deux entiers de manière naïve a une complexité de <math> \mathcal{O}(n^2)</math>, et celui de deux matrices une complexité de <math> \mathcal{O}(n^3)</math>. Afin de mieux comprendre ce qu'est la complexité algorithmique, nous devrons implémenter des algorithmes ayant le même objectif, mais étant plus efficaces. Ces algorithmes s'avèreront plus complexes mais devrait aboutir à un calcul plus rapide du produit demandé.

Nous séparerons notre wiki en deux grandes parties, la première concernera nos recherche sur [[#I - Produit d'entiers|la multiplication d'entiers]], la deuxième sur [[#II - Produit de matrices|la multiplication de matrices]].

= I - Produit d'entiers =

Notre départ commence avec l'algorithme de multiplication d'entier naïf.
En effet il s'agit de l'algorithme de multiplication le plus connu, et nous l'utiliserons comme référence pour le comparer aux futurs algorithmes plus efficaces.
Intéressons nous à sa complexité.

== 1) Nos implémentations des grands entiers ==

Qui dit produit de grands entiers dit implémentation de grands entiers.

Dans le cadre de nos recherches, nous allons devoir implémenter des algorithmes qui vont manipuler des grands entiers.

Nous avons donc choisi de créer deux représentations différentes de ceux-ci (car nous travaillons sur différents langages de programmation), nous permettant à la fois une implémentation simplifié, mais aussi de nous rapprocher d'une implémentation bas niveau.

=== A) En python ===
En python, l'utilisation des "bytes" m'a grandement servi à comprendre comment les entiers étaient manipulés à bas niveau. En effet, un des objectifs secondaires de nos recherches était de manipuler des entiers directement avec leur formes stockées sur l'ordinateur, et non pas avec des int python.
En effet l'utilisation des int python nous aurait permit de passer les étapes de retenues, de signes... D'autant plus que les bytes permettent de stocker un nombre en base 256, ce qui permet de visualiser plus facilement les grands entiers.

La forme finale de la représentation des grands entiers en python sera donc la suivante :

[ signe , bytes , bytes , (...) , bytes ]

Le signe est représenté par un entier, 1 si le nombre est positif, 0 sinon.
Cette configuration rendra plus simple la gestion des signes.

=== B) En C++ ===

En C++, pour avoir une représentation de grand entiers j'ai du définir ma propre structure pour m'affranchir de la limite de taille imposé par les entiers standards: (int32 ou int64). Pour cela, j'ai une structure qui possède l'équivalent d'un array de byte (ce qui nous permet d'être en base 256 au lieu de la base 10 habituelle), et pour traiter le signe j'utilise un booléen, ainsi en mémoire j'ai une structure de n*Octets + 1 octet en taille.

[ bytes , bytes , (...) , bytes ] [ signe ]

Le booléen prend 1 octet de place mais ne touche pas aux octets qui encode le grand entier.
Cette configuration rendra plus simple la gestion des signes dans le cadre des multiplication.

== 2) La multiplication naïve ==

=== A) Fonctionnement ===
Dans le cas de la multiplication d'entiers, nous allons prendre deux nombres qui n'ont pas nécessairement la même longueur. Soit les nombre a et b, de longueur respective <math> n </math> et <math> m </math>.
<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Multiplication.png|220px]]
<div><b>Multiplication naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Prenons deux nombres de longueur 3 et 2, et cherchons combien d'opérations l'algorithme de multiplication naïve va devoir faire pour nous renvoyer leur produit.</p>
<p>Dans un premier temps, on remarque que l'on va devoir multiplier chaque chiffre du nombre du haut par le chiffre des unités du bas, qui est 6. Cela va représenter <math>n</math> opérations. (6x5, 6x1 et 6x4)</p>
<p>Dans un deuxième temps nous constatons que nous allons devoir faire la même chose avec le chiffre des dizaines du nombre du bas. Cela nous ajoute de nouveau <math>n</math> opérations.</p>
<p>On arrive assez facilement à la conclusion que pour faire notre produit, il va nous falloir faire <math>n</math> fois <math>m</math> opérations.</p>
</div>
</div>

Ainsi, la complexité de la multiplication naïve est <math>\mathcal{O}(n^2)</math>.
Il est en de même avec la multiplication naïve récursive.

=== B) Graphique ===
Montrons maintenant sa courbe sur un graphique :

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Multiplicationnaive.png|500px]]
<div><b>Multiplication naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Les points noirs sont des repères pour que les autres courbes aient une forme cohérente.</p>
<p>Ils sont tous sur l'axe des abscisses.</p>
<p>La courbe rouge représente la complexité de la multiplication naïve.</p>
<p>On remarque que la courbe a un visuel très similaire à la fonction <math>f(x) = x^2</math> </p>
</div>
</div>

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Naif_recursif.png|500px]]
<div><b>Multiplication naïve récursive</b></div>
</div>
<div style="max-width:800px;">
<p>La courbe rouge représente la complexité de la multiplication naïve récursive.</p>
<p>Elle sera utilisé pour comparer les complexités entre algorithmes car, comme tous récursifs, elle a été codé avec les mêmes biais d'implémentation qu'eux.</p>
<p>Théoriquement les deux courbes ci-contre ont la même complexité, mais encore une fois, notre implémentation n'est pas parfaitement optimale et donc ne respecte pas de manière minutieuse le Master Theorem.</p>
</div>
</div>

== 3) La multiplication karatsuba ==

=== A) Fonctionnement ===

L'algorithme de karatsuba est un algorithme récursif de type diviser pour régner.

L'idée générale de l'algorithme est de passer de 4 multiplication à 3. En effet ces opérations étant moins couteuses, il est préférable d'en ajouter si cela permet d'enlever des multiplications.

L'algorithme de multiplication naif récursif utilise la segmentation des facteurs en deux de manière successive.

Soit <math>x</math> et <math>y</math> deux facteurs, nous avons les égalités suivantes :

<div style="font-size: 15px;">
<math>x = a \times B^{n/2} + b</math>
<math>y = c \times B^{n/2} + d</math>
</div>

Avec <math>a</math> et <math>c</math> les premières moitiés des facteurs <math>x</math> et <math>y</math>,
et <math> b </math> et <math>d</math> les dernières moitiés de ces facteurs ainsi que <math>B</math> la base d'écriture du nombre (Nous sommes en base 256 avec les bytes).

Cette présentation des deux facteurs de notre multiplication n'est que la résultante d'un découpage.
Le [[#Master Theorem|Master Theorem]] nous montre que :

<div style="font-size: 15px;">
<math>T(n) = 4T(n/2) + O(n)</math>
</div>

Puisque nous avons après découpage 4 entiers de longueur <math>n/2</math>.

Ainsi, ce découpage ne permet pas de gagner du temps d'après le [[#Master Theorem|Master Theorem]].

Cependant, l'algorithme de Karatsuba réutilise ce principe en le modifiant, ce qui nous permet de baisser la complexité globale de la multiplication dans son entièreté.

Avec l'écriture ci-dessus des nombres <math>x</math> et <math>y</math>, on peut facilement en déduire l'égalité suivante :

<div style="font-size: 15px;">
<math>x \times y = (ac) \times B^n + (ad + bc) \times B^{n/2} + bd</math>
</div>

On remarque 4 multiplications longues à faire dans cette expression. Les multiplications dont <math>B</math> est l'un des facteurs sont très rapides puisqu'il s'agit de la base dans laquelle nous travaillons. De cela en résulte un décalage plutôt qu'un vrai calcul à faire.

Karatsuba développe une partie de cette expression pour pouvoir négocier une multiplication au prix d'additions et soustractions.

En effet, nous savons déjà que :

<div style="font-size: 15px;">
<math>(a + b)(c + d) = ac + ad + bc + bd</math>
</div>

En manipulant l'égalité nous obtenons :

<div style="font-size: 15px;">
<math>ad + bc = (a + b)(c + d) - ac - bd</math>
</div>

ac et bd ayant déjà été calculé précédemment, il nous reste uniquement la multiplication <math>(a + b)(c + d)</math>.

Nous venons ainsi de calculer <math>ad + bc</math> en seulement une multiplication. C'est la que repose le gain de temps de la méthode Karatsuba par rapport à la multiplication naïve.

En effet, l'algorithme n'effectuera alors plus que 3 multiplications :
<div style="font-size: 15px;">
<math>ac</math>
<math>bd</math>
<math>(a + b)(c + d)</math>
</div>

La relation de récurrence devient donc :
<div style="font-size: 15px;">
<math>T(n)=3T(n/2)+O(n)</math>
</div>

Et le Master Theorem nous dit que :
<div style="font-size: 15px;">
<math>T(n)\in O(n^{\log_2(3)})</math>
</div>

Or <math>\log_2(3)\approx 1.585</math>, donc la complexité de l'algorithme de Karatsuba est de <math> \mathcal{O}(n^{1.585})</math>. Ce qui est bien plus efficace que la multiplication classique, surtout lorsque les facteurs deviennent très grands.

=== B) Graphique ===
<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Karatsuba.png|500px]]
<div><b>Karatsuba</b></div>
</div>
<div style="max-width:800px;">
<p>Sur le graphique ci-contre nous avons utilisé la courbe de la multiplication naïve récursive (rouge) à titre de comparaison.</p>
<p>On remarque graphiquement que Karatsuba (jaune) prend moins de temps à chaque calcul de produit.</p>
<p>On en déduit donc expérimentalement que Karatsuba à une meilleure complexité que la multiplication naïve.</p>
<p>Ainsi nous vérifions donc ce que le Master Theorem prouve, c'est à dire que la complexité de karatsuba est de <math> \mathcal{O}(n^{1.585})</math> </p>
</div>
</div>

== 4) La multiplication toom-cook-3 ==

=== A) Fonctionnement ===

L'objectif est de diviser les grands entiers X et Y en trois blocs de taille égale k.
On les traite alors comme des polynômes de degré 2:

<math>P(z) = X_2 \cdot z^2 + X_1 \cdot z + X_0</math>
<math>Q(z) = Y_2 \cdot z^2 + Y_1 \cdot z + Y_0</math>

On choisit 5 points distincts pour évaluer nos polynômes.
Ce choix de 5 points est crucial car le produit de deux polynômes de degré 2 est un polynôme de degré 4, qui nécessite 5 points pour être défini.
Les points standards sont :

P(0) = X0
P(1) = X0 + X1 + X2
P(-1) = X0 - X1 + X2
P(2) = X0 + 2*X1 + 4*X2
P(inf) = X2

(On procède de manière similaire pour Q.)

Ensuite nous multiplions récursivement chaque points de P et de Q ensemble.
On effectue ainsi 5 multiplications de nombres plus petits au lieu des 9 multiplications requises par la méthode classique.

Après, nous effectuons une interpolation, cela permet de retrouver les 5 coefficients (w_0, w_1, w_2, w_3, w_4) du polynôme produit R(z) à partir des valeurs évaluées calculées précédemment.
On résout un système d'équations linéaires : <math> R(z) = w_4 z^4 + w_3 z^3 + w_2 z^2 + w_1 z + w_0 </math>
Finalement nous pouvons recomposer notre grand entier en positionnant les coefficients w_i aux bons rangs (en les décalant) et à gérer les retenues lors de l'addition finale:
Résultat <math>= w_4 B^{4k} + w_3 B^{3k} + w_2 B^{2k} + w_1 B^k + w_0</math>

=== B) Graphique ===

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Toomcook.png|500px]]
<div><b>Karatsuba</b></div>
</div>
<div style="max-width:800px;">
<p>on a reprit multi récursive (rouge)</p>
<p>on voit que Toom (vert) en dessous de karatsuba (jaune) en dessous de multi classique (rouge)</p>
<p>meilleur complexité</p>
</div>
</div>

== 5) La transformée de Fourier rapide ==

=== A) Fonctionnement ===

La transformation de Fourier rapide étant plus complexe que les autres algorithmes, nous allons essayer d'expliquer son fonctionnement malgré ne pas avoir réussi à l'implémenter.

Il faut comprendre que cet algorithme va considérer les facteurs comme des polynômes.

D'après le théorème de l'unisolvance, il n'existe qu'un seul polynôme de degré inférieur ou égal à <math> n </math> défini par <math>n + 1</math> points distincts. Cela implique non seulement que nous pouvons représenter chaque entier par un polynôme, mais également que si nous pouvons retrouver <math>n + m + 1</math> points (avec <math>n</math> et <math>m</math> la longueur des facteurs) du polynômes issue du produit entre deux facteurs, nous pourrons le retrouver.

Soit un entier quelconque, de forme :

<math>a_n a_{n-1} (...) a_1 a_0</math>

Avec <math>a_i</math>, un chiffre composant le nombre en base 10, qui vaut en réalité dans le nombre : <math>a_i \times 10^i</math>. On peut ainsi l'écrire sous la forme :

<math> P(x) = a_0 + a_1x + a_2x^2 + \dots + a_{n-1}x^{n-1} + a_nx^n </math>

Avec <math>x = 10</math> car nous sommes en base 10, nous obtenons :

<math>P(10) = a_0 + a_1 \times 10 + \dots + a_{n-1}10^{n-1} + a_n10^n </math>

Nous venons ainsi d'écrire notre nombre sous la forme d'un polynôme unique. Pour nous permettre d'évaluer en un nombre suffisant de points, nous allons devoir ajouter des 0 pour la récursion. Il nous faudra ajouter assez de 0 pour atteindre la prochaine puissance de 2 qui sera supérieure ou égale à <math>2n + 1</math>. L'ajout de 0 ne change pas le nombre car <math>0 \times x^n</math> n'ajoute pas de coefficient.

Cet algorithme est récursif et va segmenter en deux parties nos polynômes à chaque récursion. D'un coté les indice pairs et d'un coté les impaires.

Ainsi prenons les nombres 1234 et 5678, ces nombres sont respectivement représentés par les polynômes <math> P(x) = 4 + 3x + 2x^2 + x^3 </math> et <math> P(x) = 8 + 7x + 6x^2 + 5^3 </math>. Ce sont des polynômes de degré 3, ainsi leur produit donnera lieu à un polynôme de degré 6. Il nous faudra donc au minimum 7 points d'évaluation pour retrouve ce produit. De ce fait, en les représentant de la manière suivante :

<math>[4, 3, 2, 1, 0, 0, 0, 0]</math>
<math>[8, 7, 6, 5, 0, 0, 0, 0]</math>

Nous aurons assez de récursions possible pour les évaluer en un nombre suffisant de points différents car nous auront 3 récursions à faire pour atteindre notre cas de base. A chaque récursion, nous allons diviser nos polynômes en deux parties ce qui nous fait 8 feuilles à la dernière récursion.

En effet à chaque étape de la récursion nous allons séparer nos polynômes en deux tel que :

<math>P(x)=P_{\text{pair}}(x^2) + x \cdot P_{\text{impair}}(x^2)</math>

Durant les récursions, nous segmentons les polynômes mais ne les évaluons pas. C'est à la remonté des récursions que nous allons réellement évaluer nos polynômes. Lorsque l'on atteint notre cas de base, c'est à dire des polynômes de degré 0, nous remarquons qu'ils sont constants, nous n'avons donc pas besoin de les évaluer. En effet, peut importe le point en lequel nous voudrons l'évaluer, le polynôme renverra la constante. Nous la renvoyons donc seule.
Ensuite commence la remontée des récursions. A l'étape 1 de notre remontée nous allons reformer le polynôme précédemment séparé pour obtenir un polynôme de degré 1. Puis, nous évaluons ce polynôme avec les racines seconde de l'unité. Nous faisons à nouveau remonté les évaluations et recombinons à nouveau le polynôme qui sera ainsi de degré 2.
Nous l'évaluons maintenant avec les racines 4eme de l'unité. A chaque évaluation, nous réutilisons les résultats précédents, cela nous est permit par les racines de l'unité qui ont une structure récursive exploitable.

Finalement, nous arrivons à la fin de notre FFT, avec une représentation fréquentielle de la forme :

<math> [P(W_0), P(W_1), (...), P(W_n-1), P(W_n)] </math>

Cette représentation fréquentielle n'est autre que les évaluations du polynôme P aux racines nièmes de l'unité. Nous avons donc maintenant au minimum <math>2n+1</math> évaluations des polynômes facteurs. Il nous faut maintenant trouver les évaluations du produit final, c'est à dire les évaluations concernant le polynôme qui sera issue de la multiplication. On pourra ainsi le retrouver.

Soit <math>C</math> un polynome tel que <math> C = A \times B </math>, alors on a :

<math> C(x) = A(x) \times B(x) </math>

Ainsi on en déduit que <math> C(W_n^k) = A(W_n^k) \times B(W_n^k) </math>

On comprend donc que <math>FFT(C) = FFT(A) \times FFT(B)</math>

Il faut préciser que l'on fait le produit de FFT(A) et FFT(B) terme à terme, soit évaluation par évaluation.

Une fois en possession de <math>FFT(C)</math>, qui n'est autre que l'évaluation de notre polynôme final en un nombre suffisant de points pour le retrouver, nous pouvons faire l'<math>IFFT(FFT(C))</math>, qui va nous permettre de retrouver les coefficients de notre polynôme en faisant l'exacte inverse de la FFT.

Une fois les coefficients retrouvés, il nous suffit de gérer les retenues, et nous retrouvons un entier de la forme : <math>a_0 a_1 (...) a_{n-1} a_n</math>

=== B) Graphique ===

Intéressons nous maintenant à la complexité de l'algorithme utilisant la transformée de Fourier rapide. On sait que l'algorithme passe par 5 étapes importantes :

<ul>
<li>Etape 1 : Ecrire les deux facteurs sous la forme de polynômes</li>
<li>Etape 2 : Effectuer la <math>FFT</math> des deux polynômes</li>
<li>Etape 3 : Faire le produit terme à terme des <math>FFT</math> obtenues</li>
<li>Etape 4 : Faire l'<math>IFFT</math> du produit</li>
<li>Etape 5 : Gérer les retenues et écrire le nombre qui en découle</li>
</ul>

Or, parmi toutes ces étapes, certaines sont négligeable comme l'étape 1 et 5.

Pour connaitre la complexité de l'algorithme, additionnons les complexités des étapes restantes :

Une <math>FFT</math> a une complexité de <math>\mathcal{O}(n\times logn)</math> car elle fait <math>n</math> évaluation sur <math> log(n)</math> récursions. Dans le cadre de notre algorithme, nous devons faire la <math>FFT</math> de nos deux facteurs. Soit <math>2\times \mathcal{O}(n\times logn)</math>.

Pour le produit terme à terme, nous faisons naturellement <math>n</math> opérations.

Pour finir, l'<math>IFFT</math> a la même complexité que la <math>FFT</math>. Dans le cadre de notre algorithme nous l'emploierons qu'une seule fois, ce qui fait une complexité de <math>\mathcal{O}(n\times logn)</math>.

Après addition de toutes ces complexités, nous obtenons la complexité réelle de <math>3\mathcal{O}(n\times logn) + \mathcal{O}(n)</math>.

D'après le Master Theorem, nous avons donc <math> f(n) = 3(n\times logn)+n </math>, cherchons <math>f(n)\in\mathcal{O}(g(n))</math> :

Nous pouvons ignorer les expressions linéaires ainsi que les constantes multiplicatrices, nous obtenons donc <math>\mathcal{O}(g(n)) = \mathcal{O}(n \times log n)</math>.

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:30px; text-align:center;">
[[Fichier:FFT complexite.png|500px]]
<div><b>Graphiques des complexités</b></div>
</div>
<div style="max-width:800px;">
<p>Ce graphique ci-contre ne provient pas du fruit de nos recherches personnelles mais illustre bien la comparaison entre la complexité de la FFT et des autres algorithmes.</p>
<p>On remarque que la FFT est très efficace et devance de loin les autres algorithmes en terme de complexité. </p>
<p>C'est l'un des plus performants.</p>
</div>
</div>

= II - Produit de matrices =

== 1.1) naïve ==

La multiplication naïve de matrice requiert d'avoir des tailles de lignes/colonne semblable, ensuite pour chaque membre de la matrice résultat, on doit multiplier les composantes ligne de la première matrice par les composantes colonne de la deuxième et le tout sommé.

On en déduit la formule suivante:
<math>C_{i,j} = \sum_{k=1}^{n} (A_{i,k} \times B_{k,j})</math>

Et visuellement:

[[Fichier:Matricenaive.jpeg]]

On a donc un algorithme d'ordre de complexité <math>\mathcal{O}(g(n))</math>

== 1.2) naïve récursive ==

Dans un premier temps on doit découper nos deux matrices en quatres sous matrices de plus petite taille.
<math>A = \begin{pmatrix} A_{11} & A_{12} \ A_{21} & A_{22} \end{pmatrix}</math>
<math>B = \begin{pmatrix} B_{11} & B_{12} \ B_{21} & B_{22} \end{pmatrix}</math>

Ensuite on vient calculer la matrice résultat.
<math>C_{11} = (A_{11} \times B_{11}) + (A_{12} \times B_{21})</math>
<math>C_{12} = (A_{11} \times B_{12}) + (A_{12} \times B_{22})</math>
<math>C_{21} = (A_{21} \times B_{11}) + (A_{22} \times B_{21})</math>
<math>C_{22} = (A_{21} \times B_{12}) + (A_{22} \times B_{22})</math>

Le côté récursif est utile que pour les matrices de tailles <= 32 (32 valeurs stockées dedans),
si on est au dessus de cette taille alors on divisera à nouveau nos matrices en quatres.
On aura 8 multiplications mais de plus petite taille au final.

== 2) strassen ==

=== A) Fonctionnement ===

Strassen consiste à définir 7 produits intermédiaires qui, par des jeux de sommes et de différences, permettent de reconstruire les quadrants de la matrice résultante. On passe ainsi d'une complexité de O(n^3) à environ O(n^2.81)

=== B) Graphique ===

On voit bien la différence de complexité sur la multiplication de grande matrice entre l'approche naïve et l'approche récursive qui est beaucoup plus rapide.

[[Fichier:Analyse matrices.png]]

= Conclusion =

L'étude de ces algorithmes de multiplication nous a clairement montré l'évolution de la complexité algorithmique permettant de gagner en efficacité lorsque la taille des données augmente.

La multiplication classiqe, en <math>\mathcal{O}(n^2)</math>, résulte d'une approche naïve qui devient rapidement inefficace pour les grands entiers ou les grandes matrices. L'algorithme de Karatsuba nous montre qu'organiser de manière intelligente ses calculs algébrique permet parfois de gagner beaucoup de multiplications, et donc de temps. Nous avons ainsi réussi à passer d'une complexité de <math>\mathcal{O}(n^2)</math> à <math>\mathcal{O}(n^{log_2(3)})</math>, soit environ <math>\mathcal{O}(n^{1/585})</math>.

Des méthodes encore plus avancées comme utilise l'algorithme de Toom-Cook-3 continue dans cette idées de divisions d'entiers en blocs plus petits, tandis que la transformée de Fourier rapide change complètement de point de vue. En effet la FFT n'utilise pas la représentation classique des entiers mais fait appel à une vision polynomiale, ce qui transforme la convolution classique en multiplication terme à terme, ce qui lui permet d'atteindre une complexité de <math>\mathcal{O}(n \times log n)</math>.

Dans le cas des matrices, les mêmes logiques apparaissent comme par exemple avec l'algorithme de Strassen qui se rapproche très fortement de Karatsuba en combinant de manière astucieuse les parties d'entiers qui avaient été précédemment découpée.

On remarque néanmoins que la majorité des algorithmes efficaces s'orientent vers une approche récursive et non itérative. Néanmoins, nous avons pu trouver certaines de ces implémentations (comme par exemple la FFT) en itérative.

Avec ces recherches, nous comprenons que la réorganisations des calculs algébriques peuvent aider à gagner en complexité mais que pour faire de réels progrès, il nous faudra surement changer notre point de vue une nouvelle fois, et aborder le problème sous un angle nouveau comme le font dors et déjà les algorithmes les plus performants.

= Mentions =

Le premier gif est le résultat du travail de 'Walké', licence ci-contre : https://fr.wikipedia.org/wiki/Fichier:Addition.gif

Utilisation du site de production graphique "Desmos" : https://www.desmos.com/calculator?lang=fr

= Sources =

Pour karatsuba :
<ul>
<li> https://www.youtube.com/watch?v=PZ2gdWdKHAA </li>
</ul>

Pour mieux comprendre la FFT, nous avons utilisé plusieurs sources d'informations :
<ul>
<li> https://www.youtube.com/watch?v=h7apO7q16V0&list=WL&index=1&t=886s </li>
<li> https://fr.wikipedia.org/wiki/Interpolation_polynomiale </li>
</ul>

Fichier:FFT complexite.png

2026-05-11T21:16:56Z

Mangala :

Algorithmes de multiplications d'entiers et de matrices

2026-05-11T21:13:54Z

Mangala : /* 3) La multiplication karatsuba */

= Introduction =

Depuis l'apparition des ordinateurs modernes, une quantité faramineuse de calculs a dû être effectuée. Les progressions technologiques nous poussent à envisager la puissance de calcul comme une ressource qu'il faut optimiser dans les moindres détails. C'est ainsi que l'optimisation des algorithmes de calcul est devenue cruciale, surtout lorsqu'il nous faut effectuer des opérations sur de très grands entiers par exemple.

= Objectif =

L'objectif majeur de ce projet est de comprendre de manière plus approfondie ce qu'est la '''complexité algorithmique'''.
Pour atteindre cet objectif, nous implémenterons plusieurs algorithmes de multiplication qui auront pour but de calculer le produit de grands entiers ou de matrices.

= Point important : complexité =

=== Définition ===
La complexité d'un algorithme est la quantité des ressources qu'il utilise en fonction de la taille des entrées qu'on lui demande de traiter. On peut par exemple se concentrer sur le temps qu'un algorithme prend pour renvoyer un résultat ou sur la mémoire dont il a besoin. Dans le cadre de notre projet, nous nous attarderons plus particulièrement sur la quantité de calcul effectuée en fonction de la taille des entrées, ce qui est par ailleurs étroitement liée à la notion de temps. De manière générale, plus un algorithme doit faire de calcul, plus il est lent. (Attention, toutes les opérations arithmétiques de base ne se valent pas)

De manière plus familière, on dira que la complexité d'un algorithme pourrait s'apparenter à son comportement lorsqu'il doit traiter des données plus ou moins grandes.
Chaque algorithme a une complexité, et on l'exprime par une fonction qui adopte un comportement similaire au nombre de calculs nécessaires en fonction de la taille des entrées.

=== Notation ===
La complexité réelle d'un algorithme peut être décrite par une fonction <math> f(n) </math> représentant le nombre d'opérations effectuées en fonction de la taille <math>n</math> des données d'entrée.

Cependant, afin de simplifier l'étude de cette croissance, on utilise généralement une borne asymptotique notée <math>\mathcal{O}(g(n))</math>, où <math>g(n)</math> est une fonction ayant le même ordre de grandeur que <math>f(n)</math> lorsque <math>n</math> devient grand.

On dit alors que :

<math>
f(n)\in\mathcal{O}(g(n))
</math>

si et seulement s'il existe une constante <math>C>0</math> et un entier <math>n_0</math> tels que :

<math>
\forall n\ge n_0,\ f(n)\le Cg(n)
</math>

Cette notation <math>\mathcal{O}(g(n))</math> permettra de comparer beaucoup plus facilement les algorithmes entre eux.

=== Master Theorem ===

Afin de déterminer la complexité de certains algorithmes récursifs, nous utiliserons le "Master Theorem".

Ce théorème permet d'obtenir directement l'ordre de grandeur de nombreuses relations de récurrence apparaissant dans l'analyse d'algorithmes de type « diviser pour régner », comme l'algorithme de Karatsuba ou celui de Strassen.

La démonstration complète de ce théorème dépasse le cadre de notre projet et nécessite des connaissances mathématiques plus avancées. Nous l'utiliserons donc principalement comme un outil nous permettant de déterminer efficacement la complexité asymptotique des algorithmes étudiés.

=== Graphiques ===

Les complexités étant des fonctions, nous pouvons les représenter par un graphique qui affichera le temps d'exécution (ou nombre d'opérations) en fonction de la taille des entrées.

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:30px; text-align:center;">
[[Fichier:complexite.webp|500px]]
<div><b>Graphiques des complexités</b></div>
</div>
<div style="max-width:800px;">
<p>Ce graphique ci-contre compare les complexités en fonction de la taille des d'entrées.</p>
<p>On comprend ainsi que certaines complexités ne sont pas raisonnable dans la cadre de la multiplication de grands entiers.</p>
<p>C'est pourquoi l'étude de ces algorithmes s'avère nécessaire.</p>
</div>
</div>

=== Exemple ===
L'algorithme naïf d'addition que nous avons tous appris à l'école a une complexité de <math>\mathcal{O}(n)</math>.
Soit n la taille des nombres en entrée, l'algorithme doit faire environ n addition pour arriver au résultat demandé.

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Addition.gif|220px]]
<div><b>Addition naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Comme le montre l'exemple ci-contre, 786 et 467 font 3 chiffres de long donc n sera de 3.</p>
<p>Il nous faudra 3 opérations pour additionner ces entiers.</p>
<p>C'est ainsi qu'avec une taille d'entrée n, l'algorithme de l'addition naïve va devoir faire n opérations.</p>
<p>Cet algorithme a donc une complexité <math>f(n) = n</math> qui n'a pas besoin d'être approximée.</p>
<p>Ainsi sa complexité finale sera <math>\mathcal{O}(n)</math>.</p>
</div>
</div>

= Problématique =

Le calcul du produit de deux entiers de manière naïve a une complexité de <math> \mathcal{O}(n^2)</math>, et celui de deux matrices une complexité de <math> \mathcal{O}(n^3)</math>. Afin de mieux comprendre ce qu'est la complexité algorithmique, nous devrons implémenter des algorithmes ayant le même objectif, mais étant plus efficaces. Ces algorithmes s'avèreront plus complexes mais devrait aboutir à un calcul plus rapide du produit demandé.

Nous séparerons notre wiki en deux grandes parties, la première concernera nos recherche sur [[#I - Produit d'entiers|la multiplication d'entiers]], la deuxième sur [[#II - Produit de matrices|la multiplication de matrices]].

= I - Produit d'entiers =

Notre départ commence avec l'algorithme de multiplication d'entier naïf.
En effet il s'agit de l'algorithme de multiplication le plus connu, et nous l'utiliserons comme référence pour le comparer aux futurs algorithmes plus efficaces.
Intéressons nous à sa complexité.

== 1) Nos implémentations des grands entiers ==

Qui dit produit de grands entiers dit implémentation de grands entiers.

Dans le cadre de nos recherches, nous allons devoir implémenter des algorithmes qui vont manipuler des grands entiers.

Nous avons donc choisi de créer deux représentations différentes de ceux-ci (car nous travaillons sur différents langages de programmation), nous permettant à la fois une implémentation simplifié, mais aussi de nous rapprocher d'une implémentation bas niveau.

=== A) En python ===
En python, l'utilisation des "bytes" m'a grandement servi à comprendre comment les entiers étaient manipulés à bas niveau. En effet, un des objectifs secondaires de nos recherches était de manipuler des entiers directement avec leur formes stockées sur l'ordinateur, et non pas avec des int python.
En effet l'utilisation des int python nous aurait permit de passer les étapes de retenues, de signes... D'autant plus que les bytes permettent de stocker un nombre en base 256, ce qui permet de visualiser plus facilement les grands entiers.

La forme finale de la représentation des grands entiers en python sera donc la suivante :

[ signe , bytes , bytes , (...) , bytes ]

Le signe est représenté par un entier, 1 si le nombre est positif, 0 sinon.
Cette configuration rendra plus simple la gestion des signes.

=== B) En C++ ===

En C++, pour avoir une représentation de grand entiers j'ai du définir ma propre structure pour m'affranchir de la limite de taille imposé par les entiers standards: (int32 ou int64). Pour cela, j'ai une structure qui possède l'équivalent d'un array de byte (ce qui nous permet d'être en base 256 au lieu de la base 10 habituelle), et pour traiter le signe j'utilise un booléen, ainsi en mémoire j'ai une structure de n*Octets + 1 octet en taille.

[ bytes , bytes , (...) , bytes ] [ signe ]

Le booléen prend 1 octet de place mais ne touche pas aux octets qui encode le grand entier.
Cette configuration rendra plus simple la gestion des signes dans le cadre des multiplication.

== 2) La multiplication naïve ==

=== A) Fonctionnement ===
Dans le cas de la multiplication d'entiers, nous allons prendre deux nombres qui n'ont pas nécessairement la même longueur. Soit les nombre a et b, de longueur respective <math> n </math> et <math> m </math>.
<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Multiplication.png|220px]]
<div><b>Multiplication naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Prenons deux nombres de longueur 3 et 2, et cherchons combien d'opérations l'algorithme de multiplication naïve va devoir faire pour nous renvoyer leur produit.</p>
<p>Dans un premier temps, on remarque que l'on va devoir multiplier chaque chiffre du nombre du haut par le chiffre des unités du bas, qui est 6. Cela va représenter <math>n</math> opérations. (6x5, 6x1 et 6x4)</p>
<p>Dans un deuxième temps nous constatons que nous allons devoir faire la même chose avec le chiffre des dizaines du nombre du bas. Cela nous ajoute de nouveau <math>n</math> opérations.</p>
<p>On arrive assez facilement à la conclusion que pour faire notre produit, il va nous falloir faire <math>n</math> fois <math>m</math> opérations.</p>
</div>
</div>

Ainsi, la complexité de la multiplication naïve est <math>\mathcal{O}(n^2)</math>.
Il est en de même avec la multiplication naïve récursive.

=== B) Graphique ===
Montrons maintenant sa courbe sur un graphique :

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Multiplicationnaive.png|500px]]
<div><b>Multiplication naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Les points noirs sont des repères pour que les autres courbes aient une forme cohérente.</p>
<p>Ils sont tous sur l'axe des abscisses.</p>
<p>La courbe rouge représente la complexité de la multiplication naïve.</p>
<p>On remarque que la courbe a un visuel très similaire à la fonction <math>f(x) = x^2</math> </p>
</div>
</div>

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Naif_recursif.png|500px]]
<div><b>Multiplication naïve récursive</b></div>
</div>
<div style="max-width:800px;">
<p>La courbe rouge représente la complexité de la multiplication naïve récursive.</p>
<p>Elle sera utilisé pour comparer les complexités entre algorithmes car, comme tous récursifs, elle a été codé avec les mêmes biais d'implémentation qu'eux.</p>
<p>Théoriquement les deux courbes ci-contre ont la même complexité, mais encore une fois, notre implémentation n'est pas parfaitement optimale et donc ne respecte pas de manière minutieuse le Master Theorem.</p>
</div>
</div>

== 3) La multiplication karatsuba ==

=== A) Fonctionnement ===

L'algorithme de karatsuba est un algorithme récursif de type diviser pour régner.

L'idée générale de l'algorithme est de passer de 4 multiplication à 3. En effet ces opérations étant moins couteuses, il est préférable d'en ajouter si cela permet d'enlever des multiplications.

L'algorithme de multiplication naif récursif utilise la segmentation des facteurs en deux de manière successive.

Soit <math>x</math> et <math>y</math> deux facteurs, nous avons les égalités suivantes :

<div style="font-size: 15px;">
<math>x = a \times B^{n/2} + b</math>
<math>y = c \times B^{n/2} + d</math>
</div>

Avec <math>a</math> et <math>c</math> les premières moitiés des facteurs <math>x</math> et <math>y</math>,
et <math> b </math> et <math>d</math> les dernières moitiés de ces facteurs ainsi que <math>B</math> la base d'écriture du nombre (Nous sommes en base 256 avec les bytes).

Cette présentation des deux facteurs de notre multiplication n'est que la résultante d'un découpage.
Le [[#Master Theorem|Master Theorem]] nous montre que :

<div style="font-size: 15px;">
<math>T(n) = 4T(n/2) + O(n)</math>
</div>

Puisque nous avons après découpage 4 entiers de longueur <math>n/2</math>.

Ainsi, ce découpage ne permet pas de gagner du temps d'après le [[#Master Theorem|Master Theorem]].

Cependant, l'algorithme de Karatsuba réutilise ce principe en le modifiant, ce qui nous permet de baisser la complexité globale de la multiplication dans son entièreté.

Avec l'écriture ci-dessus des nombres <math>x</math> et <math>y</math>, on peut facilement en déduire l'égalité suivante :

<div style="font-size: 15px;">
<math>x \times y = (ac) \times B^n + (ad + bc) \times B^{n/2} + bd</math>
</div>

On remarque 4 multiplications longues à faire dans cette expression. Les multiplications dont <math>B</math> est l'un des facteurs sont très rapides puisqu'il s'agit de la base dans laquelle nous travaillons. De cela en résulte un décalage plutôt qu'un vrai calcul à faire.

Karatsuba développe une partie de cette expression pour pouvoir négocier une multiplication au prix d'additions et soustractions.

En effet, nous savons déjà que :

<div style="font-size: 15px;">
<math>(a + b)(c + d) = ac + ad + bc + bd</math>
</div>

En manipulant l'égalité nous obtenons :

<div style="font-size: 15px;">
<math>ad + bc = (a + b)(c + d) - ac - bd</math>
</div>

ac et bd ayant déjà été calculé précédemment, il nous reste uniquement la multiplication <math>(a + b)(c + d)</math>.

Nous venons ainsi de calculer <math>ad + bc</math> en seulement une multiplication. C'est la que repose le gain de temps de la méthode Karatsuba par rapport à la multiplication naïve.

En effet, l'algorithme n'effectuera alors plus que 3 multiplications :
<div style="font-size: 15px;">
<math>ac</math>
<math>bd</math>
<math>(a + b)(c + d)</math>
</div>

La relation de récurrence devient donc :
<div style="font-size: 15px;">
<math>T(n)=3T(n/2)+O(n)</math>
</div>

Et le Master Theorem nous dit que :
<div style="font-size: 15px;">
<math>T(n)\in O(n^{\log_2(3)})</math>
</div>

Or <math>\log_2(3)\approx 1.585</math>, donc la complexité de l'algorithme de Karatsuba est de <math> \mathcal{O}(n^{1.585})</math>. Ce qui est bien plus efficace que la multiplication classique, surtout lorsque les facteurs deviennent très grands.

=== B) Graphique ===
<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Karatsuba.png|500px]]
<div><b>Karatsuba</b></div>
</div>
<div style="max-width:800px;">
<p>Sur le graphique ci-contre nous avons utilisé la courbe de la multiplication naïve récursive (rouge) à titre de comparaison.</p>
<p>On remarque graphiquement que Karatsuba (jaune) prend moins de temps à chaque calcul de produit.</p>
<p>On en déduit donc expérimentalement que Karatsuba à une meilleure complexité que la multiplication naïve.</p>
<p>Ainsi nous vérifions donc ce que le Master Theorem prouve, c'est à dire que la complexité de karatsuba est de <math> \mathcal{O}(n^{1.585})</math> </p>
</div>
</div>

== 4) La multiplication toom-cook-3 ==

=== A) Fonctionnement ===

L'objectif est de diviser les grands entiers X et Y en trois blocs de taille égale k.
On les traite alors comme des polynômes de degré 2:

<math>P(z) = X_2 \cdot z^2 + X_1 \cdot z + X_0</math>
<math>Q(z) = Y_2 \cdot z^2 + Y_1 \cdot z + Y_0</math>

On choisit 5 points distincts pour évaluer nos polynômes.
Ce choix de 5 points est crucial car le produit de deux polynômes de degré 2 est un polynôme de degré 4, qui nécessite 5 points pour être défini.
Les points standards sont :

P(0) = X0
P(1) = X0 + X1 + X2
P(-1) = X0 - X1 + X2
P(2) = X0 + 2*X1 + 4*X2
P(inf) = X2

(On procède de manière similaire pour Q.)

Ensuite nous multiplions récursivement chaque points de P et de Q ensemble.
On effectue ainsi 5 multiplications de nombres plus petits au lieu des 9 multiplications requises par la méthode classique.

Après, nous effectuons une interpolation, cela permet de retrouver les 5 coefficients (w_0, w_1, w_2, w_3, w_4) du polynôme produit R(z) à partir des valeurs évaluées calculées précédemment.
On résout un système d'équations linéaires : <math> R(z) = w_4 z^4 + w_3 z^3 + w_2 z^2 + w_1 z + w_0 </math>
Finalement nous pouvons recomposer notre grand entier en positionnant les coefficients w_i aux bons rangs (en les décalant) et à gérer les retenues lors de l'addition finale:
Résultat <math>= w_4 B^{4k} + w_3 B^{3k} + w_2 B^{2k} + w_1 B^k + w_0</math>

=== B) Graphique ===

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Toomcook.png|500px]]
<div><b>Karatsuba</b></div>
</div>
<div style="max-width:800px;">
<p>on a reprit multi récursive (rouge)</p>
<p>on voit que Toom (vert) en dessous de karatsuba (jaune) en dessous de multi classique (rouge)</p>
<p>meilleur complexité</p>
</div>
</div>

== 5) La transformée de Fourier rapide ==

=== A) Fonctionnement ===

La transformation de Fourier rapide étant plus complexe que les autres algorithmes, nous allons essayer d'expliquer son fonctionnement malgré ne pas avoir réussi à l'implémenter.

Il faut comprendre que cet algorithme va considérer les facteurs comme des polynômes.

D'après le théorème de l'unisolvance, il n'existe qu'un seul polynôme de degré inférieur ou égal à <math> n </math> défini par <math>n + 1</math> points distincts. Cela implique non seulement que nous pouvons représenter chaque entier par un polynôme, mais également que si nous pouvons retrouver <math>n + m + 1</math> points (avec <math>n</math> et <math>m</math> la longueur des facteurs) du polynômes issue du produit entre deux facteurs, nous pourrons le retrouver.

Soit un entier quelconque, de forme :

<math>a_n a_{n-1} (...) a_1 a_0</math>

Avec <math>a_i</math>, un chiffre composant le nombre en base 10, qui vaut en réalité dans le nombre : <math>a_i \times 10^i</math>. On peut ainsi l'écrire sous la forme :

<math> P(x) = a_0 + a_1x + a_2x^2 + \dots + a_{n-1}x^{n-1} + a_nx^n </math>

Avec <math>x = 10</math> car nous sommes en base 10, nous obtenons :

<math>P(10) = a_0 + a_1 \times 10 + \dots + a_{n-1}10^{n-1} + a_n10^n </math>

Nous venons ainsi d'écrire notre nombre sous la forme d'un polynôme unique. Pour nous permettre d'évaluer en un nombre suffisant de points, nous allons devoir ajouter des 0 pour la récursion. Il nous faudra ajouter assez de 0 pour atteindre la prochaine puissance de 2 qui sera supérieure ou égale à <math>2n + 1</math>. L'ajout de 0 ne change pas le nombre car <math>0 \times x^n</math> n'ajoute pas de coefficient.

Cet algorithme est récursif et va segmenter en deux parties nos polynômes à chaque récursion. D'un coté les indice pairs et d'un coté les impaires.

Ainsi prenons les nombres 1234 et 5678, ces nombres sont respectivement représentés par les polynômes <math> P(x) = 4 + 3x + 2x^2 + x^3 </math> et <math> P(x) = 8 + 7x + 6x^2 + 5^3 </math>. Ce sont des polynômes de degré 3, ainsi leur produit donnera lieu à un polynôme de degré 6. Il nous faudra donc au minimum 7 points d'évaluation pour retrouve ce produit. De ce fait, en les représentant de la manière suivante :

<math>[4, 3, 2, 1, 0, 0, 0, 0]</math>
<math>[8, 7, 6, 5, 0, 0, 0, 0]</math>

Nous aurons assez de récursions possible pour les évaluer en un nombre suffisant de points différents car nous auront 3 récursions à faire pour atteindre notre cas de base. A chaque récursion, nous allons diviser nos polynômes en deux parties ce qui nous fait 8 feuilles à la dernière récursion.

En effet à chaque étape de la récursion nous allons séparer nos polynômes en deux tel que :

<math>P(x)=P_{\text{pair}}(x^2) + x \cdot P_{\text{impair}}(x^2)</math>

Durant les récursions, nous segmentons les polynômes mais ne les évaluons pas. C'est à la remonté des récursions que nous allons réellement évaluer nos polynômes. Lorsque l'on atteint notre cas de base, c'est à dire des polynômes de degré 0, nous remarquons qu'ils sont constants, nous n'avons donc pas besoin de les évaluer. En effet, peut importe le point en lequel nous voudrons l'évaluer, le polynôme renverra la constante. Nous la renvoyons donc seule.
Ensuite commence la remontée des récursions. A l'étape 1 de notre remontée nous allons reformer le polynôme précédemment séparé pour obtenir un polynôme de degré 1. Puis, nous évaluons ce polynôme avec les racines seconde de l'unité. Nous faisons à nouveau remonté les évaluations et recombinons à nouveau le polynôme qui sera ainsi de degré 2.
Nous l'évaluons maintenant avec les racines 4eme de l'unité. A chaque évaluation, nous réutilisons les résultats précédents, cela nous est permit par les racines de l'unité qui ont une structure récursive exploitable.

Finalement, nous arrivons à la fin de notre FFT, avec une représentation fréquentielle de la forme :

<math> [P(W_0), P(W_1), (...), P(W_n-1), P(W_n)] </math>

Cette représentation fréquentielle n'est autre que les évaluations du polynôme P aux racines nièmes de l'unité. Nous avons donc maintenant au minimum <math>2n+1</math> évaluations des polynômes facteurs. Il nous faut maintenant trouver les évaluations du produit final, c'est à dire les évaluations concernant le polynôme qui sera issue de la multiplication. On pourra ainsi le retrouver.

Soit <math>C</math> un polynome tel que <math> C = A \times B </math>, alors on a :

<math> C(x) = A(x) \times B(x) </math>

Ainsi on en déduit que <math> C(W_n^k) = A(W_n^k) \times B(W_n^k) </math>

On comprend donc que <math>FFT(C) = FFT(A) \times FFT(B)</math>

Il faut préciser que l'on fait le produit de FFT(A) et FFT(B) terme à terme, soit évaluation par évaluation.

Une fois en possession de <math>FFT(C)</math>, qui n'est autre que l'évaluation de notre polynôme final en un nombre suffisant de points pour le retrouver, nous pouvons faire l'<math>IFFT(FFT(C))</math>, qui va nous permettre de retrouver les coefficients de notre polynôme en faisant l'exacte inverse de la FFT.

Une fois les coefficients retrouvés, il nous suffit de gérer les retenues, et nous retrouvons un entier de la forme : <math>a_0 a_1 (...) a_{n-1} a_n</math>

=== B) Graphique ===

Intéressons nous maintenant à la complexité de l'algorithme utilisant la transformée de Fourier rapide. On sait que l'algorithme passe par 5 étapes importantes :

<ul>
<li>Etape 1 : Ecrire les deux facteurs sous la forme de polynômes</li>
<li>Etape 2 : Effectuer la <math>FFT</math> des deux polynômes</li>
<li>Etape 3 : Faire le produit terme à terme des <math>FFT</math> obtenues</li>
<li>Etape 4 : Faire l'<math>IFFT</math> du produit</li>
<li>Etape 5 : Gérer les retenues et écrire le nombre qui en découle</li>
</ul>

Or, parmi toutes ces étapes, certaines sont négligeable comme l'étape 1 et 5.

Pour connaitre la complexité de l'algorithme, additionnons les complexités des étapes restantes :

Une <math>FFT</math> a une complexité de <math>\mathcal{O}(n\times logn)</math> car elle fait <math>n</math> évaluation sur <math> log(n)</math> récursions. Dans le cadre de notre algorithme, nous devons faire la <math>FFT</math> de nos deux facteurs. Soit <math>2\times \mathcal{O}(n\times logn)</math>.

Pour le produit terme à terme, nous faisons naturellement <math>n</math> opérations.

Pour finir, l'<math>IFFT</math> a la même complexité que la <math>FFT</math>. Dans le cadre de notre algorithme nous l'emploierons qu'une seule fois, ce qui fait une complexité de <math>\mathcal{O}(n\times logn)</math>.

Après addition de toutes ces complexités, nous obtenons la complexité réelle de <math>3\mathcal{O}(n\times logn) + \mathcal{O}(n)</math>.

D'après le Master Theorem, nous avons donc <math> f(n) = 3(n\times logn)+n </math>, cherchons <math>f(n)\in\mathcal{O}(g(n))</math> :

Nous pouvons ignorer les expressions linéaires ainsi que les constantes multiplicatrices, nous obtenons donc <math>\mathcal{O}(g(n)) = \mathcal{O}(n \times log n)</math>.

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:30px; text-align:center;">
[[Fichier:FFT_image.webp|500px]]
<div><b>Graphiques des complexités</b></div>
</div>
<div style="max-width:800px;">
<p>Ce graphique ci-contre ne provient pas du fruit de nos recherches personnelles mais illustre bien la comparaison entre la complexité de la FFT et des autres algorithmes.</p>
<p>On remarque que la FFT est très efficace et devance de loin les autres algorithmes en terme de complexité. </p>
<p>C'est l'un des plus performants.</p>
</div>
</div>

= II - Produit de matrices =

== 1.1) naïve ==

La multiplication naïve de matrice requiert d'avoir des tailles de lignes/colonne semblable, ensuite pour chaque membre de la matrice résultat, on doit multiplier les composantes ligne de la première matrice par les composantes colonne de la deuxième et le tout sommé.

On en déduit la formule suivante:
<math>C_{i,j} = \sum_{k=1}^{n} (A_{i,k} \times B_{k,j})</math>

Et visuellement:

[[Fichier:Matricenaive.jpeg]]

On a donc un algorithme d'ordre de complexité <math>\mathcal{O}(g(n))</math>

== 1.2) naïve récursive ==

Dans un premier temps on doit découper nos deux matrices en quatres sous matrices de plus petite taille.
<math>A = \begin{pmatrix} A_{11} & A_{12} \ A_{21} & A_{22} \end{pmatrix}</math>
<math>B = \begin{pmatrix} B_{11} & B_{12} \ B_{21} & B_{22} \end{pmatrix}</math>

Ensuite on vient calculer la matrice résultat.
<math>C_{11} = (A_{11} \times B_{11}) + (A_{12} \times B_{21})</math>
<math>C_{12} = (A_{11} \times B_{12}) + (A_{12} \times B_{22})</math>
<math>C_{21} = (A_{21} \times B_{11}) + (A_{22} \times B_{21})</math>
<math>C_{22} = (A_{21} \times B_{12}) + (A_{22} \times B_{22})</math>

Le côté récursif est utile que pour les matrices de tailles <= 32 (32 valeurs stockées dedans),
si on est au dessus de cette taille alors on divisera à nouveau nos matrices en quatres.
On aura 8 multiplications mais de plus petite taille au final.

== 2) strassen ==

=== A) Fonctionnement ===

Strassen consiste à définir 7 produits intermédiaires qui, par des jeux de sommes et de différences, permettent de reconstruire les quadrants de la matrice résultante. On passe ainsi d'une complexité de O(n^3) à environ O(n^2.81)

=== B) Graphique ===

On voit bien la différence de complexité sur la multiplication de grande matrice entre l'approche naïve et l'approche récursive qui est beaucoup plus rapide.

[[Fichier:Analyse matrices.png]]

= Conclusion =

L'étude de ces algorithmes de multiplication nous a clairement montré l'évolution de la complexité algorithmique permettant de gagner en efficacité lorsque la taille des données augmente.

La multiplication classiqe, en <math>\mathcal{O}(n^2)</math>, résulte d'une approche naïve qui devient rapidement inefficace pour les grands entiers ou les grandes matrices. L'algorithme de Karatsuba nous montre qu'organiser de manière intelligente ses calculs algébrique permet parfois de gagner beaucoup de multiplications, et donc de temps. Nous avons ainsi réussi à passer d'une complexité de <math>\mathcal{O}(n^2)</math> à <math>\mathcal{O}(n^{log_2(3)})</math>, soit environ <math>\mathcal{O}(n^{1/585})</math>.

Des méthodes encore plus avancées comme utilise l'algorithme de Toom-Cook-3 continue dans cette idées de divisions d'entiers en blocs plus petits, tandis que la transformée de Fourier rapide change complètement de point de vue. En effet la FFT n'utilise pas la représentation classique des entiers mais fait appel à une vision polynomiale, ce qui transforme la convolution classique en multiplication terme à terme, ce qui lui permet d'atteindre une complexité de <math>\mathcal{O}(n \times log n)</math>.

Dans le cas des matrices, les mêmes logiques apparaissent comme par exemple avec l'algorithme de Strassen qui se rapproche très fortement de Karatsuba en combinant de manière astucieuse les parties d'entiers qui avaient été précédemment découpée.

On remarque néanmoins que la majorité des algorithmes efficaces s'orientent vers une approche récursive et non itérative. Néanmoins, nous avons pu trouver certaines de ces implémentations (comme par exemple la FFT) en itérative.

Avec ces recherches, nous comprenons que la réorganisations des calculs algébriques peuvent aider à gagner en complexité mais que pour faire de réels progrès, il nous faudra surement changer notre point de vue une nouvelle fois, et aborder le problème sous un angle nouveau comme le font dors et déjà les algorithmes les plus performants.

= Mentions =

Le premier gif est le résultat du travail de 'Walké', licence ci-contre : https://fr.wikipedia.org/wiki/Fichier:Addition.gif

Utilisation du site de production graphique "Desmos" : https://www.desmos.com/calculator?lang=fr

= Sources =

Pour karatsuba :
<ul>
<li> https://www.youtube.com/watch?v=PZ2gdWdKHAA </li>
</ul>

Pour mieux comprendre la FFT, nous avons utilisé plusieurs sources d'informations :
<ul>
<li> https://www.youtube.com/watch?v=h7apO7q16V0&list=WL&index=1&t=886s </li>
<li> https://fr.wikipedia.org/wiki/Interpolation_polynomiale </li>
</ul>

Algorithmes de multiplications d'entiers et de matrices

2026-05-11T21:13:29Z

Mangala : /* A) Fonctionnement */

= Introduction =

Depuis l'apparition des ordinateurs modernes, une quantité faramineuse de calculs a dû être effectuée. Les progressions technologiques nous poussent à envisager la puissance de calcul comme une ressource qu'il faut optimiser dans les moindres détails. C'est ainsi que l'optimisation des algorithmes de calcul est devenue cruciale, surtout lorsqu'il nous faut effectuer des opérations sur de très grands entiers par exemple.

= Objectif =

L'objectif majeur de ce projet est de comprendre de manière plus approfondie ce qu'est la '''complexité algorithmique'''.
Pour atteindre cet objectif, nous implémenterons plusieurs algorithmes de multiplication qui auront pour but de calculer le produit de grands entiers ou de matrices.

= Point important : complexité =

=== Définition ===
La complexité d'un algorithme est la quantité des ressources qu'il utilise en fonction de la taille des entrées qu'on lui demande de traiter. On peut par exemple se concentrer sur le temps qu'un algorithme prend pour renvoyer un résultat ou sur la mémoire dont il a besoin. Dans le cadre de notre projet, nous nous attarderons plus particulièrement sur la quantité de calcul effectuée en fonction de la taille des entrées, ce qui est par ailleurs étroitement liée à la notion de temps. De manière générale, plus un algorithme doit faire de calcul, plus il est lent. (Attention, toutes les opérations arithmétiques de base ne se valent pas)

De manière plus familière, on dira que la complexité d'un algorithme pourrait s'apparenter à son comportement lorsqu'il doit traiter des données plus ou moins grandes.
Chaque algorithme a une complexité, et on l'exprime par une fonction qui adopte un comportement similaire au nombre de calculs nécessaires en fonction de la taille des entrées.

=== Notation ===
La complexité réelle d'un algorithme peut être décrite par une fonction <math> f(n) </math> représentant le nombre d'opérations effectuées en fonction de la taille <math>n</math> des données d'entrée.

Cependant, afin de simplifier l'étude de cette croissance, on utilise généralement une borne asymptotique notée <math>\mathcal{O}(g(n))</math>, où <math>g(n)</math> est une fonction ayant le même ordre de grandeur que <math>f(n)</math> lorsque <math>n</math> devient grand.

On dit alors que :

<math>
f(n)\in\mathcal{O}(g(n))
</math>

si et seulement s'il existe une constante <math>C>0</math> et un entier <math>n_0</math> tels que :

<math>
\forall n\ge n_0,\ f(n)\le Cg(n)
</math>

Cette notation <math>\mathcal{O}(g(n))</math> permettra de comparer beaucoup plus facilement les algorithmes entre eux.

=== Master Theorem ===

Afin de déterminer la complexité de certains algorithmes récursifs, nous utiliserons le "Master Theorem".

Ce théorème permet d'obtenir directement l'ordre de grandeur de nombreuses relations de récurrence apparaissant dans l'analyse d'algorithmes de type « diviser pour régner », comme l'algorithme de Karatsuba ou celui de Strassen.

La démonstration complète de ce théorème dépasse le cadre de notre projet et nécessite des connaissances mathématiques plus avancées. Nous l'utiliserons donc principalement comme un outil nous permettant de déterminer efficacement la complexité asymptotique des algorithmes étudiés.

=== Graphiques ===

Les complexités étant des fonctions, nous pouvons les représenter par un graphique qui affichera le temps d'exécution (ou nombre d'opérations) en fonction de la taille des entrées.

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:30px; text-align:center;">
[[Fichier:complexite.webp|500px]]
<div><b>Graphiques des complexités</b></div>
</div>
<div style="max-width:800px;">
<p>Ce graphique ci-contre compare les complexités en fonction de la taille des d'entrées.</p>
<p>On comprend ainsi que certaines complexités ne sont pas raisonnable dans la cadre de la multiplication de grands entiers.</p>
<p>C'est pourquoi l'étude de ces algorithmes s'avère nécessaire.</p>
</div>
</div>

=== Exemple ===
L'algorithme naïf d'addition que nous avons tous appris à l'école a une complexité de <math>\mathcal{O}(n)</math>.
Soit n la taille des nombres en entrée, l'algorithme doit faire environ n addition pour arriver au résultat demandé.

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Addition.gif|220px]]
<div><b>Addition naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Comme le montre l'exemple ci-contre, 786 et 467 font 3 chiffres de long donc n sera de 3.</p>
<p>Il nous faudra 3 opérations pour additionner ces entiers.</p>
<p>C'est ainsi qu'avec une taille d'entrée n, l'algorithme de l'addition naïve va devoir faire n opérations.</p>
<p>Cet algorithme a donc une complexité <math>f(n) = n</math> qui n'a pas besoin d'être approximée.</p>
<p>Ainsi sa complexité finale sera <math>\mathcal{O}(n)</math>.</p>
</div>
</div>

= Problématique =

Le calcul du produit de deux entiers de manière naïve a une complexité de <math> \mathcal{O}(n^2)</math>, et celui de deux matrices une complexité de <math> \mathcal{O}(n^3)</math>. Afin de mieux comprendre ce qu'est la complexité algorithmique, nous devrons implémenter des algorithmes ayant le même objectif, mais étant plus efficaces. Ces algorithmes s'avèreront plus complexes mais devrait aboutir à un calcul plus rapide du produit demandé.

Nous séparerons notre wiki en deux grandes parties, la première concernera nos recherche sur [[#I - Produit d'entiers|la multiplication d'entiers]], la deuxième sur [[#II - Produit de matrices|la multiplication de matrices]].

= I - Produit d'entiers =

Notre départ commence avec l'algorithme de multiplication d'entier naïf.
En effet il s'agit de l'algorithme de multiplication le plus connu, et nous l'utiliserons comme référence pour le comparer aux futurs algorithmes plus efficaces.
Intéressons nous à sa complexité.

== 1) Nos implémentations des grands entiers ==

Qui dit produit de grands entiers dit implémentation de grands entiers.

Dans le cadre de nos recherches, nous allons devoir implémenter des algorithmes qui vont manipuler des grands entiers.

Nous avons donc choisi de créer deux représentations différentes de ceux-ci (car nous travaillons sur différents langages de programmation), nous permettant à la fois une implémentation simplifié, mais aussi de nous rapprocher d'une implémentation bas niveau.

=== A) En python ===
En python, l'utilisation des "bytes" m'a grandement servi à comprendre comment les entiers étaient manipulés à bas niveau. En effet, un des objectifs secondaires de nos recherches était de manipuler des entiers directement avec leur formes stockées sur l'ordinateur, et non pas avec des int python.
En effet l'utilisation des int python nous aurait permit de passer les étapes de retenues, de signes... D'autant plus que les bytes permettent de stocker un nombre en base 256, ce qui permet de visualiser plus facilement les grands entiers.

La forme finale de la représentation des grands entiers en python sera donc la suivante :

[ signe , bytes , bytes , (...) , bytes ]

Le signe est représenté par un entier, 1 si le nombre est positif, 0 sinon.
Cette configuration rendra plus simple la gestion des signes.

=== B) En C++ ===

En C++, pour avoir une représentation de grand entiers j'ai du définir ma propre structure pour m'affranchir de la limite de taille imposé par les entiers standards: (int32 ou int64). Pour cela, j'ai une structure qui possède l'équivalent d'un array de byte (ce qui nous permet d'être en base 256 au lieu de la base 10 habituelle), et pour traiter le signe j'utilise un booléen, ainsi en mémoire j'ai une structure de n*Octets + 1 octet en taille.

[ bytes , bytes , (...) , bytes ] [ signe ]

Le booléen prend 1 octet de place mais ne touche pas aux octets qui encode le grand entier.
Cette configuration rendra plus simple la gestion des signes dans le cadre des multiplication.

== 2) La multiplication naïve ==

=== A) Fonctionnement ===
Dans le cas de la multiplication d'entiers, nous allons prendre deux nombres qui n'ont pas nécessairement la même longueur. Soit les nombre a et b, de longueur respective <math> n </math> et <math> m </math>.
<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Multiplication.png|220px]]
<div><b>Multiplication naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Prenons deux nombres de longueur 3 et 2, et cherchons combien d'opérations l'algorithme de multiplication naïve va devoir faire pour nous renvoyer leur produit.</p>
<p>Dans un premier temps, on remarque que l'on va devoir multiplier chaque chiffre du nombre du haut par le chiffre des unités du bas, qui est 6. Cela va représenter <math>n</math> opérations. (6x5, 6x1 et 6x4)</p>
<p>Dans un deuxième temps nous constatons que nous allons devoir faire la même chose avec le chiffre des dizaines du nombre du bas. Cela nous ajoute de nouveau <math>n</math> opérations.</p>
<p>On arrive assez facilement à la conclusion que pour faire notre produit, il va nous falloir faire <math>n</math> fois <math>m</math> opérations.</p>
</div>
</div>

Ainsi, la complexité de la multiplication naïve est <math>\mathcal{O}(n^2)</math>.
Il est en de même avec la multiplication naïve récursive.

=== B) Graphique ===
Montrons maintenant sa courbe sur un graphique :

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Multiplicationnaive.png|500px]]
<div><b>Multiplication naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Les points noirs sont des repères pour que les autres courbes aient une forme cohérente.</p>
<p>Ils sont tous sur l'axe des abscisses.</p>
<p>La courbe rouge représente la complexité de la multiplication naïve.</p>
<p>On remarque que la courbe a un visuel très similaire à la fonction <math>f(x) = x^2</math> </p>
</div>
</div>

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Naif_recursif.png|500px]]
<div><b>Multiplication naïve récursive</b></div>
</div>
<div style="max-width:800px;">
<p>La courbe rouge représente la complexité de la multiplication naïve récursive.</p>
<p>Elle sera utilisé pour comparer les complexités entre algorithmes car, comme tous récursifs, elle a été codé avec les mêmes biais d'implémentation qu'eux.</p>
<p>Théoriquement les deux courbes ci-contre ont la même complexité, mais encore une fois, notre implémentation n'est pas parfaitement optimale et donc ne respecte pas de manière minutieuse le Master Theorem.</p>
</div>
</div>

== 3) La multiplication karatsuba ==

=== A) Fonctionnement ===

L'algorithme de karatsuba est un algorithme récursif de type diviser pour régner.

L'idée générale de l'algorithme est de passer de 4 multiplication à 3. En effet ces opérations étant moins couteuses, il est préférable d'en ajouter si cela permet d'enlever des multiplications.

L'algorithme de multiplication naif récursif utilise la segmentation des facteurs en deux de manière successive.

Soit <math>x</math> et <math>y</math> deux facteurs, nous avons les égalités suivantes :

<div style="font-size: 15px;">
<math>x = a \times B^{n/2} + b</math>
<math>y = c \times B^{n/2} + d</math>
</div>

Avec <math>a</math> et <math>c</math> les premières moitiés des facteurs <math>x</math> et <math>y</math>,
et <math> b </math> et <math>d</math> les dernières moitiés de ces facteurs ainsi que <math>B</math> la base d'écriture du nombre (Nous sommes en base 256 avec les bytes).

Cette présentation des deux facteurs de notre multiplication n'est que la résultante d'un découpage.
Le [[#Master Theorem|Master Theorem]] nous montre que :

<div style="font-size: 15px;">
<math>T(n) = 4T(n/2) + O(n)</math>
</div>

Puisque nous avons après découpage 4 entiers de longueur <math>n/2</math>.

Ainsi, ce découpage ne permet pas de gagner du temps d'après le [[#Master Theorem|Master Theorem]].

Cependant, l'algorithme de Karatsuba réutilise ce principe en le modifiant, ce qui nous permet de baisser la complexité globale de la multiplication dans son entièreté.

Avec l'écriture ci-dessus des nombres <math>x</math> et <math>y</math>, on peut facilement en déduire l'égalité suivante :

<div style="font-size: 15px;">
<math>x \times y = (ac) \times B^n + (ad + bc) \times B^{n/2} + bd</math>
</div>

On remarque 4 multiplications longues à faire dans cette expression. Les multiplications dont <math>B</math> est l'un des facteurs sont très rapides puisqu'il s'agit de la base dans laquelle nous travaillons. De cela en résulte un décalage plutôt qu'un vrai calcul à faire.

Karatsuba développe une partie de cette expression pour pouvoir négocier une multiplication au prix d'additions et soustractions.

En effet, nous savons déjà que :

<div style="font-size: 15px;">
<math>(a + b)(c + d) = ac + ad + bc + bd</math>
</div>

En manipulant l'égalité nous obtenons :

<div style="font-size: 15px;">
<math>ad + bc = (a + b)(c + d) - ac - bd</math>
</div>

ac et bd ayant déjà été calculé précédemment, il nous reste uniquement la multiplication <math>(a + b)(c + d)</math>.

Nous venons ainsi de calculer <math>ad + bc</math> en seulement une multiplication. C'est la que repose le gain de temps de la méthode Karatsuba par rapport à la multiplication naïve.

En effet, l'algorithme n'effectuera alors plus que 3 multiplications :
<div style="font-size: 15px;">
<math>ac</math>
<math>bd</math>
<math>(a + b)(c + d)</math>
</div>

La relation de récurrence devient donc :
<div style="font-size: 15px;">
<math>T(n)=3T(n/2)+O(n)</math>
</div>

Et le Master Theorem nous dit que :
<div style="font-size: 15px;">
<math>T(n)\in O(n^{\log_2(3)})</math>
</div>

Or <math>\log_2(3)\approx 1.585</math>, donc la complexité de l'algorithme de Karatsuba est de <math> \mathcal{O}(n^{1.585})</math>. Ce qui est bien plus efficace que la multiplication classique, surtout lorsque les facteurs deviennent très grands.

=== B) Graphique ===
<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Karatsuba.png|500px]]
<div><b>Karatsuba</b></div>
</div>
<div style="max-width:800px;">
<p>Sur le graphique ci-contre nous avons utilisé la courbe de la multiplication naïve récursive (rouge) à titre de comparaison.</p>
<p>On remarque graphiquement que Karatsuba (jaune) prend moins de temps à chaque calcul de produit.</p>
<p>On en déduit donc expérimentalement que Karatsuba à une meilleure complexité que la multiplication naïve.</p>
<p>Ainsi nous vérifions donc ce que le Master Theorem prouve, c'est à dire que la complexité de karatsuba est de <math> \mathcal{O}(n^{1.585})</math> </p>
</div>
</div>

== 4) La multiplication toom-cook-3 ==

=== A) Fonctionnement ===

L'objectif est de diviser les grands entiers X et Y en trois blocs de taille égale k.
On les traite alors comme des polynômes de degré 2:

<math>P(z) = X_2 \cdot z^2 + X_1 \cdot z + X_0</math>
<math>Q(z) = Y_2 \cdot z^2 + Y_1 \cdot z + Y_0</math>

On choisit 5 points distincts pour évaluer nos polynômes.
Ce choix de 5 points est crucial car le produit de deux polynômes de degré 2 est un polynôme de degré 4, qui nécessite 5 points pour être défini.
Les points standards sont :

P(0) = X0
P(1) = X0 + X1 + X2
P(-1) = X0 - X1 + X2
P(2) = X0 + 2*X1 + 4*X2
P(inf) = X2

(On procède de manière similaire pour Q.)

Ensuite nous multiplions récursivement chaque points de P et de Q ensemble.
On effectue ainsi 5 multiplications de nombres plus petits au lieu des 9 multiplications requises par la méthode classique.

Après, nous effectuons une interpolation, cela permet de retrouver les 5 coefficients (w_0, w_1, w_2, w_3, w_4) du polynôme produit R(z) à partir des valeurs évaluées calculées précédemment.
On résout un système d'équations linéaires : <math> R(z) = w_4 z^4 + w_3 z^3 + w_2 z^2 + w_1 z + w_0 </math>
Finalement nous pouvons recomposer notre grand entier en positionnant les coefficients w_i aux bons rangs (en les décalant) et à gérer les retenues lors de l'addition finale:
Résultat <math>= w_4 B^{4k} + w_3 B^{3k} + w_2 B^{2k} + w_1 B^k + w_0</math>

=== B) Graphique ===

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Toomcook.png|500px]]
<div><b>Karatsuba</b></div>
</div>
<div style="max-width:800px;">
<p>on a reprit multi récursive (rouge)</p>
<p>on voit que Toom (vert) en dessous de karatsuba (jaune) en dessous de multi classique (rouge)</p>
<p>meilleur complexité</p>
</div>
</div>

== 5) La transformée de Fourier rapide ==

=== A) Fonctionnement ===

La transformation de Fourier rapide étant plus complexe que les autres algorithmes, nous allons essayer d'expliquer son fonctionnement malgré ne pas avoir réussi à l'implémenter.

Il faut comprendre que cet algorithme va considérer les facteurs comme des polynômes.

D'après le théorème de l'unisolvance, il n'existe qu'un seul polynôme de degré inférieur ou égal à <math> n </math> défini par <math>n + 1</math> points distincts. Cela implique non seulement que nous pouvons représenter chaque entier par un polynôme, mais également que si nous pouvons retrouver <math>n + m + 1</math> points (avec <math>n</math> et <math>m</math> la longueur des facteurs) du polynômes issue du produit entre deux facteurs, nous pourrons le retrouver.

Soit un entier quelconque, de forme :

<math>a_n a_{n-1} (...) a_1 a_0</math>

Avec <math>a_i</math>, un chiffre composant le nombre en base 10, qui vaut en réalité dans le nombre : <math>a_i \times 10^i</math>. On peut ainsi l'écrire sous la forme :

<math> P(x) = a_0 + a_1x + a_2x^2 + \dots + a_{n-1}x^{n-1} + a_nx^n </math>

Avec <math>x = 10</math> car nous sommes en base 10, nous obtenons :

<math>P(10) = a_0 + a_1 \times 10 + \dots + a_{n-1}10^{n-1} + a_n10^n </math>

Nous venons ainsi d'écrire notre nombre sous la forme d'un polynôme unique. Pour nous permettre d'évaluer en un nombre suffisant de points, nous allons devoir ajouter des 0 pour la récursion. Il nous faudra ajouter assez de 0 pour atteindre la prochaine puissance de 2 qui sera supérieure ou égale à <math>2n + 1</math>. L'ajout de 0 ne change pas le nombre car <math>0 \times x^n</math> n'ajoute pas de coefficient.

Cet algorithme est récursif et va segmenter en deux parties nos polynômes à chaque récursion. D'un coté les indice pairs et d'un coté les impaires.

Ainsi prenons les nombres 1234 et 5678, ces nombres sont respectivement représentés par les polynômes <math> P(x) = 4 + 3x + 2x^2 + x^3 </math> et <math> P(x) = 8 + 7x + 6x^2 + 5^3 </math>. Ce sont des polynômes de degré 3, ainsi leur produit donnera lieu à un polynôme de degré 6. Il nous faudra donc au minimum 7 points d'évaluation pour retrouve ce produit. De ce fait, en les représentant de la manière suivante :

<math>[4, 3, 2, 1, 0, 0, 0, 0]</math>
<math>[8, 7, 6, 5, 0, 0, 0, 0]</math>

Nous aurons assez de récursions possible pour les évaluer en un nombre suffisant de points différents car nous auront 3 récursions à faire pour atteindre notre cas de base. A chaque récursion, nous allons diviser nos polynômes en deux parties ce qui nous fait 8 feuilles à la dernière récursion.

En effet à chaque étape de la récursion nous allons séparer nos polynômes en deux tel que :

<math>P(x)=P_{\text{pair}}(x^2) + x \cdot P_{\text{impair}}(x^2)</math>

Durant les récursions, nous segmentons les polynômes mais ne les évaluons pas. C'est à la remonté des récursions que nous allons réellement évaluer nos polynômes. Lorsque l'on atteint notre cas de base, c'est à dire des polynômes de degré 0, nous remarquons qu'ils sont constants, nous n'avons donc pas besoin de les évaluer. En effet, peut importe le point en lequel nous voudrons l'évaluer, le polynôme renverra la constante. Nous la renvoyons donc seule.
Ensuite commence la remontée des récursions. A l'étape 1 de notre remontée nous allons reformer le polynôme précédemment séparé pour obtenir un polynôme de degré 1. Puis, nous évaluons ce polynôme avec les racines seconde de l'unité. Nous faisons à nouveau remonté les évaluations et recombinons à nouveau le polynôme qui sera ainsi de degré 2.
Nous l'évaluons maintenant avec les racines 4eme de l'unité. A chaque évaluation, nous réutilisons les résultats précédents, cela nous est permit par les racines de l'unité qui ont une structure récursive exploitable.

Finalement, nous arrivons à la fin de notre FFT, avec une représentation fréquentielle de la forme :

<math> [P(W_0), P(W_1), (...), P(W_n-1), P(W_n)] </math>

Cette représentation fréquentielle n'est autre que les évaluations du polynôme P aux racines nièmes de l'unité. Nous avons donc maintenant au minimum <math>2n+1</math> évaluations des polynômes facteurs. Il nous faut maintenant trouver les évaluations du produit final, c'est à dire les évaluations concernant le polynôme qui sera issue de la multiplication. On pourra ainsi le retrouver.

Soit <math>C</math> un polynome tel que <math> C = A \times B </math>, alors on a :

<math> C(x) = A(x) \times B(x) </math>

Ainsi on en déduit que <math> C(W_n^k) = A(W_n^k) \times B(W_n^k) </math>

On comprend donc que <math>FFT(C) = FFT(A) \times FFT(B)</math>

Il faut préciser que l'on fait le produit de FFT(A) et FFT(B) terme à terme, soit évaluation par évaluation.

Une fois en possession de <math>FFT(C)</math>, qui n'est autre que l'évaluation de notre polynôme final en un nombre suffisant de points pour le retrouver, nous pouvons faire l'<math>IFFT(FFT(C))</math>, qui va nous permettre de retrouver les coefficients de notre polynôme en faisant l'exacte inverse de la FFT.

Une fois les coefficients retrouvés, il nous suffit de gérer les retenues, et nous retrouvons un entier de la forme : <math>a_0 a_1 (...) a_{n-1} a_n</math>

=== B) Graphique ===

Intéressons nous maintenant à la complexité de l'algorithme utilisant la transformée de Fourier rapide. On sait que l'algorithme passe par 5 étapes importantes :

<ul>
<li>Etape 1 : Ecrire les deux facteurs sous la forme de polynômes</li>
<li>Etape 2 : Effectuer la <math>FFT</math> des deux polynômes</li>
<li>Etape 3 : Faire le produit terme à terme des <math>FFT</math> obtenues</li>
<li>Etape 4 : Faire l'<math>IFFT</math> du produit</li>
<li>Etape 5 : Gérer les retenues et écrire le nombre qui en découle</li>
</ul>

Or, parmi toutes ces étapes, certaines sont négligeable comme l'étape 1 et 5.

Pour connaitre la complexité de l'algorithme, additionnons les complexités des étapes restantes :

Une <math>FFT</math> a une complexité de <math>\mathcal{O}(n\times logn)</math> car elle fait <math>n</math> évaluation sur <math> log(n)</math> récursions. Dans le cadre de notre algorithme, nous devons faire la <math>FFT</math> de nos deux facteurs. Soit <math>2\times \mathcal{O}(n\times logn)</math>.

Pour le produit terme à terme, nous faisons naturellement <math>n</math> opérations.

Pour finir, l'<math>IFFT</math> a la même complexité que la <math>FFT</math>. Dans le cadre de notre algorithme nous l'emploierons qu'une seule fois, ce qui fait une complexité de <math>\mathcal{O}(n\times logn)</math>.

Après addition de toutes ces complexités, nous obtenons la complexité réelle de <math>3\mathcal{O}(n\times logn) + \mathcal{O}(n)</math>.

D'après le Master Theorem, nous avons donc <math> f(n) = 3(n\times logn)+n </math>, cherchons <math>f(n)\in\mathcal{O}(g(n))</math> :

Nous pouvons ignorer les expressions linéaires ainsi que les constantes multiplicatrices, nous obtenons donc <math>\mathcal{O}(g(n)) = \mathcal{O}(n \times log n)</math>.

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:30px; text-align:center;">
[[Fichier:FFT_image.webp|500px]]
<div><b>Graphiques des complexités</b></div>
</div>
<div style="max-width:800px;">
<p>Ce graphique ci-contre ne provient pas du fruit de nos recherches personnelles mais illustre bien la comparaison entre la complexité de la FFT et des autres algorithmes.</p>
<p>On remarque que la FFT est très efficace et devance de loin les autres algorithmes en terme de complexité. </p>
<p>C'est l'un des plus performants.</p>
</div>
</div>

= II - Produit de matrices =

== 1.1) naïve ==

La multiplication naïve de matrice requiert d'avoir des tailles de lignes/colonne semblable, ensuite pour chaque membre de la matrice résultat, on doit multiplier les composantes ligne de la première matrice par les composantes colonne de la deuxième et le tout sommé.

On en déduit la formule suivante:
<math>C_{i,j} = \sum_{k=1}^{n} (A_{i,k} \times B_{k,j})</math>

Et visuellement:

[[Fichier:Matricenaive.jpeg]]

On a donc un algorithme d'ordre de complexité <math>\mathcal{O}(g(n))</math>

== 1.2) naïve récursive ==

Dans un premier temps on doit découper nos deux matrices en quatres sous matrices de plus petite taille.
<math>A = \begin{pmatrix} A_{11} & A_{12} \ A_{21} & A_{22} \end{pmatrix}</math>
<math>B = \begin{pmatrix} B_{11} & B_{12} \ B_{21} & B_{22} \end{pmatrix}</math>

Ensuite on vient calculer la matrice résultat.
<math>C_{11} = (A_{11} \times B_{11}) + (A_{12} \times B_{21})</math>
<math>C_{12} = (A_{11} \times B_{12}) + (A_{12} \times B_{22})</math>
<math>C_{21} = (A_{21} \times B_{11}) + (A_{22} \times B_{21})</math>
<math>C_{22} = (A_{21} \times B_{12}) + (A_{22} \times B_{22})</math>

Le côté récursif est utile que pour les matrices de tailles <= 32 (32 valeurs stockées dedans),
si on est au dessus de cette taille alors on divisera à nouveau nos matrices en quatres.
On aura 8 multiplications mais de plus petite taille au final.

== 2) strassen ==

=== A) Fonctionnement ===

Strassen consiste à définir 7 produits intermédiaires qui, par des jeux de sommes et de différences, permettent de reconstruire les quadrants de la matrice résultante. On passe ainsi d'une complexité de O(n^3) à environ O(n^2.81)

=== B) Graphique ===

On voit bien la différence de complexité sur la multiplication de grande matrice entre l'approche naïve et l'approche récursive qui est beaucoup plus rapide.

[[Fichier:Analyse matrices.png]]

= Conclusion =

L'étude de ces algorithmes de multiplication nous a clairement montré l'évolution de la complexité algorithmique permettant de gagner en efficacité lorsque la taille des données augmente.

La multiplication classiqe, en <math>\mathcal{O}(n^2)</math>, résulte d'une approche naïve qui devient rapidement inefficace pour les grands entiers ou les grandes matrices. L'algorithme de Karatsuba nous montre qu'organiser de manière intelligente ses calculs algébrique permet parfois de gagner beaucoup de multiplications, et donc de temps. Nous avons ainsi réussi à passer d'une complexité de <math>\mathcal{O}(n^2)</math> à <math>\mathcal{O}(n^{log_2(3)})</math>, soit environ <math>\mathcal{O}(n^{1/585})</math>.

Des méthodes encore plus avancées comme utilise l'algorithme de Toom-Cook-3 continue dans cette idées de divisions d'entiers en blocs plus petits, tandis que la transformée de Fourier rapide change complètement de point de vue. En effet la FFT n'utilise pas la représentation classique des entiers mais fait appel à une vision polynomiale, ce qui transforme la convolution classique en multiplication terme à terme, ce qui lui permet d'atteindre une complexité de <math>\mathcal{O}(n \times log n)</math>.

Dans le cas des matrices, les mêmes logiques apparaissent comme par exemple avec l'algorithme de Strassen qui se rapproche très fortement de Karatsuba en combinant de manière astucieuse les parties d'entiers qui avaient été précédemment découpée.

On remarque néanmoins que la majorité des algorithmes efficaces s'orientent vers une approche récursive et non itérative. Néanmoins, nous avons pu trouver certaines de ces implémentations (comme par exemple la FFT) en itérative.

Avec ces recherches, nous comprenons que la réorganisations des calculs algébriques peuvent aider à gagner en complexité mais que pour faire de réels progrès, il nous faudra surement changer notre point de vue une nouvelle fois, et aborder le problème sous un angle nouveau comme le font dors et déjà les algorithmes les plus performants.

= Mentions =

Le premier gif est le résultat du travail de 'Walké', licence ci-contre : https://fr.wikipedia.org/wiki/Fichier:Addition.gif

Utilisation du site de production graphique "Desmos" : https://www.desmos.com/calculator?lang=fr

= Sources =

Pour karatsuba :
<ul>
<li> https://www.youtube.com/watch?v=PZ2gdWdKHAA </li>
</ul>

Pour mieux comprendre la FFT, nous avons utilisé plusieurs sources d'informations :
<ul>
<li> https://www.youtube.com/watch?v=h7apO7q16V0&list=WL&index=1&t=886s </li>
<li> https://fr.wikipedia.org/wiki/Interpolation_polynomiale </li>
</ul>

Algorithmes de multiplications d'entiers et de matrices

2026-05-11T21:10:01Z

Mangala : /* A) Fonctionnement */

= Introduction =

Depuis l'apparition des ordinateurs modernes, une quantité faramineuse de calculs a dû être effectuée. Les progressions technologiques nous poussent à envisager la puissance de calcul comme une ressource qu'il faut optimiser dans les moindres détails. C'est ainsi que l'optimisation des algorithmes de calcul est devenue cruciale, surtout lorsqu'il nous faut effectuer des opérations sur de très grands entiers par exemple.

= Objectif =

L'objectif majeur de ce projet est de comprendre de manière plus approfondie ce qu'est la '''complexité algorithmique'''.
Pour atteindre cet objectif, nous implémenterons plusieurs algorithmes de multiplication qui auront pour but de calculer le produit de grands entiers ou de matrices.

= Point important : complexité =

=== Définition ===
La complexité d'un algorithme est la quantité des ressources qu'il utilise en fonction de la taille des entrées qu'on lui demande de traiter. On peut par exemple se concentrer sur le temps qu'un algorithme prend pour renvoyer un résultat ou sur la mémoire dont il a besoin. Dans le cadre de notre projet, nous nous attarderons plus particulièrement sur la quantité de calcul effectuée en fonction de la taille des entrées, ce qui est par ailleurs étroitement liée à la notion de temps. De manière générale, plus un algorithme doit faire de calcul, plus il est lent. (Attention, toutes les opérations arithmétiques de base ne se valent pas)

De manière plus familière, on dira que la complexité d'un algorithme pourrait s'apparenter à son comportement lorsqu'il doit traiter des données plus ou moins grandes.
Chaque algorithme a une complexité, et on l'exprime par une fonction qui adopte un comportement similaire au nombre de calculs nécessaires en fonction de la taille des entrées.

=== Notation ===
La complexité réelle d'un algorithme peut être décrite par une fonction <math> f(n) </math> représentant le nombre d'opérations effectuées en fonction de la taille <math>n</math> des données d'entrée.

Cependant, afin de simplifier l'étude de cette croissance, on utilise généralement une borne asymptotique notée <math>\mathcal{O}(g(n))</math>, où <math>g(n)</math> est une fonction ayant le même ordre de grandeur que <math>f(n)</math> lorsque <math>n</math> devient grand.

On dit alors que :

<math>
f(n)\in\mathcal{O}(g(n))
</math>

si et seulement s'il existe une constante <math>C>0</math> et un entier <math>n_0</math> tels que :

<math>
\forall n\ge n_0,\ f(n)\le Cg(n)
</math>

Cette notation <math>\mathcal{O}(g(n))</math> permettra de comparer beaucoup plus facilement les algorithmes entre eux.

=== Master Theorem ===

Afin de déterminer la complexité de certains algorithmes récursifs, nous utiliserons le "Master Theorem".

Ce théorème permet d'obtenir directement l'ordre de grandeur de nombreuses relations de récurrence apparaissant dans l'analyse d'algorithmes de type « diviser pour régner », comme l'algorithme de Karatsuba ou celui de Strassen.

La démonstration complète de ce théorème dépasse le cadre de notre projet et nécessite des connaissances mathématiques plus avancées. Nous l'utiliserons donc principalement comme un outil nous permettant de déterminer efficacement la complexité asymptotique des algorithmes étudiés.

=== Graphiques ===

Les complexités étant des fonctions, nous pouvons les représenter par un graphique qui affichera le temps d'exécution (ou nombre d'opérations) en fonction de la taille des entrées.

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:30px; text-align:center;">
[[Fichier:complexite.webp|500px]]
<div><b>Graphiques des complexités</b></div>
</div>
<div style="max-width:800px;">
<p>Ce graphique ci-contre compare les complexités en fonction de la taille des d'entrées.</p>
<p>On comprend ainsi que certaines complexités ne sont pas raisonnable dans la cadre de la multiplication de grands entiers.</p>
<p>C'est pourquoi l'étude de ces algorithmes s'avère nécessaire.</p>
</div>
</div>

=== Exemple ===
L'algorithme naïf d'addition que nous avons tous appris à l'école a une complexité de <math>\mathcal{O}(n)</math>.
Soit n la taille des nombres en entrée, l'algorithme doit faire environ n addition pour arriver au résultat demandé.

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Addition.gif|220px]]
<div><b>Addition naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Comme le montre l'exemple ci-contre, 786 et 467 font 3 chiffres de long donc n sera de 3.</p>
<p>Il nous faudra 3 opérations pour additionner ces entiers.</p>
<p>C'est ainsi qu'avec une taille d'entrée n, l'algorithme de l'addition naïve va devoir faire n opérations.</p>
<p>Cet algorithme a donc une complexité <math>f(n) = n</math> qui n'a pas besoin d'être approximée.</p>
<p>Ainsi sa complexité finale sera <math>\mathcal{O}(n)</math>.</p>
</div>
</div>

= Problématique =

Le calcul du produit de deux entiers de manière naïve a une complexité de <math> \mathcal{O}(n^2)</math>, et celui de deux matrices une complexité de <math> \mathcal{O}(n^3)</math>. Afin de mieux comprendre ce qu'est la complexité algorithmique, nous devrons implémenter des algorithmes ayant le même objectif, mais étant plus efficaces. Ces algorithmes s'avèreront plus complexes mais devrait aboutir à un calcul plus rapide du produit demandé.

Nous séparerons notre wiki en deux grandes parties, la première concernera nos recherche sur [[#I - Produit d'entiers|la multiplication d'entiers]], la deuxième sur [[#II - Produit de matrices|la multiplication de matrices]].

= I - Produit d'entiers =

Notre départ commence avec l'algorithme de multiplication d'entier naïf.
En effet il s'agit de l'algorithme de multiplication le plus connu, et nous l'utiliserons comme référence pour le comparer aux futurs algorithmes plus efficaces.
Intéressons nous à sa complexité.

== 1) Nos implémentations des grands entiers ==

Qui dit produit de grands entiers dit implémentation de grands entiers.

Dans le cadre de nos recherches, nous allons devoir implémenter des algorithmes qui vont manipuler des grands entiers.

Nous avons donc choisi de créer deux représentations différentes de ceux-ci (car nous travaillons sur différents langages de programmation), nous permettant à la fois une implémentation simplifié, mais aussi de nous rapprocher d'une implémentation bas niveau.

=== A) En python ===
En python, l'utilisation des "bytes" m'a grandement servi à comprendre comment les entiers étaient manipulés à bas niveau. En effet, un des objectifs secondaires de nos recherches était de manipuler des entiers directement avec leur formes stockées sur l'ordinateur, et non pas avec des int python.
En effet l'utilisation des int python nous aurait permit de passer les étapes de retenues, de signes... D'autant plus que les bytes permettent de stocker un nombre en base 256, ce qui permet de visualiser plus facilement les grands entiers.

La forme finale de la représentation des grands entiers en python sera donc la suivante :

[ signe , bytes , bytes , (...) , bytes ]

Le signe est représenté par un entier, 1 si le nombre est positif, 0 sinon.
Cette configuration rendra plus simple la gestion des signes.

=== B) En C++ ===

En C++, pour avoir une représentation de grand entiers j'ai du définir ma propre structure pour m'affranchir de la limite de taille imposé par les entiers standards: (int32 ou int64). Pour cela, j'ai une structure qui possède l'équivalent d'un array de byte (ce qui nous permet d'être en base 256 au lieu de la base 10 habituelle), et pour traiter le signe j'utilise un booléen, ainsi en mémoire j'ai une structure de n*Octets + 1 octet en taille.

[ bytes , bytes , (...) , bytes ] [ signe ]

Le booléen prend 1 octet de place mais ne touche pas aux octets qui encode le grand entier.
Cette configuration rendra plus simple la gestion des signes dans le cadre des multiplication.

== 2) La multiplication naïve ==

=== A) Fonctionnement ===
Dans le cas de la multiplication d'entiers, nous allons prendre deux nombres qui n'ont pas nécessairement la même longueur. Soit les nombre a et b, de longueur respective <math> n </math> et <math> m </math>.
<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Multiplication.png|220px]]
<div><b>Multiplication naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Prenons deux nombres de longueur 3 et 2, et cherchons combien d'opérations l'algorithme de multiplication naïve va devoir faire pour nous renvoyer leur produit.</p>
<p>Dans un premier temps, on remarque que l'on va devoir multiplier chaque chiffre du nombre du haut par le chiffre des unités du bas, qui est 6. Cela va représenter <math>n</math> opérations. (6x5, 6x1 et 6x4)</p>
<p>Dans un deuxième temps nous constatons que nous allons devoir faire la même chose avec le chiffre des dizaines du nombre du bas. Cela nous ajoute de nouveau <math>n</math> opérations.</p>
<p>On arrive assez facilement à la conclusion que pour faire notre produit, il va nous falloir faire <math>n</math> fois <math>m</math> opérations.</p>
</div>
</div>

Ainsi, la complexité de la multiplication naïve est <math>\mathcal{O}(n^2)</math>.
Il est en de même avec la multiplication naïve récursive.

=== B) Graphique ===
Montrons maintenant sa courbe sur un graphique :

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Multiplicationnaive.png|500px]]
<div><b>Multiplication naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Les points noirs sont des repères pour que les autres courbes aient une forme cohérente.</p>
<p>Ils sont tous sur l'axe des abscisses.</p>
<p>La courbe rouge représente la complexité de la multiplication naïve.</p>
<p>On remarque que la courbe a un visuel très similaire à la fonction <math>f(x) = x^2</math> </p>
</div>
</div>

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Naif_recursif.png|500px]]
<div><b>Multiplication naïve récursive</b></div>
</div>
<div style="max-width:800px;">
<p>La courbe rouge représente la complexité de la multiplication naïve récursive.</p>
<p>Elle sera utilisé pour comparer les complexités entre algorithmes car, comme tous récursifs, elle a été codé avec les mêmes biais d'implémentation qu'eux.</p>
<p>Théoriquement les deux courbes ci-contre ont la même complexité, mais encore une fois, notre implémentation n'est pas parfaitement optimale et donc ne respecte pas de manière minutieuse le Master Theorem.</p>
</div>
</div>

== 3) La multiplication karatsuba ==

=== A) Fonctionnement ===

L'algorithme de karatsuba est un algorithme récursif de type diviser pour régner.

L'idée générale de l'algorithme est de passer de 4 multiplication à 3. En effet ces opérations étant moins couteuses, il est préférable d'en ajouter si cela permet d'enlever des multiplications.

L'algorithme de multiplication naif récursif utilise la segmentation des facteurs en deux de manière successive.

Soit <math>x</math> et <math>y</math> deux facteurs, nous avons les égalités suivantes :

<div style="font-size: 15px;">
<math>x = a \times B^{n/2} + b</math>
<math>y = c \times B^{n/2} + d</math>
</div>

Avec <math>a</math> et <math>c</math> les premières moitiés des facteurs <math>x</math> et <math>y</math>,
et <math> b </math> et <math>d</math> les dernières moitiés de ces facteurs ainsi que <math>B</math> la base d'écriture du nombre (Nous sommes en base 256 avec les bytes).

Cette présentation des deux facteurs de notre multiplication n'est que la résultante d'un découpage.
Le [[#Master Theorem|Master Theorem]] nous montre que :

<div style="font-size: 15px;">
<math>T(n) = 4T(n/2) + O(n)</math>
</div>

Puisque nous avons après découpage 4 entiers de longueur <math>n/2</math>.

Ainsi, ce découpage ne permet pas de gagner du temps d'après le [[#Master Theorem|Master Theorem]].

Cependant, l'algorithme de Karatsuba réutilise ce principe en le modifiant, ce qui nous permet de baisser la complexité globale de la multiplication dans son entièreté.

Avec l'écriture ci-dessus des nombres <math>x</math> et <math>y</math>, on peut facilement en déduire l'égalité suivante :

<div style="font-size: 15px;">
<math>x \times y = (ac) \times B^n + (ad + bc) \times B^{n/2} + bd</math>
</div>

On remarque 4 multiplications longues à faire dans cette expression. Les multiplications dont <math>B</math> est l'un des facteurs sont très rapides puisqu'il s'agit de la base dans laquelle nous travaillons. De cela en résulte un décalage plutôt qu'un vrai calcul à faire.

Karatsuba développe une partie de cette expression pour pouvoir négocier une multiplication au prix d'additions et soustractions.

En effet, nous savons déjà que :

<div style="font-size: 15px;">
<math>(a + b)(c + d) = ac + ad + bc + bd</math>
</div>

En manipulant l'égalité nous obtenons :

<div style="font-size: 15px;">
<math>ad + bc = (a + b)(c + d) - ac - bd</math>
</div>

ac et bd ayant déjà été calculé précédemment, il nous reste uniquement la multiplication <math>(a + b)(c + d)</math>.

Nous venons ainsi de calculer <math>ad + bc</math> en seulement une multiplication. C'est la que repose le gain de temps de la méthode Karatsuba par rapport à la multiplication naïve.

En effet, l'algorithme n'effectuera alors plus que 3 multiplications :
<div style="font-size: 15px;">
<math>ac</math>
<math>bd</math>
<math>(a + b)(c + d)</math>
</div>

La relation de récurrence devient donc :
<div style="font-size: 15px;">
<math>T(n)=3T(n/2)+O(n)</math>
</div>

Et le Master Theorem nous dit que :
<div style="font-size: 15px;">
<math>T(n)\in O(n^{\log_2(3)})</math>
</div>

Or <math>\log_2(3)\approx 1.585</math>, donc la complexité de l'algorithme de Karatsuba est de <math> \mathcal{O}(n^{1.585})</math>. Ce qui est bien plus efficace que la multiplication classique, surtout lorsque les facteurs deviennent très grands.

=== B) Graphique ===
<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Karatsuba.png|500px]]
<div><b>Karatsuba</b></div>
</div>
<div style="max-width:800px;">
<p>Sur le graphique ci-contre nous avons utilisé la courbe de la multiplication naïve récursive (rouge) à titre de comparaison.</p>
<p>On remarque graphiquement que Karatsuba (jaune) prend moins de temps à chaque calcul de produit.</p>
<p>On en déduit donc expérimentalement que Karatsuba à une meilleure complexité que la multiplication naïve.</p>
<p>Ainsi nous vérifions donc ce que le Master Theorem prouve, c'est à dire que la complexité de karatsuba est de <math> \mathcal{O}(n^{1.585})</math> </p>
</div>
</div>

== 4) La multiplication toom-cook-3 ==

=== A) Fonctionnement ===

L'objectif est de diviser les grands entiers X et Y en trois blocs de taille égale k.
On les traite alors comme des polynômes de degré 2:

<math>P(z) = X_2 \cdot z^2 + X_1 \cdot z + X_0</math>
<math>Q(z) = Y_2 \cdot z^2 + Y_1 \cdot z + Y_0</math>

On choisit 5 points distincts pour évaluer nos polynômes.
Ce choix de 5 points est crucial car le produit de deux polynômes de degré 2 est un polynôme de degré 4, qui nécessite 5 points pour être défini.
Les points standards sont :

P(0) = X0
P(1) = X0 + X1 + X2
P(-1) = X0 - X1 + X2
P(2) = X0 + 2*X1 + 4*X2
P(inf) = X2

(On procède de manière similaire pour Q.)

Ensuite nous multiplions récursivement chaque points de P et de Q ensemble.
On effectue ainsi 5 multiplications de nombres plus petits au lieu des 9 multiplications requises par la méthode classique.

Après, nous effectuons une interpolation, cela permet de retrouver les 5 coefficients (w_0, w_1, w_2, w_3, w_4) du polynôme produit R(z) à partir des valeurs évaluées calculées précédemment.
On résout un système d'équations linéaires : <math> R(z) = w_4 z^4 + w_3 z^3 + w_2 z^2 + w_1 z + w_0 </math>
Finalement nous pouvons recomposer notre grand entier en positionnant les coefficients w_i aux bons rangs (en les décalant) et à gérer les retenues lors de l'addition finale:
<math>Résultat = w_4 B^{4k} + w_3 B^{3k} + w_2 B^{2k} + w_1 B^k + w_0</math>

=== B) Graphique ===

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Toomcook.png|500px]]
<div><b>Karatsuba</b></div>
</div>
<div style="max-width:800px;">
<p>on a reprit multi récursive (rouge)</p>
<p>on voit que Toom (vert) en dessous de karatsuba (jaune) en dessous de multi classique (rouge)</p>
<p>meilleur complexité</p>
</div>
</div>

== 5) La transformée de Fourier rapide ==

=== A) Fonctionnement ===

La transformation de Fourier rapide étant plus complexe que les autres algorithmes, nous allons essayer d'expliquer son fonctionnement malgré ne pas avoir réussi à l'implémenter.

Il faut comprendre que cet algorithme va considérer les facteurs comme des polynômes.

D'après le théorème de l'unisolvance, il n'existe qu'un seul polynôme de degré inférieur ou égal à <math> n </math> défini par <math>n + 1</math> points distincts. Cela implique non seulement que nous pouvons représenter chaque entier par un polynôme, mais également que si nous pouvons retrouver <math>n + m + 1</math> points (avec <math>n</math> et <math>m</math> la longueur des facteurs) du polynômes issue du produit entre deux facteurs, nous pourrons le retrouver.

Soit un entier quelconque, de forme :

<math>a_n a_{n-1} (...) a_1 a_0</math>

Avec <math>a_i</math>, un chiffre composant le nombre en base 10, qui vaut en réalité dans le nombre : <math>a_i \times 10^i</math>. On peut ainsi l'écrire sous la forme :

<math> P(x) = a_0 + a_1x + a_2x^2 + \dots + a_{n-1}x^{n-1} + a_nx^n </math>

Avec <math>x = 10</math> car nous sommes en base 10, nous obtenons :

<math>P(10) = a_0 + a_1 \times 10 + \dots + a_{n-1}10^{n-1} + a_n10^n </math>

Nous venons ainsi d'écrire notre nombre sous la forme d'un polynôme unique. Pour nous permettre d'évaluer en un nombre suffisant de points, nous allons devoir ajouter des 0 pour la récursion. Il nous faudra ajouter assez de 0 pour atteindre la prochaine puissance de 2 qui sera supérieure ou égale à <math>2n + 1</math>. L'ajout de 0 ne change pas le nombre car <math>0 \times x^n</math> n'ajoute pas de coefficient.

Cet algorithme est récursif et va segmenter en deux parties nos polynômes à chaque récursion. D'un coté les indice pairs et d'un coté les impaires.

Ainsi prenons les nombres 1234 et 5678, ces nombres sont respectivement représentés par les polynômes <math> P(x) = 4 + 3x + 2x^2 + x^3 </math> et <math> P(x) = 8 + 7x + 6x^2 + 5^3 </math>. Ce sont des polynômes de degré 3, ainsi leur produit donnera lieu à un polynôme de degré 6. Il nous faudra donc au minimum 7 points d'évaluation pour retrouve ce produit. De ce fait, en les représentant de la manière suivante :

<math>[4, 3, 2, 1, 0, 0, 0, 0]</math>
<math>[8, 7, 6, 5, 0, 0, 0, 0]</math>

Nous aurons assez de récursions possible pour les évaluer en un nombre suffisant de points différents car nous auront 3 récursions à faire pour atteindre notre cas de base. A chaque récursion, nous allons diviser nos polynômes en deux parties ce qui nous fait 8 feuilles à la dernière récursion.

En effet à chaque étape de la récursion nous allons séparer nos polynômes en deux tel que :

<math>P(x)=P_{\text{pair}}(x^2) + x \cdot P_{\text{impair}}(x^2)</math>

Durant les récursions, nous segmentons les polynômes mais ne les évaluons pas. C'est à la remonté des récursions que nous allons réellement évaluer nos polynômes. Lorsque l'on atteint notre cas de base, c'est à dire des polynômes de degré 0, nous remarquons qu'ils sont constants, nous n'avons donc pas besoin de les évaluer. En effet, peut importe le point en lequel nous voudrons l'évaluer, le polynôme renverra la constante. Nous la renvoyons donc seule.
Ensuite commence la remontée des récursions. A l'étape 1 de notre remontée nous allons reformer le polynôme précédemment séparé pour obtenir un polynôme de degré 1. Puis, nous évaluons ce polynôme avec les racines seconde de l'unité. Nous faisons à nouveau remonté les évaluations et recombinons à nouveau le polynôme qui sera ainsi de degré 2.
Nous l'évaluons maintenant avec les racines 4eme de l'unité. A chaque évaluation, nous réutilisons les résultats précédents, cela nous est permit par les racines de l'unité qui ont une structure récursive exploitable.

Finalement, nous arrivons à la fin de notre FFT, avec une représentation fréquentielle de la forme :

<math> [P(W_0), P(W_1), (...), P(W_n-1), P(W_n)] </math>

Cette représentation fréquentielle n'est autre que les évaluations du polynôme P aux racines nièmes de l'unité. Nous avons donc maintenant au minimum <math>2n+1</math> évaluations des polynômes facteurs. Il nous faut maintenant trouver les évaluations du produit final, c'est à dire les évaluations concernant le polynôme qui sera issue de la multiplication. On pourra ainsi le retrouver.

Soit <math>C</math> un polynome tel que <math> C = A \times B </math>, alors on a :

<math> C(x) = A(x) \times B(x) </math>

Ainsi on en déduit que <math> C(W_n^k) = A(W_n^k) \times B(W_n^k) </math>

On comprend donc que <math>FFT(C) = FFT(A) \times FFT(B)</math>

Il faut préciser que l'on fait le produit de FFT(A) et FFT(B) terme à terme, soit évaluation par évaluation.

Une fois en possession de <math>FFT(C)</math>, qui n'est autre que l'évaluation de notre polynôme final en un nombre suffisant de points pour le retrouver, nous pouvons faire l'<math>IFFT(FFT(C))</math>, qui va nous permettre de retrouver les coefficients de notre polynôme en faisant l'exacte inverse de la FFT.

Une fois les coefficients retrouvés, il nous suffit de gérer les retenues, et nous retrouvons un entier de la forme : <math>a_0 a_1 (...) a_{n-1} a_n</math>

=== B) Graphique ===

Intéressons nous maintenant à la complexité de l'algorithme utilisant la transformée de Fourier rapide. On sait que l'algorithme passe par 5 étapes importantes :

<ul>
<li>Etape 1 : Ecrire les deux facteurs sous la forme de polynômes</li>
<li>Etape 2 : Effectuer la <math>FFT</math> des deux polynômes</li>
<li>Etape 3 : Faire le produit terme à terme des <math>FFT</math> obtenues</li>
<li>Etape 4 : Faire l'<math>IFFT</math> du produit</li>
<li>Etape 5 : Gérer les retenues et écrire le nombre qui en découle</li>
</ul>

Or, parmi toutes ces étapes, certaines sont négligeable comme l'étape 1 et 5.

Pour connaitre la complexité de l'algorithme, additionnons les complexités des étapes restantes :

Une <math>FFT</math> a une complexité de <math>\mathcal{O}(n\times logn)</math> car elle fait <math>n</math> évaluation sur <math> log(n)</math> récursions. Dans le cadre de notre algorithme, nous devons faire la <math>FFT</math> de nos deux facteurs. Soit <math>2\times \mathcal{O}(n\times logn)</math>.

Pour le produit terme à terme, nous faisons naturellement <math>n</math> opérations.

Pour finir, l'<math>IFFT</math> a la même complexité que la <math>FFT</math>. Dans le cadre de notre algorithme nous l'emploierons qu'une seule fois, ce qui fait une complexité de <math>\mathcal{O}(n\times logn)</math>.

Après addition de toutes ces complexités, nous obtenons la complexité réelle de <math>3\mathcal{O}(n\times logn) + \mathcal{O}(n)</math>.

D'après le Master Theorem, nous avons donc <math> f(n) = 3(n\times logn)+n </math>, cherchons <math>f(n)\in\mathcal{O}(g(n))</math> :

Nous pouvons ignorer les expressions linéaires ainsi que les constantes multiplicatrices, nous obtenons donc <math>\mathcal{O}(g(n)) = \mathcal{O}(n \times log n)</math>.

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:30px; text-align:center;">
[[Fichier:FFT_image.webp|500px]]
<div><b>Graphiques des complexités</b></div>
</div>
<div style="max-width:800px;">
<p>Ce graphique ci-contre ne provient pas du fruit de nos recherches personnelles mais illustre bien la comparaison entre la complexité de la FFT et des autres algorithmes.</p>
<p>On remarque que la FFT est très efficace et devance de loin les autres algorithmes en terme de complexité. </p>
<p>C'est l'un des plus performants.</p>
</div>
</div>

= II - Produit de matrices =

== 1.1) naïve ==

La multiplication naïve de matrice requiert d'avoir des tailles de lignes/colonne semblable, ensuite pour chaque membre de la matrice résultat, on doit multiplier les composantes ligne de la première matrice par les composantes colonne de la deuxième et le tout sommé.

On en déduit la formule suivante:
<math>C_{i,j} = \sum_{k=1}^{n} (A_{i,k} \times B_{k,j})</math>

Et visuellement:

[[Fichier:Matricenaive.jpeg]]

On a donc un algorithme d'ordre de complexité <math>\mathcal{O}(g(n))</math>

== 1.2) naïve récursive ==

Dans un premier temps on doit découper nos deux matrices en quatres sous matrices de plus petite taille.
<math>A = \begin{pmatrix} A_{11} & A_{12} \ A_{21} & A_{22} \end{pmatrix}</math>
<math>B = \begin{pmatrix} B_{11} & B_{12} \ B_{21} & B_{22} \end{pmatrix}</math>

Ensuite on vient calculer la matrice résultat.
<math>C_{11} = (A_{11} \times B_{11}) + (A_{12} \times B_{21})</math>
<math>C_{12} = (A_{11} \times B_{12}) + (A_{12} \times B_{22})</math>
<math>C_{21} = (A_{21} \times B_{11}) + (A_{22} \times B_{21})</math>
<math>C_{22} = (A_{21} \times B_{12}) + (A_{22} \times B_{22})</math>

Le côté récursif est utile que pour les matrices de tailles <= 32 (32 valeurs stockées dedans),
si on est au dessus de cette taille alors on divisera à nouveau nos matrices en quatres.
On aura 8 multiplications mais de plus petite taille au final.

== 2) strassen ==

=== A) Fonctionnement ===

Strassen consiste à définir 7 produits intermédiaires qui, par des jeux de sommes et de différences, permettent de reconstruire les quadrants de la matrice résultante. On passe ainsi d'une complexité de O(n^3) à environ O(n^2.81)

=== B) Graphique ===

On voit bien la différence de complexité sur la multiplication de grande matrice entre l'approche naïve et l'approche récursive qui est beaucoup plus rapide.

[[Fichier:Analyse matrices.png]]

= Conclusion =

L'étude de ces algorithmes de multiplication nous a clairement montré l'évolution de la complexité algorithmique permettant de gagner en efficacité lorsque la taille des données augmente.

La multiplication classiqe, en <math>\mathcal{O}(n^2)</math>, résulte d'une approche naïve qui devient rapidement inefficace pour les grands entiers ou les grandes matrices. L'algorithme de Karatsuba nous montre qu'organiser de manière intelligente ses calculs algébrique permet parfois de gagner beaucoup de multiplications, et donc de temps. Nous avons ainsi réussi à passer d'une complexité de <math>\mathcal{O}(n^2)</math> à <math>\mathcal{O}(n^{log_2(3)})</math>, soit environ <math>\mathcal{O}(n^{1/585})</math>.

Des méthodes encore plus avancées comme utilise l'algorithme de Toom-Cook-3 continue dans cette idées de divisions d'entiers en blocs plus petits, tandis que la transformée de Fourier rapide change complètement de point de vue. En effet la FFT n'utilise pas la représentation classique des entiers mais fait appel à une vision polynomiale, ce qui transforme la convolution classique en multiplication terme à terme, ce qui lui permet d'atteindre une complexité de <math>\mathcal{O}(n \times log n)</math>.

Dans le cas des matrices, les mêmes logiques apparaissent comme par exemple avec l'algorithme de Strassen qui se rapproche très fortement de Karatsuba en combinant de manière astucieuse les parties d'entiers qui avaient été précédemment découpée.

On remarque néanmoins que la majorité des algorithmes efficaces s'orientent vers une approche récursive et non itérative. Néanmoins, nous avons pu trouver certaines de ces implémentations (comme par exemple la FFT) en itérative.

Avec ces recherches, nous comprenons que la réorganisations des calculs algébriques peuvent aider à gagner en complexité mais que pour faire de réels progrès, il nous faudra surement changer notre point de vue une nouvelle fois, et aborder le problème sous un angle nouveau comme le font dors et déjà les algorithmes les plus performants.

= Mentions =

Le premier gif est le résultat du travail de 'Walké', licence ci-contre : https://fr.wikipedia.org/wiki/Fichier:Addition.gif

Utilisation du site de production graphique "Desmos" : https://www.desmos.com/calculator?lang=fr

= Sources =

Pour karatsuba :
<ul>
<li> https://www.youtube.com/watch?v=PZ2gdWdKHAA </li>
</ul>

Pour mieux comprendre la FFT, nous avons utilisé plusieurs sources d'informations :
<ul>
<li> https://www.youtube.com/watch?v=h7apO7q16V0&list=WL&index=1&t=886s </li>
<li> https://fr.wikipedia.org/wiki/Interpolation_polynomiale </li>
</ul>

Algorithmes de multiplications d'entiers et de matrices

2026-05-11T21:07:01Z

Mangala : /* B) Graphique */

= Introduction =

Depuis l'apparition des ordinateurs modernes, une quantité faramineuse de calculs a dû être effectuée. Les progressions technologiques nous poussent à envisager la puissance de calcul comme une ressource qu'il faut optimiser dans les moindres détails. C'est ainsi que l'optimisation des algorithmes de calcul est devenue cruciale, surtout lorsqu'il nous faut effectuer des opérations sur de très grands entiers par exemple.

= Objectif =

L'objectif majeur de ce projet est de comprendre de manière plus approfondie ce qu'est la '''complexité algorithmique'''.
Pour atteindre cet objectif, nous implémenterons plusieurs algorithmes de multiplication qui auront pour but de calculer le produit de grands entiers ou de matrices.

= Point important : complexité =

=== Définition ===
La complexité d'un algorithme est la quantité des ressources qu'il utilise en fonction de la taille des entrées qu'on lui demande de traiter. On peut par exemple se concentrer sur le temps qu'un algorithme prend pour renvoyer un résultat ou sur la mémoire dont il a besoin. Dans le cadre de notre projet, nous nous attarderons plus particulièrement sur la quantité de calcul effectuée en fonction de la taille des entrées, ce qui est par ailleurs étroitement liée à la notion de temps. De manière générale, plus un algorithme doit faire de calcul, plus il est lent. (Attention, toutes les opérations arithmétiques de base ne se valent pas)

De manière plus familière, on dira que la complexité d'un algorithme pourrait s'apparenter à son comportement lorsqu'il doit traiter des données plus ou moins grandes.
Chaque algorithme a une complexité, et on l'exprime par une fonction qui adopte un comportement similaire au nombre de calculs nécessaires en fonction de la taille des entrées.

=== Notation ===
La complexité réelle d'un algorithme peut être décrite par une fonction <math> f(n) </math> représentant le nombre d'opérations effectuées en fonction de la taille <math>n</math> des données d'entrée.

Cependant, afin de simplifier l'étude de cette croissance, on utilise généralement une borne asymptotique notée <math>\mathcal{O}(g(n))</math>, où <math>g(n)</math> est une fonction ayant le même ordre de grandeur que <math>f(n)</math> lorsque <math>n</math> devient grand.

On dit alors que :

<math>
f(n)\in\mathcal{O}(g(n))
</math>

si et seulement s'il existe une constante <math>C>0</math> et un entier <math>n_0</math> tels que :

<math>
\forall n\ge n_0,\ f(n)\le Cg(n)
</math>

Cette notation <math>\mathcal{O}(g(n))</math> permettra de comparer beaucoup plus facilement les algorithmes entre eux.

=== Master Theorem ===

Afin de déterminer la complexité de certains algorithmes récursifs, nous utiliserons le "Master Theorem".

Ce théorème permet d'obtenir directement l'ordre de grandeur de nombreuses relations de récurrence apparaissant dans l'analyse d'algorithmes de type « diviser pour régner », comme l'algorithme de Karatsuba ou celui de Strassen.

La démonstration complète de ce théorème dépasse le cadre de notre projet et nécessite des connaissances mathématiques plus avancées. Nous l'utiliserons donc principalement comme un outil nous permettant de déterminer efficacement la complexité asymptotique des algorithmes étudiés.

=== Graphiques ===

Les complexités étant des fonctions, nous pouvons les représenter par un graphique qui affichera le temps d'exécution (ou nombre d'opérations) en fonction de la taille des entrées.

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:30px; text-align:center;">
[[Fichier:complexite.webp|500px]]
<div><b>Graphiques des complexités</b></div>
</div>
<div style="max-width:800px;">
<p>Ce graphique ci-contre compare les complexités en fonction de la taille des d'entrées.</p>
<p>On comprend ainsi que certaines complexités ne sont pas raisonnable dans la cadre de la multiplication de grands entiers.</p>
<p>C'est pourquoi l'étude de ces algorithmes s'avère nécessaire.</p>
</div>
</div>

=== Exemple ===
L'algorithme naïf d'addition que nous avons tous appris à l'école a une complexité de <math>\mathcal{O}(n)</math>.
Soit n la taille des nombres en entrée, l'algorithme doit faire environ n addition pour arriver au résultat demandé.

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Addition.gif|220px]]
<div><b>Addition naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Comme le montre l'exemple ci-contre, 786 et 467 font 3 chiffres de long donc n sera de 3.</p>
<p>Il nous faudra 3 opérations pour additionner ces entiers.</p>
<p>C'est ainsi qu'avec une taille d'entrée n, l'algorithme de l'addition naïve va devoir faire n opérations.</p>
<p>Cet algorithme a donc une complexité <math>f(n) = n</math> qui n'a pas besoin d'être approximée.</p>
<p>Ainsi sa complexité finale sera <math>\mathcal{O}(n)</math>.</p>
</div>
</div>

= Problématique =

Le calcul du produit de deux entiers de manière naïve a une complexité de <math> \mathcal{O}(n^2)</math>, et celui de deux matrices une complexité de <math> \mathcal{O}(n^3)</math>. Afin de mieux comprendre ce qu'est la complexité algorithmique, nous devrons implémenter des algorithmes ayant le même objectif, mais étant plus efficaces. Ces algorithmes s'avèreront plus complexes mais devrait aboutir à un calcul plus rapide du produit demandé.

Nous séparerons notre wiki en deux grandes parties, la première concernera nos recherche sur [[#I - Produit d'entiers|la multiplication d'entiers]], la deuxième sur [[#II - Produit de matrices|la multiplication de matrices]].

= I - Produit d'entiers =

Notre départ commence avec l'algorithme de multiplication d'entier naïf.
En effet il s'agit de l'algorithme de multiplication le plus connu, et nous l'utiliserons comme référence pour le comparer aux futurs algorithmes plus efficaces.
Intéressons nous à sa complexité.

== 1) Nos implémentations des grands entiers ==

Qui dit produit de grands entiers dit implémentation de grands entiers.

Dans le cadre de nos recherches, nous allons devoir implémenter des algorithmes qui vont manipuler des grands entiers.

Nous avons donc choisi de créer deux représentations différentes de ceux-ci (car nous travaillons sur différents langages de programmation), nous permettant à la fois une implémentation simplifié, mais aussi de nous rapprocher d'une implémentation bas niveau.

=== A) En python ===
En python, l'utilisation des "bytes" m'a grandement servi à comprendre comment les entiers étaient manipulés à bas niveau. En effet, un des objectifs secondaires de nos recherches était de manipuler des entiers directement avec leur formes stockées sur l'ordinateur, et non pas avec des int python.
En effet l'utilisation des int python nous aurait permit de passer les étapes de retenues, de signes... D'autant plus que les bytes permettent de stocker un nombre en base 256, ce qui permet de visualiser plus facilement les grands entiers.

La forme finale de la représentation des grands entiers en python sera donc la suivante :

[ signe , bytes , bytes , (...) , bytes ]

Le signe est représenté par un entier, 1 si le nombre est positif, 0 sinon.
Cette configuration rendra plus simple la gestion des signes.

=== B) En C++ ===

En C++, pour avoir une représentation de grand entiers j'ai du définir ma propre structure pour m'affranchir de la limite de taille imposé par les entiers standards: (int32 ou int64). Pour cela, j'ai une structure qui possède l'équivalent d'un array de byte (ce qui nous permet d'être en base 256 au lieu de la base 10 habituelle), et pour traiter le signe j'utilise un booléen, ainsi en mémoire j'ai une structure de n*Octets + 1 octet en taille.

[ bytes , bytes , (...) , bytes ] [ signe ]

Le booléen prend 1 octet de place mais ne touche pas aux octets qui encode le grand entier.
Cette configuration rendra plus simple la gestion des signes dans le cadre des multiplication.

== 2) La multiplication naïve ==

=== A) Fonctionnement ===
Dans le cas de la multiplication d'entiers, nous allons prendre deux nombres qui n'ont pas nécessairement la même longueur. Soit les nombre a et b, de longueur respective <math> n </math> et <math> m </math>.
<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Multiplication.png|220px]]
<div><b>Multiplication naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Prenons deux nombres de longueur 3 et 2, et cherchons combien d'opérations l'algorithme de multiplication naïve va devoir faire pour nous renvoyer leur produit.</p>
<p>Dans un premier temps, on remarque que l'on va devoir multiplier chaque chiffre du nombre du haut par le chiffre des unités du bas, qui est 6. Cela va représenter <math>n</math> opérations. (6x5, 6x1 et 6x4)</p>
<p>Dans un deuxième temps nous constatons que nous allons devoir faire la même chose avec le chiffre des dizaines du nombre du bas. Cela nous ajoute de nouveau <math>n</math> opérations.</p>
<p>On arrive assez facilement à la conclusion que pour faire notre produit, il va nous falloir faire <math>n</math> fois <math>m</math> opérations.</p>
</div>
</div>

Ainsi, la complexité de la multiplication naïve est <math>\mathcal{O}(n^2)</math>.
Il est en de même avec la multiplication naïve récursive.

=== B) Graphique ===
Montrons maintenant sa courbe sur un graphique :

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Multiplicationnaive.png|500px]]
<div><b>Multiplication naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Les points noirs sont des repères pour que les autres courbes aient une forme cohérente.</p>
<p>Ils sont tous sur l'axe des abscisses.</p>
<p>La courbe rouge représente la complexité de la multiplication naïve.</p>
<p>On remarque que la courbe a un visuel très similaire à la fonction <math>f(x) = x^2</math> </p>
</div>
</div>

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Naif_recursif.png|500px]]
<div><b>Multiplication naïve récursive</b></div>
</div>
<div style="max-width:800px;">
<p>La courbe rouge représente la complexité de la multiplication naïve récursive.</p>
<p>Elle sera utilisé pour comparer les complexités entre algorithmes car, comme tous récursifs, elle a été codé avec les mêmes biais d'implémentation qu'eux.</p>
<p>Théoriquement les deux courbes ci-contre ont la même complexité, mais encore une fois, notre implémentation n'est pas parfaitement optimale et donc ne respecte pas de manière minutieuse le Master Theorem.</p>
</div>
</div>

== 3) La multiplication karatsuba ==

=== A) Fonctionnement ===

L'algorithme de karatsuba est un algorithme récursif de type diviser pour régner.

L'idée générale de l'algorithme est de passer de 4 multiplication à 3. En effet ces opérations étant moins couteuses, il est préférable d'en ajouter si cela permet d'enlever des multiplications.

L'algorithme de multiplication naif récursif utilise la segmentation des facteurs en deux de manière successive.

Soit <math>x</math> et <math>y</math> deux facteurs, nous avons les égalités suivantes :

<div style="font-size: 20px;">
<math>x = a \times B^{n/2} + b</math>
<math>y = c \times B^{n/2} + d</math>
</div>

Avec <math>a</math> et <math>c</math> les premières moitiés des facteurs <math>x</math> et <math>y</math>,
et <math> b </math> et <math>d</math> les dernières moitiés de ces facteurs ainsi que <math>B</math> la base d'écriture du nombre (Nous sommes en base 256 avec les bytes).

Cette présentation des deux facteurs de notre multiplication n'est que la résultante d'un découpage.
Le [[#Master Theorem|Master Theorem]] nous montre que :

<div style="font-size: 20px;">
<math>T(n) = 4T(n/2) + O(n)</math>
</div>

Puisque nous avons après découpage 4 entiers de longueur <math>n/2</math>.

Ainsi, ce découpage ne permet pas de gagner du temps d'après le [[#Master Theorem|Master Theorem]].

Cependant, l'algorithme de Karatsuba réutilise ce principe en le modifiant, ce qui nous permet de baisser la complexité globale de la multiplication dans son entièreté.

Avec l'écriture ci-dessus des nombres <math>x</math> et <math>y</math>, on peut facilement en déduire l'égalité suivante :

<div style="font-size: 20px;">
<math>x \times y = (ac) \times B^n + (ad + bc) \times B^{n/2} + bd</math>
</div>

On remarque 4 multiplications longues à faire dans cette expression. Les multiplications dont <math>B</math> est l'un des facteurs sont très rapides puisqu'il s'agit de la base dans laquelle nous travaillons. De cela en résulte un décalage plutôt qu'un vrai calcul à faire.

Karatsuba développe une partie de cette expression pour pouvoir négocier une multiplication au prix d'additions et soustractions.

En effet, nous savons déjà que :

<div style="font-size: 20px;">
<math>(a + b)(c + d) = ac + ad + bc + bd</math>
</div>

En manipulant l'égalité nous obtenons :

<div style="font-size: 20px;">
<math>ad + bc = (a + b)(c + d) - ac - bd</math>
</div>

ac et bd ayant déjà été calculé précédemment, il nous reste uniquement la multiplication <math>(a + b)(c + d)</math>.

Nous venons ainsi de calculer <math>ad + bc</math> en seulement une multiplication. C'est la que repose le gain de temps de la méthode Karatsuba par rapport à la multiplication naïve.

En effet, l'algorithme n'effectuera alors plus que 3 multiplications :
<div style="font-size: 20px;">
<math>ac</math>
<math>bd</math>
<math>(a + b)(c + d)</math>
</div>

La relation de récurrence devient donc :
<div style="font-size: 20px;">
<math>T(n)=3T(n/2)+O(n)</math>
</div>

Et le Master Theorem nous dit que :
<div style="font-size: 20px;">
<math>T(n)\in O(n^{\log_2(3)})</math>
</div>

Or <math>\log_2(3)\approx 1.585</math>, donc la complexité de l'algorithme de Karatsuba est de <math> \mathcal{O}(n^{1.585})</math>. Ce qui est bien plus efficace que la multiplication classique, surtout lorsque les facteurs deviennent très grands.

=== B) Graphique ===
<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Karatsuba.png|500px]]
<div><b>Karatsuba</b></div>
</div>
<div style="max-width:800px;">
<p>Sur le graphique ci-contre nous avons utilisé la courbe de la multiplication naïve récursive (rouge) à titre de comparaison.</p>
<p>On remarque graphiquement que Karatsuba (jaune) prend moins de temps à chaque calcul de produit.</p>
<p>On en déduit donc expérimentalement que Karatsuba à une meilleure complexité que la multiplication naïve.</p>
<p>Ainsi nous vérifions donc ce que le Master Theorem prouve, c'est à dire que la complexité de karatsuba est de <math> \mathcal{O}(n^{1.585})</math> </p>
</div>
</div>

== 4) La multiplication toom-cook-3 ==

=== A) Fonctionnement ===

L'objectif est de diviser les grands entiers X et Y en trois blocs de taille égale k.
On les traite alors comme des polynômes de degré 2:

<math>P(z) = X_2 \cdot z^2 + X_1 \cdot z + X_0</math>
<math>Q(z) = Y_2 \cdot z^2 + Y_1 \cdot z + Y_0</math>

On choisit 5 points distincts pour évaluer nos polynômes.
Ce choix de 5 points est crucial car le produit de deux polynômes de degré 2 est un polynôme de degré 4, qui nécessite 5 points pour être défini.
Les points standards sont :

P(0) = X0
P(1) = X0 + X1 + X2
P(-1) = X0 - X1 + X2
P(2) = X0 + 2*X1 + 4*X2
P(inf) = X2

(On procède de manière similaire pour Q.)

Ensuite nous multiplions récursivement chaque points de P et de Q ensemble.
On effectue ainsi 5 multiplications de nombres plus petits au lieu des 9 multiplications requises par la méthode classique.

Après, nous effectuons une interpolation, cela permet de retrouver les 5 coefficients (w_0, w_1, w_2, w_3, w_4) du polynôme produit R(z) à partir des valeurs évaluées calculées précédemment.
On résout un système d'équations linéaires : <math> R(z) = w_4 z^4 + w_3 z^3 + w_2 z^2 + w_1 z + w_0 </math>
Finalement nous pouvons recomposer notre grand entier en positionnant les coefficients w_i aux bons rangs (en les décalant) et à gérer les retenues lors de l'addition finale:
<math>Résultat = w_4 B^{4k} + w_3 B^{3k} + w_2 B^{2k} + w_1 B^k + w_0</math>

=== B) Graphique ===

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Toomcook.png|500px]]
<div><b>Karatsuba</b></div>
</div>
<div style="max-width:800px;">
<p>on a reprit multi récursive (rouge)</p>
<p>on voit que Toom (vert) en dessous de karatsuba (jaune) en dessous de multi classique (rouge)</p>
<p>meilleur complexité</p>
</div>
</div>

== 5) La transformée de Fourier rapide ==

=== A) Fonctionnement ===

La transformation de Fourier rapide étant plus complexe que les autres algorithmes, nous allons essayer d'expliquer son fonctionnement malgré ne pas avoir réussi à l'implémenter.

Il faut comprendre que cet algorithme va considérer les facteurs comme des polynômes.

D'après le théorème de l'unisolvance, il n'existe qu'un seul polynôme de degré inférieur ou égal à <math> n </math> défini par <math>n + 1</math> points distincts. Cela implique non seulement que nous pouvons représenter chaque entier par un polynôme, mais également que si nous pouvons retrouver <math>n + m + 1</math> points (avec <math>n</math> et <math>m</math> la longueur des facteurs) du polynômes issue du produit entre deux facteurs, nous pourrons le retrouver.

Soit un entier quelconque, de forme :

<math>a_n a_{n-1} (...) a_1 a_0</math>

Avec <math>a_i</math>, un chiffre composant le nombre en base 10, qui vaut en réalité dans le nombre : <math>a_i \times 10^i</math>. On peut ainsi l'écrire sous la forme :

<math> P(x) = a_0 + a_1x + a_2x^2 + \dots + a_{n-1}x^{n-1} + a_nx^n </math>

Avec <math>x = 10</math> car nous sommes en base 10, nous obtenons :

<math>P(10) = a_0 + a_1 \times 10 + \dots + a_{n-1}10^{n-1} + a_n10^n </math>

Nous venons ainsi d'écrire notre nombre sous la forme d'un polynôme unique. Pour nous permettre d'évaluer en un nombre suffisant de points, nous allons devoir ajouter des 0 pour la récursion. Il nous faudra ajouter assez de 0 pour atteindre la prochaine puissance de 2 qui sera supérieure ou égale à <math>2n + 1</math>. L'ajout de 0 ne change pas le nombre car <math>0 \times x^n</math> n'ajoute pas de coefficient.

Cet algorithme est récursif et va segmenter en deux parties nos polynômes à chaque récursion. D'un coté les indice pairs et d'un coté les impaires.

Ainsi prenons les nombres 1234 et 5678, ces nombres sont respectivement représentés par les polynômes <math> P(x) = 4 + 3x + 2x^2 + x^3 </math> et <math> P(x) = 8 + 7x + 6x^2 + 5^3 </math>. Ce sont des polynômes de degré 3, ainsi leur produit donnera lieu à un polynôme de degré 6. Il nous faudra donc au minimum 7 points d'évaluation pour retrouve ce produit. De ce fait, en les représentant de la manière suivante :

<math>[4, 3, 2, 1, 0, 0, 0, 0]</math>
<math>[8, 7, 6, 5, 0, 0, 0, 0]</math>

Nous aurons assez de récursions possible pour les évaluer en un nombre suffisant de points différents car nous auront 3 récursions à faire pour atteindre notre cas de base. A chaque récursion, nous allons diviser nos polynômes en deux parties ce qui nous fait 8 feuilles à la dernière récursion.

En effet à chaque étape de la récursion nous allons séparer nos polynômes en deux tel que :

<math>P(x)=P_{\text{pair}}(x^2) + x \cdot P_{\text{impair}}(x^2)</math>

Durant les récursions, nous segmentons les polynômes mais ne les évaluons pas. C'est à la remonté des récursions que nous allons réellement évaluer nos polynômes. Lorsque l'on atteint notre cas de base, c'est à dire des polynômes de degré 0, nous remarquons qu'ils sont constants, nous n'avons donc pas besoin de les évaluer. En effet, peut importe le point en lequel nous voudrons l'évaluer, le polynôme renverra la constante. Nous la renvoyons donc seule.
Ensuite commence la remontée des récursions. A l'étape 1 de notre remontée nous allons reformer le polynôme précédemment séparé pour obtenir un polynôme de degré 1. Puis, nous évaluons ce polynôme avec les racines seconde de l'unité. Nous faisons à nouveau remonté les évaluations et recombinons à nouveau le polynôme qui sera ainsi de degré 2.
Nous l'évaluons maintenant avec les racines 4eme de l'unité. A chaque évaluation, nous réutilisons les résultats précédents, cela nous est permit par les racines de l'unité qui ont une structure récursive exploitable.

Finalement, nous arrivons à la fin de notre FFT, avec une représentation fréquentielle de la forme :

<math> [P(W_0), P(W_1), (...), P(W_n-1), P(W_n)] </math>

Cette représentation fréquentielle n'est autre que les évaluations du polynôme P aux racines nièmes de l'unité. Nous avons donc maintenant au minimum <math>2n+1</math> évaluations des polynômes facteurs. Il nous faut maintenant trouver les évaluations du produit final, c'est à dire les évaluations concernant le polynôme qui sera issue de la multiplication. On pourra ainsi le retrouver.

Soit <math>C</math> un polynome tel que <math> C = A \times B </math>, alors on a :

<math> C(x) = A(x) \times B(x) </math>

Ainsi on en déduit que <math> C(W_n^k) = A(W_n^k) \times B(W_n^k) </math>

On comprend donc que <math>FFT(C) = FFT(A) \times FFT(B)</math>

Il faut préciser que l'on fait le produit de FFT(A) et FFT(B) terme à terme, soit évaluation par évaluation.

Une fois en possession de <math>FFT(C)</math>, qui n'est autre que l'évaluation de notre polynôme final en un nombre suffisant de points pour le retrouver, nous pouvons faire l'<math>IFFT(FFT(C))</math>, qui va nous permettre de retrouver les coefficients de notre polynôme en faisant l'exacte inverse de la FFT.

Une fois les coefficients retrouvés, il nous suffit de gérer les retenues, et nous retrouvons un entier de la forme : <math>a_0 a_1 (...) a_{n-1} a_n</math>

=== B) Graphique ===

Intéressons nous maintenant à la complexité de l'algorithme utilisant la transformée de Fourier rapide. On sait que l'algorithme passe par 5 étapes importantes :

<ul>
<li>Etape 1 : Ecrire les deux facteurs sous la forme de polynômes</li>
<li>Etape 2 : Effectuer la <math>FFT</math> des deux polynômes</li>
<li>Etape 3 : Faire le produit terme à terme des <math>FFT</math> obtenues</li>
<li>Etape 4 : Faire l'<math>IFFT</math> du produit</li>
<li>Etape 5 : Gérer les retenues et écrire le nombre qui en découle</li>
</ul>

Or, parmi toutes ces étapes, certaines sont négligeable comme l'étape 1 et 5.

Pour connaitre la complexité de l'algorithme, additionnons les complexités des étapes restantes :

Une <math>FFT</math> a une complexité de <math>\mathcal{O}(n\times logn)</math> car elle fait <math>n</math> évaluation sur <math> log(n)</math> récursions. Dans le cadre de notre algorithme, nous devons faire la <math>FFT</math> de nos deux facteurs. Soit <math>2\times \mathcal{O}(n\times logn)</math>.

Pour le produit terme à terme, nous faisons naturellement <math>n</math> opérations.

Pour finir, l'<math>IFFT</math> a la même complexité que la <math>FFT</math>. Dans le cadre de notre algorithme nous l'emploierons qu'une seule fois, ce qui fait une complexité de <math>\mathcal{O}(n\times logn)</math>.

Après addition de toutes ces complexités, nous obtenons la complexité réelle de <math>3\mathcal{O}(n\times logn) + \mathcal{O}(n)</math>.

D'après le Master Theorem, nous avons donc <math> f(n) = 3(n\times logn)+n </math>, cherchons <math>f(n)\in\mathcal{O}(g(n))</math> :

Nous pouvons ignorer les expressions linéaires ainsi que les constantes multiplicatrices, nous obtenons donc <math>\mathcal{O}(g(n)) = \mathcal{O}(n \times log n)</math>.

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:30px; text-align:center;">
[[Fichier:FFT_image.webp|500px]]
<div><b>Graphiques des complexités</b></div>
</div>
<div style="max-width:800px;">
<p>Ce graphique ci-contre ne provient pas du fruit de nos recherches personnelles mais illustre bien la comparaison entre la complexité de la FFT et des autres algorithmes.</p>
<p>On remarque que la FFT est très efficace et devance de loin les autres algorithmes en terme de complexité. </p>
<p>C'est l'un des plus performants.</p>
</div>
</div>

= II - Produit de matrices =

== 1.1) naïve ==

La multiplication naïve de matrice requiert d'avoir des tailles de lignes/colonne semblable, ensuite pour chaque membre de la matrice résultat, on doit multiplier les composantes ligne de la première matrice par les composantes colonne de la deuxième et le tout sommé.

On en déduit la formule suivante:
<math>C_{i,j} = \sum_{k=1}^{n} (A_{i,k} \times B_{k,j})</math>

Et visuellement:

[[Fichier:Matricenaive.jpeg]]

On a donc un algorithme d'ordre de complexité <math>\mathcal{O}(g(n))</math>

== 1.2) naïve récursive ==

Dans un premier temps on doit découper nos deux matrices en quatres sous matrices de plus petite taille.
<math>A = \begin{pmatrix} A_{11} & A_{12} \ A_{21} & A_{22} \end{pmatrix}</math>
<math>B = \begin{pmatrix} B_{11} & B_{12} \ B_{21} & B_{22} \end{pmatrix}</math>

Ensuite on vient calculer la matrice résultat.
<math>C_{11} = (A_{11} \times B_{11}) + (A_{12} \times B_{21})</math>
<math>C_{12} = (A_{11} \times B_{12}) + (A_{12} \times B_{22})</math>
<math>C_{21} = (A_{21} \times B_{11}) + (A_{22} \times B_{21})</math>
<math>C_{22} = (A_{21} \times B_{12}) + (A_{22} \times B_{22})</math>

Le côté récursif est utile que pour les matrices de tailles <= 32 (32 valeurs stockées dedans),
si on est au dessus de cette taille alors on divisera à nouveau nos matrices en quatres.
On aura 8 multiplications mais de plus petite taille au final.

== 2) strassen ==

=== A) Fonctionnement ===

Strassen consiste à définir 7 produits intermédiaires qui, par des jeux de sommes et de différences, permettent de reconstruire les quadrants de la matrice résultante. On passe ainsi d'une complexité de O(n^3) à environ O(n^2.81)

=== B) Graphique ===

On voit bien la différence de complexité sur la multiplication de grande matrice entre l'approche naïve et l'approche récursive qui est beaucoup plus rapide.

[[Fichier:Analyse matrices.png]]

= Conclusion =

L'étude de ces algorithmes de multiplication nous a clairement montré l'évolution de la complexité algorithmique permettant de gagner en efficacité lorsque la taille des données augmente.

La multiplication classiqe, en <math>\mathcal{O}(n^2)</math>, résulte d'une approche naïve qui devient rapidement inefficace pour les grands entiers ou les grandes matrices. L'algorithme de Karatsuba nous montre qu'organiser de manière intelligente ses calculs algébrique permet parfois de gagner beaucoup de multiplications, et donc de temps. Nous avons ainsi réussi à passer d'une complexité de <math>\mathcal{O}(n^2)</math> à <math>\mathcal{O}(n^{log_2(3)})</math>, soit environ <math>\mathcal{O}(n^{1/585})</math>.

Des méthodes encore plus avancées comme utilise l'algorithme de Toom-Cook-3 continue dans cette idées de divisions d'entiers en blocs plus petits, tandis que la transformée de Fourier rapide change complètement de point de vue. En effet la FFT n'utilise pas la représentation classique des entiers mais fait appel à une vision polynomiale, ce qui transforme la convolution classique en multiplication terme à terme, ce qui lui permet d'atteindre une complexité de <math>\mathcal{O}(n \times log n)</math>.

Dans le cas des matrices, les mêmes logiques apparaissent comme par exemple avec l'algorithme de Strassen qui se rapproche très fortement de Karatsuba en combinant de manière astucieuse les parties d'entiers qui avaient été précédemment découpée.

On remarque néanmoins que la majorité des algorithmes efficaces s'orientent vers une approche récursive et non itérative. Néanmoins, nous avons pu trouver certaines de ces implémentations (comme par exemple la FFT) en itérative.

Avec ces recherches, nous comprenons que la réorganisations des calculs algébriques peuvent aider à gagner en complexité mais que pour faire de réels progrès, il nous faudra surement changer notre point de vue une nouvelle fois, et aborder le problème sous un angle nouveau comme le font dors et déjà les algorithmes les plus performants.

= Mentions =

Le premier gif est le résultat du travail de 'Walké', licence ci-contre : https://fr.wikipedia.org/wiki/Fichier:Addition.gif

Utilisation du site de production graphique "Desmos" : https://www.desmos.com/calculator?lang=fr

= Sources =

Pour karatsuba :
<ul>
<li> https://www.youtube.com/watch?v=PZ2gdWdKHAA </li>
</ul>

Pour mieux comprendre la FFT, nous avons utilisé plusieurs sources d'informations :
<ul>
<li> https://www.youtube.com/watch?v=h7apO7q16V0&list=WL&index=1&t=886s </li>
<li> https://fr.wikipedia.org/wiki/Interpolation_polynomiale </li>
</ul>

Algorithmes de multiplications d'entiers et de matrices

2026-05-11T21:04:12Z

Mangala : /* 3) La multiplication karatsuba */

= Introduction =

Depuis l'apparition des ordinateurs modernes, une quantité faramineuse de calculs a dû être effectuée. Les progressions technologiques nous poussent à envisager la puissance de calcul comme une ressource qu'il faut optimiser dans les moindres détails. C'est ainsi que l'optimisation des algorithmes de calcul est devenue cruciale, surtout lorsqu'il nous faut effectuer des opérations sur de très grands entiers par exemple.

= Objectif =

L'objectif majeur de ce projet est de comprendre de manière plus approfondie ce qu'est la '''complexité algorithmique'''.
Pour atteindre cet objectif, nous implémenterons plusieurs algorithmes de multiplication qui auront pour but de calculer le produit de grands entiers ou de matrices.

= Point important : complexité =

=== Définition ===
La complexité d'un algorithme est la quantité des ressources qu'il utilise en fonction de la taille des entrées qu'on lui demande de traiter. On peut par exemple se concentrer sur le temps qu'un algorithme prend pour renvoyer un résultat ou sur la mémoire dont il a besoin. Dans le cadre de notre projet, nous nous attarderons plus particulièrement sur la quantité de calcul effectuée en fonction de la taille des entrées, ce qui est par ailleurs étroitement liée à la notion de temps. De manière générale, plus un algorithme doit faire de calcul, plus il est lent. (Attention, toutes les opérations arithmétiques de base ne se valent pas)

De manière plus familière, on dira que la complexité d'un algorithme pourrait s'apparenter à son comportement lorsqu'il doit traiter des données plus ou moins grandes.
Chaque algorithme a une complexité, et on l'exprime par une fonction qui adopte un comportement similaire au nombre de calculs nécessaires en fonction de la taille des entrées.

=== Notation ===
La complexité réelle d'un algorithme peut être décrite par une fonction <math> f(n) </math> représentant le nombre d'opérations effectuées en fonction de la taille <math>n</math> des données d'entrée.

Cependant, afin de simplifier l'étude de cette croissance, on utilise généralement une borne asymptotique notée <math>\mathcal{O}(g(n))</math>, où <math>g(n)</math> est une fonction ayant le même ordre de grandeur que <math>f(n)</math> lorsque <math>n</math> devient grand.

On dit alors que :

<math>
f(n)\in\mathcal{O}(g(n))
</math>

si et seulement s'il existe une constante <math>C>0</math> et un entier <math>n_0</math> tels que :

<math>
\forall n\ge n_0,\ f(n)\le Cg(n)
</math>

Cette notation <math>\mathcal{O}(g(n))</math> permettra de comparer beaucoup plus facilement les algorithmes entre eux.

=== Master Theorem ===

Afin de déterminer la complexité de certains algorithmes récursifs, nous utiliserons le "Master Theorem".

Ce théorème permet d'obtenir directement l'ordre de grandeur de nombreuses relations de récurrence apparaissant dans l'analyse d'algorithmes de type « diviser pour régner », comme l'algorithme de Karatsuba ou celui de Strassen.

La démonstration complète de ce théorème dépasse le cadre de notre projet et nécessite des connaissances mathématiques plus avancées. Nous l'utiliserons donc principalement comme un outil nous permettant de déterminer efficacement la complexité asymptotique des algorithmes étudiés.

=== Graphiques ===

Les complexités étant des fonctions, nous pouvons les représenter par un graphique qui affichera le temps d'exécution (ou nombre d'opérations) en fonction de la taille des entrées.

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:30px; text-align:center;">
[[Fichier:complexite.webp|500px]]
<div><b>Graphiques des complexités</b></div>
</div>
<div style="max-width:800px;">
<p>Ce graphique ci-contre compare les complexités en fonction de la taille des d'entrées.</p>
<p>On comprend ainsi que certaines complexités ne sont pas raisonnable dans la cadre de la multiplication de grands entiers.</p>
<p>C'est pourquoi l'étude de ces algorithmes s'avère nécessaire.</p>
</div>
</div>

=== Exemple ===
L'algorithme naïf d'addition que nous avons tous appris à l'école a une complexité de <math>\mathcal{O}(n)</math>.
Soit n la taille des nombres en entrée, l'algorithme doit faire environ n addition pour arriver au résultat demandé.

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Addition.gif|220px]]
<div><b>Addition naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Comme le montre l'exemple ci-contre, 786 et 467 font 3 chiffres de long donc n sera de 3.</p>
<p>Il nous faudra 3 opérations pour additionner ces entiers.</p>
<p>C'est ainsi qu'avec une taille d'entrée n, l'algorithme de l'addition naïve va devoir faire n opérations.</p>
<p>Cet algorithme a donc une complexité <math>f(n) = n</math> qui n'a pas besoin d'être approximée.</p>
<p>Ainsi sa complexité finale sera <math>\mathcal{O}(n)</math>.</p>
</div>
</div>

= Problématique =

Le calcul du produit de deux entiers de manière naïve a une complexité de <math> \mathcal{O}(n^2)</math>, et celui de deux matrices une complexité de <math> \mathcal{O}(n^3)</math>. Afin de mieux comprendre ce qu'est la complexité algorithmique, nous devrons implémenter des algorithmes ayant le même objectif, mais étant plus efficaces. Ces algorithmes s'avèreront plus complexes mais devrait aboutir à un calcul plus rapide du produit demandé.

Nous séparerons notre wiki en deux grandes parties, la première concernera nos recherche sur [[#I - Produit d'entiers|la multiplication d'entiers]], la deuxième sur [[#II - Produit de matrices|la multiplication de matrices]].

= I - Produit d'entiers =

Notre départ commence avec l'algorithme de multiplication d'entier naïf.
En effet il s'agit de l'algorithme de multiplication le plus connu, et nous l'utiliserons comme référence pour le comparer aux futurs algorithmes plus efficaces.
Intéressons nous à sa complexité.

== 1) Nos implémentations des grands entiers ==

Qui dit produit de grands entiers dit implémentation de grands entiers.

Dans le cadre de nos recherches, nous allons devoir implémenter des algorithmes qui vont manipuler des grands entiers.

Nous avons donc choisi de créer deux représentations différentes de ceux-ci (car nous travaillons sur différents langages de programmation), nous permettant à la fois une implémentation simplifié, mais aussi de nous rapprocher d'une implémentation bas niveau.

=== A) En python ===
En python, l'utilisation des "bytes" m'a grandement servi à comprendre comment les entiers étaient manipulés à bas niveau. En effet, un des objectifs secondaires de nos recherches était de manipuler des entiers directement avec leur formes stockées sur l'ordinateur, et non pas avec des int python.
En effet l'utilisation des int python nous aurait permit de passer les étapes de retenues, de signes... D'autant plus que les bytes permettent de stocker un nombre en base 256, ce qui permet de visualiser plus facilement les grands entiers.

La forme finale de la représentation des grands entiers en python sera donc la suivante :

[ signe , bytes , bytes , (...) , bytes ]

Le signe est représenté par un entier, 1 si le nombre est positif, 0 sinon.
Cette configuration rendra plus simple la gestion des signes.

=== B) En C++ ===

En C++, pour avoir une représentation de grand entiers j'ai du définir ma propre structure pour m'affranchir de la limite de taille imposé par les entiers standards: (int32 ou int64). Pour cela, j'ai une structure qui possède l'équivalent d'un array de byte (ce qui nous permet d'être en base 256 au lieu de la base 10 habituelle), et pour traiter le signe j'utilise un booléen, ainsi en mémoire j'ai une structure de n*Octets + 1 octet en taille.

[ bytes , bytes , (...) , bytes ] [ signe ]

Le booléen prend 1 octet de place mais ne touche pas aux octets qui encode le grand entier.
Cette configuration rendra plus simple la gestion des signes dans le cadre des multiplication.

== 2) La multiplication naïve ==

=== A) Fonctionnement ===
Dans le cas de la multiplication d'entiers, nous allons prendre deux nombres qui n'ont pas nécessairement la même longueur. Soit les nombre a et b, de longueur respective <math> n </math> et <math> m </math>.
<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Multiplication.png|220px]]
<div><b>Multiplication naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Prenons deux nombres de longueur 3 et 2, et cherchons combien d'opérations l'algorithme de multiplication naïve va devoir faire pour nous renvoyer leur produit.</p>
<p>Dans un premier temps, on remarque que l'on va devoir multiplier chaque chiffre du nombre du haut par le chiffre des unités du bas, qui est 6. Cela va représenter <math>n</math> opérations. (6x5, 6x1 et 6x4)</p>
<p>Dans un deuxième temps nous constatons que nous allons devoir faire la même chose avec le chiffre des dizaines du nombre du bas. Cela nous ajoute de nouveau <math>n</math> opérations.</p>
<p>On arrive assez facilement à la conclusion que pour faire notre produit, il va nous falloir faire <math>n</math> fois <math>m</math> opérations.</p>
</div>
</div>

Ainsi, la complexité de la multiplication naïve est <math>\mathcal{O}(n^2)</math>.
Il est en de même avec la multiplication naïve récursive.

=== B) Graphique ===
Montrons maintenant sa courbe sur un graphique :

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Multiplicationnaive.png|500px]]
<div><b>Multiplication naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Les points noirs sont des repères pour que les autres courbes aient une forme cohérente.</p>
<p>Ils sont tous sur l'axe des abscisses.</p>
<p>La courbe rouge représente la complexité de la multiplication naïve.</p>
<p>On remarque que la courbe a un visuel très similaire à la fonction <math>f(x) = x^2</math> </p>
</div>
</div>

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Naif_recursif.png|500px]]
<div><b>Multiplication naïve récursive</b></div>
</div>
<div style="max-width:800px;">
<p>La courbe rouge représente la complexité de la multiplication naïve récursive.</p>
<p>Elle sera utilisé pour comparer les complexités entre algorithmes car, comme tous récursifs, elle a été codé avec les mêmes biais d'implémentation qu'eux.</p>
<p>Théoriquement les deux courbes ci-contre ont la même complexité, mais encore une fois, notre implémentation n'est pas parfaitement optimale et donc ne respecte pas de manière minutieuse le Master Theorem.</p>
</div>
</div>

== 3) La multiplication karatsuba ==

=== A) Fonctionnement ===

L'algorithme de karatsuba est un algorithme récursif de type diviser pour régner.

L'idée générale de l'algorithme est de passer de 4 multiplication à 3. En effet ces opérations étant moins couteuses, il est préférable d'en ajouter si cela permet d'enlever des multiplications.

L'algorithme de multiplication naif récursif utilise la segmentation des facteurs en deux de manière successive.

Soit <math>x</math> et <math>y</math> deux facteurs, nous avons les égalités suivantes :

<div style="font-size: 20px;">
<math>x = a \times B^{n/2} + b</math>
<math>y = c \times B^{n/2} + d</math>
</div>

Avec <math>a</math> et <math>c</math> les premières moitiés des facteurs <math>x</math> et <math>y</math>,
et <math> b </math> et <math>d</math> les dernières moitiés de ces facteurs ainsi que <math>B</math> la base d'écriture du nombre (Nous sommes en base 256 avec les bytes).

Cette présentation des deux facteurs de notre multiplication n'est que la résultante d'un découpage.
Le [[#Master Theorem|Master Theorem]] nous montre que :

<div style="font-size: 20px;">
<math>T(n) = 4T(n/2) + O(n)</math>
</div>

Puisque nous avons après découpage 4 entiers de longueur <math>n/2</math>.

Ainsi, ce découpage ne permet pas de gagner du temps d'après le [[#Master Theorem|Master Theorem]].

Cependant, l'algorithme de Karatsuba réutilise ce principe en le modifiant, ce qui nous permet de baisser la complexité globale de la multiplication dans son entièreté.

Avec l'écriture ci-dessus des nombres <math>x</math> et <math>y</math>, on peut facilement en déduire l'égalité suivante :

<div style="font-size: 20px;">
<math>x \times y = (ac) \times B^n + (ad + bc) \times B^{n/2} + bd</math>
</div>

On remarque 4 multiplications longues à faire dans cette expression. Les multiplications dont <math>B</math> est l'un des facteurs sont très rapides puisqu'il s'agit de la base dans laquelle nous travaillons. De cela en résulte un décalage plutôt qu'un vrai calcul à faire.

Karatsuba développe une partie de cette expression pour pouvoir négocier une multiplication au prix d'additions et soustractions.

En effet, nous savons déjà que :

<div style="font-size: 20px;">
<math>(a + b)(c + d) = ac + ad + bc + bd</math>
</div>

En manipulant l'égalité nous obtenons :

<div style="font-size: 20px;">
<math>ad + bc = (a + b)(c + d) - ac - bd</math>
</div>

ac et bd ayant déjà été calculé précédemment, il nous reste uniquement la multiplication <math>(a + b)(c + d)</math>.

Nous venons ainsi de calculer <math>ad + bc</math> en seulement une multiplication. C'est la que repose le gain de temps de la méthode Karatsuba par rapport à la multiplication naïve.

En effet, l'algorithme n'effectuera alors plus que 3 multiplications :
<div style="font-size: 20px;">
<math>ac</math>
<math>bd</math>
<math>(a + b)(c + d)</math>
</div>

La relation de récurrence devient donc :
<div style="font-size: 20px;">
<math>T(n)=3T(n/2)+O(n)</math>
</div>

Et le Master Theorem nous dit que :
<div style="font-size: 20px;">
<math>T(n)\in O(n^{\log_2(3)})</math>
</div>

Or <math>\log_2(3)\approx 1.585</math>, donc la complexité de l'algorithme de Karatsuba est de <math> \mathcal{O}(n^{1.585})</math>. Ce qui est bien plus efficace que la multiplication classique, surtout lorsque les facteurs deviennent très grands.

=== B) Graphique ===
<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Karatsuba.png|500px]]
<div><b>Karatsuba</b></div>
</div>
<div style="max-width:800px;">
<p>Sur le graphique ci-contre nous avons utilisé la courbe de la multiplication naïve récursive (rouge) à titre de comparaison.</p>
<p>On remarque graphiquement que Karatsuba (jaune) prend moins de temps à chaque calcul de produit.</p>
<p>On en déduit donc expérimentalement que Karatsuba à une meilleure complexité que la multiplication naïve.</p>
<p>Ainsi nous vérifions donc ce que le Master Theorem prouve, c'est à dire que la complexité de karatsuba est de <math> \mathcal{O}(n^{1.585})</math> </p>
</div>
</div>

== 4) La multiplication toom-cook-3 ==

=== A) Fonctionnement ===

L'objectif est de diviser les grands entiers X et Y en trois blocs de taille égale k.
On les traite alors comme des polynômes de degré 2:

<math>P(z) = X_2 \cdot z^2 + X_1 \cdot z + X_0</math>
<math>Q(z) = Y_2 \cdot z^2 + Y_1 \cdot z + Y_0</math>

On choisit 5 points distincts pour évaluer nos polynômes.
Ce choix de 5 points est crucial car le produit de deux polynômes de degré 2 est un polynôme de degré 4, qui nécessite 5 points pour être défini.
Les points standards sont :

P(0) = X0
P(1) = X0 + X1 + X2
P(-1) = X0 - X1 + X2
P(2) = X0 + 2*X1 + 4*X2
P(inf) = X2

(On procède de manière similaire pour Q.)

Ensuite nous multiplions récursivement chaque points de P et de Q ensemble.
On effectue ainsi 5 multiplications de nombres plus petits au lieu des 9 multiplications requises par la méthode classique.

Après, nous effectuons une interpolation, cela permet de retrouver les 5 coefficients (w_0, w_1, w_2, w_3, w_4) du polynôme produit R(z) à partir des valeurs évaluées calculées précédemment.
On résout un système d'équations linéaires : <math> R(z) = w_4 z^4 + w_3 z^3 + w_2 z^2 + w_1 z + w_0 </math>
Finalement nous pouvons recomposer notre grand entier en positionnant les coefficients w_i aux bons rangs (en les décalant) et à gérer les retenues lors de l'addition finale:
<math>Résultat = w_4 B^{4k} + w_3 B^{3k} + w_2 B^{2k} + w_1 B^k + w_0</math>

=== B) Graphique ===

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Toomcook.png|500px]]
<div><b>Karatsuba</b></div>
</div>
<div style="max-width:800px;">
<p>on a reprit multi récursive (rouge)</p>
<p>on voit que Toom (vert) en dessous de karatsuba (jaune) en dessous de multi classique (rouge)</p>
<p>meilleur complexité</p>
</div>
</div>

== 5) La transformée de Fourier rapide ==

=== A) Fonctionnement ===

La transformation de Fourier rapide étant plus complexe que les autres algorithmes, nous allons essayer d'expliquer son fonctionnement malgré ne pas avoir réussi à l'implémenter.

Il faut comprendre que cet algorithme va considérer les facteurs comme des polynômes.

D'après le théorème de l'unisolvance, il n'existe qu'un seul polynôme de degré inférieur ou égal à <math> n </math> défini par <math>n + 1</math> points distincts. Cela implique non seulement que nous pouvons représenter chaque entier par un polynôme, mais également que si nous pouvons retrouver <math>n + m + 1</math> points (avec <math>n</math> et <math>m</math> la longueur des facteurs) du polynômes issue du produit entre deux facteurs, nous pourrons le retrouver.

Soit un entier quelconque, de forme :

<math>a_n a_{n-1} (...) a_1 a_0</math>

Avec <math>a_i</math>, un chiffre composant le nombre en base 10, qui vaut en réalité dans le nombre : <math>a_i \times 10^i</math>. On peut ainsi l'écrire sous la forme :

<math> P(x) = a_0 + a_1x + a_2x^2 + \dots + a_{n-1}x^{n-1} + a_nx^n </math>

Avec <math>x = 10</math> car nous sommes en base 10, nous obtenons :

<math>P(10) = a_0 + a_1 \times 10 + \dots + a_{n-1}10^{n-1} + a_n10^n </math>

Nous venons ainsi d'écrire notre nombre sous la forme d'un polynôme unique. Pour nous permettre d'évaluer en un nombre suffisant de points, nous allons devoir ajouter des 0 pour la récursion. Il nous faudra ajouter assez de 0 pour atteindre la prochaine puissance de 2 qui sera supérieure ou égale à <math>2n + 1</math>. L'ajout de 0 ne change pas le nombre car <math>0 \times x^n</math> n'ajoute pas de coefficient.

Cet algorithme est récursif et va segmenter en deux parties nos polynômes à chaque récursion. D'un coté les indice pairs et d'un coté les impaires.

Ainsi prenons les nombres 1234 et 5678, ces nombres sont respectivement représentés par les polynômes <math> P(x) = 4 + 3x + 2x^2 + x^3 </math> et <math> P(x) = 8 + 7x + 6x^2 + 5^3 </math>. Ce sont des polynômes de degré 3, ainsi leur produit donnera lieu à un polynôme de degré 6. Il nous faudra donc au minimum 7 points d'évaluation pour retrouve ce produit. De ce fait, en les représentant de la manière suivante :

<math>[4, 3, 2, 1, 0, 0, 0, 0]</math>
<math>[8, 7, 6, 5, 0, 0, 0, 0]</math>

Nous aurons assez de récursions possible pour les évaluer en un nombre suffisant de points différents car nous auront 3 récursions à faire pour atteindre notre cas de base. A chaque récursion, nous allons diviser nos polynômes en deux parties ce qui nous fait 8 feuilles à la dernière récursion.

En effet à chaque étape de la récursion nous allons séparer nos polynômes en deux tel que :

<math>P(x)=P_{\text{pair}}(x^2) + x \cdot P_{\text{impair}}(x^2)</math>

Durant les récursions, nous segmentons les polynômes mais ne les évaluons pas. C'est à la remonté des récursions que nous allons réellement évaluer nos polynômes. Lorsque l'on atteint notre cas de base, c'est à dire des polynômes de degré 0, nous remarquons qu'ils sont constants, nous n'avons donc pas besoin de les évaluer. En effet, peut importe le point en lequel nous voudrons l'évaluer, le polynôme renverra la constante. Nous la renvoyons donc seule.
Ensuite commence la remontée des récursions. A l'étape 1 de notre remontée nous allons reformer le polynôme précédemment séparé pour obtenir un polynôme de degré 1. Puis, nous évaluons ce polynôme avec les racines seconde de l'unité. Nous faisons à nouveau remonté les évaluations et recombinons à nouveau le polynôme qui sera ainsi de degré 2.
Nous l'évaluons maintenant avec les racines 4eme de l'unité. A chaque évaluation, nous réutilisons les résultats précédents, cela nous est permit par les racines de l'unité qui ont une structure récursive exploitable.

Finalement, nous arrivons à la fin de notre FFT, avec une représentation fréquentielle de la forme :

<math> [P(W_0), P(W_1), (...), P(W_n-1), P(W_n)] </math>

Cette représentation fréquentielle n'est autre que les évaluations du polynôme P aux racines nièmes de l'unité. Nous avons donc maintenant au minimum <math>2n+1</math> évaluations des polynômes facteurs. Il nous faut maintenant trouver les évaluations du produit final, c'est à dire les évaluations concernant le polynôme qui sera issue de la multiplication. On pourra ainsi le retrouver.

Soit <math>C</math> un polynome tel que <math> C = A \times B </math>, alors on a :

<math> C(x) = A(x) \times B(x) </math>

Ainsi on en déduit que <math> C(W_n^k) = A(W_n^k) \times B(W_n^k) </math>

On comprend donc que <math>FFT(C) = FFT(A) \times FFT(B)</math>

Il faut préciser que l'on fait le produit de FFT(A) et FFT(B) terme à terme, soit évaluation par évaluation.

Une fois en possession de <math>FFT(C)</math>, qui n'est autre que l'évaluation de notre polynôme final en un nombre suffisant de points pour le retrouver, nous pouvons faire l'<math>IFFT(FFT(C))</math>, qui va nous permettre de retrouver les coefficients de notre polynôme en faisant l'exacte inverse de la FFT.

Une fois les coefficients retrouvés, il nous suffit de gérer les retenues, et nous retrouvons un entier de la forme : <math>a_0 a_1 (...) a_{n-1} a_n</math>

=== B) Graphique ===

Intéressons nous maintenant à la complexité de l'algorithme utilisant la transformée de Fourier rapide. On sait que l'algorithme passe par 5 étapes importantes :

<ul>
<li>Etape 1 : Ecrire les deux facteurs sous la forme de polynômes</li>
<li>Etape 2 : Effectuer la <math>FFT</math> des deux polynômes</li>
<li>Etape 3 : Faire le produit terme à terme des <math>FFT</math> obtenues</li>
<li>Etape 4 : Faire l'<math>IFFT</math> du produit</li>
<li>Etape 5 : Gérer les retenues et écrire le nombre qui en découle</li>
</ul>

Or, parmi toutes ces étapes, certaines sont négligeable comme l'étape 1 et 5.

Pour connaitre la complexité de l'algorithme, additionnons les complexités des étapes restantes :

Une <math>FFT</math> a une complexité de <math>\mathcal{O}(n\times logn)</math> car elle fait <math>n</math> évaluation sur <math> log(n)</math> récursions. Dans le cadre de notre algorithme, nous devons faire la <math>FFT</math> de nos deux facteurs. Soit <math>2\times \mathcal{O}(n\times logn)</math>.

Pour le produit terme à terme, nous faisons naturellement <math>n</math> opérations.

Pour finir, l'<math>IFFT</math> a la même complexité que la <math>FFT</math>. Dans le cadre de notre algorithme nous l'emploierons qu'une seule fois, ce qui fait une complexité de <math>\mathcal{O}(n\times logn)</math>.

Après addition de toutes ces complexités, nous obtenons la complexité réelle de <math>3\mathcal{O}(n\times logn) + \mathcal{O}(n)</math>.

D'après le Master Theorem, nous avons donc <math> f(n) = 3(n\times logn)+n </math>, cherchons <math>f(n)\in\mathcal{O}(g(n))</math> :

Nous pouvons ignorer les expressions linéaires ainsi que les constantes multiplicatrices, nous obtenons donc <math>\mathcal{O}(g(n)) = \mathcal{O}(n \times log n)</math>.

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:30px; text-align:center;">
[[Fichier:FFT_image.webp|500px]]
<div><b>Graphiques des complexités</b></div>
</div>
<div style="max-width:800px;">
<p>Ce graphique ci-contre ne provient pas du fruit de nos recherches personnelles mais </p>
<p>On comprend ainsi que certaines complexités ne sont pas raisonnable dans la cadre de la multiplication de grands entiers.</p>
<p>C'est pourquoi l'étude de ces algorithmes s'avère nécessaire.</p>
</div>
</div>

= II - Produit de matrices =

== 1.1) naïve ==

La multiplication naïve de matrice requiert d'avoir des tailles de lignes/colonne semblable, ensuite pour chaque membre de la matrice résultat, on doit multiplier les composantes ligne de la première matrice par les composantes colonne de la deuxième et le tout sommé.

On en déduit la formule suivante:
<math>C_{i,j} = \sum_{k=1}^{n} (A_{i,k} \times B_{k,j})</math>

Et visuellement:

[[Fichier:Matricenaive.jpeg]]

On a donc un algorithme d'ordre de complexité <math>\mathcal{O}(g(n))</math>

== 1.2) naïve récursive ==

Dans un premier temps on doit découper nos deux matrices en quatres sous matrices de plus petite taille.
<math>A = \begin{pmatrix} A_{11} & A_{12} \ A_{21} & A_{22} \end{pmatrix}</math>
<math>B = \begin{pmatrix} B_{11} & B_{12} \ B_{21} & B_{22} \end{pmatrix}</math>

Ensuite on vient calculer la matrice résultat.
<math>C_{11} = (A_{11} \times B_{11}) + (A_{12} \times B_{21})</math>
<math>C_{12} = (A_{11} \times B_{12}) + (A_{12} \times B_{22})</math>
<math>C_{21} = (A_{21} \times B_{11}) + (A_{22} \times B_{21})</math>
<math>C_{22} = (A_{21} \times B_{12}) + (A_{22} \times B_{22})</math>

Le côté récursif est utile que pour les matrices de tailles <= 32 (32 valeurs stockées dedans),
si on est au dessus de cette taille alors on divisera à nouveau nos matrices en quatres.
On aura 8 multiplications mais de plus petite taille au final.

== 2) strassen ==

=== A) Fonctionnement ===

Strassen consiste à définir 7 produits intermédiaires qui, par des jeux de sommes et de différences, permettent de reconstruire les quadrants de la matrice résultante. On passe ainsi d'une complexité de O(n^3) à environ O(n^2.81)

=== B) Graphique ===

On voit bien la différence de complexité sur la multiplication de grande matrice entre l'approche naïve et l'approche récursive qui est beaucoup plus rapide.

[[Fichier:Analyse matrices.png]]

= Conclusion =

L'étude de ces algorithmes de multiplication nous a clairement montré l'évolution de la complexité algorithmique permettant de gagner en efficacité lorsque la taille des données augmente.

La multiplication classiqe, en <math>\mathcal{O}(n^2)</math>, résulte d'une approche naïve qui devient rapidement inefficace pour les grands entiers ou les grandes matrices. L'algorithme de Karatsuba nous montre qu'organiser de manière intelligente ses calculs algébrique permet parfois de gagner beaucoup de multiplications, et donc de temps. Nous avons ainsi réussi à passer d'une complexité de <math>\mathcal{O}(n^2)</math> à <math>\mathcal{O}(n^{log_2(3)})</math>, soit environ <math>\mathcal{O}(n^{1/585})</math>.

Des méthodes encore plus avancées comme utilise l'algorithme de Toom-Cook-3 continue dans cette idées de divisions d'entiers en blocs plus petits, tandis que la transformée de Fourier rapide change complètement de point de vue. En effet la FFT n'utilise pas la représentation classique des entiers mais fait appel à une vision polynomiale, ce qui transforme la convolution classique en multiplication terme à terme, ce qui lui permet d'atteindre une complexité de <math>\mathcal{O}(n \times log n)</math>.

Dans le cas des matrices, les mêmes logiques apparaissent comme par exemple avec l'algorithme de Strassen qui se rapproche très fortement de Karatsuba en combinant de manière astucieuse les parties d'entiers qui avaient été précédemment découpée.

On remarque néanmoins que la majorité des algorithmes efficaces s'orientent vers une approche récursive et non itérative. Néanmoins, nous avons pu trouver certaines de ces implémentations (comme par exemple la FFT) en itérative.

Avec ces recherches, nous comprenons que la réorganisations des calculs algébriques peuvent aider à gagner en complexité mais que pour faire de réels progrès, il nous faudra surement changer notre point de vue une nouvelle fois, et aborder le problème sous un angle nouveau comme le font dors et déjà les algorithmes les plus performants.

= Mentions =

Le premier gif est le résultat du travail de 'Walké', licence ci-contre : https://fr.wikipedia.org/wiki/Fichier:Addition.gif

Utilisation du site de production graphique "Desmos" : https://www.desmos.com/calculator?lang=fr

= Sources =

Pour karatsuba :
<ul>
<li> https://www.youtube.com/watch?v=PZ2gdWdKHAA </li>
</ul>

Pour mieux comprendre la FFT, nous avons utilisé plusieurs sources d'informations :
<ul>
<li> https://www.youtube.com/watch?v=h7apO7q16V0&list=WL&index=1&t=886s </li>
<li> https://fr.wikipedia.org/wiki/Interpolation_polynomiale </li>
</ul>

Algorithmes de multiplications d'entiers et de matrices

2026-05-11T19:54:40Z

Mangala : /* 2) La multiplication naïve */

= Introduction =

Depuis l'apparition des ordinateurs modernes, une quantité faramineuse de calculs a dû être effectuée. Les progressions technologiques nous poussent à envisager la puissance de calcul comme une ressource qu'il faut optimiser dans les moindres détails. C'est ainsi que l'optimisation des algorithmes de calcul est devenue cruciale, surtout lorsqu'il nous faut effectuer des opérations sur de très grands entiers par exemple.

= Objectif =

L'objectif majeur de ce projet est de comprendre de manière plus approfondie ce qu'est la '''complexité algorithmique'''.
Pour atteindre cet objectif, nous implémenterons plusieurs algorithmes de multiplication qui auront pour but de calculer le produit de grands entiers ou de matrices.

= Point important : complexité =

=== Définition ===
La complexité d'un algorithme est la quantité des ressources qu'il utilise en fonction de la taille des entrées qu'on lui demande de traiter. On peut par exemple se concentrer sur le temps qu'un algorithme prend pour renvoyer un résultat ou sur la mémoire dont il a besoin. Dans le cadre de notre projet, nous nous attarderons plus particulièrement sur la quantité de calcul effectuée en fonction de la taille des entrées, ce qui est par ailleurs étroitement liée à la notion de temps. De manière générale, plus un algorithme doit faire de calcul, plus il est lent. (Attention, toutes les opérations arithmétiques de base ne se valent pas)

De manière plus familière, on dira que la complexité d'un algorithme pourrait s'apparenter à son comportement lorsqu'il doit traiter des données plus ou moins grandes.
Chaque algorithme a une complexité, et on l'exprime par une fonction qui adopte un comportement similaire au nombre de calculs nécessaires en fonction de la taille des entrées.

=== Notation ===
La complexité réelle d'un algorithme peut être décrite par une fonction <math> f(n) </math> représentant le nombre d'opérations effectuées en fonction de la taille <math>n</math> des données d'entrée.

Cependant, afin de simplifier l'étude de cette croissance, on utilise généralement une borne asymptotique notée <math>\mathcal{O}(g(n))</math>, où <math>g(n)</math> est une fonction ayant le même ordre de grandeur que <math>f(n)</math> lorsque <math>n</math> devient grand.

On dit alors que :

<math>
f(n)\in\mathcal{O}(g(n))
</math>

si et seulement s'il existe une constante <math>C>0</math> et un entier <math>n_0</math> tels que :

<math>
\forall n\ge n_0,\ f(n)\le Cg(n)
</math>

Cette notation <math>\mathcal{O}(g(n))</math> permettra de comparer beaucoup plus facilement les algorithmes entre eux.

=== Master Theorem ===

Afin de déterminer la complexité de certains algorithmes récursifs, nous utiliserons le "Master Theorem".

Ce théorème permet d'obtenir directement l'ordre de grandeur de nombreuses relations de récurrence apparaissant dans l'analyse d'algorithmes de type « diviser pour régner », comme l'algorithme de Karatsuba ou celui de Strassen.

La démonstration complète de ce théorème dépasse le cadre de notre projet et nécessite des connaissances mathématiques plus avancées. Nous l'utiliserons donc principalement comme un outil nous permettant de déterminer efficacement la complexité asymptotique des algorithmes étudiés.

=== Graphiques ===

Les complexités étant des fonctions, nous pouvons les représenter par un graphique qui affichera le temps d'exécution (ou nombre d'opérations) en fonction de la taille des entrées.

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:30px; text-align:center;">
[[Fichier:complexite.webp|500px]]
<div><b>Graphiques des complexités</b></div>
</div>
<div style="max-width:800px;">
<p>Ce graphique ci-contre compare les complexités en fonction de la taille des d'entrées.</p>
<p>On comprend ainsi que certaines complexités ne sont pas raisonnable dans la cadre de la multiplication de grands entiers.</p>
<p>C'est pourquoi l'étude de ces algorithmes s'avère nécessaire.</p>
</div>
</div>

=== Exemple ===
L'algorithme naïf d'addition que nous avons tous appris à l'école a une complexité de <math>\mathcal{O}(n)</math>.
Soit n la taille des nombres en entrée, l'algorithme doit faire environ n addition pour arriver au résultat demandé.

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Addition.gif|220px]]
<div><b>Addition naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Comme le montre l'exemple ci-contre, 786 et 467 font 3 chiffres de long donc n sera de 3.</p>
<p>Il nous faudra 3 opérations pour additionner ces entiers.</p>
<p>C'est ainsi qu'avec une taille d'entrée n, l'algorithme de l'addition naïve va devoir faire n opérations.</p>
<p>Cet algorithme a donc une complexité <math>f(n) = n</math> qui n'a pas besoin d'être approximée.</p>
<p>Ainsi sa complexité finale sera <math>\mathcal{O}(n)</math>.</p>
</div>
</div>

= Problématique =

Le calcul du produit de deux entiers de manière naïve a une complexité de <math> \mathcal{O}(n^2)</math>, et celui de deux matrices une complexité de <math> \mathcal{O}(n^3)</math>. Afin de mieux comprendre ce qu'est la complexité algorithmique, nous devrons implémenter des algorithmes ayant le même objectif, mais étant plus efficaces. Ces algorithmes s'avèreront plus complexes mais devrait aboutir à un calcul plus rapide du produit demandé.

Nous séparerons notre wiki en deux grandes parties, la première concernera nos recherche sur [[#I - Produit d'entiers|la multiplication d'entiers]], la deuxième sur [[#II - Produit de matrices|la multiplication de matrices]].

= I - Produit d'entiers =

Notre départ commence avec l'algorithme de multiplication d'entier naïf.
En effet il s'agit de l'algorithme de multiplication le plus connu, et nous l'utiliserons comme référence pour le comparer aux futurs algorithmes plus efficaces.
Intéressons nous à sa complexité.

== 1) Nos implémentations des grands entiers ==

Qui dit produit de grands entiers dit implémentation de grands entiers.

Dans le cadre de nos recherches, nous allons devoir implémenter des algorithmes qui vont manipuler des grands entiers.

Nous avons donc choisi de créer deux représentations différentes de ceux-ci (car nous travaillons sur différents langages de programmation), nous permettant à la fois une implémentation simplifié, mais aussi de nous rapprocher d'une implémentation bas niveau.

=== A) En python ===
En python, l'utilisation des "bytes" m'a grandement servi à comprendre comment les entiers étaient manipulés à bas niveau. En effet, un des objectifs secondaires de nos recherches était de manipuler des entiers directement avec leur formes stockées sur l'ordinateur, et non pas avec des int python.
En effet l'utilisation des int python nous aurait permit de passer les étapes de retenues, de signes... D'autant plus que les bytes permettent de stocker un nombre en base 256, ce qui permet de visualiser plus facilement les grands entiers.

La forme finale de la représentation des grands entiers en python sera donc la suivante :

[ signe , bytes , bytes , (...) , bytes ]

Le signe est représenté par un entier, 1 si le nombre est positif, 0 sinon.
Cette configuration rendra plus simple la gestion des signes.

=== B) En C++ ===

En C++, pour avoir une représentation de grand entiers j'ai du définir ma propre structure pour m'affranchir de la limite de taille imposé par les entiers standards: (int32 ou int64). Pour cela, j'ai une structure qui possède l'équivalent d'un array de byte (ce qui nous permet d'être en base 256 au lieu de la base 10 habituelle), et pour traiter le signe j'utilise un booléen, ainsi en mémoire j'ai une structure de n*Octets + 1 octet en taille.

[ bytes , bytes , (...) , bytes ] [ signe ]

Le booléen prend 1 octet de place mais ne touche pas aux octets qui encode le grand entier.
Cette configuration rendra plus simple la gestion des signes dans le cadre des multiplication.

== 2) La multiplication naïve ==

=== A) Fonctionnement ===
Dans le cas de la multiplication d'entiers, nous allons prendre deux nombres qui n'ont pas nécessairement la même longueur. Soit les nombre a et b, de longueur respective <math> n </math> et <math> m </math>.
<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Multiplication.png|220px]]
<div><b>Multiplication naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Prenons deux nombres de longueur 3 et 2, et cherchons combien d'opérations l'algorithme de multiplication naïve va devoir faire pour nous renvoyer leur produit.</p>
<p>Dans un premier temps, on remarque que l'on va devoir multiplier chaque chiffre du nombre du haut par le chiffre des unités du bas, qui est 6. Cela va représenter <math>n</math> opérations. (6x5, 6x1 et 6x4)</p>
<p>Dans un deuxième temps nous constatons que nous allons devoir faire la même chose avec le chiffre des dizaines du nombre du bas. Cela nous ajoute de nouveau <math>n</math> opérations.</p>
<p>On arrive assez facilement à la conclusion que pour faire notre produit, il va nous falloir faire <math>n</math> fois <math>m</math> opérations.</p>
</div>
</div>

Ainsi, la complexité de la multiplication naïve est <math>\mathcal{O}(n^2)</math>.
Il est en de même avec la multiplication naïve récursive.

=== B) Graphique ===
Montrons maintenant sa courbe sur un graphique :

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Multiplicationnaive.png|500px]]
<div><b>Multiplication naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Les points noirs sont des repères pour que les autres courbes aient une forme cohérente.</p>
<p>Ils sont tous sur l'axe des abscisses.</p>
<p>La courbe rouge représente la complexité de la multiplication naïve.</p>
<p>On remarque que la courbe a un visuel très similaire à la fonction <math>f(x) = x^2</math> </p>
</div>
</div>

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Naif_recursif.png|500px]]
<div><b>Multiplication naïve récursive</b></div>
</div>
<div style="max-width:800px;">
<p>La courbe rouge représente la complexité de la multiplication naïve récursive.</p>
<p>Elle sera utilisé pour comparer les complexités entre algorithmes car, comme tous récursifs, elle a été codé avec les mêmes biais d'implémentation qu'eux.</p>
<p>Théoriquement les deux courbes ci-contre ont la même complexité, mais encore une fois, notre implémentation n'est pas parfaitement optimale et donc ne respecte pas de manière minutieuse le Master Theorem.</p>
</div>
</div>

== 3) La multiplication karatsuba ==

=== A) Fonctionnement ===

L'algorithme de karatsuba est un algorithme récursif de type diviser pour régner.

L'idée générale de l'algorithme est de passer de 4 multiplication à 3. En effet ces opérations étant moins couteuses, il est préférable d'en ajouter si cela permet d'enlever des multiplications.

L'algorithme de multiplication naif récursif utilise la segmentation des facteurs en deux de manière successive.

Soit <math>x</math> et <math>y</math> deux facteurs, nous avons les égalités suivantes :

<div style="font-size: 20px;">
<math>x = a \times B^{n/2} + b</math>
<math>y = c \times B^{n/2} + d</math>
</div>

Avec <math>a</math> et <math>c</math> les premières moitiés des facteurs <math>x</math> et <math>y</math>,
et <math> b </math> et <math>d</math> les dernières moitiés de ces facteurs ainsi que <math>B</math> la base d'écriture du nombre (Nous sommes en base 256 avec les bytes).

Cette présentation des deux facteurs de notre multiplication n'est que la résultante d'un découpage.
Le [[#Master Theorem|Master Theorem]] nous montre que :

<div style="font-size: 20px;">
<math>T(n) = 4T(n/2) + O(n)</math>
</div>

Puisque nous avons après découpage 4 entiers de longueur <math>n/2</math>.

Ainsi, ce découpage ne permet pas de gagner du temps d'après le [[#Master Theorem|Master Theorem]].

Cependant, l'algorithme de Karatsuba réutilise ce principe en le modifiant, ce qui nous permet de baisser la complexité globale de la multiplication dans son entièreté.

Avec l'écriture ci-dessus des nombres <math>x</math> et <math>y</math>, on peut facilement en déduire l'égalité suivante :

<div style="font-size: 20px;">
<math>x \times y = (ac) \times B^n + (ad + bc) \times B^{n/2} + bd</math>
</div>

On remarque 4 multiplications longues à faire dans cette expression. Les multiplications dont <math>B</math> est l'un des facteurs sont très rapides puisqu'il s'agit de la base dans laquelle nous travaillons. De cela en résulte un décalage plutôt qu'un vrai calcul à faire.

Karatsuba développe une partie de cette expression pour pouvoir négocier une multiplication au prix d'additions et soustractions.

En effet, nous savons déjà que :

<div style="font-size: 20px;">
<math>(a + b)(c + d) = ac + ad + bc + bd</math>
</div>

En manipulant l'égalité nous obtenons :

<div style="font-size: 20px;">
<math>ad + bc = (a + b)(c + d) - ac - bd</math>
</div>

ac et bd ayant déjà été calculé précédemment, il nous reste uniquement la multiplication <math>(a + b)(c + d)</math>.

Nous venons ainsi de calculer <math>ad + bc</math> en seulement une multiplication. C'est la que repose le gain de temps de la méthode Karatsuba par rapport à la multiplication naïve.

En effet, l'algorithme n'effectuera alors plus que 3 multiplications :
<div style="font-size: 20px;">
<math>ac</math>
<math>bd</math>
<math>(a + b)(c + d)</math>
</div>

La relation de récurrence devient donc :
<div style="font-size: 20px;">
<math>T(n)=3T(n/2)+O(n)</math>
</div>

Et le Master Theorem nous dit que :
<div style="font-size: 20px;">
<math>T(n)\in O(n^{\log_2(3)})</math>
</div>

Or <math>\log_2(3)\approx 1.585</math>, donc la complexité de l'algorithme de Karatsuba est de <math> \mathcal{O}(n^{1.585})</math>. Ce qui est bien plus efficace que la multiplication classique, surtout lorsque les facteurs deviennent très grands.

=== B) Graphique ===
<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Karatsuba.png|500px]]
<div><b>Karatsuba</b></div>
</div>
<div style="max-width:800px;">
<p>Sur le graphique ci-contre nous avons utilisé la courbe de la multiplication naïve récursive (rouge) à titre de comparaison.</p>
<p>On remarque graphiquement que Karatsuba (jaune) prend moins de temps à chaque calcul de produit.</p>
<p>On en déduit donc expérimentalement que Karatsuba à une meilleure complexité que la multiplication naïve.</p>
<p>Ainsi nous vérifions donc ce que le Master Theorem prouve, c'est à dire que la complexité de karatsuba est de <math> \mathcal{O}(n^{1.585})</math> </p>
</div>
</div>

== 4) La multiplication toom-cook-3 ==

=== A) Fonctionnement ===

L'objectif est de diviser les grands entiers X et Y en trois blocs de taille égale k.
On les traite alors comme des polynômes de degré 2:

<math>P(z) = X_2 \cdot z^2 + X_1 \cdot z + X_0</math>
<math>Q(z) = Y_2 \cdot z^2 + Y_1 \cdot z + Y_0</math>

On choisit 5 points distincts pour évaluer nos polynômes.
Ce choix de 5 points est crucial car le produit de deux polynômes de degré 2 est un polynôme de degré 4, qui nécessite 5 points pour être défini.
Les points standards sont :

P(0) = X0
P(1) = X0 + X1 + X2
P(-1) = X0 - X1 + X2
P(2) = X0 + 2*X1 + 4*X2
P(inf) = X2

(On procède de manière similaire pour Q.)

Ensuite nous multiplions récursivement chaque points de P et de Q ensemble.
On effectue ainsi 5 multiplications de nombres plus petits au lieu des 9 multiplications requises par la méthode classique.

Après, nous effectuons une interpolation, cela permet de retrouver les 5 coefficients (w_0, w_1, w_2, w_3, w_4) du polynôme produit R(z) à partir des valeurs évaluées calculées précédemment.
On résout un système d'équations linéaires : <math> R(z) = w_4 z^4 + w_3 z^3 + w_2 z^2 + w_1 z + w_0 </math>
Finalement nous pouvons recomposer notre grand entier en positionnant les coefficients w_i aux bons rangs (en les décalant) et à gérer les retenues lors de l'addition finale:
<math>Résultat = w_4 B^{4k} + w_3 B^{3k} + w_2 B^{2k} + w_1 B^k + w_0</math>

=== B) Graphique ===

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Toomcook.png|500px]]
<div><b>Karatsuba</b></div>
</div>
<div style="max-width:800px;">
<p>on a reprit multi récursive (rouge)</p>
<p>on voit que Toom (vert) en dessous de karatsuba (jaune) en dessous de multi classique (rouge)</p>
<p>meilleur complexité</p>
</div>
</div>

== 5) La transformée de Fourier rapide ==

=== A) Fonctionnement ===

La transformation de Fourier rapide étant plus complexe que les autres algorithmes, nous allons essayer d'expliquer son fonctionnement malgré ne pas avoir réussi à l'implémenter.

Il faut comprendre que cet algorithme va considérer les facteurs comme des polynômes.

D'après le théorème de l'unisolvance, il n'existe qu'un seul polynôme de degré inférieur ou égal à <math> n </math> défini par <math>n + 1</math> points distincts. Cela implique non seulement que nous pouvons représenter chaque entier par un polynôme, mais également que si nous pouvons retrouver <math>n + m + 1</math> points (avec <math>n</math> et <math>m</math> la longueur des facteurs) du polynômes issue du produit entre deux facteurs, nous pourrons le retrouver.

Soit un entier quelconque, de forme :

<math>a_n a_{n-1} (...) a_1 a_0</math>

Avec <math>a_i</math>, un chiffre composant le nombre en base 10, qui vaut en réalité dans le nombre : <math>a_i \times 10^i</math>. On peut ainsi l'écrire sous la forme :

<math> P(x) = a_0 + a_1x + a_2x^2 + \dots + a_{n-1}x^{n-1} + a_nx^n </math>

Avec <math>x = 10</math> car nous sommes en base 10, nous obtenons :

<math>P(10) = a_0 + a_1 \times 10 + \dots + a_{n-1}10^{n-1} + a_n10^n </math>

Nous venons ainsi d'écrire notre nombre sous la forme d'un polynôme unique. Pour nous permettre d'évaluer en un nombre suffisant de points, nous allons devoir ajouter des 0 pour la récursion. Il nous faudra ajouter assez de 0 pour atteindre la prochaine puissance de 2 qui sera supérieure ou égale à <math>2n + 1</math>. L'ajout de 0 ne change pas le nombre car <math>0 \times x^n</math> n'ajoute pas de coefficient.

Cet algorithme est récursif et va segmenter en deux parties nos polynômes à chaque récursion. D'un coté les indice pairs et d'un coté les impaires.

Ainsi prenons les nombres 1234 et 5678, ces nombres sont respectivement représentés par les polynômes <math> P(x) = 4 + 3x + 2x^2 + x^3 </math> et <math> P(x) = 8 + 7x + 6x^2 + 5^3 </math>. Ce sont des polynômes de degré 3, ainsi leur produit donnera lieu à un polynôme de degré 6. Il nous faudra donc au minimum 7 points d'évaluation pour retrouve ce produit. De ce fait, en les représentant de la manière suivante :

<math>[4, 3, 2, 1, 0, 0, 0, 0]</math>
<math>[8, 7, 6, 5, 0, 0, 0, 0]</math>

Nous aurons assez de récursions possible pour les évaluer en un nombre suffisant de points différents car nous auront 3 récursions à faire pour atteindre notre cas de base. A chaque récursion, nous allons diviser nos polynômes en deux parties ce qui nous fait 8 feuilles à la dernière récursion.

En effet à chaque étape de la récursion nous allons séparer nos polynômes en deux tel que :

<math>P(x)=P_{\text{pair}}(x^2) + x \cdot P_{\text{impair}}(x^2)</math>

Durant les récursions, nous segmentons les polynômes mais ne les évaluons pas. C'est à la remonté des récursions que nous allons réellement évaluer nos polynômes. Lorsque l'on atteint notre cas de base, c'est à dire des polynômes de degré 0, nous remarquons qu'ils sont constants, nous n'avons donc pas besoin de les évaluer. En effet, peut importe le point en lequel nous voudrons l'évaluer, le polynôme renverra la constante. Nous la renvoyons donc seule.
Ensuite commence la remontée des récursions. A l'étape 1 de notre remontée nous allons reformer le polynôme précédemment séparé pour obtenir un polynôme de degré 1. Puis, nous évaluons ce polynôme avec les racines seconde de l'unité. Nous faisons à nouveau remonté les évaluations et recombinons à nouveau le polynôme qui sera ainsi de degré 2.
Nous l'évaluons maintenant avec les racines 4eme de l'unité. A chaque évaluation, nous réutilisons les résultats précédents, cela nous est permit par les racines de l'unité qui ont une structure récursive exploitable.

Finalement, nous arrivons à la fin de notre FFT, avec une représentation fréquentielle de la forme :

<math> [P(W_0), P(W_1), (...), P(W_n-1), P(W_n)] </math>

Cette représentation fréquentielle n'est autre que les évaluations du polynôme P aux racines nièmes de l'unité. Nous avons donc maintenant au minimum <math>2n+1</math> évaluations des polynômes facteurs. Il nous faut maintenant trouver les évaluations du produit final, c'est à dire les évaluations concernant le polynôme qui sera issue de la multiplication. On pourra ainsi le retrouver.

Soit <math>C</math> un polynome tel que <math> C = A \times B </math>, alors on a :

<math> C(x) = A(x) \times B(x) </math>

Ainsi on en déduit que <math> C(W_n^k) = A(W_n^k) \times B(W_n^k) </math>

On comprend donc que <math>FFT(C) = FFT(A) \times FFT(B)</math>

Il faut préciser que l'on fait le produit de FFT(A) et FFT(B) terme à terme, soit évaluation par évaluation.

Une fois en possession de <math>FFT(C)</math>, qui n'est autre que l'évaluation de notre polynôme final en un nombre suffisant de points pour le retrouver, nous pouvons faire l'<math>IFFT(FFT(C))</math>, qui va nous permettre de retrouver les coefficients de notre polynôme en faisant l'exacte inverse de la FFT.

Une fois les coefficients retrouvés, il nous suffit de gérer les retenues, et nous retrouvons un entier de la forme : <math>a_0 a_1 (...) a_{n-1} a_n</math>

=== B) Graphique ===

Intéressons nous maintenant à la complexité de l'algorithme utilisant la transformée de Fourier rapide. On sait que l'algorithme passe par 5 étapes importantes :

<ul>
<li>Etape 1 : Ecrire les deux facteurs sous la forme de polynômes</li>
<li>Etape 2 : Effectuer la <math>FFT</math> des deux polynômes</li>
<li>Etape 3 : Faire le produit terme à terme des <math>FFT</math> obtenues</li>
<li>Etape 4 : Faire l'<math>IFFT</math> du produit</li>
<li>Etape 5 : Gérer les retenues et écrire le nombre qui en découle</li>
</ul>

Or, parmi toutes ces étapes, certaines sont négligeable comme l'étape 1 et 5.

Pour connaitre la complexité de l'algorithme, additionnons les complexités des étapes restantes :

Une <math>FFT</math> a une complexité de <math>\mathcal{O}(n\times logn)</math> car elle fait <math>n</math> évaluation sur <math> log(n)</math> récursions. Dans le cadre de notre algorithme, nous devons faire la <math>FFT</math> de nos deux facteurs. Soit <math>2\times \mathcal{O}(n\times logn)</math>.

Pour le produit terme à terme, nous faisons naturellement <math>n</math> opérations.

Pour finir, l'<math>IFFT</math> a la même complexité que la <math>FFT</math>. Dans le cadre de notre algorithme nous l'emploierons qu'une seule fois, ce qui fait une complexité de <math>\mathcal{O}(n\times logn)</math>.

Après addition de toutes ces complexités, nous obtenons la complexité réelle de <math>3\mathcal{O}(n\times logn) + \mathcal{O}(n)</math>.

D'après le Master Theorem, nous avons donc <math> f(n) = 3(n\times logn)+n </math>, cherchons <math>f(n)\in\mathcal{O}(g(n))</math> :

Nous pouvons ignorer les expressions linéaires ainsi que les constantes multiplicatrices, nous obtenons donc <math>\mathcal{O}(g(n)) = \mathcal{O}(n \times log n)</math>.

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:30px; text-align:center;">
[[Fichier:FFT_image.webp|500px]]
<div><b>Graphiques des complexités</b></div>
</div>
<div style="max-width:800px;">
<p>Ce graphique ci-contre ne provient pas du fruit de nos recherches personnelles mais </p>
<p>On comprend ainsi que certaines complexités ne sont pas raisonnable dans la cadre de la multiplication de grands entiers.</p>
<p>C'est pourquoi l'étude de ces algorithmes s'avère nécessaire.</p>
</div>
</div>

= II - Produit de matrices =

== 1.1) naïve ==

La multiplication naïve de matrice requiert d'avoir des tailles de lignes/colonne semblable, ensuite pour chaque membre de la matrice résultat, on doit multiplier les composantes ligne de la première matrice par les composantes colonne de la deuxième et le tout sommé.

On en déduit la formule suivante:
<math>C_{i,j} = \sum_{k=1}^{n} (A_{i,k} \times B_{k,j})</math>

Et visuellement:

[[Fichier:Matricenaive.jpeg]]

On a donc un algorithme d'ordre de complexité <math>\mathcal{O}(g(n))</math>

== 1.2) naïve récursive ==

Dans un premier temps on doit découper nos deux matrices en quatres sous matrices de plus petite taille.
<math>A = \begin{pmatrix} A_{11} & A_{12} \ A_{21} & A_{22} \end{pmatrix}</math>
<math>B = \begin{pmatrix} B_{11} & B_{12} \ B_{21} & B_{22} \end{pmatrix}</math>

Ensuite on vient calculer la matrice résultat.
<math>C_{11} = (A_{11} \times B_{11}) + (A_{12} \times B_{21})</math>
<math>C_{12} = (A_{11} \times B_{12}) + (A_{12} \times B_{22})</math>
<math>C_{21} = (A_{21} \times B_{11}) + (A_{22} \times B_{21})</math>
<math>C_{22} = (A_{21} \times B_{12}) + (A_{22} \times B_{22})</math>

Le côté récursif est utile que pour les matrices de tailles <= 32 (32 valeurs stockées dedans),
si on est au dessus de cette taille alors on divisera à nouveau nos matrices en quatres.
On aura 8 multiplications mais de plus petite taille au final.

== 2) strassen ==

=== A) Fonctionnement ===

Strassen consiste à définir 7 produits intermédiaires qui, par des jeux de sommes et de différences, permettent de reconstruire les quadrants de la matrice résultante. On passe ainsi d'une complexité de O(n^3) à environ O(n^2.81)

=== B) Graphique ===

On voit bien la différence de complexité sur la multiplication de grande matrice entre l'approche naïve et l'approche récursive qui est beaucoup plus rapide.

[[Fichier:Analyse matrices.png]]

= Conclusion =

L'étude de ces algorithmes de multiplication nous a clairement montré l'évolution de la complexité algorithmique permettant de gagner en efficacité lorsque la taille des données augmente.

La multiplication classiqe, en <math>\mathcal{O}(n^2)</math>, résulte d'une approche naïve qui devient rapidement inefficace pour les grands entiers ou les grandes matrices. L'algorithme de Karatsuba nous montre qu'organiser de manière intelligente ses calculs algébrique permet parfois de gagner beaucoup de multiplications, et donc de temps. Nous avons ainsi réussi à passer d'une complexité de <math>\mathcal{O}(n^2)</math> à <math>\mathcal{O}(n^{log_2(3)})</math>, soit environ <math>\mathcal{O}(n^{1/585})</math>.

Des méthodes encore plus avancées comme utilise l'algorithme de Toom-Cook-3 continue dans cette idées de divisions d'entiers en blocs plus petits, tandis que la transformée de Fourier rapide change complètement de point de vue. En effet la FFT n'utilise pas la représentation classique des entiers mais fait appel à une vision polynomiale, ce qui transforme la convolution classique en multiplication terme à terme, ce qui lui permet d'atteindre une complexité de <math>\mathcal{O}(n \times log n)</math>.

Dans le cas des matrices, les mêmes logiques apparaissent comme par exemple avec l'algorithme de Strassen qui se rapproche très fortement de Karatsuba en combinant de manière astucieuse les parties d'entiers qui avaient été précédemment découpée.

On remarque néanmoins que la majorité des algorithmes efficaces s'orientent vers une approche récursive et non itérative. Néanmoins, nous avons pu trouver certaines de ces implémentations (comme par exemple la FFT) en itérative.

Avec ces recherches, nous comprenons que la réorganisations des calculs algébriques peuvent aider à gagner en complexité mais que pour faire de réels progrès, il nous faudra surement changer notre point de vue une nouvelle fois, et aborder le problème sous un angle nouveau comme le font dors et déjà les algorithmes les plus performants.

= Mentions =

Le premier gif est le résultat du travail de 'Walké', licence ci-contre : https://fr.wikipedia.org/wiki/Fichier:Addition.gif

Utilisation du site de production graphique "Desmos" : https://www.desmos.com/calculator?lang=fr

= Sources =

Pour karatsuba :
<ul>
<li> https://www.youtube.com/watch?v=PZ2gdWdKHAA </li>
</ul>

Pour mieux comprendre la FFT, nous avons utilisé plusieurs sources d'informations :
<ul>
<li> https://www.youtube.com/watch?v=h7apO7q16V0&list=WL&index=1&t=886s </li>
<li> https://fr.wikipedia.org/wiki/Interpolation_polynomiale </li>
</ul>

Algorithmes de multiplications d'entiers et de matrices

2026-05-11T19:39:16Z

Mangala : /* Mentions */

= Introduction =

Depuis l'apparition des ordinateurs modernes, une quantité faramineuse de calculs a dû être effectuée. Les progressions technologiques nous poussent à envisager la puissance de calcul comme une ressource qu'il faut optimiser dans les moindres détails. C'est ainsi que l'optimisation des algorithmes de calcul est devenue cruciale, surtout lorsqu'il nous faut effectuer des opérations sur de très grands entiers par exemple.

= Objectif =

L'objectif majeur de ce projet est de comprendre de manière plus approfondie ce qu'est la '''complexité algorithmique'''.
Pour atteindre cet objectif, nous implémenterons plusieurs algorithmes de multiplication qui auront pour but de calculer le produit de grands entiers ou de matrices.

= Point important : complexité =

=== Définition ===
La complexité d'un algorithme est la quantité des ressources qu'il utilise en fonction de la taille des entrées qu'on lui demande de traiter. On peut par exemple se concentrer sur le temps qu'un algorithme prend pour renvoyer un résultat ou sur la mémoire dont il a besoin. Dans le cadre de notre projet, nous nous attarderons plus particulièrement sur la quantité de calcul effectuée en fonction de la taille des entrées, ce qui est par ailleurs étroitement liée à la notion de temps. De manière générale, plus un algorithme doit faire de calcul, plus il est lent. (Attention, toutes les opérations arithmétiques de base ne se valent pas)

De manière plus familière, on dira que la complexité d'un algorithme pourrait s'apparenter à son comportement lorsqu'il doit traiter des données plus ou moins grandes.
Chaque algorithme a une complexité, et on l'exprime par une fonction qui adopte un comportement similaire au nombre de calculs nécessaires en fonction de la taille des entrées.

=== Notation ===
La complexité réelle d'un algorithme peut être décrite par une fonction <math> f(n) </math> représentant le nombre d'opérations effectuées en fonction de la taille <math>n</math> des données d'entrée.

Cependant, afin de simplifier l'étude de cette croissance, on utilise généralement une borne asymptotique notée <math>\mathcal{O}(g(n))</math>, où <math>g(n)</math> est une fonction ayant le même ordre de grandeur que <math>f(n)</math> lorsque <math>n</math> devient grand.

On dit alors que :

<math>
f(n)\in\mathcal{O}(g(n))
</math>

si et seulement s'il existe une constante <math>C>0</math> et un entier <math>n_0</math> tels que :

<math>
\forall n\ge n_0,\ f(n)\le Cg(n)
</math>

Cette notation <math>\mathcal{O}(g(n))</math> permettra de comparer beaucoup plus facilement les algorithmes entre eux.

=== Master Theorem ===

Afin de déterminer la complexité de certains algorithmes récursifs, nous utiliserons le "Master Theorem".

Ce théorème permet d'obtenir directement l'ordre de grandeur de nombreuses relations de récurrence apparaissant dans l'analyse d'algorithmes de type « diviser pour régner », comme l'algorithme de Karatsuba ou celui de Strassen.

La démonstration complète de ce théorème dépasse le cadre de notre projet et nécessite des connaissances mathématiques plus avancées. Nous l'utiliserons donc principalement comme un outil nous permettant de déterminer efficacement la complexité asymptotique des algorithmes étudiés.

=== Graphiques ===

Les complexités étant des fonctions, nous pouvons les représenter par un graphique qui affichera le temps d'exécution (ou nombre d'opérations) en fonction de la taille des entrées.

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:30px; text-align:center;">
[[Fichier:complexite.webp|500px]]
<div><b>Graphiques des complexités</b></div>
</div>
<div style="max-width:800px;">
<p>Ce graphique ci-contre compare les complexités en fonction de la taille des d'entrées.</p>
<p>On comprend ainsi que certaines complexités ne sont pas raisonnable dans la cadre de la multiplication de grands entiers.</p>
<p>C'est pourquoi l'étude de ces algorithmes s'avère nécessaire.</p>
</div>
</div>

=== Exemple ===
L'algorithme naïf d'addition que nous avons tous appris à l'école a une complexité de <math>\mathcal{O}(n)</math>.
Soit n la taille des nombres en entrée, l'algorithme doit faire environ n addition pour arriver au résultat demandé.

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Addition.gif|220px]]
<div><b>Addition naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Comme le montre l'exemple ci-contre, 786 et 467 font 3 chiffres de long donc n sera de 3.</p>
<p>Il nous faudra 3 opérations pour additionner ces entiers.</p>
<p>C'est ainsi qu'avec une taille d'entrée n, l'algorithme de l'addition naïve va devoir faire n opérations.</p>
<p>Cet algorithme a donc une complexité <math>f(n) = n</math> qui n'a pas besoin d'être approximée.</p>
<p>Ainsi sa complexité finale sera <math>\mathcal{O}(n)</math>.</p>
</div>
</div>

= Problématique =

Le calcul du produit de deux entiers de manière naïve a une complexité de <math> \mathcal{O}(n^2)</math>, et celui de deux matrices une complexité de <math> \mathcal{O}(n^3)</math>. Afin de mieux comprendre ce qu'est la complexité algorithmique, nous devrons implémenter des algorithmes ayant le même objectif, mais étant plus efficaces. Ces algorithmes s'avèreront plus complexes mais devrait aboutir à un calcul plus rapide du produit demandé.

Nous séparerons notre wiki en deux grandes parties, la première concernera nos recherche sur [[#I - Produit d'entiers|la multiplication d'entiers]], la deuxième sur [[#II - Produit de matrices|la multiplication de matrices]].

= I - Produit d'entiers =

Notre départ commence avec l'algorithme de multiplication d'entier naïf.
En effet il s'agit de l'algorithme de multiplication le plus connu, et nous l'utiliserons comme référence pour le comparer aux futurs algorithmes plus efficaces.
Intéressons nous à sa complexité.

== 1) Nos implémentations des grands entiers ==

Qui dit produit de grands entiers dit implémentation de grands entiers.

Dans le cadre de nos recherches, nous allons devoir implémenter des algorithmes qui vont manipuler des grands entiers.

Nous avons donc choisi de créer deux représentations différentes de ceux-ci (car nous travaillons sur différents langages de programmation), nous permettant à la fois une implémentation simplifié, mais aussi de nous rapprocher d'une implémentation bas niveau.

=== A) En python ===
En python, l'utilisation des "bytes" m'a grandement servi à comprendre comment les entiers étaient manipulés à bas niveau. En effet, un des objectifs secondaires de nos recherches était de manipuler des entiers directement avec leur formes stockées sur l'ordinateur, et non pas avec des int python.
En effet l'utilisation des int python nous aurait permit de passer les étapes de retenues, de signes... D'autant plus que les bytes permettent de stocker un nombre en base 256, ce qui permet de visualiser plus facilement les grands entiers.

La forme finale de la représentation des grands entiers en python sera donc la suivante :

[ signe , bytes , bytes , (...) , bytes ]

Le signe est représenté par un entier, 1 si le nombre est positif, 0 sinon.
Cette configuration rendra plus simple la gestion des signes.

=== B) En C++ ===

En C++, pour avoir une représentation de grand entiers j'ai du définir ma propre structure pour m'affranchir de la limite de taille imposé par les entiers standards: (int32 ou int64). Pour cela, j'ai une structure qui possède l'équivalent d'un array de byte (ce qui nous permet d'être en base 256 au lieu de la base 10 habituelle), et pour traiter le signe j'utilise un booléen, ainsi en mémoire j'ai une structure de n*Octets + 1 octet en taille.

[ bytes , bytes , (...) , bytes ] [ signe ]

Le booléen prend 1 octet de place mais ne touche pas aux octets qui encode le grand entier.
Cette configuration rendra plus simple la gestion des signes dans le cadre des multiplication.

== 2) La multiplication naïve ==

=== A) Fonctionnement ===
Dans le cas de la multiplication d'entiers, nous allons prendre deux nombres qui n'ont pas nécessairement la même longueur. Soit les nombre a et b, de longueur respective <math>n</math> et <math>m</math>.
<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Multiplication.png|220px]]
<div><b>Multiplication naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Prenons deux nombres de longueur 3 et 2, et cherchons combien d'opérations l'algorithme de multiplication naïve va devoir faire pour nous renvoyer leur produit.</p>
<p>Dans un premier temps, on remarque que l'on va devoir multiplier chaque chiffre du nombre du haut par le chiffre des unités du bas, qui est 6. Cela va représenter <math>n</math> opérations. (6x5, 6x1 et 6x4)</p>
<p>Dans un deuxième temps nous constatons que nous allons devoir faire la même chose avec le chiffre des dizaines du nombre du bas. Cela nous ajoute de nouveau <math>n</math> opérations.</p>
<p>On arrive assez facilement à la conclusion que pour faire notre produit, il va nous falloir faire <math>n</math> fois <math>m</math> opérations.</p>
</div>
</div>

Ainsi, la complexité de la multiplication naïve est <math>\mathcal{O}(n^2)</math>.
Il est en de même avec la multiplication naïve récursive.

=== B) Graphique ===
Montrons maintenant sa courbe sur un graphique :

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Multiplicationnaive.png|500px]]
<div><b>Multiplication naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Les points noirs sont des repères pour que les autres courbes aient une forme cohérente.</p>
<p>Ils sont tous sur l'axe des abscisses.</p>
<p>La courbe rouge représente la complexité de la multiplication naïve.</p>
<p>On remarque que la courbe a un visuel très similaire à la fonction <math>f(x) = x^2</math> </p>
</div>
</div>

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Naif_recursif.png|500px]]
<div><b>Multiplication naïve récursive</b></div>
</div>
<div style="max-width:800px;">
<p>La courbe rouge représente la complexité de la multiplication naïve récursive.</p>
<p>Elle sera utilisé pour comparer les complexités entre algorithmes car, comme tous récursifs, elle a été codé avec les mêmes biais d'implémentation qu'eux.</p>
<p>Théoriquement les deux courbes ci-contre ont la même complexité, mais encore une fois, notre implémentation n'est pas parfaitement optimale et donc ne respecte pas de manière minutieuse le Master Theorem.</p>
</div>
</div>

== 3) La multiplication karatsuba ==

=== A) Fonctionnement ===

L'algorithme de karatsuba est un algorithme récursif de type diviser pour régner.

L'idée générale de l'algorithme est de passer de 4 multiplication à 3. En effet ces opérations étant moins couteuses, il est préférable d'en ajouter si cela permet d'enlever des multiplications.

L'algorithme de multiplication naif récursif utilise la segmentation des facteurs en deux de manière successive.

Soit <math>x</math> et <math>y</math> deux facteurs, nous avons les égalités suivantes :

<div style="font-size: 20px;">
<math>x = a \times B^{n/2} + b</math>
<math>y = c \times B^{n/2} + d</math>
</div>

Avec <math>a</math> et <math>c</math> les premières moitiés des facteurs <math>x</math> et <math>y</math>,
et <math> b </math> et <math>d</math> les dernières moitiés de ces facteurs ainsi que <math>B</math> la base d'écriture du nombre (Nous sommes en base 256 avec les bytes).

Cette présentation des deux facteurs de notre multiplication n'est que la résultante d'un découpage.
Le [[#Master Theorem|Master Theorem]] nous montre que :

<div style="font-size: 20px;">
<math>T(n) = 4T(n/2) + O(n)</math>
</div>

Puisque nous avons après découpage 4 entiers de longueur <math>n/2</math>.

Ainsi, ce découpage ne permet pas de gagner du temps d'après le [[#Master Theorem|Master Theorem]].

Cependant, l'algorithme de Karatsuba réutilise ce principe en le modifiant, ce qui nous permet de baisser la complexité globale de la multiplication dans son entièreté.

Avec l'écriture ci-dessus des nombres <math>x</math> et <math>y</math>, on peut facilement en déduire l'égalité suivante :

<div style="font-size: 20px;">
<math>x \times y = (ac) \times B^n + (ad + bc) \times B^{n/2} + bd</math>
</div>

On remarque 4 multiplications longues à faire dans cette expression. Les multiplications dont <math>B</math> est l'un des facteurs sont très rapides puisqu'il s'agit de la base dans laquelle nous travaillons. De cela en résulte un décalage plutôt qu'un vrai calcul à faire.

Karatsuba développe une partie de cette expression pour pouvoir négocier une multiplication au prix d'additions et soustractions.

En effet, nous savons déjà que :

<div style="font-size: 20px;">
<math>(a + b)(c + d) = ac + ad + bc + bd</math>
</div>

En manipulant l'égalité nous obtenons :

<div style="font-size: 20px;">
<math>ad + bc = (a + b)(c + d) - ac - bd</math>
</div>

ac et bd ayant déjà été calculé précédemment, il nous reste uniquement la multiplication <math>(a + b)(c + d)</math>.

Nous venons ainsi de calculer <math>ad + bc</math> en seulement une multiplication. C'est la que repose le gain de temps de la méthode Karatsuba par rapport à la multiplication naïve.

En effet, l'algorithme n'effectuera alors plus que 3 multiplications :
<div style="font-size: 20px;">
<math>ac</math>
<math>bd</math>
<math>(a + b)(c + d)</math>
</div>

La relation de récurrence devient donc :
<div style="font-size: 20px;">
<math>T(n)=3T(n/2)+O(n)</math>
</div>

Et le Master Theorem nous dit que :
<div style="font-size: 20px;">
<math>T(n)\in O(n^{\log_2(3)})</math>
</div>

Or <math>\log_2(3)\approx 1.585</math>, donc la complexité de l'algorithme de Karatsuba est de <math> \mathcal{O}(n^{1.585})</math>. Ce qui est bien plus efficace que la multiplication classique, surtout lorsque les facteurs deviennent très grands.

=== B) Graphique ===
<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Karatsuba.png|500px]]
<div><b>Karatsuba</b></div>
</div>
<div style="max-width:800px;">
<p>Sur le graphique ci-contre nous avons utilisé la courbe de la multiplication naïve récursive (rouge) à titre de comparaison.</p>
<p>On remarque graphiquement que Karatsuba (jaune) prend moins de temps à chaque calcul de produit.</p>
<p>On en déduit donc expérimentalement que Karatsuba à une meilleure complexité que la multiplication naïve.</p>
<p>Ainsi nous vérifions donc ce que le Master Theorem prouve, c'est à dire que la complexité de karatsuba est de <math> \mathcal{O}(n^{1.585})</math> </p>
</div>
</div>

== 4) La multiplication toom-cook-3 ==

=== A) Fonctionnement ===

L'objectif est de diviser les grands entiers X et Y en trois blocs de taille égale k.
On les traite alors comme des polynômes de degré 2:

<math>P(z) = X_2 \cdot z^2 + X_1 \cdot z + X_0</math>
<math>Q(z) = Y_2 \cdot z^2 + Y_1 \cdot z + Y_0</math>

On choisit 5 points distincts pour évaluer nos polynômes.
Ce choix de 5 points est crucial car le produit de deux polynômes de degré 2 est un polynôme de degré 4, qui nécessite 5 points pour être défini.
Les points standards sont :

P(0) = X0
P(1) = X0 + X1 + X2
P(-1) = X0 - X1 + X2
P(2) = X0 + 2*X1 + 4*X2
P(inf) = X2

(On procède de manière similaire pour Q.)

Ensuite nous multiplions récursivement chaque points de P et de Q ensemble.
On effectue ainsi 5 multiplications de nombres plus petits au lieu des 9 multiplications requises par la méthode classique.

Après, nous effectuons une interpolation, cela permet de retrouver les 5 coefficients (w_0, w_1, w_2, w_3, w_4) du polynôme produit R(z) à partir des valeurs évaluées calculées précédemment.
On résout un système d'équations linéaires : <math> R(z) = w_4 z^4 + w_3 z^3 + w_2 z^2 + w_1 z + w_0 </math>
Finalement nous pouvons recomposer notre grand entier en positionnant les coefficients w_i aux bons rangs (en les décalant) et à gérer les retenues lors de l'addition finale:
<math>Résultat = w_4 B^{4k} + w_3 B^{3k} + w_2 B^{2k} + w_1 B^k + w_0</math>

=== B) Graphique ===

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Toomcook.png|500px]]
<div><b>Karatsuba</b></div>
</div>
<div style="max-width:800px;">
<p>on a reprit multi récursive (rouge)</p>
<p>on voit que Toom (vert) en dessous de karatsuba (jaune) en dessous de multi classique (rouge)</p>
<p>meilleur complexité</p>
</div>
</div>

== 5) La transformée de Fourier rapide ==

=== A) Fonctionnement ===

La transformation de Fourier rapide étant plus complexe que les autres algorithmes, nous allons essayer d'expliquer son fonctionnement malgré ne pas avoir réussi à l'implémenter.

Il faut comprendre que cet algorithme va considérer les facteurs comme des polynômes.

D'après le théorème de l'unisolvance, il n'existe qu'un seul polynôme de degré inférieur ou égal à <math> n </math> défini par <math>n + 1</math> points distincts. Cela implique non seulement que nous pouvons représenter chaque entier par un polynôme, mais également que si nous pouvons retrouver <math>n + m + 1</math> points (avec <math>n</math> et <math>m</math> la longueur des facteurs) du polynômes issue du produit entre deux facteurs, nous pourrons le retrouver.

Soit un entier quelconque, de forme :

<math>a_n a_{n-1} (...) a_1 a_0</math>

Avec <math>a_i</math>, un chiffre composant le nombre en base 10, qui vaut en réalité dans le nombre : <math>a_i \times 10^i</math>. On peut ainsi l'écrire sous la forme :

<math> P(x) = a_0 + a_1x + a_2x^2 + \dots + a_{n-1}x^{n-1} + a_nx^n </math>

Avec <math>x = 10</math> car nous sommes en base 10, nous obtenons :

<math>P(10) = a_0 + a_1 \times 10 + \dots + a_{n-1}10^{n-1} + a_n10^n </math>

Nous venons ainsi d'écrire notre nombre sous la forme d'un polynôme unique. Pour nous permettre d'évaluer en un nombre suffisant de points, nous allons devoir ajouter des 0 pour la récursion. Il nous faudra ajouter assez de 0 pour atteindre la prochaine puissance de 2 qui sera supérieure ou égale à <math>2n + 1</math>. L'ajout de 0 ne change pas le nombre car <math>0 \times x^n</math> n'ajoute pas de coefficient.

Cet algorithme est récursif et va segmenter en deux parties nos polynômes à chaque récursion. D'un coté les indice pairs et d'un coté les impaires.

Ainsi prenons les nombres 1234 et 5678, ces nombres sont respectivement représentés par les polynômes <math> P(x) = 4 + 3x + 2x^2 + x^3 </math> et <math> P(x) = 8 + 7x + 6x^2 + 5^3 </math>. Ce sont des polynômes de degré 3, ainsi leur produit donnera lieu à un polynôme de degré 6. Il nous faudra donc au minimum 7 points d'évaluation pour retrouve ce produit. De ce fait, en les représentant de la manière suivante :

<math>[4, 3, 2, 1, 0, 0, 0, 0]</math>
<math>[8, 7, 6, 5, 0, 0, 0, 0]</math>

Nous aurons assez de récursions possible pour les évaluer en un nombre suffisant de points différents car nous auront 3 récursions à faire pour atteindre notre cas de base. A chaque récursion, nous allons diviser nos polynômes en deux parties ce qui nous fait 8 feuilles à la dernière récursion.

En effet à chaque étape de la récursion nous allons séparer nos polynômes en deux tel que :

<math>P(x)=P_{\text{pair}}(x^2) + x \cdot P_{\text{impair}}(x^2)</math>

Durant les récursions, nous segmentons les polynômes mais ne les évaluons pas. C'est à la remonté des récursions que nous allons réellement évaluer nos polynômes. Lorsque l'on atteint notre cas de base, c'est à dire des polynômes de degré 0, nous remarquons qu'ils sont constants, nous n'avons donc pas besoin de les évaluer. En effet, peut importe le point en lequel nous voudrons l'évaluer, le polynôme renverra la constante. Nous la renvoyons donc seule.
Ensuite commence la remontée des récursions. A l'étape 1 de notre remontée nous allons reformer le polynôme précédemment séparé pour obtenir un polynôme de degré 1. Puis, nous évaluons ce polynôme avec les racines seconde de l'unité. Nous faisons à nouveau remonté les évaluations et recombinons à nouveau le polynôme qui sera ainsi de degré 2.
Nous l'évaluons maintenant avec les racines 4eme de l'unité. A chaque évaluation, nous réutilisons les résultats précédents, cela nous est permit par les racines de l'unité qui ont une structure récursive exploitable.

Finalement, nous arrivons à la fin de notre FFT, avec une représentation fréquentielle de la forme :

<math> [P(W_0), P(W_1), (...), P(W_n-1), P(W_n)] </math>

Cette représentation fréquentielle n'est autre que les évaluations du polynôme P aux racines nièmes de l'unité. Nous avons donc maintenant au minimum <math>2n+1</math> évaluations des polynômes facteurs. Il nous faut maintenant trouver les évaluations du produit final, c'est à dire les évaluations concernant le polynôme qui sera issue de la multiplication. On pourra ainsi le retrouver.

Soit <math>C</math> un polynome tel que <math> C = A \times B </math>, alors on a :

<math> C(x) = A(x) \times B(x) </math>

Ainsi on en déduit que <math> C(W_n^k) = A(W_n^k) \times B(W_n^k) </math>

On comprend donc que <math>FFT(C) = FFT(A) \times FFT(B)</math>

Il faut préciser que l'on fait le produit de FFT(A) et FFT(B) terme à terme, soit évaluation par évaluation.

Une fois en possession de <math>FFT(C)</math>, qui n'est autre que l'évaluation de notre polynôme final en un nombre suffisant de points pour le retrouver, nous pouvons faire l'<math>IFFT(FFT(C))</math>, qui va nous permettre de retrouver les coefficients de notre polynôme en faisant l'exacte inverse de la FFT.

Une fois les coefficients retrouvés, il nous suffit de gérer les retenues, et nous retrouvons un entier de la forme : <math>a_0 a_1 (...) a_{n-1} a_n</math>

=== B) Graphique ===

Intéressons nous maintenant à la complexité de l'algorithme utilisant la transformée de Fourier rapide. On sait que l'algorithme passe par 5 étapes importantes :

<ul>
<li>Etape 1 : Ecrire les deux facteurs sous la forme de polynômes</li>
<li>Etape 2 : Effectuer la <math>FFT</math> des deux polynômes</li>
<li>Etape 3 : Faire le produit terme à terme des <math>FFT</math> obtenues</li>
<li>Etape 4 : Faire l'<math>IFFT</math> du produit</li>
<li>Etape 5 : Gérer les retenues et écrire le nombre qui en découle</li>
</ul>

Or, parmi toutes ces étapes, certaines sont négligeable comme l'étape 1 et 5.

Pour connaitre la complexité de l'algorithme, additionnons les complexités des étapes restantes :

Une <math>FFT</math> a une complexité de <math>\mathcal{O}(n\times logn)</math> car elle fait <math>n</math> évaluation sur <math> log(n)</math> récursions. Dans le cadre de notre algorithme, nous devons faire la <math>FFT</math> de nos deux facteurs. Soit <math>2\times \mathcal{O}(n\times logn)</math>.

Pour le produit terme à terme, nous faisons naturellement <math>n</math> opérations.

Pour finir, l'<math>IFFT</math> a la même complexité que la <math>FFT</math>. Dans le cadre de notre algorithme nous l'emploierons qu'une seule fois, ce qui fait une complexité de <math>\mathcal{O}(n\times logn)</math>.

Après addition de toutes ces complexités, nous obtenons la complexité réelle de <math>3\mathcal{O}(n\times logn) + \mathcal{O}(n)</math>.

D'après le Master Theorem, nous avons donc <math> f(n) = 3(n\times logn)+n </math>, cherchons <math>f(n)\in\mathcal{O}(g(n))</math> :

Nous pouvons ignorer les expressions linéaires ainsi que les constantes multiplicatrices, nous obtenons donc <math>\mathcal{O}(g(n)) = \mathcal{O}(n \times log n)</math>.

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:30px; text-align:center;">
[[Fichier:FFT_image.webp|500px]]
<div><b>Graphiques des complexités</b></div>
</div>
<div style="max-width:800px;">
<p>Ce graphique ci-contre ne provient pas du fruit de nos recherches personnelles mais </p>
<p>On comprend ainsi que certaines complexités ne sont pas raisonnable dans la cadre de la multiplication de grands entiers.</p>
<p>C'est pourquoi l'étude de ces algorithmes s'avère nécessaire.</p>
</div>
</div>

= II - Produit de matrices =

== 1.1) naïve ==

La multiplication naïve de matrice requiert d'avoir des tailles de lignes/colonne semblable, ensuite pour chaque membre de la matrice résultat, on doit multiplier les composantes ligne de la première matrice par les composantes colonne de la deuxième et le tout sommé.

On en déduit la formule suivante:
<math>C_{i,j} = \sum_{k=1}^{n} (A_{i,k} \times B_{k,j})</math>

Et visuellement:

[[Fichier:Matricenaive.jpeg]]

On a donc un algorithme d'ordre de complexité <math>\mathcal{O}(g(n))</math>

== 1.2) naïve récursive ==

Dans un premier temps on doit découper nos deux matrices en quatres sous matrices de plus petite taille.
<math>A = \begin{pmatrix} A_{11} & A_{12} \ A_{21} & A_{22} \end{pmatrix}</math>
<math>B = \begin{pmatrix} B_{11} & B_{12} \ B_{21} & B_{22} \end{pmatrix}</math>

Ensuite on vient calculer la matrice résultat.
<math>C_{11} = (A_{11} \times B_{11}) + (A_{12} \times B_{21})</math>
<math>C_{12} = (A_{11} \times B_{12}) + (A_{12} \times B_{22})</math>
<math>C_{21} = (A_{21} \times B_{11}) + (A_{22} \times B_{21})</math>
<math>C_{22} = (A_{21} \times B_{12}) + (A_{22} \times B_{22})</math>

Le côté récursif est utile que pour les matrices de tailles <= 32 (32 valeurs stockées dedans),
si on est au dessus de cette taille alors on divisera à nouveau nos matrices en quatres.
On aura 8 multiplications mais de plus petite taille au final.

== 2) strassen ==

=== A) Fonctionnement ===

Strassen consiste à définir 7 produits intermédiaires qui, par des jeux de sommes et de différences, permettent de reconstruire les quadrants de la matrice résultante. On passe ainsi d'une complexité de O(n^3) à environ O(n^2.81)

=== B) Graphique ===

On voit bien la différence de complexité sur la multiplication de grande matrice entre l'approche naïve et l'approche récursive qui est beaucoup plus rapide.

[[Fichier:Analyse matrices.png]]

= Conclusion =

L'étude de ces algorithmes de multiplication nous a clairement montré l'évolution de la complexité algorithmique permettant de gagner en efficacité lorsque la taille des données augmente.

La multiplication classiqe, en <math>\mathcal{O}(n^2)</math>, résulte d'une approche naïve qui devient rapidement inefficace pour les grands entiers ou les grandes matrices. L'algorithme de Karatsuba nous montre qu'organiser de manière intelligente ses calculs algébrique permet parfois de gagner beaucoup de multiplications, et donc de temps. Nous avons ainsi réussi à passer d'une complexité de <math>\mathcal{O}(n^2)</math> à <math>\mathcal{O}(n^{log_2(3)})</math>, soit environ <math>\mathcal{O}(n^{1/585})</math>.

Des méthodes encore plus avancées comme utilise l'algorithme de Toom-Cook-3 continue dans cette idées de divisions d'entiers en blocs plus petits, tandis que la transformée de Fourier rapide change complètement de point de vue. En effet la FFT n'utilise pas la représentation classique des entiers mais fait appel à une vision polynomiale, ce qui transforme la convolution classique en multiplication terme à terme, ce qui lui permet d'atteindre une complexité de <math>\mathcal{O}(n \times log n)</math>.

Dans le cas des matrices, les mêmes logiques apparaissent comme par exemple avec l'algorithme de Strassen qui se rapproche très fortement de Karatsuba en combinant de manière astucieuse les parties d'entiers qui avaient été précédemment découpée.

On remarque néanmoins que la majorité des algorithmes efficaces s'orientent vers une approche récursive et non itérative. Néanmoins, nous avons pu trouver certaines de ces implémentations (comme par exemple la FFT) en itérative.

Avec ces recherches, nous comprenons que la réorganisations des calculs algébriques peuvent aider à gagner en complexité mais que pour faire de réels progrès, il nous faudra surement changer notre point de vue une nouvelle fois, et aborder le problème sous un angle nouveau comme le font dors et déjà les algorithmes les plus performants.

= Mentions =

Le premier gif est le résultat du travail de 'Walké', licence ci-contre : https://fr.wikipedia.org/wiki/Fichier:Addition.gif

Utilisation du site de production graphique "Desmos" : https://www.desmos.com/calculator?lang=fr

= Sources =

Pour karatsuba :
<ul>
<li> https://www.youtube.com/watch?v=PZ2gdWdKHAA </li>
</ul>

Pour mieux comprendre la FFT, nous avons utilisé plusieurs sources d'informations :
<ul>
<li> https://www.youtube.com/watch?v=h7apO7q16V0&list=WL&index=1&t=886s </li>
<li> https://fr.wikipedia.org/wiki/Interpolation_polynomiale </li>
</ul>

Algorithmes de multiplications d'entiers et de matrices

2026-05-11T18:54:03Z

Mangala : /* Conclusion */

= Introduction =

Depuis l'apparition des ordinateurs modernes, une quantité faramineuse de calculs a dû être effectuée. Les progressions technologiques nous poussent à envisager la puissance de calcul comme une ressource qu'il faut optimiser dans les moindres détails. C'est ainsi que l'optimisation des algorithmes de calcul est devenue cruciale, surtout lorsqu'il nous faut effectuer des opérations sur de très grands entiers par exemple.

= Objectif =

L'objectif majeur de ce projet est de comprendre de manière plus approfondie ce qu'est la '''complexité algorithmique'''.
Pour atteindre cet objectif, nous implémenterons plusieurs algorithmes de multiplication qui auront pour but de calculer le produit de grands entiers ou de matrices.

= Point important : complexité =

=== Définition ===
La complexité d'un algorithme est la quantité des ressources qu'il utilise en fonction de la taille des entrées qu'on lui demande de traiter. On peut par exemple se concentrer sur le temps qu'un algorithme prend pour renvoyer un résultat ou sur la mémoire dont il a besoin. Dans le cadre de notre projet, nous nous attarderons plus particulièrement sur la quantité de calcul effectuée en fonction de la taille des entrées, ce qui est par ailleurs étroitement liée à la notion de temps. De manière générale, plus un algorithme doit faire de calcul, plus il est lent. (Attention, toutes les opérations arithmétiques de base ne se valent pas)

De manière plus familière, on dira que la complexité d'un algorithme pourrait s'apparenter à son comportement lorsqu'il doit traiter des données plus ou moins grandes.
Chaque algorithme a une complexité, et on l'exprime par une fonction qui adopte un comportement similaire au nombre de calculs nécessaires en fonction de la taille des entrées.

=== Notation ===
La complexité réelle d'un algorithme peut être décrite par une fonction <math> f(n) </math> représentant le nombre d'opérations effectuées en fonction de la taille <math>n</math> des données d'entrée.

Cependant, afin de simplifier l'étude de cette croissance, on utilise généralement une borne asymptotique notée <math>\mathcal{O}(g(n))</math>, où <math>g(n)</math> est une fonction ayant le même ordre de grandeur que <math>f(n)</math> lorsque <math>n</math> devient grand.

On dit alors que :

<math>
f(n)\in\mathcal{O}(g(n))
</math>

si et seulement s'il existe une constante <math>C>0</math> et un entier <math>n_0</math> tels que :

<math>
\forall n\ge n_0,\ f(n)\le Cg(n)
</math>

Cette notation <math>\mathcal{O}(g(n))</math> permettra de comparer beaucoup plus facilement les algorithmes entre eux.

=== Master Theorem ===

Afin de déterminer la complexité de certains algorithmes récursifs, nous utiliserons le "Master Theorem".

Ce théorème permet d'obtenir directement l'ordre de grandeur de nombreuses relations de récurrence apparaissant dans l'analyse d'algorithmes de type « diviser pour régner », comme l'algorithme de Karatsuba ou celui de Strassen.

La démonstration complète de ce théorème dépasse le cadre de notre projet et nécessite des connaissances mathématiques plus avancées. Nous l'utiliserons donc principalement comme un outil nous permettant de déterminer efficacement la complexité asymptotique des algorithmes étudiés.

=== Graphiques ===

Les complexités étant des fonctions, nous pouvons les représenter par un graphique qui affichera le temps d'exécution (ou nombre d'opérations) en fonction de la taille des entrées.

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:30px; text-align:center;">
[[Fichier:complexite.webp|500px]]
<div><b>Graphiques des complexités</b></div>
</div>
<div style="max-width:800px;">
<p>Ce graphique ci-contre compare les complexités en fonction de la taille des d'entrées.</p>
<p>On comprend ainsi que certaines complexités ne sont pas raisonnable dans la cadre de la multiplication de grands entiers.</p>
<p>C'est pourquoi l'étude de ces algorithmes s'avère nécessaire.</p>
</div>
</div>

=== Exemple ===
L'algorithme naïf d'addition que nous avons tous appris à l'école a une complexité de <math>\mathcal{O}(n)</math>.
Soit n la taille des nombres en entrée, l'algorithme doit faire environ n addition pour arriver au résultat demandé.

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Addition.gif|220px]]
<div><b>Addition naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Comme le montre l'exemple ci-contre, 786 et 467 font 3 chiffres de long donc n sera de 3.</p>
<p>Il nous faudra 3 opérations pour additionner ces entiers.</p>
<p>C'est ainsi qu'avec une taille d'entrée n, l'algorithme de l'addition naïve va devoir faire n opérations.</p>
<p>Cet algorithme a donc une complexité <math>f(n) = n</math> qui n'a pas besoin d'être approximée.</p>
<p>Ainsi sa complexité finale sera <math>\mathcal{O}(n)</math>.</p>
</div>
</div>

= Problématique =

Le calcul du produit de deux entiers de manière naïve a une complexité de <math> \mathcal{O}(n^2)</math>, et celui de deux matrices une complexité de <math> \mathcal{O}(n^3)</math>. Afin de mieux comprendre ce qu'est la complexité algorithmique, nous devrons implémenter des algorithmes ayant le même objectif, mais étant plus efficaces. Ces algorithmes s'avèreront plus complexes mais devrait aboutir à un calcul plus rapide du produit demandé.

Nous séparerons notre wiki en deux grandes parties, la première concernera nos recherche sur [[#I - Produit d'entiers|la multiplication d'entiers]], la deuxième sur [[#II - Produit de matrices|la multiplication de matrices]].

= I - Produit d'entiers =

Notre départ commence avec l'algorithme de multiplication d'entier naïf.
En effet il s'agit de l'algorithme de multiplication le plus connu, et nous l'utiliserons comme référence pour le comparer aux futurs algorithmes plus efficaces.
Intéressons nous à sa complexité.

== 1) Nos implémentations des grands entiers ==

Qui dit produit de grands entiers dit implémentation de grands entiers.

Dans le cadre de nos recherches, nous allons devoir implémenter des algorithmes qui vont manipuler des grands entiers.

Nous avons donc choisi de créer deux représentations différentes de ceux-ci (car nous travaillons sur différents langages de programmation), nous permettant à la fois une implémentation simplifié, mais aussi de nous rapprocher d'une implémentation bas niveau.

=== A) En python ===
En python, l'utilisation des "bytes" m'a grandement servi à comprendre comment les entiers étaient manipulés à bas niveau. En effet, un des objectifs secondaires de nos recherches était de manipuler des entiers directement avec leur formes stockées sur l'ordinateur, et non pas avec des int python.
En effet l'utilisation des int python nous aurait permit de passer les étapes de retenues, de signes... D'autant plus que les bytes permettent de stocker un nombre en base 256, ce qui permet de visualiser plus facilement les grands entiers.

La forme finale de la représentation des grands entiers en python sera donc la suivante :

[ signe , bytes , bytes , (...) , bytes ]

Le signe est représenté par un entier, 1 si le nombre est positif, 0 sinon.
Cette configuration rendra plus simple la gestion des signes.

=== B) En C++ ===

En C++, pour avoir une représentation de grand entiers j'ai du définir ma propre structure pour m'affranchir de la limite de taille imposé par les entiers standards: (int32 ou int64). Pour cela, j'ai une structure qui possède l'équivalent d'un array de byte (ce qui nous permet d'être en base 256 au lieu de la base 10 habituelle), et pour traiter le signe j'utilise un booléen, ainsi en mémoire j'ai une structure de n*Octets + 1 octet en taille.

[ bytes , bytes , (...) , bytes ] [ signe ]

Le booléen prend 1 octet de place mais ne touche pas aux octets qui encode le grand entier.
Cette configuration rendra plus simple la gestion des signes dans le cadre des multiplication.

== 2) La multiplication naïve ==

=== A) Fonctionnement ===
Dans le cas de la multiplication d'entiers, nous allons prendre deux nombres qui n'ont pas nécessairement la même longueur. Soit les nombre a et b, de longueur respective <math>n</math> et <math>m</math>.
<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Multiplication.png|220px]]
<div><b>Multiplication naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Prenons deux nombres de longueur 3 et 2, et cherchons combien d'opérations l'algorithme de multiplication naïve va devoir faire pour nous renvoyer leur produit.</p>
<p>Dans un premier temps, on remarque que l'on va devoir multiplier chaque chiffre du nombre du haut par le chiffre des unités du bas, qui est 6. Cela va représenter <math>n</math> opérations. (6x5, 6x1 et 6x4)</p>
<p>Dans un deuxième temps nous constatons que nous allons devoir faire la même chose avec le chiffre des dizaines du nombre du bas. Cela nous ajoute de nouveau <math>n</math> opérations.</p>
<p>On arrive assez facilement à la conclusion que pour faire notre produit, il va nous falloir faire <math>n</math> fois <math>m</math> opérations.</p>
</div>
</div>

Ainsi, la complexité de la multiplication naïve est <math>\mathcal{O}(n^2)</math>.
Il est en de même avec la multiplication naïve récursive.

=== B) Graphique ===
Montrons maintenant sa courbe sur un graphique :

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Multiplicationnaive.png|500px]]
<div><b>Multiplication naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Les points noirs sont des repères pour que les autres courbes aient une forme cohérente.</p>
<p>Ils sont tous sur l'axe des abscisses.</p>
<p>La courbe rouge représente la complexité de la multiplication naïve.</p>
<p>On remarque que la courbe a un visuel très similaire à la fonction <math>f(x) = x^2</math> </p>
</div>
</div>

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Naif_recursif.png|500px]]
<div><b>Multiplication naïve récursive</b></div>
</div>
<div style="max-width:800px;">
<p>La courbe rouge représente la complexité de la multiplication naïve récursive.</p>
<p>Elle sera utilisé pour comparer les complexités entre algorithmes car, comme tous récursifs, elle a été codé avec les mêmes biais d'implémentation qu'eux.</p>
<p>Théoriquement les deux courbes ci-contre ont la même complexité, mais encore une fois, notre implémentation n'est pas parfaitement optimale et donc ne respecte pas de manière minutieuse le Master Theorem.</p>
</div>
</div>

== 3) La multiplication karatsuba ==

=== A) Fonctionnement ===

L'algorithme de karatsuba est un algorithme récursif de type diviser pour régner.

L'idée générale de l'algorithme est de passer de 4 multiplication à 3. En effet ces opérations étant moins couteuses, il est préférable d'en ajouter si cela permet d'enlever des multiplications.

L'algorithme de multiplication naif récursif utilise la segmentation des facteurs en deux de manière successive.

Soit <math>x</math> et <math>y</math> deux facteurs, nous avons les égalités suivantes :

<div style="font-size: 20px;">
<math>x = a \times B^{n/2} + b</math>
<math>y = c \times B^{n/2} + d</math>
</div>

Avec <math>a</math> et <math>c</math> les premières moitiés des facteurs <math>x</math> et <math>y</math>,
et <math> b </math> et <math>d</math> les dernières moitiés de ces facteurs ainsi que <math>B</math> la base d'écriture du nombre (Nous sommes en base 256 avec les bytes).

Cette présentation des deux facteurs de notre multiplication n'est que la résultante d'un découpage.
Le [[#Master Theorem|Master Theorem]] nous montre que :

<div style="font-size: 20px;">
<math>T(n) = 4T(n/2) + O(n)</math>
</div>

Puisque nous avons après découpage 4 entiers de longueur <math>n/2</math>.

Ainsi, ce découpage ne permet pas de gagner du temps d'après le [[#Master Theorem|Master Theorem]].

Cependant, l'algorithme de Karatsuba réutilise ce principe en le modifiant, ce qui nous permet de baisser la complexité globale de la multiplication dans son entièreté.

Avec l'écriture ci-dessus des nombres <math>x</math> et <math>y</math>, on peut facilement en déduire l'égalité suivante :

<div style="font-size: 20px;">
<math>x \times y = (ac) \times B^n + (ad + bc) \times B^{n/2} + bd</math>
</div>

On remarque 4 multiplications longues à faire dans cette expression. Les multiplications dont <math>B</math> est l'un des facteurs sont très rapides puisqu'il s'agit de la base dans laquelle nous travaillons. De cela en résulte un décalage plutôt qu'un vrai calcul à faire.

Karatsuba développe une partie de cette expression pour pouvoir négocier une multiplication au prix d'additions et soustractions.

En effet, nous savons déjà que :

<div style="font-size: 20px;">
<math>(a + b)(c + d) = ac + ad + bc + bd</math>
</div>

En manipulant l'égalité nous obtenons :

<div style="font-size: 20px;">
<math>ad + bc = (a + b)(c + d) - ac - bd</math>
</div>

ac et bd ayant déjà été calculé précédemment, il nous reste uniquement la multiplication <math>(a + b)(c + d)</math>.

Nous venons ainsi de calculer <math>ad + bc</math> en seulement une multiplication. C'est la que repose le gain de temps de la méthode Karatsuba par rapport à la multiplication naïve.

En effet, l'algorithme n'effectuera alors plus que 3 multiplications :
<div style="font-size: 20px;">
<math>ac</math>
<math>bd</math>
<math>(a + b)(c + d)</math>
</div>

La relation de récurrence devient donc :
<div style="font-size: 20px;">
<math>T(n)=3T(n/2)+O(n)</math>
</div>

Et le Master Theorem nous dit que :
<div style="font-size: 20px;">
<math>T(n)\in O(n^{\log_2(3)})</math>
</div>

Or <math>\log_2(3)\approx 1.585</math>, donc la complexité de l'algorithme de Karatsuba est de <math> \mathcal{O}(n^{1.585})</math>. Ce qui est bien plus efficace que la multiplication classique, surtout lorsque les facteurs deviennent très grands.

=== B) Graphique ===
<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Karatsuba.png|500px]]
<div><b>Karatsuba</b></div>
</div>
<div style="max-width:800px;">
<p>Sur le graphique ci-contre nous avons utilisé la courbe de la multiplication naïve récursive (rouge) à titre de comparaison.</p>
<p>On remarque graphiquement que Karatsuba (jaune) prend moins de temps à chaque calcul de produit.</p>
<p>On en déduit donc expérimentalement que Karatsuba à une meilleure complexité que la multiplication naïve.</p>
<p>Ainsi nous vérifions donc ce que le Master Theorem prouve, c'est à dire que la complexité de karatsuba est de <math> \mathcal{O}(n^{1.585})</math> </p>
</div>
</div>

== 4) La multiplication toom-cook-3 ==

=== A) Fonctionnement ===

L'objectif est de diviser les grands entiers X et Y en trois blocs de taille égale k.
On les traite alors comme des polynômes de degré 2:

<math>P(z) = X_2 \cdot z^2 + X_1 \cdot z + X_0</math>
<math>Q(z) = Y_2 \cdot z^2 + Y_1 \cdot z + Y_0</math>

On choisit 5 points distincts pour évaluer nos polynômes.
Ce choix de 5 points est crucial car le produit de deux polynômes de degré 2 est un polynôme de degré 4, qui nécessite 5 points pour être défini.
Les points standards sont :

P(0) = X0
P(1) = X0 + X1 + X2
P(-1) = X0 - X1 + X2
P(2) = X0 + 2*X1 + 4*X2
P(inf) = X2

(On procède de manière similaire pour Q.)

Ensuite nous multiplions récursivement chaque points de P et de Q ensemble.
On effectue ainsi 5 multiplications de nombres plus petits au lieu des 9 multiplications requises par la méthode classique.

Après, nous effectuons une interpolation, cela permet de retrouver les 5 coefficients (w_0, w_1, w_2, w_3, w_4) du polynôme produit R(z) à partir des valeurs évaluées calculées précédemment.
On résout un système d'équations linéaires : <math> R(z) = w_4 z^4 + w_3 z^3 + w_2 z^2 + w_1 z + w_0 </math>
Finalement nous pouvons recomposer notre grand entier en positionnant les coefficients w_i aux bons rangs (en les décalant) et à gérer les retenues lors de l'addition finale:
<math>Résultat = w_4 B^{4k} + w_3 B^{3k} + w_2 B^{2k} + w_1 B^k + w_0</math>

=== B) Graphique ===

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Toomcook.png|500px]]
<div><b>Karatsuba</b></div>
</div>
<div style="max-width:800px;">
<p>on a reprit multi récursive (rouge)</p>
<p>on voit que Toom (vert) en dessous de karatsuba (jaune) en dessous de multi classique (rouge)</p>
<p>meilleur complexité</p>
</div>
</div>

== 5) La transformée de Fourier rapide ==

=== A) Fonctionnement ===

La transformation de Fourier rapide étant plus complexe que les autres algorithmes, nous allons essayer d'expliquer son fonctionnement malgré ne pas avoir réussi à l'implémenter.

Il faut comprendre que cet algorithme va considérer les facteurs comme des polynômes.

D'après le théorème de l'unisolvance, il n'existe qu'un seul polynôme de degré inférieur ou égal à <math> n </math> défini par <math>n + 1</math> points distincts. Cela implique non seulement que nous pouvons représenter chaque entier par un polynôme, mais également que si nous pouvons retrouver <math>n + m + 1</math> points (avec <math>n</math> et <math>m</math> la longueur des facteurs) du polynômes issue du produit entre deux facteurs, nous pourrons le retrouver.

Soit un entier quelconque, de forme :

<math>a_n a_{n-1} (...) a_1 a_0</math>

Avec <math>a_i</math>, un chiffre composant le nombre en base 10, qui vaut en réalité dans le nombre : <math>a_i \times 10^i</math>. On peut ainsi l'écrire sous la forme :

<math> P(x) = a_0 + a_1x + a_2x^2 + \dots + a_{n-1}x^{n-1} + a_nx^n </math>

Avec <math>x = 10</math> car nous sommes en base 10, nous obtenons :

<math>P(10) = a_0 + a_1 \times 10 + \dots + a_{n-1}10^{n-1} + a_n10^n </math>

Nous venons ainsi d'écrire notre nombre sous la forme d'un polynôme unique. Pour nous permettre d'évaluer en un nombre suffisant de points, nous allons devoir ajouter des 0 pour la récursion. Il nous faudra ajouter assez de 0 pour atteindre la prochaine puissance de 2 qui sera supérieure ou égale à <math>2n + 1</math>. L'ajout de 0 ne change pas le nombre car <math>0 \times x^n</math> n'ajoute pas de coefficient.

Cet algorithme est récursif et va segmenter en deux parties nos polynômes à chaque récursion. D'un coté les indice pairs et d'un coté les impaires.

Ainsi prenons les nombres 1234 et 5678, ces nombres sont respectivement représentés par les polynômes <math> P(x) = 4 + 3x + 2x^2 + x^3 </math> et <math> P(x) = 8 + 7x + 6x^2 + 5^3 </math>. Ce sont des polynômes de degré 3, ainsi leur produit donnera lieu à un polynôme de degré 6. Il nous faudra donc au minimum 7 points d'évaluation pour retrouve ce produit. De ce fait, en les représentant de la manière suivante :

<math>[4, 3, 2, 1, 0, 0, 0, 0]</math>
<math>[8, 7, 6, 5, 0, 0, 0, 0]</math>

Nous aurons assez de récursions possible pour les évaluer en un nombre suffisant de points différents car nous auront 3 récursions à faire pour atteindre notre cas de base. A chaque récursion, nous allons diviser nos polynômes en deux parties ce qui nous fait 8 feuilles à la dernière récursion.

En effet à chaque étape de la récursion nous allons séparer nos polynômes en deux tel que :

<math>P(x)=P_{\text{pair}}(x^2) + x \cdot P_{\text{impair}}(x^2)</math>

Durant les récursions, nous segmentons les polynômes mais ne les évaluons pas. C'est à la remonté des récursions que nous allons réellement évaluer nos polynômes. Lorsque l'on atteint notre cas de base, c'est à dire des polynômes de degré 0, nous remarquons qu'ils sont constants, nous n'avons donc pas besoin de les évaluer. En effet, peut importe le point en lequel nous voudrons l'évaluer, le polynôme renverra la constante. Nous la renvoyons donc seule.
Ensuite commence la remontée des récursions. A l'étape 1 de notre remontée nous allons reformer le polynôme précédemment séparé pour obtenir un polynôme de degré 1. Puis, nous évaluons ce polynôme avec les racines seconde de l'unité. Nous faisons à nouveau remonté les évaluations et recombinons à nouveau le polynôme qui sera ainsi de degré 2.
Nous l'évaluons maintenant avec les racines 4eme de l'unité. A chaque évaluation, nous réutilisons les résultats précédents, cela nous est permit par les racines de l'unité qui ont une structure récursive exploitable.

Finalement, nous arrivons à la fin de notre FFT, avec une représentation fréquentielle de la forme :

<math> [P(W_0), P(W_1), (...), P(W_n-1), P(W_n)] </math>

Cette représentation fréquentielle n'est autre que les évaluations du polynôme P aux racines nièmes de l'unité. Nous avons donc maintenant au minimum <math>2n+1</math> évaluations des polynômes facteurs. Il nous faut maintenant trouver les évaluations du produit final, c'est à dire les évaluations concernant le polynôme qui sera issue de la multiplication. On pourra ainsi le retrouver.

Soit <math>C</math> un polynome tel que <math> C = A \times B </math>, alors on a :

<math> C(x) = A(x) \times B(x) </math>

Ainsi on en déduit que <math> C(W_n^k) = A(W_n^k) \times B(W_n^k) </math>

On comprend donc que <math>FFT(C) = FFT(A) \times FFT(B)</math>

Il faut préciser que l'on fait le produit de FFT(A) et FFT(B) terme à terme, soit évaluation par évaluation.

Une fois en possession de <math>FFT(C)</math>, qui n'est autre que l'évaluation de notre polynôme final en un nombre suffisant de points pour le retrouver, nous pouvons faire l'<math>IFFT(FFT(C))</math>, qui va nous permettre de retrouver les coefficients de notre polynôme en faisant l'exacte inverse de la FFT.

Une fois les coefficients retrouvés, il nous suffit de gérer les retenues, et nous retrouvons un entier de la forme : <math>a_0 a_1 (...) a_{n-1} a_n</math>

=== B) Graphique ===

Intéressons nous maintenant à la complexité de l'algorithme utilisant la transformée de Fourier rapide. On sait que l'algorithme passe par 5 étapes importantes :

<ul>
<li>Etape 1 : Ecrire les deux facteurs sous la forme de polynômes</li>
<li>Etape 2 : Effectuer la <math>FFT</math> des deux polynômes</li>
<li>Etape 3 : Faire le produit terme à terme des <math>FFT</math> obtenues</li>
<li>Etape 4 : Faire l'<math>IFFT</math> du produit</li>
<li>Etape 5 : Gérer les retenues et écrire le nombre qui en découle</li>
</ul>

Or, parmi toutes ces étapes, certaines sont négligeable comme l'étape 1 et 5.

Pour connaitre la complexité de l'algorithme, additionnons les complexités des étapes restantes :

Une <math>FFT</math> a une complexité de <math>\mathcal{O}(n\times logn)</math> car elle fait <math>n</math> évaluation sur <math> log(n)</math> récursions. Dans le cadre de notre algorithme, nous devons faire la <math>FFT</math> de nos deux facteurs. Soit <math>2\times \mathcal{O}(n\times logn)</math>.

Pour le produit terme à terme, nous faisons naturellement <math>n</math> opérations.

Pour finir, l'<math>IFFT</math> a la même complexité que la <math>FFT</math>. Dans le cadre de notre algorithme nous l'emploierons qu'une seule fois, ce qui fait une complexité de <math>\mathcal{O}(n\times logn)</math>.

Après addition de toutes ces complexités, nous obtenons la complexité réelle de <math>3\mathcal{O}(n\times logn) + \mathcal{O}(n)</math>.

D'après le Master Theorem, nous avons donc <math> f(n) = 3(n\times logn)+n </math>, cherchons <math>f(n)\in\mathcal{O}(g(n))</math> :

Nous pouvons ignorer les expressions linéaires ainsi que les constantes multiplicatrices, nous obtenons donc <math>\mathcal{O}(g(n)) = \mathcal{O}(n \times log n)</math>.

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:30px; text-align:center;">
[[Fichier:FFT_image.webp|500px]]
<div><b>Graphiques des complexités</b></div>
</div>
<div style="max-width:800px;">
<p>Ce graphique ci-contre ne provient pas du fruit de nos recherches personnelles mais </p>
<p>On comprend ainsi que certaines complexités ne sont pas raisonnable dans la cadre de la multiplication de grands entiers.</p>
<p>C'est pourquoi l'étude de ces algorithmes s'avère nécessaire.</p>
</div>
</div>

= II - Produit de matrices =

== 1.1) naïve ==

La multiplication naïve de matrice requiert d'avoir des tailles de lignes/colonne semblable, ensuite pour chaque membre de la matrice résultat, on doit multiplier les composantes ligne de la première matrice par les composantes colonne de la deuxième et le tout sommé.

On en déduit la formule suivante:
<math>C_{i,j} = \sum_{k=1}^{n} (A_{i,k} \times B_{k,j})</math>

Et visuellement:

[[Fichier:Matricenaive.jpeg]]

On a donc un algorithme d'ordre de complexité <math>\mathcal{O}(g(n))</math>

== 1.2) naïve récursive ==

Dans un premier temps on doit découper nos deux matrices en quatres sous matrices de plus petite taille.
<math>A = \begin{pmatrix} A_{11} & A_{12} \ A_{21} & A_{22} \end{pmatrix}</math>
<math>B = \begin{pmatrix} B_{11} & B_{12} \ B_{21} & B_{22} \end{pmatrix}</math>

Ensuite on vient calculer la matrice résultat.
<math>C_{11} = (A_{11} \times B_{11}) + (A_{12} \times B_{21})</math>
<math>C_{12} = (A_{11} \times B_{12}) + (A_{12} \times B_{22})</math>
<math>C_{21} = (A_{21} \times B_{11}) + (A_{22} \times B_{21})</math>
<math>C_{22} = (A_{21} \times B_{12}) + (A_{22} \times B_{22})</math>

Le côté récursif est utile que pour les matrices de tailles <= 32 (32 valeurs stockées dedans),
si on est au dessus de cette taille alors on divisera à nouveau nos matrices en quatres.
On aura 8 multiplications mais de plus petite taille au final.

== 2) strassen ==

=== A) Fonctionnement ===

Strassen consiste à définir 7 produits intermédiaires qui, par des jeux de sommes et de différences, permettent de reconstruire les quadrants de la matrice résultante. On passe ainsi d'une complexité de O(n^3) à environ O(n^2.81)

=== B) Graphique ===

On voit bien la différence de complexité sur la multiplication de grande matrice entre l'approche naïve et l'approche récursive qui est beaucoup plus rapide.

[[Fichier:Analyse matrices.png]]

= Conclusion =

L'étude de ces algorithmes de multiplication nous a clairement montré l'évolution de la complexité algorithmique permettant de gagner en efficacité lorsque la taille des données augmente.

La multiplication classiqe, en <math>\mathcal{O}(n^2)</math>, résulte d'une approche naïve qui devient rapidement inefficace pour les grands entiers ou les grandes matrices. L'algorithme de Karatsuba nous montre qu'organiser de manière intelligente ses calculs algébrique permet parfois de gagner beaucoup de multiplications, et donc de temps. Nous avons ainsi réussi à passer d'une complexité de <math>\mathcal{O}(n^2)</math> à <math>\mathcal{O}(n^{log_2(3)})</math>, soit environ <math>\mathcal{O}(n^{1/585})</math>.

Des méthodes encore plus avancées comme utilise l'algorithme de Toom-Cook-3 continue dans cette idées de divisions d'entiers en blocs plus petits, tandis que la transformée de Fourier rapide change complètement de point de vue. En effet la FFT n'utilise pas la représentation classique des entiers mais fait appel à une vision polynomiale, ce qui transforme la convolution classique en multiplication terme à terme, ce qui lui permet d'atteindre une complexité de <math>\mathcal{O}(n \times log n)</math>.

Dans le cas des matrices, les mêmes logiques apparaissent comme par exemple avec l'algorithme de Strassen qui se rapproche très fortement de Karatsuba en combinant de manière astucieuse les parties d'entiers qui avaient été précédemment découpée.

On remarque néanmoins que la majorité des algorithmes efficaces s'orientent vers une approche récursive et non itérative. Néanmoins, nous avons pu trouver certaines de ces implémentations (comme par exemple la FFT) en itérative.

Avec ces recherches, nous comprenons que la réorganisations des calculs algébriques peuvent aider à gagner en complexité mais que pour faire de réels progrès, il nous faudra surement changer notre point de vue une nouvelle fois, et aborder le problème sous un angle nouveau comme le font dors et déjà les algorithmes les plus performants.

= Mentions =

Le premier gif est le résultat du travail de 'Walké', licence ci-contre : https://fr.wikipedia.org/wiki/Fichier:Addition.gif

= Sources =

Pour karatsuba :
<ul>
<li> https://www.youtube.com/watch?v=PZ2gdWdKHAA </li>
</ul>

Pour mieux comprendre la FFT, nous avons utilisé plusieurs sources d'informations :
<ul>
<li> https://www.youtube.com/watch?v=h7apO7q16V0&list=WL&index=1&t=886s </li>
<li> https://fr.wikipedia.org/wiki/Interpolation_polynomiale </li>
</ul>

Algorithmes de multiplications d'entiers et de matrices

2026-05-11T18:53:29Z

Mangala : /* Conclusion */

= Introduction =

Depuis l'apparition des ordinateurs modernes, une quantité faramineuse de calculs a dû être effectuée. Les progressions technologiques nous poussent à envisager la puissance de calcul comme une ressource qu'il faut optimiser dans les moindres détails. C'est ainsi que l'optimisation des algorithmes de calcul est devenue cruciale, surtout lorsqu'il nous faut effectuer des opérations sur de très grands entiers par exemple.

= Objectif =

L'objectif majeur de ce projet est de comprendre de manière plus approfondie ce qu'est la '''complexité algorithmique'''.
Pour atteindre cet objectif, nous implémenterons plusieurs algorithmes de multiplication qui auront pour but de calculer le produit de grands entiers ou de matrices.

= Point important : complexité =

=== Définition ===
La complexité d'un algorithme est la quantité des ressources qu'il utilise en fonction de la taille des entrées qu'on lui demande de traiter. On peut par exemple se concentrer sur le temps qu'un algorithme prend pour renvoyer un résultat ou sur la mémoire dont il a besoin. Dans le cadre de notre projet, nous nous attarderons plus particulièrement sur la quantité de calcul effectuée en fonction de la taille des entrées, ce qui est par ailleurs étroitement liée à la notion de temps. De manière générale, plus un algorithme doit faire de calcul, plus il est lent. (Attention, toutes les opérations arithmétiques de base ne se valent pas)

De manière plus familière, on dira que la complexité d'un algorithme pourrait s'apparenter à son comportement lorsqu'il doit traiter des données plus ou moins grandes.
Chaque algorithme a une complexité, et on l'exprime par une fonction qui adopte un comportement similaire au nombre de calculs nécessaires en fonction de la taille des entrées.

=== Notation ===
La complexité réelle d'un algorithme peut être décrite par une fonction <math> f(n) </math> représentant le nombre d'opérations effectuées en fonction de la taille <math>n</math> des données d'entrée.

Cependant, afin de simplifier l'étude de cette croissance, on utilise généralement une borne asymptotique notée <math>\mathcal{O}(g(n))</math>, où <math>g(n)</math> est une fonction ayant le même ordre de grandeur que <math>f(n)</math> lorsque <math>n</math> devient grand.

On dit alors que :

<math>
f(n)\in\mathcal{O}(g(n))
</math>

si et seulement s'il existe une constante <math>C>0</math> et un entier <math>n_0</math> tels que :

<math>
\forall n\ge n_0,\ f(n)\le Cg(n)
</math>

Cette notation <math>\mathcal{O}(g(n))</math> permettra de comparer beaucoup plus facilement les algorithmes entre eux.

=== Master Theorem ===

Afin de déterminer la complexité de certains algorithmes récursifs, nous utiliserons le "Master Theorem".

Ce théorème permet d'obtenir directement l'ordre de grandeur de nombreuses relations de récurrence apparaissant dans l'analyse d'algorithmes de type « diviser pour régner », comme l'algorithme de Karatsuba ou celui de Strassen.

La démonstration complète de ce théorème dépasse le cadre de notre projet et nécessite des connaissances mathématiques plus avancées. Nous l'utiliserons donc principalement comme un outil nous permettant de déterminer efficacement la complexité asymptotique des algorithmes étudiés.

=== Graphiques ===

Les complexités étant des fonctions, nous pouvons les représenter par un graphique qui affichera le temps d'exécution (ou nombre d'opérations) en fonction de la taille des entrées.

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:30px; text-align:center;">
[[Fichier:complexite.webp|500px]]
<div><b>Graphiques des complexités</b></div>
</div>
<div style="max-width:800px;">
<p>Ce graphique ci-contre compare les complexités en fonction de la taille des d'entrées.</p>
<p>On comprend ainsi que certaines complexités ne sont pas raisonnable dans la cadre de la multiplication de grands entiers.</p>
<p>C'est pourquoi l'étude de ces algorithmes s'avère nécessaire.</p>
</div>
</div>

=== Exemple ===
L'algorithme naïf d'addition que nous avons tous appris à l'école a une complexité de <math>\mathcal{O}(n)</math>.
Soit n la taille des nombres en entrée, l'algorithme doit faire environ n addition pour arriver au résultat demandé.

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Addition.gif|220px]]
<div><b>Addition naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Comme le montre l'exemple ci-contre, 786 et 467 font 3 chiffres de long donc n sera de 3.</p>
<p>Il nous faudra 3 opérations pour additionner ces entiers.</p>
<p>C'est ainsi qu'avec une taille d'entrée n, l'algorithme de l'addition naïve va devoir faire n opérations.</p>
<p>Cet algorithme a donc une complexité <math>f(n) = n</math> qui n'a pas besoin d'être approximée.</p>
<p>Ainsi sa complexité finale sera <math>\mathcal{O}(n)</math>.</p>
</div>
</div>

= Problématique =

Le calcul du produit de deux entiers de manière naïve a une complexité de <math> \mathcal{O}(n^2)</math>, et celui de deux matrices une complexité de <math> \mathcal{O}(n^3)</math>. Afin de mieux comprendre ce qu'est la complexité algorithmique, nous devrons implémenter des algorithmes ayant le même objectif, mais étant plus efficaces. Ces algorithmes s'avèreront plus complexes mais devrait aboutir à un calcul plus rapide du produit demandé.

Nous séparerons notre wiki en deux grandes parties, la première concernera nos recherche sur [[#I - Produit d'entiers|la multiplication d'entiers]], la deuxième sur [[#II - Produit de matrices|la multiplication de matrices]].

= I - Produit d'entiers =

Notre départ commence avec l'algorithme de multiplication d'entier naïf.
En effet il s'agit de l'algorithme de multiplication le plus connu, et nous l'utiliserons comme référence pour le comparer aux futurs algorithmes plus efficaces.
Intéressons nous à sa complexité.

== 1) Nos implémentations des grands entiers ==

Qui dit produit de grands entiers dit implémentation de grands entiers.

Dans le cadre de nos recherches, nous allons devoir implémenter des algorithmes qui vont manipuler des grands entiers.

Nous avons donc choisi de créer deux représentations différentes de ceux-ci (car nous travaillons sur différents langages de programmation), nous permettant à la fois une implémentation simplifié, mais aussi de nous rapprocher d'une implémentation bas niveau.

=== A) En python ===
En python, l'utilisation des "bytes" m'a grandement servi à comprendre comment les entiers étaient manipulés à bas niveau. En effet, un des objectifs secondaires de nos recherches était de manipuler des entiers directement avec leur formes stockées sur l'ordinateur, et non pas avec des int python.
En effet l'utilisation des int python nous aurait permit de passer les étapes de retenues, de signes... D'autant plus que les bytes permettent de stocker un nombre en base 256, ce qui permet de visualiser plus facilement les grands entiers.

La forme finale de la représentation des grands entiers en python sera donc la suivante :

[ signe , bytes , bytes , (...) , bytes ]

Le signe est représenté par un entier, 1 si le nombre est positif, 0 sinon.
Cette configuration rendra plus simple la gestion des signes.

=== B) En C++ ===

En C++, pour avoir une représentation de grand entiers j'ai du définir ma propre structure pour m'affranchir de la limite de taille imposé par les entiers standards: (int32 ou int64). Pour cela, j'ai une structure qui possède l'équivalent d'un array de byte (ce qui nous permet d'être en base 256 au lieu de la base 10 habituelle), et pour traiter le signe j'utilise un booléen, ainsi en mémoire j'ai une structure de n*Octets + 1 octet en taille.

[ bytes , bytes , (...) , bytes ] [ signe ]

Le booléen prend 1 octet de place mais ne touche pas aux octets qui encode le grand entier.
Cette configuration rendra plus simple la gestion des signes dans le cadre des multiplication.

== 2) La multiplication naïve ==

=== A) Fonctionnement ===
Dans le cas de la multiplication d'entiers, nous allons prendre deux nombres qui n'ont pas nécessairement la même longueur. Soit les nombre a et b, de longueur respective <math>n</math> et <math>m</math>.
<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Multiplication.png|220px]]
<div><b>Multiplication naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Prenons deux nombres de longueur 3 et 2, et cherchons combien d'opérations l'algorithme de multiplication naïve va devoir faire pour nous renvoyer leur produit.</p>
<p>Dans un premier temps, on remarque que l'on va devoir multiplier chaque chiffre du nombre du haut par le chiffre des unités du bas, qui est 6. Cela va représenter <math>n</math> opérations. (6x5, 6x1 et 6x4)</p>
<p>Dans un deuxième temps nous constatons que nous allons devoir faire la même chose avec le chiffre des dizaines du nombre du bas. Cela nous ajoute de nouveau <math>n</math> opérations.</p>
<p>On arrive assez facilement à la conclusion que pour faire notre produit, il va nous falloir faire <math>n</math> fois <math>m</math> opérations.</p>
</div>
</div>

Ainsi, la complexité de la multiplication naïve est <math>\mathcal{O}(n^2)</math>.
Il est en de même avec la multiplication naïve récursive.

=== B) Graphique ===
Montrons maintenant sa courbe sur un graphique :

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Multiplicationnaive.png|500px]]
<div><b>Multiplication naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Les points noirs sont des repères pour que les autres courbes aient une forme cohérente.</p>
<p>Ils sont tous sur l'axe des abscisses.</p>
<p>La courbe rouge représente la complexité de la multiplication naïve.</p>
<p>On remarque que la courbe a un visuel très similaire à la fonction <math>f(x) = x^2</math> </p>
</div>
</div>

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Naif_recursif.png|500px]]
<div><b>Multiplication naïve récursive</b></div>
</div>
<div style="max-width:800px;">
<p>La courbe rouge représente la complexité de la multiplication naïve récursive.</p>
<p>Elle sera utilisé pour comparer les complexités entre algorithmes car, comme tous récursifs, elle a été codé avec les mêmes biais d'implémentation qu'eux.</p>
<p>Théoriquement les deux courbes ci-contre ont la même complexité, mais encore une fois, notre implémentation n'est pas parfaitement optimale et donc ne respecte pas de manière minutieuse le Master Theorem.</p>
</div>
</div>

== 3) La multiplication karatsuba ==

=== A) Fonctionnement ===

L'algorithme de karatsuba est un algorithme récursif de type diviser pour régner.

L'idée générale de l'algorithme est de passer de 4 multiplication à 3. En effet ces opérations étant moins couteuses, il est préférable d'en ajouter si cela permet d'enlever des multiplications.

L'algorithme de multiplication naif récursif utilise la segmentation des facteurs en deux de manière successive.

Soit <math>x</math> et <math>y</math> deux facteurs, nous avons les égalités suivantes :

<div style="font-size: 20px;">
<math>x = a \times B^{n/2} + b</math>
<math>y = c \times B^{n/2} + d</math>
</div>

Avec <math>a</math> et <math>c</math> les premières moitiés des facteurs <math>x</math> et <math>y</math>,
et <math> b </math> et <math>d</math> les dernières moitiés de ces facteurs ainsi que <math>B</math> la base d'écriture du nombre (Nous sommes en base 256 avec les bytes).

Cette présentation des deux facteurs de notre multiplication n'est que la résultante d'un découpage.
Le [[#Master Theorem|Master Theorem]] nous montre que :

<div style="font-size: 20px;">
<math>T(n) = 4T(n/2) + O(n)</math>
</div>

Puisque nous avons après découpage 4 entiers de longueur <math>n/2</math>.

Ainsi, ce découpage ne permet pas de gagner du temps d'après le [[#Master Theorem|Master Theorem]].

Cependant, l'algorithme de Karatsuba réutilise ce principe en le modifiant, ce qui nous permet de baisser la complexité globale de la multiplication dans son entièreté.

Avec l'écriture ci-dessus des nombres <math>x</math> et <math>y</math>, on peut facilement en déduire l'égalité suivante :

<div style="font-size: 20px;">
<math>x \times y = (ac) \times B^n + (ad + bc) \times B^{n/2} + bd</math>
</div>

On remarque 4 multiplications longues à faire dans cette expression. Les multiplications dont <math>B</math> est l'un des facteurs sont très rapides puisqu'il s'agit de la base dans laquelle nous travaillons. De cela en résulte un décalage plutôt qu'un vrai calcul à faire.

Karatsuba développe une partie de cette expression pour pouvoir négocier une multiplication au prix d'additions et soustractions.

En effet, nous savons déjà que :

<div style="font-size: 20px;">
<math>(a + b)(c + d) = ac + ad + bc + bd</math>
</div>

En manipulant l'égalité nous obtenons :

<div style="font-size: 20px;">
<math>ad + bc = (a + b)(c + d) - ac - bd</math>
</div>

ac et bd ayant déjà été calculé précédemment, il nous reste uniquement la multiplication <math>(a + b)(c + d)</math>.

Nous venons ainsi de calculer <math>ad + bc</math> en seulement une multiplication. C'est la que repose le gain de temps de la méthode Karatsuba par rapport à la multiplication naïve.

En effet, l'algorithme n'effectuera alors plus que 3 multiplications :
<div style="font-size: 20px;">
<math>ac</math>
<math>bd</math>
<math>(a + b)(c + d)</math>
</div>

La relation de récurrence devient donc :
<div style="font-size: 20px;">
<math>T(n)=3T(n/2)+O(n)</math>
</div>

Et le Master Theorem nous dit que :
<div style="font-size: 20px;">
<math>T(n)\in O(n^{\log_2(3)})</math>
</div>

Or <math>\log_2(3)\approx 1.585</math>, donc la complexité de l'algorithme de Karatsuba est de <math> \mathcal{O}(n^{1.585})</math>. Ce qui est bien plus efficace que la multiplication classique, surtout lorsque les facteurs deviennent très grands.

=== B) Graphique ===
<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Karatsuba.png|500px]]
<div><b>Karatsuba</b></div>
</div>
<div style="max-width:800px;">
<p>Sur le graphique ci-contre nous avons utilisé la courbe de la multiplication naïve récursive (rouge) à titre de comparaison.</p>
<p>On remarque graphiquement que Karatsuba (jaune) prend moins de temps à chaque calcul de produit.</p>
<p>On en déduit donc expérimentalement que Karatsuba à une meilleure complexité que la multiplication naïve.</p>
<p>Ainsi nous vérifions donc ce que le Master Theorem prouve, c'est à dire que la complexité de karatsuba est de <math> \mathcal{O}(n^{1.585})</math> </p>
</div>
</div>

== 4) La multiplication toom-cook-3 ==

=== A) Fonctionnement ===

L'objectif est de diviser les grands entiers X et Y en trois blocs de taille égale k.
On les traite alors comme des polynômes de degré 2:

<math>P(z) = X_2 \cdot z^2 + X_1 \cdot z + X_0</math>
<math>Q(z) = Y_2 \cdot z^2 + Y_1 \cdot z + Y_0</math>

On choisit 5 points distincts pour évaluer nos polynômes.
Ce choix de 5 points est crucial car le produit de deux polynômes de degré 2 est un polynôme de degré 4, qui nécessite 5 points pour être défini.
Les points standards sont :

P(0) = X0
P(1) = X0 + X1 + X2
P(-1) = X0 - X1 + X2
P(2) = X0 + 2*X1 + 4*X2
P(inf) = X2

(On procède de manière similaire pour Q.)

Ensuite nous multiplions récursivement chaque points de P et de Q ensemble.
On effectue ainsi 5 multiplications de nombres plus petits au lieu des 9 multiplications requises par la méthode classique.

Après, nous effectuons une interpolation, cela permet de retrouver les 5 coefficients (w_0, w_1, w_2, w_3, w_4) du polynôme produit R(z) à partir des valeurs évaluées calculées précédemment.
On résout un système d'équations linéaires : <math> R(z) = w_4 z^4 + w_3 z^3 + w_2 z^2 + w_1 z + w_0 </math>
Finalement nous pouvons recomposer notre grand entier en positionnant les coefficients w_i aux bons rangs (en les décalant) et à gérer les retenues lors de l'addition finale:
<math>Résultat = w_4 B^{4k} + w_3 B^{3k} + w_2 B^{2k} + w_1 B^k + w_0</math>

=== B) Graphique ===

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Toomcook.png|500px]]
<div><b>Karatsuba</b></div>
</div>
<div style="max-width:800px;">
<p>on a reprit multi récursive (rouge)</p>
<p>on voit que Toom (vert) en dessous de karatsuba (jaune) en dessous de multi classique (rouge)</p>
<p>meilleur complexité</p>
</div>
</div>

== 5) La transformée de Fourier rapide ==

=== A) Fonctionnement ===

La transformation de Fourier rapide étant plus complexe que les autres algorithmes, nous allons essayer d'expliquer son fonctionnement malgré ne pas avoir réussi à l'implémenter.

Il faut comprendre que cet algorithme va considérer les facteurs comme des polynômes.

D'après le théorème de l'unisolvance, il n'existe qu'un seul polynôme de degré inférieur ou égal à <math> n </math> défini par <math>n + 1</math> points distincts. Cela implique non seulement que nous pouvons représenter chaque entier par un polynôme, mais également que si nous pouvons retrouver <math>n + m + 1</math> points (avec <math>n</math> et <math>m</math> la longueur des facteurs) du polynômes issue du produit entre deux facteurs, nous pourrons le retrouver.

Soit un entier quelconque, de forme :

<math>a_n a_{n-1} (...) a_1 a_0</math>

Avec <math>a_i</math>, un chiffre composant le nombre en base 10, qui vaut en réalité dans le nombre : <math>a_i \times 10^i</math>. On peut ainsi l'écrire sous la forme :

<math> P(x) = a_0 + a_1x + a_2x^2 + \dots + a_{n-1}x^{n-1} + a_nx^n </math>

Avec <math>x = 10</math> car nous sommes en base 10, nous obtenons :

<math>P(10) = a_0 + a_1 \times 10 + \dots + a_{n-1}10^{n-1} + a_n10^n </math>

Nous venons ainsi d'écrire notre nombre sous la forme d'un polynôme unique. Pour nous permettre d'évaluer en un nombre suffisant de points, nous allons devoir ajouter des 0 pour la récursion. Il nous faudra ajouter assez de 0 pour atteindre la prochaine puissance de 2 qui sera supérieure ou égale à <math>2n + 1</math>. L'ajout de 0 ne change pas le nombre car <math>0 \times x^n</math> n'ajoute pas de coefficient.

Cet algorithme est récursif et va segmenter en deux parties nos polynômes à chaque récursion. D'un coté les indice pairs et d'un coté les impaires.

Ainsi prenons les nombres 1234 et 5678, ces nombres sont respectivement représentés par les polynômes <math> P(x) = 4 + 3x + 2x^2 + x^3 </math> et <math> P(x) = 8 + 7x + 6x^2 + 5^3 </math>. Ce sont des polynômes de degré 3, ainsi leur produit donnera lieu à un polynôme de degré 6. Il nous faudra donc au minimum 7 points d'évaluation pour retrouve ce produit. De ce fait, en les représentant de la manière suivante :

<math>[4, 3, 2, 1, 0, 0, 0, 0]</math>
<math>[8, 7, 6, 5, 0, 0, 0, 0]</math>

Nous aurons assez de récursions possible pour les évaluer en un nombre suffisant de points différents car nous auront 3 récursions à faire pour atteindre notre cas de base. A chaque récursion, nous allons diviser nos polynômes en deux parties ce qui nous fait 8 feuilles à la dernière récursion.

En effet à chaque étape de la récursion nous allons séparer nos polynômes en deux tel que :

<math>P(x)=P_{\text{pair}}(x^2) + x \cdot P_{\text{impair}}(x^2)</math>

Durant les récursions, nous segmentons les polynômes mais ne les évaluons pas. C'est à la remonté des récursions que nous allons réellement évaluer nos polynômes. Lorsque l'on atteint notre cas de base, c'est à dire des polynômes de degré 0, nous remarquons qu'ils sont constants, nous n'avons donc pas besoin de les évaluer. En effet, peut importe le point en lequel nous voudrons l'évaluer, le polynôme renverra la constante. Nous la renvoyons donc seule.
Ensuite commence la remontée des récursions. A l'étape 1 de notre remontée nous allons reformer le polynôme précédemment séparé pour obtenir un polynôme de degré 1. Puis, nous évaluons ce polynôme avec les racines seconde de l'unité. Nous faisons à nouveau remonté les évaluations et recombinons à nouveau le polynôme qui sera ainsi de degré 2.
Nous l'évaluons maintenant avec les racines 4eme de l'unité. A chaque évaluation, nous réutilisons les résultats précédents, cela nous est permit par les racines de l'unité qui ont une structure récursive exploitable.

Finalement, nous arrivons à la fin de notre FFT, avec une représentation fréquentielle de la forme :

<math> [P(W_0), P(W_1), (...), P(W_n-1), P(W_n)] </math>

Cette représentation fréquentielle n'est autre que les évaluations du polynôme P aux racines nièmes de l'unité. Nous avons donc maintenant au minimum <math>2n+1</math> évaluations des polynômes facteurs. Il nous faut maintenant trouver les évaluations du produit final, c'est à dire les évaluations concernant le polynôme qui sera issue de la multiplication. On pourra ainsi le retrouver.

Soit <math>C</math> un polynome tel que <math> C = A \times B </math>, alors on a :

<math> C(x) = A(x) \times B(x) </math>

Ainsi on en déduit que <math> C(W_n^k) = A(W_n^k) \times B(W_n^k) </math>

On comprend donc que <math>FFT(C) = FFT(A) \times FFT(B)</math>

Il faut préciser que l'on fait le produit de FFT(A) et FFT(B) terme à terme, soit évaluation par évaluation.

Une fois en possession de <math>FFT(C)</math>, qui n'est autre que l'évaluation de notre polynôme final en un nombre suffisant de points pour le retrouver, nous pouvons faire l'<math>IFFT(FFT(C))</math>, qui va nous permettre de retrouver les coefficients de notre polynôme en faisant l'exacte inverse de la FFT.

Une fois les coefficients retrouvés, il nous suffit de gérer les retenues, et nous retrouvons un entier de la forme : <math>a_0 a_1 (...) a_{n-1} a_n</math>

=== B) Graphique ===

Intéressons nous maintenant à la complexité de l'algorithme utilisant la transformée de Fourier rapide. On sait que l'algorithme passe par 5 étapes importantes :

<ul>
<li>Etape 1 : Ecrire les deux facteurs sous la forme de polynômes</li>
<li>Etape 2 : Effectuer la <math>FFT</math> des deux polynômes</li>
<li>Etape 3 : Faire le produit terme à terme des <math>FFT</math> obtenues</li>
<li>Etape 4 : Faire l'<math>IFFT</math> du produit</li>
<li>Etape 5 : Gérer les retenues et écrire le nombre qui en découle</li>
</ul>

Or, parmi toutes ces étapes, certaines sont négligeable comme l'étape 1 et 5.

Pour connaitre la complexité de l'algorithme, additionnons les complexités des étapes restantes :

Une <math>FFT</math> a une complexité de <math>\mathcal{O}(n\times logn)</math> car elle fait <math>n</math> évaluation sur <math> log(n)</math> récursions. Dans le cadre de notre algorithme, nous devons faire la <math>FFT</math> de nos deux facteurs. Soit <math>2\times \mathcal{O}(n\times logn)</math>.

Pour le produit terme à terme, nous faisons naturellement <math>n</math> opérations.

Pour finir, l'<math>IFFT</math> a la même complexité que la <math>FFT</math>. Dans le cadre de notre algorithme nous l'emploierons qu'une seule fois, ce qui fait une complexité de <math>\mathcal{O}(n\times logn)</math>.

Après addition de toutes ces complexités, nous obtenons la complexité réelle de <math>3\mathcal{O}(n\times logn) + \mathcal{O}(n)</math>.

D'après le Master Theorem, nous avons donc <math> f(n) = 3(n\times logn)+n </math>, cherchons <math>f(n)\in\mathcal{O}(g(n))</math> :

Nous pouvons ignorer les expressions linéaires ainsi que les constantes multiplicatrices, nous obtenons donc <math>\mathcal{O}(g(n)) = \mathcal{O}(n \times log n)</math>.

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:30px; text-align:center;">
[[Fichier:FFT_image.webp|500px]]
<div><b>Graphiques des complexités</b></div>
</div>
<div style="max-width:800px;">
<p>Ce graphique ci-contre ne provient pas du fruit de nos recherches personnelles mais </p>
<p>On comprend ainsi que certaines complexités ne sont pas raisonnable dans la cadre de la multiplication de grands entiers.</p>
<p>C'est pourquoi l'étude de ces algorithmes s'avère nécessaire.</p>
</div>
</div>

= II - Produit de matrices =

== 1.1) naïve ==

La multiplication naïve de matrice requiert d'avoir des tailles de lignes/colonne semblable, ensuite pour chaque membre de la matrice résultat, on doit multiplier les composantes ligne de la première matrice par les composantes colonne de la deuxième et le tout sommé.

On en déduit la formule suivante:
<math>C_{i,j} = \sum_{k=1}^{n} (A_{i,k} \times B_{k,j})</math>

Et visuellement:

[[Fichier:Matricenaive.jpeg]]

On a donc un algorithme d'ordre de complexité <math>\mathcal{O}(g(n))</math>

== 1.2) naïve récursive ==

Dans un premier temps on doit découper nos deux matrices en quatres sous matrices de plus petite taille.
<math>A = \begin{pmatrix} A_{11} & A_{12} \ A_{21} & A_{22} \end{pmatrix}</math>
<math>B = \begin{pmatrix} B_{11} & B_{12} \ B_{21} & B_{22} \end{pmatrix}</math>

Ensuite on vient calculer la matrice résultat.
<math>C_{11} = (A_{11} \times B_{11}) + (A_{12} \times B_{21})</math>
<math>C_{12} = (A_{11} \times B_{12}) + (A_{12} \times B_{22})</math>
<math>C_{21} = (A_{21} \times B_{11}) + (A_{22} \times B_{21})</math>
<math>C_{22} = (A_{21} \times B_{12}) + (A_{22} \times B_{22})</math>

Le côté récursif est utile que pour les matrices de tailles <= 32 (32 valeurs stockées dedans),
si on est au dessus de cette taille alors on divisera à nouveau nos matrices en quatres.
On aura 8 multiplications mais de plus petite taille au final.

== 2) strassen ==

=== A) Fonctionnement ===

Strassen consiste à définir 7 produits intermédiaires qui, par des jeux de sommes et de différences, permettent de reconstruire les quadrants de la matrice résultante. On passe ainsi d'une complexité de O(n^3) à environ O(n^2.81)

=== B) Graphique ===

On voit bien la différence de complexité sur la multiplication de grande matrice entre l'approche naïve et l'approche récursive qui est beaucoup plus rapide.

[[Fichier:Analyse matrices.png]]

= Conclusion =

L'étude de ces algorithmes de multiplication nous a clairement montré l'évolution de la complexité algorithmique permettant de gagner en efficacité lorsque la taille des données augmente.

La multiplication classiqe, en <math> \mathcal{O}(n^2) </math>, résulte d'une approche naïve qui devient rapidement inefficace pour les grands entiers ou les grandes matrices. L'algorithme de Karatsuba nous montre qu'organiser de manière intelligente ses calculs algébrique permet parfois de gagner beaucoup de multiplications, et donc de temps. Nous avons ainsi réussi à passer d'une complexité de <math>\mathcal{O}(n^2)</math> à <math>\mathcal{O}(n^{log_2(3)})</math>, soit environ <math>\mathcal{O}(n^{1/585})</math>.

Des méthodes encore plus avancées comme utilise l'algorithme de Toom-Cook-3 continue dans cette idées de divisions d'entiers en blocs plus petits, tandis que la transformée de Fourier rapide change complètement de point de vue. En effet la FFT n'utilise pas la représentation classique des entiers mais fait appel à une vision polynomiale, ce qui transforme la convolution classique en multiplication terme à terme, ce qui lui permet d'atteindre une complexité de <math>\mathcal{O}(n \times log n)</math>.

Dans le cas des matrices, les mêmes logiques apparaissent comme par exemple avec l'algorithme de Strassen qui se rapproche très fortement de Karatsuba en combinant de manière astucieuse les parties d'entiers qui avaient été précédemment découpée.

On remarque néanmoins que la majorité des algorithmes efficaces s'orientent vers une approche récursive et non itérative. Néanmoins, nous avons pu trouver certaines de ces implémentations (comme par exemple la FFT) en itérative.

Avec ces recherches, nous comprenons que la réorganisations des calculs algébriques peuvent aider à gagner en complexité mais que pour faire de réels progrès, il nous faudra surement changer notre point de vue une nouvelle fois, et aborder le problème sous un angle nouveau comme le font dors et déjà les algorithmes les plus performants.

= Mentions =

Le premier gif est le résultat du travail de 'Walké', licence ci-contre : https://fr.wikipedia.org/wiki/Fichier:Addition.gif

= Sources =

Pour karatsuba :
<ul>
<li> https://www.youtube.com/watch?v=PZ2gdWdKHAA </li>
</ul>

Pour mieux comprendre la FFT, nous avons utilisé plusieurs sources d'informations :
<ul>
<li> https://www.youtube.com/watch?v=h7apO7q16V0&list=WL&index=1&t=886s </li>
<li> https://fr.wikipedia.org/wiki/Interpolation_polynomiale </li>
</ul>

Algorithmes de multiplications d'entiers et de matrices

2026-05-11T18:38:10Z

Mangala : /* Notation */

= Introduction =

Depuis l'apparition des ordinateurs modernes, une quantité faramineuse de calculs a dû être effectuée. Les progressions technologiques nous poussent à envisager la puissance de calcul comme une ressource qu'il faut optimiser dans les moindres détails. C'est ainsi que l'optimisation des algorithmes de calcul est devenue cruciale, surtout lorsqu'il nous faut effectuer des opérations sur de très grands entiers par exemple.

= Objectif =

L'objectif majeur de ce projet est de comprendre de manière plus approfondie ce qu'est la '''complexité algorithmique'''.
Pour atteindre cet objectif, nous implémenterons plusieurs algorithmes de multiplication qui auront pour but de calculer le produit de grands entiers ou de matrices.

= Point important : complexité =

=== Définition ===
La complexité d'un algorithme est la quantité des ressources qu'il utilise en fonction de la taille des entrées qu'on lui demande de traiter. On peut par exemple se concentrer sur le temps qu'un algorithme prend pour renvoyer un résultat ou sur la mémoire dont il a besoin. Dans le cadre de notre projet, nous nous attarderons plus particulièrement sur la quantité de calcul effectuée en fonction de la taille des entrées, ce qui est par ailleurs étroitement liée à la notion de temps. De manière générale, plus un algorithme doit faire de calcul, plus il est lent. (Attention, toutes les opérations arithmétiques de base ne se valent pas)

De manière plus familière, on dira que la complexité d'un algorithme pourrait s'apparenter à son comportement lorsqu'il doit traiter des données plus ou moins grandes.
Chaque algorithme a une complexité, et on l'exprime par une fonction qui adopte un comportement similaire au nombre de calculs nécessaires en fonction de la taille des entrées.

=== Notation ===
La complexité réelle d'un algorithme peut être décrite par une fonction <math> f(n) </math> représentant le nombre d'opérations effectuées en fonction de la taille <math>n</math> des données d'entrée.

Cependant, afin de simplifier l'étude de cette croissance, on utilise généralement une borne asymptotique notée <math>\mathcal{O}(g(n))</math>, où <math>g(n)</math> est une fonction ayant le même ordre de grandeur que <math>f(n)</math> lorsque <math>n</math> devient grand.

On dit alors que :

<math>
f(n)\in\mathcal{O}(g(n))
</math>

si et seulement s'il existe une constante <math>C>0</math> et un entier <math>n_0</math> tels que :

<math>
\forall n\ge n_0,\ f(n)\le Cg(n)
</math>

Cette notation <math>\mathcal{O}(g(n))</math> permettra de comparer beaucoup plus facilement les algorithmes entre eux.

=== Master Theorem ===

Afin de déterminer la complexité de certains algorithmes récursifs, nous utiliserons le "Master Theorem".

Ce théorème permet d'obtenir directement l'ordre de grandeur de nombreuses relations de récurrence apparaissant dans l'analyse d'algorithmes de type « diviser pour régner », comme l'algorithme de Karatsuba ou celui de Strassen.

La démonstration complète de ce théorème dépasse le cadre de notre projet et nécessite des connaissances mathématiques plus avancées. Nous l'utiliserons donc principalement comme un outil nous permettant de déterminer efficacement la complexité asymptotique des algorithmes étudiés.

=== Graphiques ===

Les complexités étant des fonctions, nous pouvons les représenter par un graphique qui affichera le temps d'exécution (ou nombre d'opérations) en fonction de la taille des entrées.

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:30px; text-align:center;">
[[Fichier:complexite.webp|500px]]
<div><b>Graphiques des complexités</b></div>
</div>
<div style="max-width:800px;">
<p>Ce graphique ci-contre compare les complexités en fonction de la taille des d'entrées.</p>
<p>On comprend ainsi que certaines complexités ne sont pas raisonnable dans la cadre de la multiplication de grands entiers.</p>
<p>C'est pourquoi l'étude de ces algorithmes s'avère nécessaire.</p>
</div>
</div>

=== Exemple ===
L'algorithme naïf d'addition que nous avons tous appris à l'école a une complexité de <math>\mathcal{O}(n)</math>.
Soit n la taille des nombres en entrée, l'algorithme doit faire environ n addition pour arriver au résultat demandé.

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Addition.gif|220px]]
<div><b>Addition naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Comme le montre l'exemple ci-contre, 786 et 467 font 3 chiffres de long donc n sera de 3.</p>
<p>Il nous faudra 3 opérations pour additionner ces entiers.</p>
<p>C'est ainsi qu'avec une taille d'entrée n, l'algorithme de l'addition naïve va devoir faire n opérations.</p>
<p>Cet algorithme a donc une complexité <math>f(n) = n</math> qui n'a pas besoin d'être approximée.</p>
<p>Ainsi sa complexité finale sera <math>\mathcal{O}(n)</math>.</p>
</div>
</div>

= Problématique =

Le calcul du produit de deux entiers de manière naïve a une complexité de <math> \mathcal{O}(n^2)</math>, et celui de deux matrices une complexité de <math> \mathcal{O}(n^3)</math>. Afin de mieux comprendre ce qu'est la complexité algorithmique, nous devrons implémenter des algorithmes ayant le même objectif, mais étant plus efficaces. Ces algorithmes s'avèreront plus complexes mais devrait aboutir à un calcul plus rapide du produit demandé.

Nous séparerons notre wiki en deux grandes parties, la première concernera nos recherche sur [[#I - Produit d'entiers|la multiplication d'entiers]], la deuxième sur [[#II - Produit de matrices|la multiplication de matrices]].

= I - Produit d'entiers =

Notre départ commence avec l'algorithme de multiplication d'entier naïf.
En effet il s'agit de l'algorithme de multiplication le plus connu, et nous l'utiliserons comme référence pour le comparer aux futurs algorithmes plus efficaces.
Intéressons nous à sa complexité.

== 1) Nos implémentations des grands entiers ==

Qui dit produit de grands entiers dit implémentation de grands entiers.

Dans le cadre de nos recherches, nous allons devoir implémenter des algorithmes qui vont manipuler des grands entiers.

Nous avons donc choisi de créer deux représentations différentes de ceux-ci (car nous travaillons sur différents langages de programmation), nous permettant à la fois une implémentation simplifié, mais aussi de nous rapprocher d'une implémentation bas niveau.

=== A) En python ===
En python, l'utilisation des "bytes" m'a grandement servi à comprendre comment les entiers étaient manipulés à bas niveau. En effet, un des objectifs secondaires de nos recherches était de manipuler des entiers directement avec leur formes stockées sur l'ordinateur, et non pas avec des int python.
En effet l'utilisation des int python nous aurait permit de passer les étapes de retenues, de signes... D'autant plus que les bytes permettent de stocker un nombre en base 256, ce qui permet de visualiser plus facilement les grands entiers.

La forme finale de la représentation des grands entiers en python sera donc la suivante :

[ signe , bytes , bytes , (...) , bytes ]

Le signe est représenté par un entier, 1 si le nombre est positif, 0 sinon.
Cette configuration rendra plus simple la gestion des signes.

=== B) En C++ ===

En C++, pour avoir une représentation de grand entiers j'ai du définir ma propre structure pour m'affranchir de la limite de taille imposé par les entiers standards: (int32 ou int64). Pour cela, j'ai une structure qui possède l'équivalent d'un array de byte (ce qui nous permet d'être en base 256 au lieu de la base 10 habituelle), et pour traiter le signe j'utilise un booléen, ainsi en mémoire j'ai une structure de n*Octets + 1 octet en taille.

[ bytes , bytes , (...) , bytes ] [ signe ]

Le booléen prend 1 octet de place mais ne touche pas aux octets qui encode le grand entier.
Cette configuration rendra plus simple la gestion des signes dans le cadre des multiplication.

== 2) La multiplication naïve ==

=== A) Fonctionnement ===
Dans le cas de la multiplication d'entiers, nous allons prendre deux nombres qui n'ont pas nécessairement la même longueur. Soit les nombre a et b, de longueur respective <math>n</math> et <math>m</math>.
<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Multiplication.png|220px]]
<div><b>Multiplication naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Prenons deux nombres de longueur 3 et 2, et cherchons combien d'opérations l'algorithme de multiplication naïve va devoir faire pour nous renvoyer leur produit.</p>
<p>Dans un premier temps, on remarque que l'on va devoir multiplier chaque chiffre du nombre du haut par le chiffre des unités du bas, qui est 6. Cela va représenter <math>n</math> opérations. (6x5, 6x1 et 6x4)</p>
<p>Dans un deuxième temps nous constatons que nous allons devoir faire la même chose avec le chiffre des dizaines du nombre du bas. Cela nous ajoute de nouveau <math>n</math> opérations.</p>
<p>On arrive assez facilement à la conclusion que pour faire notre produit, il va nous falloir faire <math>n</math> fois <math>m</math> opérations.</p>
</div>
</div>

Ainsi, la complexité de la multiplication naïve est <math>\mathcal{O}(n^2)</math>.
Il est en de même avec la multiplication naïve récursive.

=== B) Graphique ===
Montrons maintenant sa courbe sur un graphique :

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Multiplicationnaive.png|500px]]
<div><b>Multiplication naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Les points noirs sont des repères pour que les autres courbes aient une forme cohérente.</p>
<p>Ils sont tous sur l'axe des abscisses.</p>
<p>La courbe rouge représente la complexité de la multiplication naïve.</p>
<p>On remarque que la courbe a un visuel très similaire à la fonction <math>f(x) = x^2</math> </p>
</div>
</div>

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Naif_recursif.png|500px]]
<div><b>Multiplication naïve récursive</b></div>
</div>
<div style="max-width:800px;">
<p>La courbe rouge représente la complexité de la multiplication naïve récursive.</p>
<p>Elle sera utilisé pour comparer les complexités entre algorithmes car, comme tous récursifs, elle a été codé avec les mêmes biais d'implémentation qu'eux.</p>
<p>Théoriquement les deux courbes ci-contre ont la même complexité, mais encore une fois, notre implémentation n'est pas parfaitement optimale et donc ne respecte pas de manière minutieuse le Master Theorem.</p>
</div>
</div>

== 3) La multiplication karatsuba ==

=== A) Fonctionnement ===

L'algorithme de karatsuba est un algorithme récursif de type diviser pour régner.

L'idée générale de l'algorithme est de passer de 4 multiplication à 3. En effet ces opérations étant moins couteuses, il est préférable d'en ajouter si cela permet d'enlever des multiplications.

L'algorithme de multiplication naif récursif utilise la segmentation des facteurs en deux de manière successive.

Soit <math>x</math> et <math>y</math> deux facteurs, nous avons les égalités suivantes :

<div style="font-size: 20px;">
<math>x = a \times B^{n/2} + b</math>
<math>y = c \times B^{n/2} + d</math>
</div>

Avec <math>a</math> et <math>c</math> les premières moitiés des facteurs <math>x</math> et <math>y</math>,
et <math> b </math> et <math>d</math> les dernières moitiés de ces facteurs ainsi que <math>B</math> la base d'écriture du nombre (Nous sommes en base 256 avec les bytes).

Cette présentation des deux facteurs de notre multiplication n'est que la résultante d'un découpage.
Le [[#Master Theorem|Master Theorem]] nous montre que :

<div style="font-size: 20px;">
<math>T(n) = 4T(n/2) + O(n)</math>
</div>

Puisque nous avons après découpage 4 entiers de longueur <math>n/2</math>.

Ainsi, ce découpage ne permet pas de gagner du temps d'après le [[#Master Theorem|Master Theorem]].

Cependant, l'algorithme de Karatsuba réutilise ce principe en le modifiant, ce qui nous permet de baisser la complexité globale de la multiplication dans son entièreté.

Avec l'écriture ci-dessus des nombres <math>x</math> et <math>y</math>, on peut facilement en déduire l'égalité suivante :

<div style="font-size: 20px;">
<math>x \times y = (ac) \times B^n + (ad + bc) \times B^{n/2} + bd</math>
</div>

On remarque 4 multiplications longues à faire dans cette expression. Les multiplications dont <math>B</math> est l'un des facteurs sont très rapides puisqu'il s'agit de la base dans laquelle nous travaillons. De cela en résulte un décalage plutôt qu'un vrai calcul à faire.

Karatsuba développe une partie de cette expression pour pouvoir négocier une multiplication au prix d'additions et soustractions.

En effet, nous savons déjà que :

<div style="font-size: 20px;">
<math>(a + b)(c + d) = ac + ad + bc + bd</math>
</div>

En manipulant l'égalité nous obtenons :

<div style="font-size: 20px;">
<math>ad + bc = (a + b)(c + d) - ac - bd</math>
</div>

ac et bd ayant déjà été calculé précédemment, il nous reste uniquement la multiplication <math>(a + b)(c + d)</math>.

Nous venons ainsi de calculer <math>ad + bc</math> en seulement une multiplication. C'est la que repose le gain de temps de la méthode Karatsuba par rapport à la multiplication naïve.

En effet, l'algorithme n'effectuera alors plus que 3 multiplications :
<div style="font-size: 20px;">
<math>ac</math>
<math>bd</math>
<math>(a + b)(c + d)</math>
</div>

La relation de récurrence devient donc :
<div style="font-size: 20px;">
<math>T(n)=3T(n/2)+O(n)</math>
</div>

Et le Master Theorem nous dit que :
<div style="font-size: 20px;">
<math>T(n)\in O(n^{\log_2(3)})</math>
</div>

Or <math>\log_2(3)\approx 1.585</math>, donc la complexité de l'algorithme de Karatsuba est de <math> \mathcal{O}(n^{1.585})</math>. Ce qui est bien plus efficace que la multiplication classique, surtout lorsque les facteurs deviennent très grands.

=== B) Graphique ===
<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Karatsuba.png|500px]]
<div><b>Karatsuba</b></div>
</div>
<div style="max-width:800px;">
<p>Sur le graphique ci-contre nous avons utilisé la courbe de la multiplication naïve récursive (rouge) à titre de comparaison.</p>
<p>On remarque graphiquement que Karatsuba (jaune) prend moins de temps à chaque calcul de produit.</p>
<p>On en déduit donc expérimentalement que Karatsuba à une meilleure complexité que la multiplication naïve.</p>
<p>Ainsi nous vérifions donc ce que le Master Theorem prouve, c'est à dire que la complexité de karatsuba est de <math> \mathcal{O}(n^{1.585})</math> </p>
</div>
</div>

== 4) La multiplication toom-cook-3 ==

=== A) Fonctionnement ===

L'objectif est de diviser les grands entiers X et Y en trois blocs de taille égale k.
On les traite alors comme des polynômes de degré 2:

<math>P(z) = X_2 \cdot z^2 + X_1 \cdot z + X_0</math>
<math>Q(z) = Y_2 \cdot z^2 + Y_1 \cdot z + Y_0</math>

On choisit 5 points distincts pour évaluer nos polynômes.
Ce choix de 5 points est crucial car le produit de deux polynômes de degré 2 est un polynôme de degré 4, qui nécessite 5 points pour être défini.
Les points standards sont :

P(0) = X0
P(1) = X0 + X1 + X2
P(-1) = X0 - X1 + X2
P(2) = X0 + 2*X1 + 4*X2
P(inf) = X2

(On procède de manière similaire pour Q.)

Ensuite nous multiplions récursivement chaque points de P et de Q ensemble.
On effectue ainsi 5 multiplications de nombres plus petits au lieu des 9 multiplications requises par la méthode classique.

Après, nous effectuons une interpolation, cela permet de retrouver les 5 coefficients (w_0, w_1, w_2, w_3, w_4) du polynôme produit R(z) à partir des valeurs évaluées calculées précédemment.
On résout un système d'équations linéaires : <math> R(z) = w_4 z^4 + w_3 z^3 + w_2 z^2 + w_1 z + w_0 </math>
Finalement nous pouvons recomposer notre grand entier en positionnant les coefficients w_i aux bons rangs (en les décalant) et à gérer les retenues lors de l'addition finale:
<math>Résultat = w_4 B^{4k} + w_3 B^{3k} + w_2 B^{2k} + w_1 B^k + w_0</math>

=== B) Graphique ===

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Toomcook.png|500px]]
<div><b>Karatsuba</b></div>
</div>
<div style="max-width:800px;">
<p>on a reprit multi récursive (rouge)</p>
<p>on voit que Toom (vert) en dessous de karatsuba (jaune) en dessous de multi classique (rouge)</p>
<p>meilleur complexité</p>
</div>
</div>

== 5) La transformée de Fourier rapide ==

=== A) Fonctionnement ===

La transformation de Fourier rapide étant plus complexe que les autres algorithmes, nous allons essayer d'expliquer son fonctionnement malgré ne pas avoir réussi à l'implémenter.

Il faut comprendre que cet algorithme va considérer les facteurs comme des polynômes.

D'après le théorème de l'unisolvance, il n'existe qu'un seul polynôme de degré inférieur ou égal à <math> n </math> défini par <math>n + 1</math> points distincts. Cela implique non seulement que nous pouvons représenter chaque entier par un polynôme, mais également que si nous pouvons retrouver <math>n + m + 1</math> points (avec <math>n</math> et <math>m</math> la longueur des facteurs) du polynômes issue du produit entre deux facteurs, nous pourrons le retrouver.

Soit un entier quelconque, de forme :

<math>a_n a_{n-1} (...) a_1 a_0</math>

Avec <math>a_i</math>, un chiffre composant le nombre en base 10, qui vaut en réalité dans le nombre : <math>a_i \times 10^i</math>. On peut ainsi l'écrire sous la forme :

<math> P(x) = a_0 + a_1x + a_2x^2 + \dots + a_{n-1}x^{n-1} + a_nx^n </math>

Avec <math>x = 10</math> car nous sommes en base 10, nous obtenons :

<math>P(10) = a_0 + a_1 \times 10 + \dots + a_{n-1}10^{n-1} + a_n10^n </math>

Nous venons ainsi d'écrire notre nombre sous la forme d'un polynôme unique. Pour nous permettre d'évaluer en un nombre suffisant de points, nous allons devoir ajouter des 0 pour la récursion. Il nous faudra ajouter assez de 0 pour atteindre la prochaine puissance de 2 qui sera supérieure ou égale à <math>2n + 1</math>. L'ajout de 0 ne change pas le nombre car <math>0 \times x^n</math> n'ajoute pas de coefficient.

Cet algorithme est récursif et va segmenter en deux parties nos polynômes à chaque récursion. D'un coté les indice pairs et d'un coté les impaires.

Ainsi prenons les nombres 1234 et 5678, ces nombres sont respectivement représentés par les polynômes <math> P(x) = 4 + 3x + 2x^2 + x^3 </math> et <math> P(x) = 8 + 7x + 6x^2 + 5^3 </math>. Ce sont des polynômes de degré 3, ainsi leur produit donnera lieu à un polynôme de degré 6. Il nous faudra donc au minimum 7 points d'évaluation pour retrouve ce produit. De ce fait, en les représentant de la manière suivante :

<math>[4, 3, 2, 1, 0, 0, 0, 0]</math>
<math>[8, 7, 6, 5, 0, 0, 0, 0]</math>

Nous aurons assez de récursions possible pour les évaluer en un nombre suffisant de points différents car nous auront 3 récursions à faire pour atteindre notre cas de base. A chaque récursion, nous allons diviser nos polynômes en deux parties ce qui nous fait 8 feuilles à la dernière récursion.

En effet à chaque étape de la récursion nous allons séparer nos polynômes en deux tel que :

<math>P(x)=P_{\text{pair}}(x^2) + x \cdot P_{\text{impair}}(x^2)</math>

Durant les récursions, nous segmentons les polynômes mais ne les évaluons pas. C'est à la remonté des récursions que nous allons réellement évaluer nos polynômes. Lorsque l'on atteint notre cas de base, c'est à dire des polynômes de degré 0, nous remarquons qu'ils sont constants, nous n'avons donc pas besoin de les évaluer. En effet, peut importe le point en lequel nous voudrons l'évaluer, le polynôme renverra la constante. Nous la renvoyons donc seule.
Ensuite commence la remontée des récursions. A l'étape 1 de notre remontée nous allons reformer le polynôme précédemment séparé pour obtenir un polynôme de degré 1. Puis, nous évaluons ce polynôme avec les racines seconde de l'unité. Nous faisons à nouveau remonté les évaluations et recombinons à nouveau le polynôme qui sera ainsi de degré 2.
Nous l'évaluons maintenant avec les racines 4eme de l'unité. A chaque évaluation, nous réutilisons les résultats précédents, cela nous est permit par les racines de l'unité qui ont une structure récursive exploitable.

Finalement, nous arrivons à la fin de notre FFT, avec une représentation fréquentielle de la forme :

<math> [P(W_0), P(W_1), (...), P(W_n-1), P(W_n)] </math>

Cette représentation fréquentielle n'est autre que les évaluations du polynôme P aux racines nièmes de l'unité. Nous avons donc maintenant au minimum <math>2n+1</math> évaluations des polynômes facteurs. Il nous faut maintenant trouver les évaluations du produit final, c'est à dire les évaluations concernant le polynôme qui sera issue de la multiplication. On pourra ainsi le retrouver.

Soit <math>C</math> un polynome tel que <math> C = A \times B </math>, alors on a :

<math> C(x) = A(x) \times B(x) </math>

Ainsi on en déduit que <math> C(W_n^k) = A(W_n^k) \times B(W_n^k) </math>

On comprend donc que <math>FFT(C) = FFT(A) \times FFT(B)</math>

Il faut préciser que l'on fait le produit de FFT(A) et FFT(B) terme à terme, soit évaluation par évaluation.

Une fois en possession de <math>FFT(C)</math>, qui n'est autre que l'évaluation de notre polynôme final en un nombre suffisant de points pour le retrouver, nous pouvons faire l'<math>IFFT(FFT(C))</math>, qui va nous permettre de retrouver les coefficients de notre polynôme en faisant l'exacte inverse de la FFT.

Une fois les coefficients retrouvés, il nous suffit de gérer les retenues, et nous retrouvons un entier de la forme : <math>a_0 a_1 (...) a_{n-1} a_n</math>

=== B) Graphique ===

Intéressons nous maintenant à la complexité de l'algorithme utilisant la transformée de Fourier rapide. On sait que l'algorithme passe par 5 étapes importantes :

<ul>
<li>Etape 1 : Ecrire les deux facteurs sous la forme de polynômes</li>
<li>Etape 2 : Effectuer la <math>FFT</math> des deux polynômes</li>
<li>Etape 3 : Faire le produit terme à terme des <math>FFT</math> obtenues</li>
<li>Etape 4 : Faire l'<math>IFFT</math> du produit</li>
<li>Etape 5 : Gérer les retenues et écrire le nombre qui en découle</li>
</ul>

Or, parmi toutes ces étapes, certaines sont négligeable comme l'étape 1 et 5.

Pour connaitre la complexité de l'algorithme, additionnons les complexités des étapes restantes :

Une <math>FFT</math> a une complexité de <math>\mathcal{O}(n\times logn)</math> car elle fait <math>n</math> évaluation sur <math> log(n)</math> récursions. Dans le cadre de notre algorithme, nous devons faire la <math>FFT</math> de nos deux facteurs. Soit <math>2\times \mathcal{O}(n\times logn)</math>.

Pour le produit terme à terme, nous faisons naturellement <math>n</math> opérations.

Pour finir, l'<math>IFFT</math> a la même complexité que la <math>FFT</math>. Dans le cadre de notre algorithme nous l'emploierons qu'une seule fois, ce qui fait une complexité de <math>\mathcal{O}(n\times logn)</math>.

Après addition de toutes ces complexités, nous obtenons la complexité réelle de <math>3\mathcal{O}(n\times logn) + \mathcal{O}(n)</math>.

D'après le Master Theorem, nous avons donc <math> f(n) = 3(n\times logn)+n </math>, cherchons <math>f(n)\in\mathcal{O}(g(n))</math> :

Nous pouvons ignorer les expressions linéaires ainsi que les constantes multiplicatrices, nous obtenons donc <math>\mathcal{O}(g(n)) = \mathcal{O}(n \times log n)</math>.

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:30px; text-align:center;">
[[Fichier:FFT_image.webp|500px]]
<div><b>Graphiques des complexités</b></div>
</div>
<div style="max-width:800px;">
<p>Ce graphique ci-contre ne provient pas du fruit de nos recherches personnelles mais </p>
<p>On comprend ainsi que certaines complexités ne sont pas raisonnable dans la cadre de la multiplication de grands entiers.</p>
<p>C'est pourquoi l'étude de ces algorithmes s'avère nécessaire.</p>
</div>
</div>

= II - Produit de matrices =

== 1.1) naïve ==

La multiplication naïve de matrice requiert d'avoir des tailles de lignes/colonne semblable, ensuite pour chaque membre de la matrice résultat, on doit multiplier les composantes ligne de la première matrice par les composantes colonne de la deuxième et le tout sommé.

On en déduit la formule suivante:
<math>C_{i,j} = \sum_{k=1}^{n} (A_{i,k} \times B_{k,j})</math>

Et visuellement:

[[Fichier:Matricenaive.jpeg]]

On a donc un algorithme d'ordre de complexité <math>\mathcal{O}(g(n))</math>

== 1.2) naïve récursive ==

Dans un premier temps on doit découper nos deux matrices en quatres sous matrices de plus petite taille.
<math>A = \begin{pmatrix} A_{11} & A_{12} \ A_{21} & A_{22} \end{pmatrix}</math>
<math>B = \begin{pmatrix} B_{11} & B_{12} \ B_{21} & B_{22} \end{pmatrix}</math>

Ensuite on vient calculer la matrice résultat.
<math>C_{11} = (A_{11} \times B_{11}) + (A_{12} \times B_{21})</math>
<math>C_{12} = (A_{11} \times B_{12}) + (A_{12} \times B_{22})</math>
<math>C_{21} = (A_{21} \times B_{11}) + (A_{22} \times B_{21})</math>
<math>C_{22} = (A_{21} \times B_{12}) + (A_{22} \times B_{22})</math>

Le côté récursif est utile que pour les matrices de tailles <= 32 (32 valeurs stockées dedans),
si on est au dessus de cette taille alors on divisera à nouveau nos matrices en quatres.
On aura 8 multiplications mais de plus petite taille au final.

== 2) strassen ==

=== A) Fonctionnement ===

Strassen consiste à définir 7 produits intermédiaires qui, par des jeux de sommes et de différences, permettent de reconstruire les quadrants de la matrice résultante. On passe ainsi d'une complexité de O(n^3) à environ O(n^2.81)

=== B) Graphique ===

On voit bien la différence de complexité sur la multiplication de grande matrice entre l'approche naïve et l'approche récursive qui est beaucoup plus rapide.

[[Fichier:Analyse matrices.png]]

= Conclusion =

L'étude de ces algorithmes de multiplication nous a clairement montré l'évolution de la complexité algorithmique permettant de gagner en efficacité lorsque la taille des données augmente.

La multiplication classiqe, en <math>\mathcal{O}(n^2)</math>, résulte d'une approche naïve qui devient rapidement inefficace pour les grands entiers ou les grandes matrices. L'algorithme de Karatsuba nous montre qu'organiser de manière intelligente ses calculs algébrique permet parfois de gagner beaucoup de multiplications, et donc de temps. Nous avons ainsi réussi à passer d'une complexité de <math>\mathcal{O}(n^2)</math> à <math>\mathcal{O}(n^{log_2(3)})</math>, soit environ <math>\mathcal{O}(n^{1/585})</math>.

Des méthodes encore plus avancées comme utilise l'algorithme de Toom-Cook-3 continue dans cette idées de divisions d'entiers en blocs plus petits, tandis que la transformée de Fourier rapide change complètement de point de vue. En effet la FFT n'utilise pas la représentation classique des entiers mais fait appel à une vision polynomiale, ce qui transforme la convolution classique en multiplication terme à terme, ce qui lui permet d'atteindre une complexité de <math>\mathcal{O}(n \times log n)</math>.

Dans le cas des matrices, les mêmes logiques apparaissent comme par exemple avec l'algorithme de Strassen qui se rapproche très fortement de Karatsuba en combinant de manière astucieuse les parties d'entiers qui avaient été précédemment découpée.

On remarque néanmoins que la majorité des algorithmes efficaces s'orientent vers une approche récursive et non itérative. Néanmoins, nous avons pu trouver certaines de ces implémentations (comme par exemple la FFT) en itérative.

Avec ces recherches, nous comprenons que la réorganisations des calculs algébriques peuvent aider à gagner en complexité mais que pour faire de réels progrès, il nous faudra surement changer notre point de vue une nouvelle fois, et aborder le problème sous un angle nouveau comme le font dors et déjà les algorithmes les plus performants.

= Mentions =

Le premier gif est le résultat du travail de 'Walké', licence ci-contre : https://fr.wikipedia.org/wiki/Fichier:Addition.gif

= Sources =

Pour karatsuba :
<ul>
<li> https://www.youtube.com/watch?v=PZ2gdWdKHAA </li>
</ul>

Pour mieux comprendre la FFT, nous avons utilisé plusieurs sources d'informations :
<ul>
<li> https://www.youtube.com/watch?v=h7apO7q16V0&list=WL&index=1&t=886s </li>
<li> https://fr.wikipedia.org/wiki/Interpolation_polynomiale </li>
</ul>

Algorithmes de multiplications d'entiers et de matrices

2026-05-11T18:37:53Z

Mangala : /* Sources */

= Introduction =

Depuis l'apparition des ordinateurs modernes, une quantité faramineuse de calculs a dû être effectuée. Les progressions technologiques nous poussent à envisager la puissance de calcul comme une ressource qu'il faut optimiser dans les moindres détails. C'est ainsi que l'optimisation des algorithmes de calcul est devenue cruciale, surtout lorsqu'il nous faut effectuer des opérations sur de très grands entiers par exemple.

= Objectif =

L'objectif majeur de ce projet est de comprendre de manière plus approfondie ce qu'est la '''complexité algorithmique'''.
Pour atteindre cet objectif, nous implémenterons plusieurs algorithmes de multiplication qui auront pour but de calculer le produit de grands entiers ou de matrices.

= Point important : complexité =

=== Définition ===
La complexité d'un algorithme est la quantité des ressources qu'il utilise en fonction de la taille des entrées qu'on lui demande de traiter. On peut par exemple se concentrer sur le temps qu'un algorithme prend pour renvoyer un résultat ou sur la mémoire dont il a besoin. Dans le cadre de notre projet, nous nous attarderons plus particulièrement sur la quantité de calcul effectuée en fonction de la taille des entrées, ce qui est par ailleurs étroitement liée à la notion de temps. De manière générale, plus un algorithme doit faire de calcul, plus il est lent. (Attention, toutes les opérations arithmétiques de base ne se valent pas)

De manière plus familière, on dira que la complexité d'un algorithme pourrait s'apparenter à son comportement lorsqu'il doit traiter des données plus ou moins grandes.
Chaque algorithme a une complexité, et on l'exprime par une fonction qui adopte un comportement similaire au nombre de calculs nécessaires en fonction de la taille des entrées.

=== Notation ===
La complexité réelle d'un algorithme peut être décrite par une fonction <math>f(n)</math> représentant le nombre d'opérations effectuées en fonction de la taille <math>n</math> des données d'entrée.

Cependant, afin de simplifier l'étude de cette croissance, on utilise généralement une borne asymptotique notée <math>\mathcal{O}(g(n))</math>, où <math>g(n)</math> est une fonction ayant le même ordre de grandeur que <math>f(n)</math> lorsque <math>n</math> devient grand.

On dit alors que :

<math>
f(n)\in\mathcal{O}(g(n))
</math>

si et seulement s'il existe une constante <math>C>0</math> et un entier <math>n_0</math> tels que :

<math>
\forall n\ge n_0,\ f(n)\le Cg(n)
</math>

Cette notation <math>\mathcal{O}(g(n))</math> permettra de comparer beaucoup plus facilement les algorithmes entre eux.

=== Master Theorem ===

Afin de déterminer la complexité de certains algorithmes récursifs, nous utiliserons le "Master Theorem".

Ce théorème permet d'obtenir directement l'ordre de grandeur de nombreuses relations de récurrence apparaissant dans l'analyse d'algorithmes de type « diviser pour régner », comme l'algorithme de Karatsuba ou celui de Strassen.

La démonstration complète de ce théorème dépasse le cadre de notre projet et nécessite des connaissances mathématiques plus avancées. Nous l'utiliserons donc principalement comme un outil nous permettant de déterminer efficacement la complexité asymptotique des algorithmes étudiés.

=== Graphiques ===

Les complexités étant des fonctions, nous pouvons les représenter par un graphique qui affichera le temps d'exécution (ou nombre d'opérations) en fonction de la taille des entrées.

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:30px; text-align:center;">
[[Fichier:complexite.webp|500px]]
<div><b>Graphiques des complexités</b></div>
</div>
<div style="max-width:800px;">
<p>Ce graphique ci-contre compare les complexités en fonction de la taille des d'entrées.</p>
<p>On comprend ainsi que certaines complexités ne sont pas raisonnable dans la cadre de la multiplication de grands entiers.</p>
<p>C'est pourquoi l'étude de ces algorithmes s'avère nécessaire.</p>
</div>
</div>

=== Exemple ===
L'algorithme naïf d'addition que nous avons tous appris à l'école a une complexité de <math>\mathcal{O}(n)</math>.
Soit n la taille des nombres en entrée, l'algorithme doit faire environ n addition pour arriver au résultat demandé.

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Addition.gif|220px]]
<div><b>Addition naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Comme le montre l'exemple ci-contre, 786 et 467 font 3 chiffres de long donc n sera de 3.</p>
<p>Il nous faudra 3 opérations pour additionner ces entiers.</p>
<p>C'est ainsi qu'avec une taille d'entrée n, l'algorithme de l'addition naïve va devoir faire n opérations.</p>
<p>Cet algorithme a donc une complexité <math>f(n) = n</math> qui n'a pas besoin d'être approximée.</p>
<p>Ainsi sa complexité finale sera <math>\mathcal{O}(n)</math>.</p>
</div>
</div>

= Problématique =

Le calcul du produit de deux entiers de manière naïve a une complexité de <math> \mathcal{O}(n^2)</math>, et celui de deux matrices une complexité de <math> \mathcal{O}(n^3)</math>. Afin de mieux comprendre ce qu'est la complexité algorithmique, nous devrons implémenter des algorithmes ayant le même objectif, mais étant plus efficaces. Ces algorithmes s'avèreront plus complexes mais devrait aboutir à un calcul plus rapide du produit demandé.

Nous séparerons notre wiki en deux grandes parties, la première concernera nos recherche sur [[#I - Produit d'entiers|la multiplication d'entiers]], la deuxième sur [[#II - Produit de matrices|la multiplication de matrices]].

= I - Produit d'entiers =

Notre départ commence avec l'algorithme de multiplication d'entier naïf.
En effet il s'agit de l'algorithme de multiplication le plus connu, et nous l'utiliserons comme référence pour le comparer aux futurs algorithmes plus efficaces.
Intéressons nous à sa complexité.

== 1) Nos implémentations des grands entiers ==

Qui dit produit de grands entiers dit implémentation de grands entiers.

Dans le cadre de nos recherches, nous allons devoir implémenter des algorithmes qui vont manipuler des grands entiers.

Nous avons donc choisi de créer deux représentations différentes de ceux-ci (car nous travaillons sur différents langages de programmation), nous permettant à la fois une implémentation simplifié, mais aussi de nous rapprocher d'une implémentation bas niveau.

=== A) En python ===
En python, l'utilisation des "bytes" m'a grandement servi à comprendre comment les entiers étaient manipulés à bas niveau. En effet, un des objectifs secondaires de nos recherches était de manipuler des entiers directement avec leur formes stockées sur l'ordinateur, et non pas avec des int python.
En effet l'utilisation des int python nous aurait permit de passer les étapes de retenues, de signes... D'autant plus que les bytes permettent de stocker un nombre en base 256, ce qui permet de visualiser plus facilement les grands entiers.

La forme finale de la représentation des grands entiers en python sera donc la suivante :

[ signe , bytes , bytes , (...) , bytes ]

Le signe est représenté par un entier, 1 si le nombre est positif, 0 sinon.
Cette configuration rendra plus simple la gestion des signes.

=== B) En C++ ===

En C++, pour avoir une représentation de grand entiers j'ai du définir ma propre structure pour m'affranchir de la limite de taille imposé par les entiers standards: (int32 ou int64). Pour cela, j'ai une structure qui possède l'équivalent d'un array de byte (ce qui nous permet d'être en base 256 au lieu de la base 10 habituelle), et pour traiter le signe j'utilise un booléen, ainsi en mémoire j'ai une structure de n*Octets + 1 octet en taille.

[ bytes , bytes , (...) , bytes ] [ signe ]

Le booléen prend 1 octet de place mais ne touche pas aux octets qui encode le grand entier.
Cette configuration rendra plus simple la gestion des signes dans le cadre des multiplication.

== 2) La multiplication naïve ==

=== A) Fonctionnement ===
Dans le cas de la multiplication d'entiers, nous allons prendre deux nombres qui n'ont pas nécessairement la même longueur. Soit les nombre a et b, de longueur respective <math>n</math> et <math>m</math>.
<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Multiplication.png|220px]]
<div><b>Multiplication naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Prenons deux nombres de longueur 3 et 2, et cherchons combien d'opérations l'algorithme de multiplication naïve va devoir faire pour nous renvoyer leur produit.</p>
<p>Dans un premier temps, on remarque que l'on va devoir multiplier chaque chiffre du nombre du haut par le chiffre des unités du bas, qui est 6. Cela va représenter <math>n</math> opérations. (6x5, 6x1 et 6x4)</p>
<p>Dans un deuxième temps nous constatons que nous allons devoir faire la même chose avec le chiffre des dizaines du nombre du bas. Cela nous ajoute de nouveau <math>n</math> opérations.</p>
<p>On arrive assez facilement à la conclusion que pour faire notre produit, il va nous falloir faire <math>n</math> fois <math>m</math> opérations.</p>
</div>
</div>

Ainsi, la complexité de la multiplication naïve est <math>\mathcal{O}(n^2)</math>.
Il est en de même avec la multiplication naïve récursive.

=== B) Graphique ===
Montrons maintenant sa courbe sur un graphique :

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Multiplicationnaive.png|500px]]
<div><b>Multiplication naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Les points noirs sont des repères pour que les autres courbes aient une forme cohérente.</p>
<p>Ils sont tous sur l'axe des abscisses.</p>
<p>La courbe rouge représente la complexité de la multiplication naïve.</p>
<p>On remarque que la courbe a un visuel très similaire à la fonction <math>f(x) = x^2</math> </p>
</div>
</div>

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Naif_recursif.png|500px]]
<div><b>Multiplication naïve récursive</b></div>
</div>
<div style="max-width:800px;">
<p>La courbe rouge représente la complexité de la multiplication naïve récursive.</p>
<p>Elle sera utilisé pour comparer les complexités entre algorithmes car, comme tous récursifs, elle a été codé avec les mêmes biais d'implémentation qu'eux.</p>
<p>Théoriquement les deux courbes ci-contre ont la même complexité, mais encore une fois, notre implémentation n'est pas parfaitement optimale et donc ne respecte pas de manière minutieuse le Master Theorem.</p>
</div>
</div>

== 3) La multiplication karatsuba ==

=== A) Fonctionnement ===

L'algorithme de karatsuba est un algorithme récursif de type diviser pour régner.

L'idée générale de l'algorithme est de passer de 4 multiplication à 3. En effet ces opérations étant moins couteuses, il est préférable d'en ajouter si cela permet d'enlever des multiplications.

L'algorithme de multiplication naif récursif utilise la segmentation des facteurs en deux de manière successive.

Soit <math>x</math> et <math>y</math> deux facteurs, nous avons les égalités suivantes :

<div style="font-size: 20px;">
<math>x = a \times B^{n/2} + b</math>
<math>y = c \times B^{n/2} + d</math>
</div>

Avec <math>a</math> et <math>c</math> les premières moitiés des facteurs <math>x</math> et <math>y</math>,
et <math> b </math> et <math>d</math> les dernières moitiés de ces facteurs ainsi que <math>B</math> la base d'écriture du nombre (Nous sommes en base 256 avec les bytes).

Cette présentation des deux facteurs de notre multiplication n'est que la résultante d'un découpage.
Le [[#Master Theorem|Master Theorem]] nous montre que :

<div style="font-size: 20px;">
<math>T(n) = 4T(n/2) + O(n)</math>
</div>

Puisque nous avons après découpage 4 entiers de longueur <math>n/2</math>.

Ainsi, ce découpage ne permet pas de gagner du temps d'après le [[#Master Theorem|Master Theorem]].

Cependant, l'algorithme de Karatsuba réutilise ce principe en le modifiant, ce qui nous permet de baisser la complexité globale de la multiplication dans son entièreté.

Avec l'écriture ci-dessus des nombres <math>x</math> et <math>y</math>, on peut facilement en déduire l'égalité suivante :

<div style="font-size: 20px;">
<math>x \times y = (ac) \times B^n + (ad + bc) \times B^{n/2} + bd</math>
</div>

On remarque 4 multiplications longues à faire dans cette expression. Les multiplications dont <math>B</math> est l'un des facteurs sont très rapides puisqu'il s'agit de la base dans laquelle nous travaillons. De cela en résulte un décalage plutôt qu'un vrai calcul à faire.

Karatsuba développe une partie de cette expression pour pouvoir négocier une multiplication au prix d'additions et soustractions.

En effet, nous savons déjà que :

<div style="font-size: 20px;">
<math>(a + b)(c + d) = ac + ad + bc + bd</math>
</div>

En manipulant l'égalité nous obtenons :

<div style="font-size: 20px;">
<math>ad + bc = (a + b)(c + d) - ac - bd</math>
</div>

ac et bd ayant déjà été calculé précédemment, il nous reste uniquement la multiplication <math>(a + b)(c + d)</math>.

Nous venons ainsi de calculer <math>ad + bc</math> en seulement une multiplication. C'est la que repose le gain de temps de la méthode Karatsuba par rapport à la multiplication naïve.

En effet, l'algorithme n'effectuera alors plus que 3 multiplications :
<div style="font-size: 20px;">
<math>ac</math>
<math>bd</math>
<math>(a + b)(c + d)</math>
</div>

La relation de récurrence devient donc :
<div style="font-size: 20px;">
<math>T(n)=3T(n/2)+O(n)</math>
</div>

Et le Master Theorem nous dit que :
<div style="font-size: 20px;">
<math>T(n)\in O(n^{\log_2(3)})</math>
</div>

Or <math>\log_2(3)\approx 1.585</math>, donc la complexité de l'algorithme de Karatsuba est de <math> \mathcal{O}(n^{1.585})</math>. Ce qui est bien plus efficace que la multiplication classique, surtout lorsque les facteurs deviennent très grands.

=== B) Graphique ===
<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Karatsuba.png|500px]]
<div><b>Karatsuba</b></div>
</div>
<div style="max-width:800px;">
<p>Sur le graphique ci-contre nous avons utilisé la courbe de la multiplication naïve récursive (rouge) à titre de comparaison.</p>
<p>On remarque graphiquement que Karatsuba (jaune) prend moins de temps à chaque calcul de produit.</p>
<p>On en déduit donc expérimentalement que Karatsuba à une meilleure complexité que la multiplication naïve.</p>
<p>Ainsi nous vérifions donc ce que le Master Theorem prouve, c'est à dire que la complexité de karatsuba est de <math> \mathcal{O}(n^{1.585})</math> </p>
</div>
</div>

== 4) La multiplication toom-cook-3 ==

=== A) Fonctionnement ===

L'objectif est de diviser les grands entiers X et Y en trois blocs de taille égale k.
On les traite alors comme des polynômes de degré 2:

<math>P(z) = X_2 \cdot z^2 + X_1 \cdot z + X_0</math>
<math>Q(z) = Y_2 \cdot z^2 + Y_1 \cdot z + Y_0</math>

On choisit 5 points distincts pour évaluer nos polynômes.
Ce choix de 5 points est crucial car le produit de deux polynômes de degré 2 est un polynôme de degré 4, qui nécessite 5 points pour être défini.
Les points standards sont :

P(0) = X0
P(1) = X0 + X1 + X2
P(-1) = X0 - X1 + X2
P(2) = X0 + 2*X1 + 4*X2
P(inf) = X2

(On procède de manière similaire pour Q.)

Ensuite nous multiplions récursivement chaque points de P et de Q ensemble.
On effectue ainsi 5 multiplications de nombres plus petits au lieu des 9 multiplications requises par la méthode classique.

Après, nous effectuons une interpolation, cela permet de retrouver les 5 coefficients (w_0, w_1, w_2, w_3, w_4) du polynôme produit R(z) à partir des valeurs évaluées calculées précédemment.
On résout un système d'équations linéaires : <math> R(z) = w_4 z^4 + w_3 z^3 + w_2 z^2 + w_1 z + w_0 </math>
Finalement nous pouvons recomposer notre grand entier en positionnant les coefficients w_i aux bons rangs (en les décalant) et à gérer les retenues lors de l'addition finale:
<math>Résultat = w_4 B^{4k} + w_3 B^{3k} + w_2 B^{2k} + w_1 B^k + w_0</math>

=== B) Graphique ===

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Toomcook.png|500px]]
<div><b>Karatsuba</b></div>
</div>
<div style="max-width:800px;">
<p>on a reprit multi récursive (rouge)</p>
<p>on voit que Toom (vert) en dessous de karatsuba (jaune) en dessous de multi classique (rouge)</p>
<p>meilleur complexité</p>
</div>
</div>

== 5) La transformée de Fourier rapide ==

=== A) Fonctionnement ===

La transformation de Fourier rapide étant plus complexe que les autres algorithmes, nous allons essayer d'expliquer son fonctionnement malgré ne pas avoir réussi à l'implémenter.

Il faut comprendre que cet algorithme va considérer les facteurs comme des polynômes.

D'après le théorème de l'unisolvance, il n'existe qu'un seul polynôme de degré inférieur ou égal à <math> n </math> défini par <math>n + 1</math> points distincts. Cela implique non seulement que nous pouvons représenter chaque entier par un polynôme, mais également que si nous pouvons retrouver <math>n + m + 1</math> points (avec <math>n</math> et <math>m</math> la longueur des facteurs) du polynômes issue du produit entre deux facteurs, nous pourrons le retrouver.

Soit un entier quelconque, de forme :

<math>a_n a_{n-1} (...) a_1 a_0</math>

Avec <math>a_i</math>, un chiffre composant le nombre en base 10, qui vaut en réalité dans le nombre : <math>a_i \times 10^i</math>. On peut ainsi l'écrire sous la forme :

<math> P(x) = a_0 + a_1x + a_2x^2 + \dots + a_{n-1}x^{n-1} + a_nx^n </math>

Avec <math>x = 10</math> car nous sommes en base 10, nous obtenons :

<math>P(10) = a_0 + a_1 \times 10 + \dots + a_{n-1}10^{n-1} + a_n10^n </math>

Nous venons ainsi d'écrire notre nombre sous la forme d'un polynôme unique. Pour nous permettre d'évaluer en un nombre suffisant de points, nous allons devoir ajouter des 0 pour la récursion. Il nous faudra ajouter assez de 0 pour atteindre la prochaine puissance de 2 qui sera supérieure ou égale à <math>2n + 1</math>. L'ajout de 0 ne change pas le nombre car <math>0 \times x^n</math> n'ajoute pas de coefficient.

Cet algorithme est récursif et va segmenter en deux parties nos polynômes à chaque récursion. D'un coté les indice pairs et d'un coté les impaires.

Ainsi prenons les nombres 1234 et 5678, ces nombres sont respectivement représentés par les polynômes <math> P(x) = 4 + 3x + 2x^2 + x^3 </math> et <math> P(x) = 8 + 7x + 6x^2 + 5^3 </math>. Ce sont des polynômes de degré 3, ainsi leur produit donnera lieu à un polynôme de degré 6. Il nous faudra donc au minimum 7 points d'évaluation pour retrouve ce produit. De ce fait, en les représentant de la manière suivante :

<math>[4, 3, 2, 1, 0, 0, 0, 0]</math>
<math>[8, 7, 6, 5, 0, 0, 0, 0]</math>

Nous aurons assez de récursions possible pour les évaluer en un nombre suffisant de points différents car nous auront 3 récursions à faire pour atteindre notre cas de base. A chaque récursion, nous allons diviser nos polynômes en deux parties ce qui nous fait 8 feuilles à la dernière récursion.

En effet à chaque étape de la récursion nous allons séparer nos polynômes en deux tel que :

<math>P(x)=P_{\text{pair}}(x^2) + x \cdot P_{\text{impair}}(x^2)</math>

Durant les récursions, nous segmentons les polynômes mais ne les évaluons pas. C'est à la remonté des récursions que nous allons réellement évaluer nos polynômes. Lorsque l'on atteint notre cas de base, c'est à dire des polynômes de degré 0, nous remarquons qu'ils sont constants, nous n'avons donc pas besoin de les évaluer. En effet, peut importe le point en lequel nous voudrons l'évaluer, le polynôme renverra la constante. Nous la renvoyons donc seule.
Ensuite commence la remontée des récursions. A l'étape 1 de notre remontée nous allons reformer le polynôme précédemment séparé pour obtenir un polynôme de degré 1. Puis, nous évaluons ce polynôme avec les racines seconde de l'unité. Nous faisons à nouveau remonté les évaluations et recombinons à nouveau le polynôme qui sera ainsi de degré 2.
Nous l'évaluons maintenant avec les racines 4eme de l'unité. A chaque évaluation, nous réutilisons les résultats précédents, cela nous est permit par les racines de l'unité qui ont une structure récursive exploitable.

Finalement, nous arrivons à la fin de notre FFT, avec une représentation fréquentielle de la forme :

<math> [P(W_0), P(W_1), (...), P(W_n-1), P(W_n)] </math>

Cette représentation fréquentielle n'est autre que les évaluations du polynôme P aux racines nièmes de l'unité. Nous avons donc maintenant au minimum <math>2n+1</math> évaluations des polynômes facteurs. Il nous faut maintenant trouver les évaluations du produit final, c'est à dire les évaluations concernant le polynôme qui sera issue de la multiplication. On pourra ainsi le retrouver.

Soit <math>C</math> un polynome tel que <math> C = A \times B </math>, alors on a :

<math> C(x) = A(x) \times B(x) </math>

Ainsi on en déduit que <math> C(W_n^k) = A(W_n^k) \times B(W_n^k) </math>

On comprend donc que <math>FFT(C) = FFT(A) \times FFT(B)</math>

Il faut préciser que l'on fait le produit de FFT(A) et FFT(B) terme à terme, soit évaluation par évaluation.

Une fois en possession de <math>FFT(C)</math>, qui n'est autre que l'évaluation de notre polynôme final en un nombre suffisant de points pour le retrouver, nous pouvons faire l'<math>IFFT(FFT(C))</math>, qui va nous permettre de retrouver les coefficients de notre polynôme en faisant l'exacte inverse de la FFT.

Une fois les coefficients retrouvés, il nous suffit de gérer les retenues, et nous retrouvons un entier de la forme : <math>a_0 a_1 (...) a_{n-1} a_n</math>

=== B) Graphique ===

Intéressons nous maintenant à la complexité de l'algorithme utilisant la transformée de Fourier rapide. On sait que l'algorithme passe par 5 étapes importantes :

<ul>
<li>Etape 1 : Ecrire les deux facteurs sous la forme de polynômes</li>
<li>Etape 2 : Effectuer la <math>FFT</math> des deux polynômes</li>
<li>Etape 3 : Faire le produit terme à terme des <math>FFT</math> obtenues</li>
<li>Etape 4 : Faire l'<math>IFFT</math> du produit</li>
<li>Etape 5 : Gérer les retenues et écrire le nombre qui en découle</li>
</ul>

Or, parmi toutes ces étapes, certaines sont négligeable comme l'étape 1 et 5.

Pour connaitre la complexité de l'algorithme, additionnons les complexités des étapes restantes :

Une <math>FFT</math> a une complexité de <math>\mathcal{O}(n\times logn)</math> car elle fait <math>n</math> évaluation sur <math> log(n)</math> récursions. Dans le cadre de notre algorithme, nous devons faire la <math>FFT</math> de nos deux facteurs. Soit <math>2\times \mathcal{O}(n\times logn)</math>.

Pour le produit terme à terme, nous faisons naturellement <math>n</math> opérations.

Pour finir, l'<math>IFFT</math> a la même complexité que la <math>FFT</math>. Dans le cadre de notre algorithme nous l'emploierons qu'une seule fois, ce qui fait une complexité de <math>\mathcal{O}(n\times logn)</math>.

Après addition de toutes ces complexités, nous obtenons la complexité réelle de <math>3\mathcal{O}(n\times logn) + \mathcal{O}(n)</math>.

D'après le Master Theorem, nous avons donc <math> f(n) = 3(n\times logn)+n </math>, cherchons <math>f(n)\in\mathcal{O}(g(n))</math> :

Nous pouvons ignorer les expressions linéaires ainsi que les constantes multiplicatrices, nous obtenons donc <math>\mathcal{O}(g(n)) = \mathcal{O}(n \times log n)</math>.

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:30px; text-align:center;">
[[Fichier:FFT_image.webp|500px]]
<div><b>Graphiques des complexités</b></div>
</div>
<div style="max-width:800px;">
<p>Ce graphique ci-contre ne provient pas du fruit de nos recherches personnelles mais </p>
<p>On comprend ainsi que certaines complexités ne sont pas raisonnable dans la cadre de la multiplication de grands entiers.</p>
<p>C'est pourquoi l'étude de ces algorithmes s'avère nécessaire.</p>
</div>
</div>

= II - Produit de matrices =

== 1.1) naïve ==

La multiplication naïve de matrice requiert d'avoir des tailles de lignes/colonne semblable, ensuite pour chaque membre de la matrice résultat, on doit multiplier les composantes ligne de la première matrice par les composantes colonne de la deuxième et le tout sommé.

On en déduit la formule suivante:
<math>C_{i,j} = \sum_{k=1}^{n} (A_{i,k} \times B_{k,j})</math>

Et visuellement:

[[Fichier:Matricenaive.jpeg]]

On a donc un algorithme d'ordre de complexité <math>\mathcal{O}(g(n))</math>

== 1.2) naïve récursive ==

Dans un premier temps on doit découper nos deux matrices en quatres sous matrices de plus petite taille.
<math>A = \begin{pmatrix} A_{11} & A_{12} \ A_{21} & A_{22} \end{pmatrix}</math>
<math>B = \begin{pmatrix} B_{11} & B_{12} \ B_{21} & B_{22} \end{pmatrix}</math>

Ensuite on vient calculer la matrice résultat.
<math>C_{11} = (A_{11} \times B_{11}) + (A_{12} \times B_{21})</math>
<math>C_{12} = (A_{11} \times B_{12}) + (A_{12} \times B_{22})</math>
<math>C_{21} = (A_{21} \times B_{11}) + (A_{22} \times B_{21})</math>
<math>C_{22} = (A_{21} \times B_{12}) + (A_{22} \times B_{22})</math>

Le côté récursif est utile que pour les matrices de tailles <= 32 (32 valeurs stockées dedans),
si on est au dessus de cette taille alors on divisera à nouveau nos matrices en quatres.
On aura 8 multiplications mais de plus petite taille au final.

== 2) strassen ==

=== A) Fonctionnement ===

Strassen consiste à définir 7 produits intermédiaires qui, par des jeux de sommes et de différences, permettent de reconstruire les quadrants de la matrice résultante. On passe ainsi d'une complexité de O(n^3) à environ O(n^2.81)

=== B) Graphique ===

On voit bien la différence de complexité sur la multiplication de grande matrice entre l'approche naïve et l'approche récursive qui est beaucoup plus rapide.

[[Fichier:Analyse matrices.png]]

= Conclusion =

L'étude de ces algorithmes de multiplication nous a clairement montré l'évolution de la complexité algorithmique permettant de gagner en efficacité lorsque la taille des données augmente.

La multiplication classiqe, en <math>\mathcal{O}(n^2)</math>, résulte d'une approche naïve qui devient rapidement inefficace pour les grands entiers ou les grandes matrices. L'algorithme de Karatsuba nous montre qu'organiser de manière intelligente ses calculs algébrique permet parfois de gagner beaucoup de multiplications, et donc de temps. Nous avons ainsi réussi à passer d'une complexité de <math>\mathcal{O}(n^2)</math> à <math>\mathcal{O}(n^{log_2(3)})</math>, soit environ <math>\mathcal{O}(n^{1/585})</math>.

Des méthodes encore plus avancées comme utilise l'algorithme de Toom-Cook-3 continue dans cette idées de divisions d'entiers en blocs plus petits, tandis que la transformée de Fourier rapide change complètement de point de vue. En effet la FFT n'utilise pas la représentation classique des entiers mais fait appel à une vision polynomiale, ce qui transforme la convolution classique en multiplication terme à terme, ce qui lui permet d'atteindre une complexité de <math>\mathcal{O}(n \times log n)</math>.

Dans le cas des matrices, les mêmes logiques apparaissent comme par exemple avec l'algorithme de Strassen qui se rapproche très fortement de Karatsuba en combinant de manière astucieuse les parties d'entiers qui avaient été précédemment découpée.

On remarque néanmoins que la majorité des algorithmes efficaces s'orientent vers une approche récursive et non itérative. Néanmoins, nous avons pu trouver certaines de ces implémentations (comme par exemple la FFT) en itérative.

Avec ces recherches, nous comprenons que la réorganisations des calculs algébriques peuvent aider à gagner en complexité mais que pour faire de réels progrès, il nous faudra surement changer notre point de vue une nouvelle fois, et aborder le problème sous un angle nouveau comme le font dors et déjà les algorithmes les plus performants.

= Mentions =

Le premier gif est le résultat du travail de 'Walké', licence ci-contre : https://fr.wikipedia.org/wiki/Fichier:Addition.gif

= Sources =

Pour karatsuba :
<ul>
<li> https://www.youtube.com/watch?v=PZ2gdWdKHAA </li>
</ul>

Pour mieux comprendre la FFT, nous avons utilisé plusieurs sources d'informations :
<ul>
<li> https://www.youtube.com/watch?v=h7apO7q16V0&list=WL&index=1&t=886s </li>
<li> https://fr.wikipedia.org/wiki/Interpolation_polynomiale </li>
</ul>

Algorithmes de multiplications d'entiers et de matrices

2026-05-11T18:37:12Z

Mangala : /* A) Fonctionnement */

= Introduction =

Depuis l'apparition des ordinateurs modernes, une quantité faramineuse de calculs a dû être effectuée. Les progressions technologiques nous poussent à envisager la puissance de calcul comme une ressource qu'il faut optimiser dans les moindres détails. C'est ainsi que l'optimisation des algorithmes de calcul est devenue cruciale, surtout lorsqu'il nous faut effectuer des opérations sur de très grands entiers par exemple.

= Objectif =

L'objectif majeur de ce projet est de comprendre de manière plus approfondie ce qu'est la '''complexité algorithmique'''.
Pour atteindre cet objectif, nous implémenterons plusieurs algorithmes de multiplication qui auront pour but de calculer le produit de grands entiers ou de matrices.

= Point important : complexité =

=== Définition ===
La complexité d'un algorithme est la quantité des ressources qu'il utilise en fonction de la taille des entrées qu'on lui demande de traiter. On peut par exemple se concentrer sur le temps qu'un algorithme prend pour renvoyer un résultat ou sur la mémoire dont il a besoin. Dans le cadre de notre projet, nous nous attarderons plus particulièrement sur la quantité de calcul effectuée en fonction de la taille des entrées, ce qui est par ailleurs étroitement liée à la notion de temps. De manière générale, plus un algorithme doit faire de calcul, plus il est lent. (Attention, toutes les opérations arithmétiques de base ne se valent pas)

De manière plus familière, on dira que la complexité d'un algorithme pourrait s'apparenter à son comportement lorsqu'il doit traiter des données plus ou moins grandes.
Chaque algorithme a une complexité, et on l'exprime par une fonction qui adopte un comportement similaire au nombre de calculs nécessaires en fonction de la taille des entrées.

=== Notation ===
La complexité réelle d'un algorithme peut être décrite par une fonction <math>f(n)</math> représentant le nombre d'opérations effectuées en fonction de la taille <math>n</math> des données d'entrée.

Cependant, afin de simplifier l'étude de cette croissance, on utilise généralement une borne asymptotique notée <math>\mathcal{O}(g(n))</math>, où <math>g(n)</math> est une fonction ayant le même ordre de grandeur que <math>f(n)</math> lorsque <math>n</math> devient grand.

On dit alors que :

<math>
f(n)\in\mathcal{O}(g(n))
</math>

si et seulement s'il existe une constante <math>C>0</math> et un entier <math>n_0</math> tels que :

<math>
\forall n\ge n_0,\ f(n)\le Cg(n)
</math>

Cette notation <math>\mathcal{O}(g(n))</math> permettra de comparer beaucoup plus facilement les algorithmes entre eux.

=== Master Theorem ===

Afin de déterminer la complexité de certains algorithmes récursifs, nous utiliserons le "Master Theorem".

Ce théorème permet d'obtenir directement l'ordre de grandeur de nombreuses relations de récurrence apparaissant dans l'analyse d'algorithmes de type « diviser pour régner », comme l'algorithme de Karatsuba ou celui de Strassen.

La démonstration complète de ce théorème dépasse le cadre de notre projet et nécessite des connaissances mathématiques plus avancées. Nous l'utiliserons donc principalement comme un outil nous permettant de déterminer efficacement la complexité asymptotique des algorithmes étudiés.

=== Graphiques ===

Les complexités étant des fonctions, nous pouvons les représenter par un graphique qui affichera le temps d'exécution (ou nombre d'opérations) en fonction de la taille des entrées.

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:30px; text-align:center;">
[[Fichier:complexite.webp|500px]]
<div><b>Graphiques des complexités</b></div>
</div>
<div style="max-width:800px;">
<p>Ce graphique ci-contre compare les complexités en fonction de la taille des d'entrées.</p>
<p>On comprend ainsi que certaines complexités ne sont pas raisonnable dans la cadre de la multiplication de grands entiers.</p>
<p>C'est pourquoi l'étude de ces algorithmes s'avère nécessaire.</p>
</div>
</div>

=== Exemple ===
L'algorithme naïf d'addition que nous avons tous appris à l'école a une complexité de <math>\mathcal{O}(n)</math>.
Soit n la taille des nombres en entrée, l'algorithme doit faire environ n addition pour arriver au résultat demandé.

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Addition.gif|220px]]
<div><b>Addition naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Comme le montre l'exemple ci-contre, 786 et 467 font 3 chiffres de long donc n sera de 3.</p>
<p>Il nous faudra 3 opérations pour additionner ces entiers.</p>
<p>C'est ainsi qu'avec une taille d'entrée n, l'algorithme de l'addition naïve va devoir faire n opérations.</p>
<p>Cet algorithme a donc une complexité <math>f(n) = n</math> qui n'a pas besoin d'être approximée.</p>
<p>Ainsi sa complexité finale sera <math>\mathcal{O}(n)</math>.</p>
</div>
</div>

= Problématique =

Le calcul du produit de deux entiers de manière naïve a une complexité de <math> \mathcal{O}(n^2)</math>, et celui de deux matrices une complexité de <math> \mathcal{O}(n^3)</math>. Afin de mieux comprendre ce qu'est la complexité algorithmique, nous devrons implémenter des algorithmes ayant le même objectif, mais étant plus efficaces. Ces algorithmes s'avèreront plus complexes mais devrait aboutir à un calcul plus rapide du produit demandé.

Nous séparerons notre wiki en deux grandes parties, la première concernera nos recherche sur [[#I - Produit d'entiers|la multiplication d'entiers]], la deuxième sur [[#II - Produit de matrices|la multiplication de matrices]].

= I - Produit d'entiers =

Notre départ commence avec l'algorithme de multiplication d'entier naïf.
En effet il s'agit de l'algorithme de multiplication le plus connu, et nous l'utiliserons comme référence pour le comparer aux futurs algorithmes plus efficaces.
Intéressons nous à sa complexité.

== 1) Nos implémentations des grands entiers ==

Qui dit produit de grands entiers dit implémentation de grands entiers.

Dans le cadre de nos recherches, nous allons devoir implémenter des algorithmes qui vont manipuler des grands entiers.

Nous avons donc choisi de créer deux représentations différentes de ceux-ci (car nous travaillons sur différents langages de programmation), nous permettant à la fois une implémentation simplifié, mais aussi de nous rapprocher d'une implémentation bas niveau.

=== A) En python ===
En python, l'utilisation des "bytes" m'a grandement servi à comprendre comment les entiers étaient manipulés à bas niveau. En effet, un des objectifs secondaires de nos recherches était de manipuler des entiers directement avec leur formes stockées sur l'ordinateur, et non pas avec des int python.
En effet l'utilisation des int python nous aurait permit de passer les étapes de retenues, de signes... D'autant plus que les bytes permettent de stocker un nombre en base 256, ce qui permet de visualiser plus facilement les grands entiers.

La forme finale de la représentation des grands entiers en python sera donc la suivante :

[ signe , bytes , bytes , (...) , bytes ]

Le signe est représenté par un entier, 1 si le nombre est positif, 0 sinon.
Cette configuration rendra plus simple la gestion des signes.

=== B) En C++ ===

En C++, pour avoir une représentation de grand entiers j'ai du définir ma propre structure pour m'affranchir de la limite de taille imposé par les entiers standards: (int32 ou int64). Pour cela, j'ai une structure qui possède l'équivalent d'un array de byte (ce qui nous permet d'être en base 256 au lieu de la base 10 habituelle), et pour traiter le signe j'utilise un booléen, ainsi en mémoire j'ai une structure de n*Octets + 1 octet en taille.

[ bytes , bytes , (...) , bytes ] [ signe ]

Le booléen prend 1 octet de place mais ne touche pas aux octets qui encode le grand entier.
Cette configuration rendra plus simple la gestion des signes dans le cadre des multiplication.

== 2) La multiplication naïve ==

=== A) Fonctionnement ===
Dans le cas de la multiplication d'entiers, nous allons prendre deux nombres qui n'ont pas nécessairement la même longueur. Soit les nombre a et b, de longueur respective <math>n</math> et <math>m</math>.
<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Multiplication.png|220px]]
<div><b>Multiplication naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Prenons deux nombres de longueur 3 et 2, et cherchons combien d'opérations l'algorithme de multiplication naïve va devoir faire pour nous renvoyer leur produit.</p>
<p>Dans un premier temps, on remarque que l'on va devoir multiplier chaque chiffre du nombre du haut par le chiffre des unités du bas, qui est 6. Cela va représenter <math>n</math> opérations. (6x5, 6x1 et 6x4)</p>
<p>Dans un deuxième temps nous constatons que nous allons devoir faire la même chose avec le chiffre des dizaines du nombre du bas. Cela nous ajoute de nouveau <math>n</math> opérations.</p>
<p>On arrive assez facilement à la conclusion que pour faire notre produit, il va nous falloir faire <math>n</math> fois <math>m</math> opérations.</p>
</div>
</div>

Ainsi, la complexité de la multiplication naïve est <math>\mathcal{O}(n^2)</math>.
Il est en de même avec la multiplication naïve récursive.

=== B) Graphique ===
Montrons maintenant sa courbe sur un graphique :

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Multiplicationnaive.png|500px]]
<div><b>Multiplication naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Les points noirs sont des repères pour que les autres courbes aient une forme cohérente.</p>
<p>Ils sont tous sur l'axe des abscisses.</p>
<p>La courbe rouge représente la complexité de la multiplication naïve.</p>
<p>On remarque que la courbe a un visuel très similaire à la fonction <math>f(x) = x^2</math> </p>
</div>
</div>

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Naif_recursif.png|500px]]
<div><b>Multiplication naïve récursive</b></div>
</div>
<div style="max-width:800px;">
<p>La courbe rouge représente la complexité de la multiplication naïve récursive.</p>
<p>Elle sera utilisé pour comparer les complexités entre algorithmes car, comme tous récursifs, elle a été codé avec les mêmes biais d'implémentation qu'eux.</p>
<p>Théoriquement les deux courbes ci-contre ont la même complexité, mais encore une fois, notre implémentation n'est pas parfaitement optimale et donc ne respecte pas de manière minutieuse le Master Theorem.</p>
</div>
</div>

== 3) La multiplication karatsuba ==

=== A) Fonctionnement ===

L'algorithme de karatsuba est un algorithme récursif de type diviser pour régner.

L'idée générale de l'algorithme est de passer de 4 multiplication à 3. En effet ces opérations étant moins couteuses, il est préférable d'en ajouter si cela permet d'enlever des multiplications.

L'algorithme de multiplication naif récursif utilise la segmentation des facteurs en deux de manière successive.

Soit <math>x</math> et <math>y</math> deux facteurs, nous avons les égalités suivantes :

<div style="font-size: 20px;">
<math>x = a \times B^{n/2} + b</math>
<math>y = c \times B^{n/2} + d</math>
</div>

Avec <math>a</math> et <math>c</math> les premières moitiés des facteurs <math>x</math> et <math>y</math>,
et <math> b </math> et <math>d</math> les dernières moitiés de ces facteurs ainsi que <math>B</math> la base d'écriture du nombre (Nous sommes en base 256 avec les bytes).

Cette présentation des deux facteurs de notre multiplication n'est que la résultante d'un découpage.
Le [[#Master Theorem|Master Theorem]] nous montre que :

<div style="font-size: 20px;">
<math>T(n) = 4T(n/2) + O(n)</math>
</div>

Puisque nous avons après découpage 4 entiers de longueur <math>n/2</math>.

Ainsi, ce découpage ne permet pas de gagner du temps d'après le [[#Master Theorem|Master Theorem]].

Cependant, l'algorithme de Karatsuba réutilise ce principe en le modifiant, ce qui nous permet de baisser la complexité globale de la multiplication dans son entièreté.

Avec l'écriture ci-dessus des nombres <math>x</math> et <math>y</math>, on peut facilement en déduire l'égalité suivante :

<div style="font-size: 20px;">
<math>x \times y = (ac) \times B^n + (ad + bc) \times B^{n/2} + bd</math>
</div>

On remarque 4 multiplications longues à faire dans cette expression. Les multiplications dont <math>B</math> est l'un des facteurs sont très rapides puisqu'il s'agit de la base dans laquelle nous travaillons. De cela en résulte un décalage plutôt qu'un vrai calcul à faire.

Karatsuba développe une partie de cette expression pour pouvoir négocier une multiplication au prix d'additions et soustractions.

En effet, nous savons déjà que :

<div style="font-size: 20px;">
<math>(a + b)(c + d) = ac + ad + bc + bd</math>
</div>

En manipulant l'égalité nous obtenons :

<div style="font-size: 20px;">
<math>ad + bc = (a + b)(c + d) - ac - bd</math>
</div>

ac et bd ayant déjà été calculé précédemment, il nous reste uniquement la multiplication <math>(a + b)(c + d)</math>.

Nous venons ainsi de calculer <math>ad + bc</math> en seulement une multiplication. C'est la que repose le gain de temps de la méthode Karatsuba par rapport à la multiplication naïve.

En effet, l'algorithme n'effectuera alors plus que 3 multiplications :
<div style="font-size: 20px;">
<math>ac</math>
<math>bd</math>
<math>(a + b)(c + d)</math>
</div>

La relation de récurrence devient donc :
<div style="font-size: 20px;">
<math>T(n)=3T(n/2)+O(n)</math>
</div>

Et le Master Theorem nous dit que :
<div style="font-size: 20px;">
<math>T(n)\in O(n^{\log_2(3)})</math>
</div>

Or <math>\log_2(3)\approx 1.585</math>, donc la complexité de l'algorithme de Karatsuba est de <math> \mathcal{O}(n^{1.585})</math>. Ce qui est bien plus efficace que la multiplication classique, surtout lorsque les facteurs deviennent très grands.

=== B) Graphique ===
<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Karatsuba.png|500px]]
<div><b>Karatsuba</b></div>
</div>
<div style="max-width:800px;">
<p>Sur le graphique ci-contre nous avons utilisé la courbe de la multiplication naïve récursive (rouge) à titre de comparaison.</p>
<p>On remarque graphiquement que Karatsuba (jaune) prend moins de temps à chaque calcul de produit.</p>
<p>On en déduit donc expérimentalement que Karatsuba à une meilleure complexité que la multiplication naïve.</p>
<p>Ainsi nous vérifions donc ce que le Master Theorem prouve, c'est à dire que la complexité de karatsuba est de <math> \mathcal{O}(n^{1.585})</math> </p>
</div>
</div>

== 4) La multiplication toom-cook-3 ==

=== A) Fonctionnement ===

L'objectif est de diviser les grands entiers X et Y en trois blocs de taille égale k.
On les traite alors comme des polynômes de degré 2:

<math>P(z) = X_2 \cdot z^2 + X_1 \cdot z + X_0</math>
<math>Q(z) = Y_2 \cdot z^2 + Y_1 \cdot z + Y_0</math>

On choisit 5 points distincts pour évaluer nos polynômes.
Ce choix de 5 points est crucial car le produit de deux polynômes de degré 2 est un polynôme de degré 4, qui nécessite 5 points pour être défini.
Les points standards sont :

P(0) = X0
P(1) = X0 + X1 + X2
P(-1) = X0 - X1 + X2
P(2) = X0 + 2*X1 + 4*X2
P(inf) = X2

(On procède de manière similaire pour Q.)

Ensuite nous multiplions récursivement chaque points de P et de Q ensemble.
On effectue ainsi 5 multiplications de nombres plus petits au lieu des 9 multiplications requises par la méthode classique.

Après, nous effectuons une interpolation, cela permet de retrouver les 5 coefficients (w_0, w_1, w_2, w_3, w_4) du polynôme produit R(z) à partir des valeurs évaluées calculées précédemment.
On résout un système d'équations linéaires : <math> R(z) = w_4 z^4 + w_3 z^3 + w_2 z^2 + w_1 z + w_0 </math>
Finalement nous pouvons recomposer notre grand entier en positionnant les coefficients w_i aux bons rangs (en les décalant) et à gérer les retenues lors de l'addition finale:
<math>Résultat = w_4 B^{4k} + w_3 B^{3k} + w_2 B^{2k} + w_1 B^k + w_0</math>

=== B) Graphique ===

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Toomcook.png|500px]]
<div><b>Karatsuba</b></div>
</div>
<div style="max-width:800px;">
<p>on a reprit multi récursive (rouge)</p>
<p>on voit que Toom (vert) en dessous de karatsuba (jaune) en dessous de multi classique (rouge)</p>
<p>meilleur complexité</p>
</div>
</div>

== 5) La transformée de Fourier rapide ==

=== A) Fonctionnement ===

La transformation de Fourier rapide étant plus complexe que les autres algorithmes, nous allons essayer d'expliquer son fonctionnement malgré ne pas avoir réussi à l'implémenter.

Il faut comprendre que cet algorithme va considérer les facteurs comme des polynômes.

D'après le théorème de l'unisolvance, il n'existe qu'un seul polynôme de degré inférieur ou égal à <math> n </math> défini par <math>n + 1</math> points distincts. Cela implique non seulement que nous pouvons représenter chaque entier par un polynôme, mais également que si nous pouvons retrouver <math>n + m + 1</math> points (avec <math>n</math> et <math>m</math> la longueur des facteurs) du polynômes issue du produit entre deux facteurs, nous pourrons le retrouver.

Soit un entier quelconque, de forme :

<math>a_n a_{n-1} (...) a_1 a_0</math>

Avec <math>a_i</math>, un chiffre composant le nombre en base 10, qui vaut en réalité dans le nombre : <math>a_i \times 10^i</math>. On peut ainsi l'écrire sous la forme :

<math> P(x) = a_0 + a_1x + a_2x^2 + \dots + a_{n-1}x^{n-1} + a_nx^n </math>

Avec <math>x = 10</math> car nous sommes en base 10, nous obtenons :

<math>P(10) = a_0 + a_1 \times 10 + \dots + a_{n-1}10^{n-1} + a_n10^n </math>

Nous venons ainsi d'écrire notre nombre sous la forme d'un polynôme unique. Pour nous permettre d'évaluer en un nombre suffisant de points, nous allons devoir ajouter des 0 pour la récursion. Il nous faudra ajouter assez de 0 pour atteindre la prochaine puissance de 2 qui sera supérieure ou égale à <math>2n + 1</math>. L'ajout de 0 ne change pas le nombre car <math>0 \times x^n</math> n'ajoute pas de coefficient.

Cet algorithme est récursif et va segmenter en deux parties nos polynômes à chaque récursion. D'un coté les indice pairs et d'un coté les impaires.

Ainsi prenons les nombres 1234 et 5678, ces nombres sont respectivement représentés par les polynômes <math> P(x) = 4 + 3x + 2x^2 + x^3 </math> et <math> P(x) = 8 + 7x + 6x^2 + 5^3 </math>. Ce sont des polynômes de degré 3, ainsi leur produit donnera lieu à un polynôme de degré 6. Il nous faudra donc au minimum 7 points d'évaluation pour retrouve ce produit. De ce fait, en les représentant de la manière suivante :

<math>[4, 3, 2, 1, 0, 0, 0, 0]</math>
<math>[8, 7, 6, 5, 0, 0, 0, 0]</math>

Nous aurons assez de récursions possible pour les évaluer en un nombre suffisant de points différents car nous auront 3 récursions à faire pour atteindre notre cas de base. A chaque récursion, nous allons diviser nos polynômes en deux parties ce qui nous fait 8 feuilles à la dernière récursion.

En effet à chaque étape de la récursion nous allons séparer nos polynômes en deux tel que :

<math>P(x)=P_{\text{pair}}(x^2) + x \cdot P_{\text{impair}}(x^2)</math>

Durant les récursions, nous segmentons les polynômes mais ne les évaluons pas. C'est à la remonté des récursions que nous allons réellement évaluer nos polynômes. Lorsque l'on atteint notre cas de base, c'est à dire des polynômes de degré 0, nous remarquons qu'ils sont constants, nous n'avons donc pas besoin de les évaluer. En effet, peut importe le point en lequel nous voudrons l'évaluer, le polynôme renverra la constante. Nous la renvoyons donc seule.
Ensuite commence la remontée des récursions. A l'étape 1 de notre remontée nous allons reformer le polynôme précédemment séparé pour obtenir un polynôme de degré 1. Puis, nous évaluons ce polynôme avec les racines seconde de l'unité. Nous faisons à nouveau remonté les évaluations et recombinons à nouveau le polynôme qui sera ainsi de degré 2.
Nous l'évaluons maintenant avec les racines 4eme de l'unité. A chaque évaluation, nous réutilisons les résultats précédents, cela nous est permit par les racines de l'unité qui ont une structure récursive exploitable.

Finalement, nous arrivons à la fin de notre FFT, avec une représentation fréquentielle de la forme :

<math> [P(W_0), P(W_1), (...), P(W_n-1), P(W_n)] </math>

Cette représentation fréquentielle n'est autre que les évaluations du polynôme P aux racines nièmes de l'unité. Nous avons donc maintenant au minimum <math>2n+1</math> évaluations des polynômes facteurs. Il nous faut maintenant trouver les évaluations du produit final, c'est à dire les évaluations concernant le polynôme qui sera issue de la multiplication. On pourra ainsi le retrouver.

Soit <math>C</math> un polynome tel que <math> C = A \times B </math>, alors on a :

<math> C(x) = A(x) \times B(x) </math>

Ainsi on en déduit que <math> C(W_n^k) = A(W_n^k) \times B(W_n^k) </math>

On comprend donc que <math>FFT(C) = FFT(A) \times FFT(B)</math>

Il faut préciser que l'on fait le produit de FFT(A) et FFT(B) terme à terme, soit évaluation par évaluation.

Une fois en possession de <math>FFT(C)</math>, qui n'est autre que l'évaluation de notre polynôme final en un nombre suffisant de points pour le retrouver, nous pouvons faire l'<math>IFFT(FFT(C))</math>, qui va nous permettre de retrouver les coefficients de notre polynôme en faisant l'exacte inverse de la FFT.

Une fois les coefficients retrouvés, il nous suffit de gérer les retenues, et nous retrouvons un entier de la forme : <math>a_0 a_1 (...) a_{n-1} a_n</math>

=== B) Graphique ===

Intéressons nous maintenant à la complexité de l'algorithme utilisant la transformée de Fourier rapide. On sait que l'algorithme passe par 5 étapes importantes :

<ul>
<li>Etape 1 : Ecrire les deux facteurs sous la forme de polynômes</li>
<li>Etape 2 : Effectuer la <math>FFT</math> des deux polynômes</li>
<li>Etape 3 : Faire le produit terme à terme des <math>FFT</math> obtenues</li>
<li>Etape 4 : Faire l'<math>IFFT</math> du produit</li>
<li>Etape 5 : Gérer les retenues et écrire le nombre qui en découle</li>
</ul>

Or, parmi toutes ces étapes, certaines sont négligeable comme l'étape 1 et 5.

Pour connaitre la complexité de l'algorithme, additionnons les complexités des étapes restantes :

Une <math>FFT</math> a une complexité de <math>\mathcal{O}(n\times logn)</math> car elle fait <math>n</math> évaluation sur <math> log(n)</math> récursions. Dans le cadre de notre algorithme, nous devons faire la <math>FFT</math> de nos deux facteurs. Soit <math>2\times \mathcal{O}(n\times logn)</math>.

Pour le produit terme à terme, nous faisons naturellement <math>n</math> opérations.

Pour finir, l'<math>IFFT</math> a la même complexité que la <math>FFT</math>. Dans le cadre de notre algorithme nous l'emploierons qu'une seule fois, ce qui fait une complexité de <math>\mathcal{O}(n\times logn)</math>.

Après addition de toutes ces complexités, nous obtenons la complexité réelle de <math>3\mathcal{O}(n\times logn) + \mathcal{O}(n)</math>.

D'après le Master Theorem, nous avons donc <math> f(n) = 3(n\times logn)+n </math>, cherchons <math>f(n)\in\mathcal{O}(g(n))</math> :

Nous pouvons ignorer les expressions linéaires ainsi que les constantes multiplicatrices, nous obtenons donc <math>\mathcal{O}(g(n)) = \mathcal{O}(n \times log n)</math>.

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:30px; text-align:center;">
[[Fichier:FFT_image.webp|500px]]
<div><b>Graphiques des complexités</b></div>
</div>
<div style="max-width:800px;">
<p>Ce graphique ci-contre ne provient pas du fruit de nos recherches personnelles mais </p>
<p>On comprend ainsi que certaines complexités ne sont pas raisonnable dans la cadre de la multiplication de grands entiers.</p>
<p>C'est pourquoi l'étude de ces algorithmes s'avère nécessaire.</p>
</div>
</div>

= II - Produit de matrices =

== 1.1) naïve ==

La multiplication naïve de matrice requiert d'avoir des tailles de lignes/colonne semblable, ensuite pour chaque membre de la matrice résultat, on doit multiplier les composantes ligne de la première matrice par les composantes colonne de la deuxième et le tout sommé.

On en déduit la formule suivante:
<math>C_{i,j} = \sum_{k=1}^{n} (A_{i,k} \times B_{k,j})</math>

Et visuellement:

[[Fichier:Matricenaive.jpeg]]

On a donc un algorithme d'ordre de complexité <math>\mathcal{O}(g(n))</math>

== 1.2) naïve récursive ==

Dans un premier temps on doit découper nos deux matrices en quatres sous matrices de plus petite taille.
<math>A = \begin{pmatrix} A_{11} & A_{12} \ A_{21} & A_{22} \end{pmatrix}</math>
<math>B = \begin{pmatrix} B_{11} & B_{12} \ B_{21} & B_{22} \end{pmatrix}</math>

Ensuite on vient calculer la matrice résultat.
<math>C_{11} = (A_{11} \times B_{11}) + (A_{12} \times B_{21})</math>
<math>C_{12} = (A_{11} \times B_{12}) + (A_{12} \times B_{22})</math>
<math>C_{21} = (A_{21} \times B_{11}) + (A_{22} \times B_{21})</math>
<math>C_{22} = (A_{21} \times B_{12}) + (A_{22} \times B_{22})</math>

Le côté récursif est utile que pour les matrices de tailles <= 32 (32 valeurs stockées dedans),
si on est au dessus de cette taille alors on divisera à nouveau nos matrices en quatres.
On aura 8 multiplications mais de plus petite taille au final.

== 2) strassen ==

=== A) Fonctionnement ===

Strassen consiste à définir 7 produits intermédiaires qui, par des jeux de sommes et de différences, permettent de reconstruire les quadrants de la matrice résultante. On passe ainsi d'une complexité de O(n^3) à environ O(n^2.81)

=== B) Graphique ===

On voit bien la différence de complexité sur la multiplication de grande matrice entre l'approche naïve et l'approche récursive qui est beaucoup plus rapide.

[[Fichier:Analyse matrices.png]]

= Conclusion =

L'étude de ces algorithmes de multiplication nous a clairement montré l'évolution de la complexité algorithmique permettant de gagner en efficacité lorsque la taille des données augmente.

La multiplication classiqe, en <math>\mathcal{O}(n^2)</math>, résulte d'une approche naïve qui devient rapidement inefficace pour les grands entiers ou les grandes matrices. L'algorithme de Karatsuba nous montre qu'organiser de manière intelligente ses calculs algébrique permet parfois de gagner beaucoup de multiplications, et donc de temps. Nous avons ainsi réussi à passer d'une complexité de <math>\mathcal{O}(n^2)</math> à <math>\mathcal{O}(n^{log_2(3)})</math>, soit environ <math>\mathcal{O}(n^{1/585})</math>.

Des méthodes encore plus avancées comme utilise l'algorithme de Toom-Cook-3 continue dans cette idées de divisions d'entiers en blocs plus petits, tandis que la transformée de Fourier rapide change complètement de point de vue. En effet la FFT n'utilise pas la représentation classique des entiers mais fait appel à une vision polynomiale, ce qui transforme la convolution classique en multiplication terme à terme, ce qui lui permet d'atteindre une complexité de <math>\mathcal{O}(n \times log n)</math>.

Dans le cas des matrices, les mêmes logiques apparaissent comme par exemple avec l'algorithme de Strassen qui se rapproche très fortement de Karatsuba en combinant de manière astucieuse les parties d'entiers qui avaient été précédemment découpée.

On remarque néanmoins que la majorité des algorithmes efficaces s'orientent vers une approche récursive et non itérative. Néanmoins, nous avons pu trouver certaines de ces implémentations (comme par exemple la FFT) en itérative.

Avec ces recherches, nous comprenons que la réorganisations des calculs algébriques peuvent aider à gagner en complexité mais que pour faire de réels progrès, il nous faudra surement changer notre point de vue une nouvelle fois, et aborder le problème sous un angle nouveau comme le font dors et déjà les algorithmes les plus performants.

= Mentions =

Le premier gif est le résultat du travail de 'Walké', licence ci-contre : https://fr.wikipedia.org/wiki/Fichier:Addition.gif

= Sources =

Pour karatsuba : https://www.youtube.com/watch?v=PZ2gdWdKHAA

Pour mieux comprendre la FFT, nous avons utilisé plusieurs sources d'informations :
<ul>
<li> https://www.youtube.com/watch?v=h7apO7q16V0&list=WL&index=1&t=886s </li>
<li> https://fr.wikipedia.org/wiki/Interpolation_polynomiale </li>
</ul>

Algorithmes de multiplications d'entiers et de matrices

2026-05-11T18:36:49Z

Mangala : /* A) Fonctionnement */

= Introduction =

Depuis l'apparition des ordinateurs modernes, une quantité faramineuse de calculs a dû être effectuée. Les progressions technologiques nous poussent à envisager la puissance de calcul comme une ressource qu'il faut optimiser dans les moindres détails. C'est ainsi que l'optimisation des algorithmes de calcul est devenue cruciale, surtout lorsqu'il nous faut effectuer des opérations sur de très grands entiers par exemple.

= Objectif =

L'objectif majeur de ce projet est de comprendre de manière plus approfondie ce qu'est la '''complexité algorithmique'''.
Pour atteindre cet objectif, nous implémenterons plusieurs algorithmes de multiplication qui auront pour but de calculer le produit de grands entiers ou de matrices.

= Point important : complexité =

=== Définition ===
La complexité d'un algorithme est la quantité des ressources qu'il utilise en fonction de la taille des entrées qu'on lui demande de traiter. On peut par exemple se concentrer sur le temps qu'un algorithme prend pour renvoyer un résultat ou sur la mémoire dont il a besoin. Dans le cadre de notre projet, nous nous attarderons plus particulièrement sur la quantité de calcul effectuée en fonction de la taille des entrées, ce qui est par ailleurs étroitement liée à la notion de temps. De manière générale, plus un algorithme doit faire de calcul, plus il est lent. (Attention, toutes les opérations arithmétiques de base ne se valent pas)

De manière plus familière, on dira que la complexité d'un algorithme pourrait s'apparenter à son comportement lorsqu'il doit traiter des données plus ou moins grandes.
Chaque algorithme a une complexité, et on l'exprime par une fonction qui adopte un comportement similaire au nombre de calculs nécessaires en fonction de la taille des entrées.

=== Notation ===
La complexité réelle d'un algorithme peut être décrite par une fonction <math>f(n)</math> représentant le nombre d'opérations effectuées en fonction de la taille <math>n</math> des données d'entrée.

Cependant, afin de simplifier l'étude de cette croissance, on utilise généralement une borne asymptotique notée <math>\mathcal{O}(g(n))</math>, où <math>g(n)</math> est une fonction ayant le même ordre de grandeur que <math>f(n)</math> lorsque <math>n</math> devient grand.

On dit alors que :

<math>
f(n)\in\mathcal{O}(g(n))
</math>

si et seulement s'il existe une constante <math>C>0</math> et un entier <math>n_0</math> tels que :

<math>
\forall n\ge n_0,\ f(n)\le Cg(n)
</math>

Cette notation <math>\mathcal{O}(g(n))</math> permettra de comparer beaucoup plus facilement les algorithmes entre eux.

=== Master Theorem ===

Afin de déterminer la complexité de certains algorithmes récursifs, nous utiliserons le "Master Theorem".

Ce théorème permet d'obtenir directement l'ordre de grandeur de nombreuses relations de récurrence apparaissant dans l'analyse d'algorithmes de type « diviser pour régner », comme l'algorithme de Karatsuba ou celui de Strassen.

La démonstration complète de ce théorème dépasse le cadre de notre projet et nécessite des connaissances mathématiques plus avancées. Nous l'utiliserons donc principalement comme un outil nous permettant de déterminer efficacement la complexité asymptotique des algorithmes étudiés.

=== Graphiques ===

Les complexités étant des fonctions, nous pouvons les représenter par un graphique qui affichera le temps d'exécution (ou nombre d'opérations) en fonction de la taille des entrées.

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:30px; text-align:center;">
[[Fichier:complexite.webp|500px]]
<div><b>Graphiques des complexités</b></div>
</div>
<div style="max-width:800px;">
<p>Ce graphique ci-contre compare les complexités en fonction de la taille des d'entrées.</p>
<p>On comprend ainsi que certaines complexités ne sont pas raisonnable dans la cadre de la multiplication de grands entiers.</p>
<p>C'est pourquoi l'étude de ces algorithmes s'avère nécessaire.</p>
</div>
</div>

=== Exemple ===
L'algorithme naïf d'addition que nous avons tous appris à l'école a une complexité de <math>\mathcal{O}(n)</math>.
Soit n la taille des nombres en entrée, l'algorithme doit faire environ n addition pour arriver au résultat demandé.

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Addition.gif|220px]]
<div><b>Addition naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Comme le montre l'exemple ci-contre, 786 et 467 font 3 chiffres de long donc n sera de 3.</p>
<p>Il nous faudra 3 opérations pour additionner ces entiers.</p>
<p>C'est ainsi qu'avec une taille d'entrée n, l'algorithme de l'addition naïve va devoir faire n opérations.</p>
<p>Cet algorithme a donc une complexité <math>f(n) = n</math> qui n'a pas besoin d'être approximée.</p>
<p>Ainsi sa complexité finale sera <math>\mathcal{O}(n)</math>.</p>
</div>
</div>

= Problématique =

Le calcul du produit de deux entiers de manière naïve a une complexité de <math> \mathcal{O}(n^2)</math>, et celui de deux matrices une complexité de <math> \mathcal{O}(n^3)</math>. Afin de mieux comprendre ce qu'est la complexité algorithmique, nous devrons implémenter des algorithmes ayant le même objectif, mais étant plus efficaces. Ces algorithmes s'avèreront plus complexes mais devrait aboutir à un calcul plus rapide du produit demandé.

Nous séparerons notre wiki en deux grandes parties, la première concernera nos recherche sur [[#I - Produit d'entiers|la multiplication d'entiers]], la deuxième sur [[#II - Produit de matrices|la multiplication de matrices]].

= I - Produit d'entiers =

Notre départ commence avec l'algorithme de multiplication d'entier naïf.
En effet il s'agit de l'algorithme de multiplication le plus connu, et nous l'utiliserons comme référence pour le comparer aux futurs algorithmes plus efficaces.
Intéressons nous à sa complexité.

== 1) Nos implémentations des grands entiers ==

Qui dit produit de grands entiers dit implémentation de grands entiers.

Dans le cadre de nos recherches, nous allons devoir implémenter des algorithmes qui vont manipuler des grands entiers.

Nous avons donc choisi de créer deux représentations différentes de ceux-ci (car nous travaillons sur différents langages de programmation), nous permettant à la fois une implémentation simplifié, mais aussi de nous rapprocher d'une implémentation bas niveau.

=== A) En python ===
En python, l'utilisation des "bytes" m'a grandement servi à comprendre comment les entiers étaient manipulés à bas niveau. En effet, un des objectifs secondaires de nos recherches était de manipuler des entiers directement avec leur formes stockées sur l'ordinateur, et non pas avec des int python.
En effet l'utilisation des int python nous aurait permit de passer les étapes de retenues, de signes... D'autant plus que les bytes permettent de stocker un nombre en base 256, ce qui permet de visualiser plus facilement les grands entiers.

La forme finale de la représentation des grands entiers en python sera donc la suivante :

[ signe , bytes , bytes , (...) , bytes ]

Le signe est représenté par un entier, 1 si le nombre est positif, 0 sinon.
Cette configuration rendra plus simple la gestion des signes.

=== B) En C++ ===

En C++, pour avoir une représentation de grand entiers j'ai du définir ma propre structure pour m'affranchir de la limite de taille imposé par les entiers standards: (int32 ou int64). Pour cela, j'ai une structure qui possède l'équivalent d'un array de byte (ce qui nous permet d'être en base 256 au lieu de la base 10 habituelle), et pour traiter le signe j'utilise un booléen, ainsi en mémoire j'ai une structure de n*Octets + 1 octet en taille.

[ bytes , bytes , (...) , bytes ] [ signe ]

Le booléen prend 1 octet de place mais ne touche pas aux octets qui encode le grand entier.
Cette configuration rendra plus simple la gestion des signes dans le cadre des multiplication.

== 2) La multiplication naïve ==

=== A) Fonctionnement ===
Dans le cas de la multiplication d'entiers, nous allons prendre deux nombres qui n'ont pas nécessairement la même longueur. Soit les nombre a et b, de longueur respective <math> n </math> et <math> m </math>.
<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Multiplication.png|220px]]
<div><b>Multiplication naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Prenons deux nombres de longueur 3 et 2, et cherchons combien d'opérations l'algorithme de multiplication naïve va devoir faire pour nous renvoyer leur produit.</p>
<p>Dans un premier temps, on remarque que l'on va devoir multiplier chaque chiffre du nombre du haut par le chiffre des unités du bas, qui est 6. Cela va représenter <math>n</math> opérations. (6x5, 6x1 et 6x4)</p>
<p>Dans un deuxième temps nous constatons que nous allons devoir faire la même chose avec le chiffre des dizaines du nombre du bas. Cela nous ajoute de nouveau <math>n</math> opérations.</p>
<p>On arrive assez facilement à la conclusion que pour faire notre produit, il va nous falloir faire <math>n</math> fois <math>m</math> opérations.</p>
</div>
</div>

Ainsi, la complexité de la multiplication naïve est <math>\mathcal{O}(n^2)</math>.
Il est en de même avec la multiplication naïve récursive.

=== B) Graphique ===
Montrons maintenant sa courbe sur un graphique :

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Multiplicationnaive.png|500px]]
<div><b>Multiplication naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Les points noirs sont des repères pour que les autres courbes aient une forme cohérente.</p>
<p>Ils sont tous sur l'axe des abscisses.</p>
<p>La courbe rouge représente la complexité de la multiplication naïve.</p>
<p>On remarque que la courbe a un visuel très similaire à la fonction <math>f(x) = x^2</math> </p>
</div>
</div>

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Naif_recursif.png|500px]]
<div><b>Multiplication naïve récursive</b></div>
</div>
<div style="max-width:800px;">
<p>La courbe rouge représente la complexité de la multiplication naïve récursive.</p>
<p>Elle sera utilisé pour comparer les complexités entre algorithmes car, comme tous récursifs, elle a été codé avec les mêmes biais d'implémentation qu'eux.</p>
<p>Théoriquement les deux courbes ci-contre ont la même complexité, mais encore une fois, notre implémentation n'est pas parfaitement optimale et donc ne respecte pas de manière minutieuse le Master Theorem.</p>
</div>
</div>

== 3) La multiplication karatsuba ==

=== A) Fonctionnement ===

L'algorithme de karatsuba est un algorithme récursif de type diviser pour régner.

L'idée générale de l'algorithme est de passer de 4 multiplication à 3. En effet ces opérations étant moins couteuses, il est préférable d'en ajouter si cela permet d'enlever des multiplications.

L'algorithme de multiplication naif récursif utilise la segmentation des facteurs en deux de manière successive.

Soit <math>x</math> et <math>y</math> deux facteurs, nous avons les égalités suivantes :

<div style="font-size: 20px;">
<math>x = a \times B^{n/2} + b</math>
<math>y = c \times B^{n/2} + d</math>
</div>

Avec <math>a</math> et <math>c</math> les premières moitiés des facteurs <math>x</math> et <math>y</math>,
et <math> b </math> et <math>d</math> les dernières moitiés de ces facteurs ainsi que <math>B</math> la base d'écriture du nombre (Nous sommes en base 256 avec les bytes).

Cette présentation des deux facteurs de notre multiplication n'est que la résultante d'un découpage.
Le [[#Master Theorem|Master Theorem]] nous montre que :

<div style="font-size: 20px;">
<math>T(n) = 4T(n/2) + O(n)</math>
</div>

Puisque nous avons après découpage 4 entiers de longueur <math>n/2</math>.

Ainsi, ce découpage ne permet pas de gagner du temps d'après le [[#Master Theorem|Master Theorem]].

Cependant, l'algorithme de Karatsuba réutilise ce principe en le modifiant, ce qui nous permet de baisser la complexité globale de la multiplication dans son entièreté.

Avec l'écriture ci-dessus des nombres <math>x</math> et <math>y</math>, on peut facilement en déduire l'égalité suivante :

<div style="font-size: 20px;">
<math>x \times y = (ac) \times B^n + (ad + bc) \times B^{n/2} + bd</math>
</div>

On remarque 4 multiplications longues à faire dans cette expression. Les multiplications dont <math>B</math> est l'un des facteurs sont très rapides puisqu'il s'agit de la base dans laquelle nous travaillons. De cela en résulte un décalage plutôt qu'un vrai calcul à faire.

Karatsuba développe une partie de cette expression pour pouvoir négocier une multiplication au prix d'additions et soustractions.

En effet, nous savons déjà que :

<div style="font-size: 20px;">
<math>(a + b)(c + d) = ac + ad + bc + bd</math>
</div>

En manipulant l'égalité nous obtenons :

<div style="font-size: 20px;">
<math>ad + bc = (a + b)(c + d) - ac - bd</math>
</div>

ac et bd ayant déjà été calculé précédemment, il nous reste uniquement la multiplication <math>(a + b)(c + d)</math>.

Nous venons ainsi de calculer <math>ad + bc</math> en seulement une multiplication. C'est la que repose le gain de temps de la méthode Karatsuba par rapport à la multiplication naïve.

En effet, l'algorithme n'effectuera alors plus que 3 multiplications :
<div style="font-size: 20px;">
<math>ac</math>
<math>bd</math>
<math>(a + b)(c + d)</math>
</div>

La relation de récurrence devient donc :
<div style="font-size: 20px;">
<math>T(n)=3T(n/2)+O(n)</math>
</div>

Et le Master Theorem nous dit que :
<div style="font-size: 20px;">
<math>T(n)\in O(n^{\log_2(3)})</math>
</div>

Or <math>\log_2(3)\approx 1.585</math>, donc la complexité de l'algorithme de Karatsuba est de <math> \mathcal{O}(n^{1.585})</math>. Ce qui est bien plus efficace que la multiplication classique, surtout lorsque les facteurs deviennent très grands.

=== B) Graphique ===
<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Karatsuba.png|500px]]
<div><b>Karatsuba</b></div>
</div>
<div style="max-width:800px;">
<p>Sur le graphique ci-contre nous avons utilisé la courbe de la multiplication naïve récursive (rouge) à titre de comparaison.</p>
<p>On remarque graphiquement que Karatsuba (jaune) prend moins de temps à chaque calcul de produit.</p>
<p>On en déduit donc expérimentalement que Karatsuba à une meilleure complexité que la multiplication naïve.</p>
<p>Ainsi nous vérifions donc ce que le Master Theorem prouve, c'est à dire que la complexité de karatsuba est de <math> \mathcal{O}(n^{1.585})</math> </p>
</div>
</div>

== 4) La multiplication toom-cook-3 ==

=== A) Fonctionnement ===

L'objectif est de diviser les grands entiers X et Y en trois blocs de taille égale k.
On les traite alors comme des polynômes de degré 2:

<math>P(z) = X_2 \cdot z^2 + X_1 \cdot z + X_0</math>
<math>Q(z) = Y_2 \cdot z^2 + Y_1 \cdot z + Y_0</math>

On choisit 5 points distincts pour évaluer nos polynômes.
Ce choix de 5 points est crucial car le produit de deux polynômes de degré 2 est un polynôme de degré 4, qui nécessite 5 points pour être défini.
Les points standards sont :

P(0) = X0
P(1) = X0 + X1 + X2
P(-1) = X0 - X1 + X2
P(2) = X0 + 2*X1 + 4*X2
P(inf) = X2

(On procède de manière similaire pour Q.)

Ensuite nous multiplions récursivement chaque points de P et de Q ensemble.
On effectue ainsi 5 multiplications de nombres plus petits au lieu des 9 multiplications requises par la méthode classique.

Après, nous effectuons une interpolation, cela permet de retrouver les 5 coefficients (w_0, w_1, w_2, w_3, w_4) du polynôme produit R(z) à partir des valeurs évaluées calculées précédemment.
On résout un système d'équations linéaires : <math> R(z) = w_4 z^4 + w_3 z^3 + w_2 z^2 + w_1 z + w_0 </math>
Finalement nous pouvons recomposer notre grand entier en positionnant les coefficients w_i aux bons rangs (en les décalant) et à gérer les retenues lors de l'addition finale:
<math>Résultat = w_4 B^{4k} + w_3 B^{3k} + w_2 B^{2k} + w_1 B^k + w_0</math>

=== B) Graphique ===

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Toomcook.png|500px]]
<div><b>Karatsuba</b></div>
</div>
<div style="max-width:800px;">
<p>on a reprit multi récursive (rouge)</p>
<p>on voit que Toom (vert) en dessous de karatsuba (jaune) en dessous de multi classique (rouge)</p>
<p>meilleur complexité</p>
</div>
</div>

== 5) La transformée de Fourier rapide ==

=== A) Fonctionnement ===

La transformation de Fourier rapide étant plus complexe que les autres algorithmes, nous allons essayer d'expliquer son fonctionnement malgré ne pas avoir réussi à l'implémenter.

Il faut comprendre que cet algorithme va considérer les facteurs comme des polynômes.

D'après le théorème de l'unisolvance, il n'existe qu'un seul polynôme de degré inférieur ou égal à <math> n </math> défini par <math>n + 1</math> points distincts. Cela implique non seulement que nous pouvons représenter chaque entier par un polynôme, mais également que si nous pouvons retrouver <math>n + m + 1</math> points (avec <math>n</math> et <math>m</math> la longueur des facteurs) du polynômes issue du produit entre deux facteurs, nous pourrons le retrouver.

Soit un entier quelconque, de forme :

<math>a_n a_{n-1} (...) a_1 a_0</math>

Avec <math>a_i</math>, un chiffre composant le nombre en base 10, qui vaut en réalité dans le nombre : <math>a_i \times 10^i</math>. On peut ainsi l'écrire sous la forme :

<math> P(x) = a_0 + a_1x + a_2x^2 + \dots + a_{n-1}x^{n-1} + a_nx^n </math>

Avec <math>x = 10</math> car nous sommes en base 10, nous obtenons :

<math>P(10) = a_0 + a_1 \times 10 + \dots + a_{n-1}10^{n-1} + a_n10^n </math>

Nous venons ainsi d'écrire notre nombre sous la forme d'un polynôme unique. Pour nous permettre d'évaluer en un nombre suffisant de points, nous allons devoir ajouter des 0 pour la récursion. Il nous faudra ajouter assez de 0 pour atteindre la prochaine puissance de 2 qui sera supérieure ou égale à <math>2n + 1</math>. L'ajout de 0 ne change pas le nombre car <math>0 \times x^n</math> n'ajoute pas de coefficient.

Cet algorithme est récursif et va segmenter en deux parties nos polynômes à chaque récursion. D'un coté les indice pairs et d'un coté les impaires.

Ainsi prenons les nombres 1234 et 5678, ces nombres sont respectivement représentés par les polynômes <math> P(x) = 4 + 3x + 2x^2 + x^3 </math> et <math> P(x) = 8 + 7x + 6x^2 + 5^3 </math>. Ce sont des polynômes de degré 3, ainsi leur produit donnera lieu à un polynôme de degré 6. Il nous faudra donc au minimum 7 points d'évaluation pour retrouve ce produit. De ce fait, en les représentant de la manière suivante :

<math>[4, 3, 2, 1, 0, 0, 0, 0]</math>
<math>[8, 7, 6, 5, 0, 0, 0, 0]</math>

Nous aurons assez de récursions possible pour les évaluer en un nombre suffisant de points différents car nous auront 3 récursions à faire pour atteindre notre cas de base. A chaque récursion, nous allons diviser nos polynômes en deux parties ce qui nous fait 8 feuilles à la dernière récursion.

En effet à chaque étape de la récursion nous allons séparer nos polynômes en deux tel que :

<math>P(x)=P_{\text{pair}}(x^2) + x \cdot P_{\text{impair}}(x^2)</math>

Durant les récursions, nous segmentons les polynômes mais ne les évaluons pas. C'est à la remonté des récursions que nous allons réellement évaluer nos polynômes. Lorsque l'on atteint notre cas de base, c'est à dire des polynômes de degré 0, nous remarquons qu'ils sont constants, nous n'avons donc pas besoin de les évaluer. En effet, peut importe le point en lequel nous voudrons l'évaluer, le polynôme renverra la constante. Nous la renvoyons donc seule.
Ensuite commence la remontée des récursions. A l'étape 1 de notre remontée nous allons reformer le polynôme précédemment séparé pour obtenir un polynôme de degré 1. Puis, nous évaluons ce polynôme avec les racines seconde de l'unité. Nous faisons à nouveau remonté les évaluations et recombinons à nouveau le polynôme qui sera ainsi de degré 2.
Nous l'évaluons maintenant avec les racines 4eme de l'unité. A chaque évaluation, nous réutilisons les résultats précédents, cela nous est permit par les racines de l'unité qui ont une structure récursive exploitable.

Finalement, nous arrivons à la fin de notre FFT, avec une représentation fréquentielle de la forme :

<math> [P(W_0), P(W_1), (...), P(W_n-1), P(W_n)] </math>

Cette représentation fréquentielle n'est autre que les évaluations du polynôme P aux racines nièmes de l'unité. Nous avons donc maintenant au minimum <math>2n+1</math> évaluations des polynômes facteurs. Il nous faut maintenant trouver les évaluations du produit final, c'est à dire les évaluations concernant le polynôme qui sera issue de la multiplication. On pourra ainsi le retrouver.

Soit <math>C</math> un polynome tel que <math> C = A \times B </math>, alors on a :

<math> C(x) = A(x) \times B(x) </math>

Ainsi on en déduit que <math> C(W_n^k) = A(W_n^k) \times B(W_n^k) </math>

On comprend donc que <math>FFT(C) = FFT(A) \times FFT(B)</math>

Il faut préciser que l'on fait le produit de FFT(A) et FFT(B) terme à terme, soit évaluation par évaluation.

Une fois en possession de <math>FFT(C)</math>, qui n'est autre que l'évaluation de notre polynôme final en un nombre suffisant de points pour le retrouver, nous pouvons faire l'<math>IFFT(FFT(C))</math>, qui va nous permettre de retrouver les coefficients de notre polynôme en faisant l'exacte inverse de la FFT.

Une fois les coefficients retrouvés, il nous suffit de gérer les retenues, et nous retrouvons un entier de la forme : <math>a_0 a_1 (...) a_{n-1} a_n</math>

=== B) Graphique ===

Intéressons nous maintenant à la complexité de l'algorithme utilisant la transformée de Fourier rapide. On sait que l'algorithme passe par 5 étapes importantes :

<ul>
<li>Etape 1 : Ecrire les deux facteurs sous la forme de polynômes</li>
<li>Etape 2 : Effectuer la <math>FFT</math> des deux polynômes</li>
<li>Etape 3 : Faire le produit terme à terme des <math>FFT</math> obtenues</li>
<li>Etape 4 : Faire l'<math>IFFT</math> du produit</li>
<li>Etape 5 : Gérer les retenues et écrire le nombre qui en découle</li>
</ul>

Or, parmi toutes ces étapes, certaines sont négligeable comme l'étape 1 et 5.

Pour connaitre la complexité de l'algorithme, additionnons les complexités des étapes restantes :

Une <math>FFT</math> a une complexité de <math>\mathcal{O}(n\times logn)</math> car elle fait <math>n</math> évaluation sur <math> log(n)</math> récursions. Dans le cadre de notre algorithme, nous devons faire la <math>FFT</math> de nos deux facteurs. Soit <math>2\times \mathcal{O}(n\times logn)</math>.

Pour le produit terme à terme, nous faisons naturellement <math>n</math> opérations.

Pour finir, l'<math>IFFT</math> a la même complexité que la <math>FFT</math>. Dans le cadre de notre algorithme nous l'emploierons qu'une seule fois, ce qui fait une complexité de <math>\mathcal{O}(n\times logn)</math>.

Après addition de toutes ces complexités, nous obtenons la complexité réelle de <math>3\mathcal{O}(n\times logn) + \mathcal{O}(n)</math>.

D'après le Master Theorem, nous avons donc <math> f(n) = 3(n\times logn)+n </math>, cherchons <math>f(n)\in\mathcal{O}(g(n))</math> :

Nous pouvons ignorer les expressions linéaires ainsi que les constantes multiplicatrices, nous obtenons donc <math>\mathcal{O}(g(n)) = \mathcal{O}(n \times log n)</math>.

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:30px; text-align:center;">
[[Fichier:FFT_image.webp|500px]]
<div><b>Graphiques des complexités</b></div>
</div>
<div style="max-width:800px;">
<p>Ce graphique ci-contre ne provient pas du fruit de nos recherches personnelles mais </p>
<p>On comprend ainsi que certaines complexités ne sont pas raisonnable dans la cadre de la multiplication de grands entiers.</p>
<p>C'est pourquoi l'étude de ces algorithmes s'avère nécessaire.</p>
</div>
</div>

= II - Produit de matrices =

== 1.1) naïve ==

La multiplication naïve de matrice requiert d'avoir des tailles de lignes/colonne semblable, ensuite pour chaque membre de la matrice résultat, on doit multiplier les composantes ligne de la première matrice par les composantes colonne de la deuxième et le tout sommé.

On en déduit la formule suivante:
<math>C_{i,j} = \sum_{k=1}^{n} (A_{i,k} \times B_{k,j})</math>

Et visuellement:

[[Fichier:Matricenaive.jpeg]]

On a donc un algorithme d'ordre de complexité <math>\mathcal{O}(g(n))</math>

== 1.2) naïve récursive ==

Dans un premier temps on doit découper nos deux matrices en quatres sous matrices de plus petite taille.
<math>A = \begin{pmatrix} A_{11} & A_{12} \ A_{21} & A_{22} \end{pmatrix}</math>
<math>B = \begin{pmatrix} B_{11} & B_{12} \ B_{21} & B_{22} \end{pmatrix}</math>

Ensuite on vient calculer la matrice résultat.
<math>C_{11} = (A_{11} \times B_{11}) + (A_{12} \times B_{21})</math>
<math>C_{12} = (A_{11} \times B_{12}) + (A_{12} \times B_{22})</math>
<math>C_{21} = (A_{21} \times B_{11}) + (A_{22} \times B_{21})</math>
<math>C_{22} = (A_{21} \times B_{12}) + (A_{22} \times B_{22})</math>

Le côté récursif est utile que pour les matrices de tailles <= 32 (32 valeurs stockées dedans),
si on est au dessus de cette taille alors on divisera à nouveau nos matrices en quatres.
On aura 8 multiplications mais de plus petite taille au final.

== 2) strassen ==

=== A) Fonctionnement ===

Strassen consiste à définir 7 produits intermédiaires qui, par des jeux de sommes et de différences, permettent de reconstruire les quadrants de la matrice résultante. On passe ainsi d'une complexité de O(n^3) à environ O(n^2.81)

=== B) Graphique ===

On voit bien la différence de complexité sur la multiplication de grande matrice entre l'approche naïve et l'approche récursive qui est beaucoup plus rapide.

[[Fichier:Analyse matrices.png]]

= Conclusion =

L'étude de ces algorithmes de multiplication nous a clairement montré l'évolution de la complexité algorithmique permettant de gagner en efficacité lorsque la taille des données augmente.

La multiplication classiqe, en <math>\mathcal{O}(n^2)</math>, résulte d'une approche naïve qui devient rapidement inefficace pour les grands entiers ou les grandes matrices. L'algorithme de Karatsuba nous montre qu'organiser de manière intelligente ses calculs algébrique permet parfois de gagner beaucoup de multiplications, et donc de temps. Nous avons ainsi réussi à passer d'une complexité de <math>\mathcal{O}(n^2)</math> à <math>\mathcal{O}(n^{log_2(3)})</math>, soit environ <math>\mathcal{O}(n^{1/585})</math>.

Des méthodes encore plus avancées comme utilise l'algorithme de Toom-Cook-3 continue dans cette idées de divisions d'entiers en blocs plus petits, tandis que la transformée de Fourier rapide change complètement de point de vue. En effet la FFT n'utilise pas la représentation classique des entiers mais fait appel à une vision polynomiale, ce qui transforme la convolution classique en multiplication terme à terme, ce qui lui permet d'atteindre une complexité de <math>\mathcal{O}(n \times log n)</math>.

Dans le cas des matrices, les mêmes logiques apparaissent comme par exemple avec l'algorithme de Strassen qui se rapproche très fortement de Karatsuba en combinant de manière astucieuse les parties d'entiers qui avaient été précédemment découpée.

On remarque néanmoins que la majorité des algorithmes efficaces s'orientent vers une approche récursive et non itérative. Néanmoins, nous avons pu trouver certaines de ces implémentations (comme par exemple la FFT) en itérative.

Avec ces recherches, nous comprenons que la réorganisations des calculs algébriques peuvent aider à gagner en complexité mais que pour faire de réels progrès, il nous faudra surement changer notre point de vue une nouvelle fois, et aborder le problème sous un angle nouveau comme le font dors et déjà les algorithmes les plus performants.

= Mentions =

Le premier gif est le résultat du travail de 'Walké', licence ci-contre : https://fr.wikipedia.org/wiki/Fichier:Addition.gif

= Sources =

Pour karatsuba : https://www.youtube.com/watch?v=PZ2gdWdKHAA

Pour mieux comprendre la FFT, nous avons utilisé plusieurs sources d'informations :
<ul>
<li> https://www.youtube.com/watch?v=h7apO7q16V0&list=WL&index=1&t=886s </li>
<li> https://fr.wikipedia.org/wiki/Interpolation_polynomiale </li>
</ul>

Algorithmes de multiplications d'entiers et de matrices

2026-05-11T15:41:45Z

Mangala : /* A) Fonctionnement */

= Introduction =

Depuis l'apparition des ordinateurs modernes, une quantité faramineuse de calculs a dû être effectuée. Les progressions technologiques nous poussent à envisager la puissance de calcul comme une ressource qu'il faut optimiser dans les moindres détails. C'est ainsi que l'optimisation des algorithmes de calcul est devenue cruciale, surtout lorsqu'il nous faut effectuer des opérations sur de très grands entiers par exemple.

= Objectif =

L'objectif majeur de ce projet est de comprendre de manière plus approfondie ce qu'est la '''complexité algorithmique'''.
Pour atteindre cet objectif, nous implémenterons plusieurs algorithmes de multiplication qui auront pour but de calculer le produit de grands entiers ou de matrices.

= Point important : complexité =

=== Définition ===
La complexité d'un algorithme est la quantité des ressources qu'il utilise en fonction de la taille des entrées qu'on lui demande de traiter. On peut par exemple se concentrer sur le temps qu'un algorithme prend pour renvoyer un résultat ou sur la mémoire dont il a besoin. Dans le cadre de notre projet, nous nous attarderons plus particulièrement sur la quantité de calcul effectuée en fonction de la taille des entrées, ce qui est par ailleurs étroitement liée à la notion de temps. De manière générale, plus un algorithme doit faire de calcul, plus il est lent. (Attention, toutes les opérations arithmétiques de base ne se valent pas)

De manière plus familière, on dira que la complexité d'un algorithme pourrait s'apparenter à son comportement lorsqu'il doit traiter des données plus ou moins grandes.
Chaque algorithme a une complexité, et on l'exprime par une fonction qui adopte un comportement similaire au nombre de calculs nécessaires en fonction de la taille des entrées.

=== Notation ===
La complexité réelle d'un algorithme peut être décrite par une fonction <math>f(n)</math> représentant le nombre d'opérations effectuées en fonction de la taille <math>n</math> des données d'entrée.

Cependant, afin de simplifier l'étude de cette croissance, on utilise généralement une borne asymptotique notée <math>\mathcal{O}(g(n))</math>, où <math>g(n)</math> est une fonction ayant le même ordre de grandeur que <math>f(n)</math> lorsque <math>n</math> devient grand.

On dit alors que :

<math>
f(n)\in\mathcal{O}(g(n))
</math>

si et seulement s'il existe une constante <math>C>0</math> et un entier <math>n_0</math> tels que :

<math>
\forall n\ge n_0,\ f(n)\le Cg(n)
</math>

Cette notation <math>\mathcal{O}(g(n))</math> permettra de comparer beaucoup plus facilement les algorithmes entre eux.

=== Master Theorem ===

Afin de déterminer la complexité de certains algorithmes récursifs, nous utiliserons le "Master Theorem".

Ce théorème permet d'obtenir directement l'ordre de grandeur de nombreuses relations de récurrence apparaissant dans l'analyse d'algorithmes de type « diviser pour régner », comme l'algorithme de Karatsuba ou celui de Strassen.

La démonstration complète de ce théorème dépasse le cadre de notre projet et nécessite des connaissances mathématiques plus avancées. Nous l'utiliserons donc principalement comme un outil nous permettant de déterminer efficacement la complexité asymptotique des algorithmes étudiés.

=== Graphiques ===

Les complexités étant des fonctions, nous pouvons les représenter par un graphique qui affichera le temps d'exécution (ou nombre d'opérations) en fonction de la taille des entrées.

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:30px; text-align:center;">
[[Fichier:complexite.webp|500px]]
<div><b>Graphiques des complexités</b></div>
</div>
<div style="max-width:800px;">
<p>Ce graphique ci-contre compare les complexités en fonction de la taille des d'entrées.</p>
<p>On comprend ainsi que certaines complexités ne sont pas raisonnable dans la cadre de la multiplication de grands entiers.</p>
<p>C'est pourquoi l'étude de ces algorithmes s'avère nécessaire.</p>
</div>
</div>

=== Exemple ===
L'algorithme naïf d'addition que nous avons tous appris à l'école a une complexité de <math>\mathcal{O}(n)</math>.
Soit n la taille des nombres en entrée, l'algorithme doit faire environ n addition pour arriver au résultat demandé.

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Addition.gif|220px]]
<div><b>Addition naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Comme le montre l'exemple ci-contre, 786 et 467 font 3 chiffres de long donc n sera de 3.</p>
<p>Il nous faudra 3 opérations pour additionner ces entiers.</p>
<p>C'est ainsi qu'avec une taille d'entrée n, l'algorithme de l'addition naïve va devoir faire n opérations.</p>
<p>Cet algorithme a donc une complexité <math>f(n) = n</math> qui n'a pas besoin d'être approximée.</p>
<p>Ainsi sa complexité finale sera <math>\mathcal{O}(n)</math>.</p>
</div>
</div>

= Problématique =

Le calcul du produit de deux entiers de manière naïve a une complexité de <math> \mathcal{O}(n^2)</math>, et celui de deux matrices une complexité de <math> \mathcal{O}(n^3)</math>. Afin de mieux comprendre ce qu'est la complexité algorithmique, nous devrons implémenter des algorithmes ayant le même objectif, mais étant plus efficaces. Ces algorithmes s'avèreront plus complexes mais devrait aboutir à un calcul plus rapide du produit demandé.

Nous séparerons notre wiki en deux grandes parties, la première concernera nos recherche sur [[#I - Produit d'entiers|la multiplication d'entiers]], la deuxième sur [[#II - Produit de matrices|la multiplication de matrices]].

= I - Produit d'entiers =

Notre départ commence avec l'algorithme de multiplication d'entier naïf.
En effet il s'agit de l'algorithme de multiplication le plus connu, et nous l'utiliserons comme référence pour le comparer aux futurs algorithmes plus efficaces.
Intéressons nous à sa complexité.

== 1) Nos implémentations des grands entiers ==

Qui dit produit de grands entiers dit implémentation de grands entiers.

Dans le cadre de nos recherches, nous allons devoir implémenter des algorithmes qui vont manipuler des grands entiers.

Nous avons donc choisi de créer deux représentations différentes de ceux-ci (car nous travaillons sur différents langages de programmation), nous permettant à la fois une implémentation simplifié, mais aussi de nous rapprocher d'une implémentation bas niveau.

=== A) En python ===
En python, l'utilisation des "bytes" m'a grandement servi à comprendre comment les entiers étaient manipulés à bas niveau. En effet, un des objectifs secondaires de nos recherches était de manipuler des entiers directement avec leur formes stockées sur l'ordinateur, et non pas avec des int python.
En effet l'utilisation des int python nous aurait permit de passer les étapes de retenues, de signes... D'autant plus que les bytes permettent de stocker un nombre en base 256, ce qui permet de visualiser plus facilement les grands entiers.

La forme finale de la représentation des grands entiers en python sera donc la suivante :

[ signe , bytes , bytes , (...) , bytes ]

Le signe est représenté par un entier, 1 si le nombre est positif, 0 sinon.
Cette configuration rendra plus simple la gestion des signes.

=== B) En C++ ===

En C++, pour avoir une représentation de grand entiers j'ai du définir ma propre structure pour m'affranchir de la limite de taille imposé par les entiers standards: (int32 ou int64). Pour cela, j'ai une structure qui possède l'équivalent d'un array de byte (ce qui nous permet d'être en base 256 au lieu de la base 10 habituelle), et pour traiter le signe j'utilise un booléen, ainsi en mémoire j'ai une structure de n*Octets + 1 octet en taille.

[ bytes , bytes , (...) , bytes ] [ signe ]

Le booléen prend 1 octet de place mais ne touche pas aux octets qui encode le grand entier.
Cette configuration rendra plus simple la gestion des signes dans le cadre des multiplication.

== 2) La multiplication naïve ==

=== A) Fonctionnement ===
Dans le cas de la multiplication d'entiers, nous allons prendre deux nombres qui n'ont pas nécessairement la même longueur. Soit les nombre a et b, de longueur respective <math>n</math> et <math> m </math>.
<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Multiplication.png|220px]]
<div><b>Multiplication naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Prenons deux nombres de longueur 3 et 2, et cherchons combien d'opérations l'algorithme de multiplication naïve va devoir faire pour nous renvoyer leur produit.</p>
<p>Dans un premier temps, on remarque que l'on va devoir multiplier chaque chiffre du nombre du haut par le chiffre des unités du bas, qui est 6. Cela va représenter <math>n</math> opérations. (6x5, 6x1 et 6x4)</p>
<p>Dans un deuxième temps nous constatons que nous allons devoir faire la même chose avec le chiffre des dizaines du nombre du bas. Cela nous ajoute de nouveau <math>n</math> opérations.</p>
<p>On arrive assez facilement à la conclusion que pour faire notre produit, il va nous falloir faire <math>n</math> fois <math>m</math> opérations.</p>
</div>
</div>

Ainsi, la complexité de la multiplication naïve est <math>\mathcal{O}(n^2)</math>.
Il est en de même avec la multiplication naïve récursive.

=== B) Graphique ===
Montrons maintenant sa courbe sur un graphique :

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Multiplicationnaive.png|500px]]
<div><b>Multiplication naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Les points noirs sont des repères pour que les autres courbes aient une forme cohérente.</p>
<p>Ils sont tous sur l'axe des abscisses.</p>
<p>La courbe rouge représente la complexité de la multiplication naïve.</p>
<p>On remarque que la courbe a un visuel très similaire à la fonction <math>f(x) = x^2</math> </p>
</div>
</div>

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Naif_recursif.png|500px]]
<div><b>Multiplication naïve récursive</b></div>
</div>
<div style="max-width:800px;">
<p>La courbe rouge représente la complexité de la multiplication naïve récursive.</p>
<p>Elle sera utilisé pour comparer les complexités entre algorithmes car, comme tous récursifs, elle a été codé avec les mêmes biais d'implémentation qu'eux.</p>
<p>Théoriquement les deux courbes ci-contre ont la même complexité, mais encore une fois, notre implémentation n'est pas parfaitement optimale et donc ne respecte pas de manière minutieuse le Master Theorem.</p>
</div>
</div>

== 3) La multiplication karatsuba ==

=== A) Fonctionnement ===

L'algorithme de karatsuba est un algorithme récursif de type diviser pour régner.

L'idée générale de l'algorithme est de passer de 4 multiplication à 3. En effet ces opérations étant moins couteuses, il est préférable d'en ajouter si cela permet d'enlever des multiplications.

L'algorithme de multiplication naif récursif utilise la segmentation des facteurs en deux de manière successive.

Soit <math>x</math> et <math>y</math> deux facteurs, nous avons les égalités suivantes :

<div style="font-size: 20px;">
<math>x = a \times B^{n/2} + b</math>
<math>y = c \times B^{n/2} + d</math>
</div>

Avec <math>a</math> et <math>c</math> les premières moitiés des facteurs <math>x</math> et <math>y</math>,
et <math> b </math> et <math>d</math> les dernières moitiés de ces facteurs ainsi que <math>B</math> la base d'écriture du nombre (Nous sommes en base 256 avec les bytes).

Cette présentation des deux facteurs de notre multiplication n'est que la résultante d'un découpage.
Le [[#Master Theorem|Master Theorem]] nous montre que :

<div style="font-size: 20px;">
<math>T(n) = 4T(n/2) + O(n)</math>
</div>

Puisque nous avons après découpage 4 entiers de longueur <math>n/2</math>.

Ainsi, ce découpage ne permet pas de gagner du temps d'après le [[#Master Theorem|Master Theorem]].

Cependant, l'algorithme de Karatsuba réutilise ce principe en le modifiant, ce qui nous permet de baisser la complexité globale de la multiplication dans son entièreté.

Avec l'écriture ci-dessus des nombres <math>x</math> et <math>y</math>, on peut facilement en déduire l'égalité suivante :

<div style="font-size: 20px;">
<math>x \times y = (ac) \times B^n + (ad + bc) \times B^{n/2} + bd</math>
</div>

On remarque 4 multiplications longues à faire dans cette expression. Les multiplications dont <math>B</math> est l'un des facteurs sont très rapides puisqu'il s'agit de la base dans laquelle nous travaillons. De cela en résulte un décalage plutôt qu'un vrai calcul à faire.

Karatsuba développe une partie de cette expression pour pouvoir négocier une multiplication au prix d'additions et soustractions.

En effet, nous savons déjà que :

<div style="font-size: 20px;">
<math>(a + b)(c + d) = ac + ad + bc + bd</math>
</div>

En manipulant l'égalité nous obtenons :

<div style="font-size: 20px;">
<math>ad + bc = (a + b)(c + d) - ac - bd</math>
</div>

ac et bd ayant déjà été calculé précédemment, il nous reste uniquement la multiplication <math>(a + b)(c + d)</math>.

Nous venons ainsi de calculer <math>ad + bc</math> en seulement une multiplication. C'est la que repose le gain de temps de la méthode Karatsuba par rapport à la multiplication naïve.

En effet, l'algorithme n'effectuera alors plus que 3 multiplications :
<div style="font-size: 20px;">
<math>ac</math>
<math>bd</math>
<math>(a + b)(c + d)</math>
</div>

La relation de récurrence devient donc :
<div style="font-size: 20px;">
<math>T(n)=3T(n/2)+O(n)</math>
</div>

Et le Master Theorem nous dit que :
<div style="font-size: 20px;">
<math>T(n)\in O(n^{\log_2(3)})</math>
</div>

Or <math>\log_2(3)\approx 1.585</math>, donc la complexité de l'algorithme de Karatsuba est de <math> \mathcal{O}(n^{1.585})</math>. Ce qui est bien plus efficace que la multiplication classique, surtout lorsque les facteurs deviennent très grands.

=== B) Graphique ===
<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Karatsuba.png|500px]]
<div><b>Karatsuba</b></div>
</div>
<div style="max-width:800px;">
<p>Sur le graphique ci-contre nous avons utilisé la courbe de la multiplication naïve récursive (rouge) à titre de comparaison.</p>
<p>On remarque graphiquement que Karatsuba (jaune) prend moins de temps à chaque calcul de produit.</p>
<p>On en déduit donc expérimentalement que Karatsuba à une meilleure complexité que la multiplication naïve.</p>
<p>Ainsi nous vérifions donc ce que le Master Theorem prouve, c'est à dire que la complexité de karatsuba est de <math> \mathcal{O}(n^{1.585})</math> </p>
</div>
</div>

== 4) La multiplication toom-cook-3 ==

=== A) Fonctionnement ===

L'objectif est de diviser les grands entiers X et Y en trois blocs de taille égale k.
On les traite alors comme des polynômes de degré 2:

<math>P(z) = X_2 \cdot z^2 + X_1 \cdot z + X_0</math>
<math>Q(z) = Y_2 \cdot z^2 + Y_1 \cdot z + Y_0</math>

On choisit 5 points distincts pour évaluer nos polynômes.
Ce choix de 5 points est crucial car le produit de deux polynômes de degré 2 est un polynôme de degré 4, qui nécessite 5 points pour être défini.
Les points standards sont :

P(0) = X0
P(1) = X0 + X1 + X2
P(-1) = X0 - X1 + X2
P(2) = X0 + 2*X1 + 4*X2
P(inf) = X2

(On procède de manière similaire pour Q.)

Ensuite nous multiplions récursivement chaque points de P et de Q ensemble.
On effectue ainsi 5 multiplications de nombres plus petits au lieu des 9 multiplications requises par la méthode classique.

Après, nous effectuons une interpolation, cela permet de retrouver les 5 coefficients (w_0, w_1, w_2, w_3, w_4) du polynôme produit R(z) à partir des valeurs évaluées calculées précédemment.
On résout un système d'équations linéaires : <math> R(z) = w_4 z^4 + w_3 z^3 + w_2 z^2 + w_1 z + w_0 </math>
Finalement nous pouvons recomposer notre grand entier en positionnant les coefficients w_i aux bons rangs (en les décalant) et à gérer les retenues lors de l'addition finale:
<math>Résultat = w_4 B^{4k} + w_3 B^{3k} + w_2 B^{2k} + w_1 B^k + w_0</math>

=== B) Graphique ===

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Toomcook.png|500px]]
<div><b>Karatsuba</b></div>
</div>
<div style="max-width:800px;">
<p>on a reprit multi récursive (rouge)</p>
<p>on voit que Toom (vert) en dessous de karatsuba (jaune) en dessous de multi classique (rouge)</p>
<p>meilleur complexité</p>
</div>
</div>

== 5) La transformée de Fourier rapide ==

=== A) Fonctionnement ===

La transformation de Fourier rapide étant plus complexe que les autres algorithmes, nous allons essayer d'expliquer son fonctionnement malgré ne pas avoir réussi à l'implémenter.

Il faut comprendre que cet algorithme va considérer les facteurs comme des polynômes.

D'après le théorème de l'unisolvance, il n'existe qu'un seul polynôme de degré inférieur ou égal à <math> n </math> défini par <math>n + 1</math> points distincts. Cela implique non seulement que nous pouvons représenter chaque entier par un polynôme, mais également que si nous pouvons retrouver <math>n + m + 1</math> points (avec <math>n</math> et <math>m</math> la longueur des facteurs) du polynômes issue du produit entre deux facteurs, nous pourrons le retrouver.

Soit un entier quelconque, de forme :

<math>a_n a_{n-1} (...) a_1 a_0</math>

Avec <math>a_i</math>, un chiffre composant le nombre en base 10, qui vaut en réalité dans le nombre : <math>a_i \times 10^i</math>. On peut ainsi l'écrire sous la forme :

<math> P(x) = a_0 + a_1x + a_2x^2 + \dots + a_{n-1}x^{n-1} + a_nx^n </math>

Avec <math>x = 10</math> car nous sommes en base 10, nous obtenons :

<math>P(10) = a_0 + a_1 \times 10 + \dots + a_{n-1}10^{n-1} + a_n10^n </math>

Nous venons ainsi d'écrire notre nombre sous la forme d'un polynôme unique. Pour nous permettre d'évaluer en un nombre suffisant de points, nous allons devoir ajouter des 0 pour la récursion. Il nous faudra ajouter assez de 0 pour atteindre la prochaine puissance de 2 qui sera supérieure ou égale à <math>2n + 1</math>. L'ajout de 0 ne change pas le nombre car <math>0 \times x^n</math> n'ajoute pas de coefficient.

Cet algorithme est récursif et va segmenter en deux parties nos polynômes à chaque récursion. D'un coté les indice pairs et d'un coté les impaires.

Ainsi prenons les nombres 1234 et 5678, ces nombres sont respectivement représentés par les polynômes <math> P(x) = 4 + 3x + 2x^2 + x^3 </math> et <math> P(x) = 8 + 7x + 6x^2 + 5^3 </math>. Ce sont des polynômes de degré 3, ainsi leur produit donnera lieu à un polynôme de degré 6. Il nous faudra donc au minimum 7 points d'évaluation pour retrouve ce produit. De ce fait, en les représentant de la manière suivante :

<math>[4, 3, 2, 1, 0, 0, 0, 0]</math>
<math>[8, 7, 6, 5, 0, 0, 0, 0]</math>

Nous aurons assez de récursions possible pour les évaluer en un nombre suffisant de points différents car nous auront 3 récursions à faire pour atteindre notre cas de base. A chaque récursion, nous allons diviser nos polynômes en deux parties ce qui nous fait 8 feuilles à la dernière récursion.

En effet à chaque étape de la récursion nous allons séparer nos polynômes en deux tel que :

<math>P(x)=P_{\text{pair}}(x^2) + x \cdot P_{\text{impair}}(x^2)</math>

Durant les récursions, nous segmentons les polynômes mais ne les évaluons pas. C'est à la remonté des récursions que nous allons réellement évaluer nos polynômes. Lorsque l'on atteint notre cas de base, c'est à dire des polynômes de degré 0, nous remarquons qu'ils sont constants, nous n'avons donc pas besoin de les évaluer. En effet, peut importe le point en lequel nous voudrons l'évaluer, le polynôme renverra la constante. Nous la renvoyons donc seule.
Ensuite commence la remontée des récursions. A l'étape 1 de notre remontée nous allons reformer le polynôme précédemment séparé pour obtenir un polynôme de degré 1. Puis, nous évaluons ce polynôme avec les racines seconde de l'unité. Nous faisons à nouveau remonté les évaluations et recombinons à nouveau le polynôme qui sera ainsi de degré 2.
Nous l'évaluons maintenant avec les racines 4eme de l'unité. A chaque évaluation, nous réutilisons les résultats précédents, cela nous est permit par les racines de l'unité qui ont une structure récursive exploitable.

Finalement, nous arrivons à la fin de notre FFT, avec une représentation fréquentielle de la forme :

<math> [P(W_0), P(W_1), (...), P(W_n-1), P(W_n)] </math>

Cette représentation fréquentielle n'est autre que les évaluations du polynôme P aux racines nièmes de l'unité. Nous avons donc maintenant au minimum <math>2n+1</math> évaluations des polynômes facteurs. Il nous faut maintenant trouver les évaluations du produit final, c'est à dire les évaluations concernant le polynôme qui sera issue de la multiplication. On pourra ainsi le retrouver.

Soit <math>C</math> un polynome tel que <math> C = A \times B </math>, alors on a :

<math> C(x) = A(x) \times B(x) </math>

Ainsi on en déduit que <math> C(W_n^k) = A(W_n^k) \times B(W_n^k) </math>

On comprend donc que <math>FFT(C) = FFT(A) \times FFT(B)</math>

Il faut préciser que l'on fait le produit de FFT(A) et FFT(B) terme à terme, soit évaluation par évaluation.

Une fois en possession de <math>FFT(C)</math>, qui n'est autre que l'évaluation de notre polynôme final en un nombre suffisant de points pour le retrouver, nous pouvons faire l'<math>IFFT(FFT(C))</math>, qui va nous permettre de retrouver les coefficients de notre polynôme en faisant l'exacte inverse de la FFT.

Une fois les coefficients retrouvés, il nous suffit de gérer les retenues, et nous retrouvons un entier de la forme : <math>a_0 a_1 (...) a_{n-1} a_n</math>

=== B) Graphique ===

Intéressons nous maintenant à la complexité de l'algorithme utilisant la transformée de Fourier rapide. On sait que l'algorithme passe par 5 étapes importantes :

<ul>
<li>Etape 1 : Ecrire les deux facteurs sous la forme de polynômes</li>
<li>Etape 2 : Effectuer la <math>FFT</math> des deux polynômes</li>
<li>Etape 3 : Faire le produit terme à terme des <math>FFT</math> obtenues</li>
<li>Etape 4 : Faire l'<math>IFFT</math> du produit</li>
<li>Etape 5 : Gérer les retenues et écrire le nombre qui en découle</li>
</ul>

Or, parmi toutes ces étapes, certaines sont négligeable comme l'étape 1 et 5.

Pour connaitre la complexité de l'algorithme, additionnons les complexités des étapes restantes :

Une <math>FFT</math> a une complexité de <math>\mathcal{O}(n\times logn)</math> car elle fait <math>n</math> évaluation sur <math> log(n)</math> récursions. Dans le cadre de notre algorithme, nous devons faire la <math>FFT</math> de nos deux facteurs. Soit <math>2\times \mathcal{O}(n\times logn)</math>.

Pour le produit terme à terme, nous faisons naturellement <math>n</math> opérations.

Pour finir, l'<math>IFFT</math> a la même complexité que la <math>FFT</math>. Dans le cadre de notre algorithme nous l'emploierons qu'une seule fois, ce qui fait une complexité de <math>\mathcal{O}(n\times logn)</math>.

Après addition de toutes ces complexités, nous obtenons la complexité réelle de <math>3\mathcal{O}(n\times logn) + \mathcal{O}(n)</math>.

D'après le Master Theorem, nous avons donc <math> f(n) = 3(n\times logn)+n </math>, cherchons <math>f(n)\in\mathcal{O}(g(n))</math> :

Nous pouvons ignorer les expressions linéaires ainsi que les constantes multiplicatrices, nous obtenons donc <math>\mathcal{O}(g(n)) = \mathcal{O}(n \times log n)</math>.

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:30px; text-align:center;">
[[Fichier:FFT_image.webp|500px]]
<div><b>Graphiques des complexités</b></div>
</div>
<div style="max-width:800px;">
<p>Ce graphique ci-contre ne provient pas du fruit de nos recherches personnelles mais </p>
<p>On comprend ainsi que certaines complexités ne sont pas raisonnable dans la cadre de la multiplication de grands entiers.</p>
<p>C'est pourquoi l'étude de ces algorithmes s'avère nécessaire.</p>
</div>
</div>

= II - Produit de matrices =

== 1.1) naïve ==

La multiplication naïve de matrice requiert d'avoir des tailles de lignes/colonne semblable, ensuite pour chaque membre de la matrice résultat, on doit multiplier les composantes ligne de la première matrice par les composantes colonne de la deuxième et le tout sommé.

On en déduit la formule suivante:
<math>C_{i,j} = \sum_{k=1}^{n} (A_{i,k} \times B_{k,j})</math>

Et visuellement:

[[Fichier:Matricenaive.jpeg]]

On a donc un algorithme d'ordre de complexité <math>\mathcal{O}(g(n))</math>

== 1.2) naïve récursive ==

Dans un premier temps on doit découper nos deux matrices en quatres sous matrices de plus petite taille.
<math>A = \begin{pmatrix} A_{11} & A_{12} \ A_{21} & A_{22} \end{pmatrix}</math>
<math>B = \begin{pmatrix} B_{11} & B_{12} \ B_{21} & B_{22} \end{pmatrix}</math>

Ensuite on vient calculer la matrice résultat.
<math>C_{11} = (A_{11} \times B_{11}) + (A_{12} \times B_{21})</math>
<math>C_{12} = (A_{11} \times B_{12}) + (A_{12} \times B_{22})</math>
<math>C_{21} = (A_{21} \times B_{11}) + (A_{22} \times B_{21})</math>
<math>C_{22} = (A_{21} \times B_{12}) + (A_{22} \times B_{22})</math>

Le côté récursif est utile que pour les matrices de tailles <= 32 (32 valeurs stockées dedans),
si on est au dessus de cette taille alors on divisera à nouveau nos matrices en quatres.
On aura 8 multiplications mais de plus petite taille au final.

== 2) strassen ==

=== A) Fonctionnement ===

Strassen consiste à définir 7 produits intermédiaires qui, par des jeux de sommes et de différences, permettent de reconstruire les quadrants de la matrice résultante. On passe ainsi d'une complexité de O(n^3) à environ O(n^2.81)

=== B) Graphique ===

On voit bien la différence de complexité sur la multiplication de grande matrice entre l'approche naïve et l'approche récursive qui est beaucoup plus rapide.

[[Fichier:Analyse matrices.png]]

= Conclusion =

L'étude de ces algorithmes de multiplication nous a clairement montré l'évolution de la complexité algorithmique permettant de gagner en efficacité lorsque la taille des données augmente.

La multiplication classiqe, en <math>\mathcal{O}(n^2)</math>, résulte d'une approche naïve qui devient rapidement inefficace pour les grands entiers ou les grandes matrices. L'algorithme de Karatsuba nous montre qu'organiser de manière intelligente ses calculs algébrique permet parfois de gagner beaucoup de multiplications, et donc de temps. Nous avons ainsi réussi à passer d'une complexité de <math>\mathcal{O}(n^2)</math> à <math>\mathcal{O}(n^{log_2(3)})</math>, soit environ <math>\mathcal{O}(n^{1/585})</math>.

Des méthodes encore plus avancées comme utilise l'algorithme de Toom-Cook-3 continue dans cette idées de divisions d'entiers en blocs plus petits, tandis que la transformée de Fourier rapide change complètement de point de vue. En effet la FFT n'utilise pas la représentation classique des entiers mais fait appel à une vision polynomiale, ce qui transforme la convolution classique en multiplication terme à terme, ce qui lui permet d'atteindre une complexité de <math>\mathcal{O}(n \times log n)</math>.

Dans le cas des matrices, les mêmes logiques apparaissent comme par exemple avec l'algorithme de Strassen qui se rapproche très fortement de Karatsuba en combinant de manière astucieuse les parties d'entiers qui avaient été précédemment découpée.

On remarque néanmoins que la majorité des algorithmes efficaces s'orientent vers une approche récursive et non itérative. Néanmoins, nous avons pu trouver certaines de ces implémentations (comme par exemple la FFT) en itérative.

Avec ces recherches, nous comprenons que la réorganisations des calculs algébriques peuvent aider à gagner en complexité mais que pour faire de réels progrès, il nous faudra surement changer notre point de vue une nouvelle fois, et aborder le problème sous un angle nouveau comme le font dors et déjà les algorithmes les plus performants.

= Mentions =

Le premier gif est le résultat du travail de 'Walké', licence ci-contre : https://fr.wikipedia.org/wiki/Fichier:Addition.gif

= Sources =

Pour karatsuba : https://www.youtube.com/watch?v=PZ2gdWdKHAA

Pour mieux comprendre la FFT, nous avons utilisé plusieurs sources d'informations :
<ul>
<li> https://www.youtube.com/watch?v=h7apO7q16V0&list=WL&index=1&t=886s </li>
<li> https://fr.wikipedia.org/wiki/Interpolation_polynomiale </li>
</ul>

Algorithmes de multiplications d'entiers et de matrices

2026-05-11T15:40:48Z

Mangala : /* Conclusion */

= Introduction =

Depuis l'apparition des ordinateurs modernes, une quantité faramineuse de calculs a dû être effectuée. Les progressions technologiques nous poussent à envisager la puissance de calcul comme une ressource qu'il faut optimiser dans les moindres détails. C'est ainsi que l'optimisation des algorithmes de calcul est devenue cruciale, surtout lorsqu'il nous faut effectuer des opérations sur de très grands entiers par exemple.

= Objectif =

L'objectif majeur de ce projet est de comprendre de manière plus approfondie ce qu'est la '''complexité algorithmique'''.
Pour atteindre cet objectif, nous implémenterons plusieurs algorithmes de multiplication qui auront pour but de calculer le produit de grands entiers ou de matrices.

= Point important : complexité =

=== Définition ===
La complexité d'un algorithme est la quantité des ressources qu'il utilise en fonction de la taille des entrées qu'on lui demande de traiter. On peut par exemple se concentrer sur le temps qu'un algorithme prend pour renvoyer un résultat ou sur la mémoire dont il a besoin. Dans le cadre de notre projet, nous nous attarderons plus particulièrement sur la quantité de calcul effectuée en fonction de la taille des entrées, ce qui est par ailleurs étroitement liée à la notion de temps. De manière générale, plus un algorithme doit faire de calcul, plus il est lent. (Attention, toutes les opérations arithmétiques de base ne se valent pas)

De manière plus familière, on dira que la complexité d'un algorithme pourrait s'apparenter à son comportement lorsqu'il doit traiter des données plus ou moins grandes.
Chaque algorithme a une complexité, et on l'exprime par une fonction qui adopte un comportement similaire au nombre de calculs nécessaires en fonction de la taille des entrées.

=== Notation ===
La complexité réelle d'un algorithme peut être décrite par une fonction <math>f(n)</math> représentant le nombre d'opérations effectuées en fonction de la taille <math>n</math> des données d'entrée.

Cependant, afin de simplifier l'étude de cette croissance, on utilise généralement une borne asymptotique notée <math>\mathcal{O}(g(n))</math>, où <math>g(n)</math> est une fonction ayant le même ordre de grandeur que <math>f(n)</math> lorsque <math>n</math> devient grand.

On dit alors que :

<math>
f(n)\in\mathcal{O}(g(n))
</math>

si et seulement s'il existe une constante <math>C>0</math> et un entier <math>n_0</math> tels que :

<math>
\forall n\ge n_0,\ f(n)\le Cg(n)
</math>

Cette notation <math>\mathcal{O}(g(n))</math> permettra de comparer beaucoup plus facilement les algorithmes entre eux.

=== Master Theorem ===

Afin de déterminer la complexité de certains algorithmes récursifs, nous utiliserons le "Master Theorem".

Ce théorème permet d'obtenir directement l'ordre de grandeur de nombreuses relations de récurrence apparaissant dans l'analyse d'algorithmes de type « diviser pour régner », comme l'algorithme de Karatsuba ou celui de Strassen.

La démonstration complète de ce théorème dépasse le cadre de notre projet et nécessite des connaissances mathématiques plus avancées. Nous l'utiliserons donc principalement comme un outil nous permettant de déterminer efficacement la complexité asymptotique des algorithmes étudiés.

=== Graphiques ===

Les complexités étant des fonctions, nous pouvons les représenter par un graphique qui affichera le temps d'exécution (ou nombre d'opérations) en fonction de la taille des entrées.

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:30px; text-align:center;">
[[Fichier:complexite.webp|500px]]
<div><b>Graphiques des complexités</b></div>
</div>
<div style="max-width:800px;">
<p>Ce graphique ci-contre compare les complexités en fonction de la taille des d'entrées.</p>
<p>On comprend ainsi que certaines complexités ne sont pas raisonnable dans la cadre de la multiplication de grands entiers.</p>
<p>C'est pourquoi l'étude de ces algorithmes s'avère nécessaire.</p>
</div>
</div>

=== Exemple ===
L'algorithme naïf d'addition que nous avons tous appris à l'école a une complexité de <math>\mathcal{O}(n)</math>.
Soit n la taille des nombres en entrée, l'algorithme doit faire environ n addition pour arriver au résultat demandé.

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Addition.gif|220px]]
<div><b>Addition naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Comme le montre l'exemple ci-contre, 786 et 467 font 3 chiffres de long donc n sera de 3.</p>
<p>Il nous faudra 3 opérations pour additionner ces entiers.</p>
<p>C'est ainsi qu'avec une taille d'entrée n, l'algorithme de l'addition naïve va devoir faire n opérations.</p>
<p>Cet algorithme a donc une complexité <math>f(n) = n</math> qui n'a pas besoin d'être approximée.</p>
<p>Ainsi sa complexité finale sera <math>\mathcal{O}(n)</math>.</p>
</div>
</div>

= Problématique =

Le calcul du produit de deux entiers de manière naïve a une complexité de <math> \mathcal{O}(n^2)</math>, et celui de deux matrices une complexité de <math> \mathcal{O}(n^3)</math>. Afin de mieux comprendre ce qu'est la complexité algorithmique, nous devrons implémenter des algorithmes ayant le même objectif, mais étant plus efficaces. Ces algorithmes s'avèreront plus complexes mais devrait aboutir à un calcul plus rapide du produit demandé.

Nous séparerons notre wiki en deux grandes parties, la première concernera nos recherche sur [[#I - Produit d'entiers|la multiplication d'entiers]], la deuxième sur [[#II - Produit de matrices|la multiplication de matrices]].

= I - Produit d'entiers =

Notre départ commence avec l'algorithme de multiplication d'entier naïf.
En effet il s'agit de l'algorithme de multiplication le plus connu, et nous l'utiliserons comme référence pour le comparer aux futurs algorithmes plus efficaces.
Intéressons nous à sa complexité.

== 1) Nos implémentations des grands entiers ==

Qui dit produit de grands entiers dit implémentation de grands entiers.

Dans le cadre de nos recherches, nous allons devoir implémenter des algorithmes qui vont manipuler des grands entiers.

Nous avons donc choisi de créer deux représentations différentes de ceux-ci (car nous travaillons sur différents langages de programmation), nous permettant à la fois une implémentation simplifié, mais aussi de nous rapprocher d'une implémentation bas niveau.

=== A) En python ===
En python, l'utilisation des "bytes" m'a grandement servi à comprendre comment les entiers étaient manipulés à bas niveau. En effet, un des objectifs secondaires de nos recherches était de manipuler des entiers directement avec leur formes stockées sur l'ordinateur, et non pas avec des int python.
En effet l'utilisation des int python nous aurait permit de passer les étapes de retenues, de signes... D'autant plus que les bytes permettent de stocker un nombre en base 256, ce qui permet de visualiser plus facilement les grands entiers.

La forme finale de la représentation des grands entiers en python sera donc la suivante :

[ signe , bytes , bytes , (...) , bytes ]

Le signe est représenté par un entier, 1 si le nombre est positif, 0 sinon.
Cette configuration rendra plus simple la gestion des signes.

=== B) En C++ ===

En C++, pour avoir une représentation de grand entiers j'ai du définir ma propre structure pour m'affranchir de la limite de taille imposé par les entiers standards: (int32 ou int64). Pour cela, j'ai une structure qui possède l'équivalent d'un array de byte (ce qui nous permet d'être en base 256 au lieu de la base 10 habituelle), et pour traiter le signe j'utilise un booléen, ainsi en mémoire j'ai une structure de n*Octets + 1 octet en taille.

[ bytes , bytes , (...) , bytes ] [ signe ]

Le booléen prend 1 octet de place mais ne touche pas aux octets qui encode le grand entier.
Cette configuration rendra plus simple la gestion des signes dans le cadre des multiplication.

== 2) La multiplication naïve ==

=== A) Fonctionnement ===
Dans le cas de la multiplication d'entiers, nous allons prendre deux nombres qui n'ont pas nécessairement la même longueur. Soit les nombre a et b, de longueur respective <math>n</math> et <math> m </math>.
<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Multiplication.png|220px]]
<div><b>Multiplication naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Prenons deux nombres de longueur 3 et 2, et cherchons combien d'opérations l'algorithme de multiplication naïve va devoir faire pour nous renvoyer leur produit.</p>
<p>Dans un premier temps, on remarque que l'on va devoir multiplier chaque chiffre du nombre du haut par le chiffre des unités du bas, qui est 6. Cela va représenter <math>n</math> opérations. (6x5, 6x1 et 6x4)</p>
<p>Dans un deuxième temps nous constatons que nous allons devoir faire la même chose avec le chiffre des dizaines du nombre du bas. Cela nous ajoute de nouveau <math>n</math> opérations.</p>
<p>On arrive assez facilement à la conclusion que pour faire notre produit, il va nous falloir faire <math>n</math> fois <math>m</math> opérations.</p>
</div>
</div>

Ainsi, la complexité de la multiplication naïve est <math>\mathcal{O}(n^2)</math>.
Il est en de même avec la multiplication naïve récursive.

=== B) Graphique ===
Montrons maintenant sa courbe sur un graphique :

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Multiplicationnaive.png|500px]]
<div><b>Multiplication naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Les points noirs sont des repères pour que les autres courbes aient une forme cohérente.</p>
<p>Ils sont tous sur l'axe des abscisses.</p>
<p>La courbe rouge représente la complexité de la multiplication naïve.</p>
<p>On remarque que la courbe a un visuel très similaire à la fonction <math>f(x) = x^2</math> </p>
</div>
</div>

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Naif_recursif.png|500px]]
<div><b>Multiplication naïve récursive</b></div>
</div>
<div style="max-width:800px;">
<p>La courbe rouge représente la complexité de la multiplication naïve récursive.</p>
<p>Elle sera utilisé pour comparer les complexités entre algorithmes car, comme tous récursifs, elle a été codé avec les mêmes biais d'implémentation qu'eux.</p>
<p>Théoriquement les deux courbes ci-contre ont la même complexité, mais encore une fois, notre implémentation n'est pas parfaitement optimale et donc ne respecte pas de manière minutieuse le Master Theorem.</p>
</div>
</div>

== 3) La multiplication karatsuba ==

=== A) Fonctionnement ===

L'algorithme de karatsuba est un algorithme récursif de type diviser pour régner.

L'idée générale de l'algorithme est de passer de 4 multiplication à 3. En effet ces opérations étant moins couteuses, il est préférable d'en ajouter si cela permet d'enlever des multiplications.

L'algorithme de multiplication naif récursif utilise la segmentation des facteurs en deux de manière successive.

Soit <math>x</math> et <math>y</math> deux facteurs, nous avons les égalités suivantes :

<div style="font-size: 20px;">
<math>x = a \times B^{n/2} + b</math>
<math>y = c \times B^{n/2} + d</math>
</div>

Avec <math>a</math> et <math>c</math> les premières moitiés des facteurs <math>x</math> et <math>y</math>,
et <math>b</math> et <math>d</math> les dernières moitiés de ces facteurs ainsi que <math>B</math> la base d'écriture du nombre (Nous sommes en base 256 avec les bytes).

Cette présentation des deux facteurs de notre multiplication n'est que la résultante d'un découpage.
Le [[#Master Theorem|Master Theorem]] nous montre que :

<div style="font-size: 20px;">
<math>T(n) = 4T(n/2) + O(n)</math>
</div>

Puisque nous avons après découpage 4 entiers de longueur <math>n/2</math>.

Ainsi, ce découpage ne permet pas de gagner du temps d'après le [[#Master Theorem|Master Theorem]].

Cependant, l'algorithme de Karatsuba réutilise ce principe en le modifiant, ce qui nous permet de baisser la complexité globale de la multiplication dans son entièreté.

Avec l'écriture ci-dessus des nombres <math>x</math> et <math>y</math>, on peut facilement en déduire l'égalité suivante :

<div style="font-size: 20px;">
<math>x \times y = (ac) \times B^n + (ad + bc) \times B^{n/2} + bd</math>
</div>

On remarque 4 multiplications longues à faire dans cette expression. Les multiplications dont <math>B</math> est l'un des facteurs sont très rapides puisqu'il s'agit de la base dans laquelle nous travaillons. De cela en résulte un décalage plutôt qu'un vrai calcul à faire.

Karatsuba développe une partie de cette expression pour pouvoir négocier une multiplication au prix d'additions et soustractions.

En effet, nous savons déjà que :

<div style="font-size: 20px;">
<math>(a + b)(c + d) = ac + ad + bc + bd</math>
</div>

En manipulant l'égalité nous obtenons :

<div style="font-size: 20px;">
<math>ad + bc = (a + b)(c + d) - ac - bd</math>
</div>

ac et bd ayant déjà été calculé précédemment, il nous reste uniquement la multiplication <math>(a + b)(c + d)</math>.

Nous venons ainsi de calculer <math>ad + bc</math> en seulement une multiplication. C'est la que repose le gain de temps de la méthode Karatsuba par rapport à la multiplication naïve.

En effet, l'algorithme n'effectuera alors plus que 3 multiplications :
<div style="font-size: 20px;">
<math>ac</math>
<math>bd</math>
<math>(a + b)(c + d)</math>
</div>

La relation de récurrence devient donc :
<div style="font-size: 20px;">
<math>T(n)=3T(n/2)+O(n)</math>
</div>

Et le Master Theorem nous dit que :
<div style="font-size: 20px;">
<math>T(n)\in O(n^{\log_2(3)})</math>
</div>

Or <math>\log_2(3)\approx 1.585</math>, donc la complexité de l'algorithme de Karatsuba est de <math> \mathcal{O}(n^{1.585})</math>. Ce qui est bien plus efficace que la multiplication classique, surtout lorsque les facteurs deviennent très grands.

=== B) Graphique ===
<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Karatsuba.png|500px]]
<div><b>Karatsuba</b></div>
</div>
<div style="max-width:800px;">
<p>Sur le graphique ci-contre nous avons utilisé la courbe de la multiplication naïve récursive (rouge) à titre de comparaison.</p>
<p>On remarque graphiquement que Karatsuba (jaune) prend moins de temps à chaque calcul de produit.</p>
<p>On en déduit donc expérimentalement que Karatsuba à une meilleure complexité que la multiplication naïve.</p>
<p>Ainsi nous vérifions donc ce que le Master Theorem prouve, c'est à dire que la complexité de karatsuba est de <math> \mathcal{O}(n^{1.585})</math> </p>
</div>
</div>

== 4) La multiplication toom-cook-3 ==

=== A) Fonctionnement ===

L'objectif est de diviser les grands entiers X et Y en trois blocs de taille égale k.
On les traite alors comme des polynômes de degré 2:

<math>P(z) = X_2 \cdot z^2 + X_1 \cdot z + X_0</math>
<math>Q(z) = Y_2 \cdot z^2 + Y_1 \cdot z + Y_0</math>

On choisit 5 points distincts pour évaluer nos polynômes.
Ce choix de 5 points est crucial car le produit de deux polynômes de degré 2 est un polynôme de degré 4, qui nécessite 5 points pour être défini.
Les points standards sont :

P(0) = X0
P(1) = X0 + X1 + X2
P(-1) = X0 - X1 + X2
P(2) = X0 + 2*X1 + 4*X2
P(inf) = X2

(On procède de manière similaire pour Q.)

Ensuite nous multiplions récursivement chaque points de P et de Q ensemble.
On effectue ainsi 5 multiplications de nombres plus petits au lieu des 9 multiplications requises par la méthode classique.

Après, nous effectuons une interpolation, cela permet de retrouver les 5 coefficients (w_0, w_1, w_2, w_3, w_4) du polynôme produit R(z) à partir des valeurs évaluées calculées précédemment.
On résout un système d'équations linéaires : <math> R(z) = w_4 z^4 + w_3 z^3 + w_2 z^2 + w_1 z + w_0 </math>
Finalement nous pouvons recomposer notre grand entier en positionnant les coefficients w_i aux bons rangs (en les décalant) et à gérer les retenues lors de l'addition finale:
<math>Résultat = w_4 B^{4k} + w_3 B^{3k} + w_2 B^{2k} + w_1 B^k + w_0</math>

=== B) Graphique ===

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Toomcook.png|500px]]
<div><b>Karatsuba</b></div>
</div>
<div style="max-width:800px;">
<p>on a reprit multi récursive (rouge)</p>
<p>on voit que Toom (vert) en dessous de karatsuba (jaune) en dessous de multi classique (rouge)</p>
<p>meilleur complexité</p>
</div>
</div>

== 5) La transformée de Fourier rapide ==

=== A) Fonctionnement ===

La transformation de Fourier rapide étant plus complexe que les autres algorithmes, nous allons essayer d'expliquer son fonctionnement malgré ne pas avoir réussi à l'implémenter.

Il faut comprendre que cet algorithme va considérer les facteurs comme des polynômes.

D'après le théorème de l'unisolvance, il n'existe qu'un seul polynôme de degré inférieur ou égal à <math> n </math> défini par <math>n + 1</math> points distincts. Cela implique non seulement que nous pouvons représenter chaque entier par un polynôme, mais également que si nous pouvons retrouver <math>n + m + 1</math> points (avec <math>n</math> et <math>m</math> la longueur des facteurs) du polynômes issue du produit entre deux facteurs, nous pourrons le retrouver.

Soit un entier quelconque, de forme :

<math>a_n a_{n-1} (...) a_1 a_0</math>

Avec <math>a_i</math>, un chiffre composant le nombre en base 10, qui vaut en réalité dans le nombre : <math>a_i \times 10^i</math>. On peut ainsi l'écrire sous la forme :

<math> P(x) = a_0 + a_1x + a_2x^2 + \dots + a_{n-1}x^{n-1} + a_nx^n </math>

Avec <math>x = 10</math> car nous sommes en base 10, nous obtenons :

<math>P(10) = a_0 + a_1 \times 10 + \dots + a_{n-1}10^{n-1} + a_n10^n </math>

Nous venons ainsi d'écrire notre nombre sous la forme d'un polynôme unique. Pour nous permettre d'évaluer en un nombre suffisant de points, nous allons devoir ajouter des 0 pour la récursion. Il nous faudra ajouter assez de 0 pour atteindre la prochaine puissance de 2 qui sera supérieure ou égale à <math>2n + 1</math>. L'ajout de 0 ne change pas le nombre car <math>0 \times x^n</math> n'ajoute pas de coefficient.

Cet algorithme est récursif et va segmenter en deux parties nos polynômes à chaque récursion. D'un coté les indice pairs et d'un coté les impaires.

Ainsi prenons les nombres 1234 et 5678, ces nombres sont respectivement représentés par les polynômes <math> P(x) = 4 + 3x + 2x^2 + x^3 </math> et <math> P(x) = 8 + 7x + 6x^2 + 5^3 </math>. Ce sont des polynômes de degré 3, ainsi leur produit donnera lieu à un polynôme de degré 6. Il nous faudra donc au minimum 7 points d'évaluation pour retrouve ce produit. De ce fait, en les représentant de la manière suivante :

<math>[4, 3, 2, 1, 0, 0, 0, 0]</math>
<math>[8, 7, 6, 5, 0, 0, 0, 0]</math>

Nous aurons assez de récursions possible pour les évaluer en un nombre suffisant de points différents car nous auront 3 récursions à faire pour atteindre notre cas de base. A chaque récursion, nous allons diviser nos polynômes en deux parties ce qui nous fait 8 feuilles à la dernière récursion.

En effet à chaque étape de la récursion nous allons séparer nos polynômes en deux tel que :

<math>P(x)=P_{\text{pair}}(x^2) + x \cdot P_{\text{impair}}(x^2)</math>

Durant les récursions, nous segmentons les polynômes mais ne les évaluons pas. C'est à la remonté des récursions que nous allons réellement évaluer nos polynômes. Lorsque l'on atteint notre cas de base, c'est à dire des polynômes de degré 0, nous remarquons qu'ils sont constants, nous n'avons donc pas besoin de les évaluer. En effet, peut importe le point en lequel nous voudrons l'évaluer, le polynôme renverra la constante. Nous la renvoyons donc seule.
Ensuite commence la remontée des récursions. A l'étape 1 de notre remontée nous allons reformer le polynôme précédemment séparé pour obtenir un polynôme de degré 1. Puis, nous évaluons ce polynôme avec les racines seconde de l'unité. Nous faisons à nouveau remonté les évaluations et recombinons à nouveau le polynôme qui sera ainsi de degré 2.
Nous l'évaluons maintenant avec les racines 4eme de l'unité. A chaque évaluation, nous réutilisons les résultats précédents, cela nous est permit par les racines de l'unité qui ont une structure récursive exploitable.

Finalement, nous arrivons à la fin de notre FFT, avec une représentation fréquentielle de la forme :

<math> [P(W_0), P(W_1), (...), P(W_n-1), P(W_n)] </math>

Cette représentation fréquentielle n'est autre que les évaluations du polynôme P aux racines nièmes de l'unité. Nous avons donc maintenant au minimum <math>2n+1</math> évaluations des polynômes facteurs. Il nous faut maintenant trouver les évaluations du produit final, c'est à dire les évaluations concernant le polynôme qui sera issue de la multiplication. On pourra ainsi le retrouver.

Soit <math>C</math> un polynome tel que <math> C = A \times B </math>, alors on a :

<math> C(x) = A(x) \times B(x) </math>

Ainsi on en déduit que <math> C(W_n^k) = A(W_n^k) \times B(W_n^k) </math>

On comprend donc que <math>FFT(C) = FFT(A) \times FFT(B)</math>

Il faut préciser que l'on fait le produit de FFT(A) et FFT(B) terme à terme, soit évaluation par évaluation.

Une fois en possession de <math>FFT(C)</math>, qui n'est autre que l'évaluation de notre polynôme final en un nombre suffisant de points pour le retrouver, nous pouvons faire l'<math>IFFT(FFT(C))</math>, qui va nous permettre de retrouver les coefficients de notre polynôme en faisant l'exacte inverse de la FFT.

Une fois les coefficients retrouvés, il nous suffit de gérer les retenues, et nous retrouvons un entier de la forme : <math>a_0 a_1 (...) a_{n-1} a_n</math>

=== B) Graphique ===

Intéressons nous maintenant à la complexité de l'algorithme utilisant la transformée de Fourier rapide. On sait que l'algorithme passe par 5 étapes importantes :

<ul>
<li>Etape 1 : Ecrire les deux facteurs sous la forme de polynômes</li>
<li>Etape 2 : Effectuer la <math>FFT</math> des deux polynômes</li>
<li>Etape 3 : Faire le produit terme à terme des <math>FFT</math> obtenues</li>
<li>Etape 4 : Faire l'<math>IFFT</math> du produit</li>
<li>Etape 5 : Gérer les retenues et écrire le nombre qui en découle</li>
</ul>

Or, parmi toutes ces étapes, certaines sont négligeable comme l'étape 1 et 5.

Pour connaitre la complexité de l'algorithme, additionnons les complexités des étapes restantes :

Une <math>FFT</math> a une complexité de <math>\mathcal{O}(n\times logn)</math> car elle fait <math>n</math> évaluation sur <math> log(n)</math> récursions. Dans le cadre de notre algorithme, nous devons faire la <math>FFT</math> de nos deux facteurs. Soit <math>2\times \mathcal{O}(n\times logn)</math>.

Pour le produit terme à terme, nous faisons naturellement <math>n</math> opérations.

Pour finir, l'<math>IFFT</math> a la même complexité que la <math>FFT</math>. Dans le cadre de notre algorithme nous l'emploierons qu'une seule fois, ce qui fait une complexité de <math>\mathcal{O}(n\times logn)</math>.

Après addition de toutes ces complexités, nous obtenons la complexité réelle de <math>3\mathcal{O}(n\times logn) + \mathcal{O}(n)</math>.

D'après le Master Theorem, nous avons donc <math> f(n) = 3(n\times logn)+n </math>, cherchons <math>f(n)\in\mathcal{O}(g(n))</math> :

Nous pouvons ignorer les expressions linéaires ainsi que les constantes multiplicatrices, nous obtenons donc <math>\mathcal{O}(g(n)) = \mathcal{O}(n \times log n)</math>.

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:30px; text-align:center;">
[[Fichier:FFT_image.webp|500px]]
<div><b>Graphiques des complexités</b></div>
</div>
<div style="max-width:800px;">
<p>Ce graphique ci-contre ne provient pas du fruit de nos recherches personnelles mais </p>
<p>On comprend ainsi que certaines complexités ne sont pas raisonnable dans la cadre de la multiplication de grands entiers.</p>
<p>C'est pourquoi l'étude de ces algorithmes s'avère nécessaire.</p>
</div>
</div>

= II - Produit de matrices =

== 1.1) naïve ==

La multiplication naïve de matrice requiert d'avoir des tailles de lignes/colonne semblable, ensuite pour chaque membre de la matrice résultat, on doit multiplier les composantes ligne de la première matrice par les composantes colonne de la deuxième et le tout sommé.

On en déduit la formule suivante:
<math>C_{i,j} = \sum_{k=1}^{n} (A_{i,k} \times B_{k,j})</math>

Et visuellement:

[[Fichier:Matricenaive.jpeg]]

On a donc un algorithme d'ordre de complexité <math>\mathcal{O}(g(n))</math>

== 1.2) naïve récursive ==

Dans un premier temps on doit découper nos deux matrices en quatres sous matrices de plus petite taille.
<math>A = \begin{pmatrix} A_{11} & A_{12} \ A_{21} & A_{22} \end{pmatrix}</math>
<math>B = \begin{pmatrix} B_{11} & B_{12} \ B_{21} & B_{22} \end{pmatrix}</math>

Ensuite on vient calculer la matrice résultat.
<math>C_{11} = (A_{11} \times B_{11}) + (A_{12} \times B_{21})</math>
<math>C_{12} = (A_{11} \times B_{12}) + (A_{12} \times B_{22})</math>
<math>C_{21} = (A_{21} \times B_{11}) + (A_{22} \times B_{21})</math>
<math>C_{22} = (A_{21} \times B_{12}) + (A_{22} \times B_{22})</math>

Le côté récursif est utile que pour les matrices de tailles <= 32 (32 valeurs stockées dedans),
si on est au dessus de cette taille alors on divisera à nouveau nos matrices en quatres.
On aura 8 multiplications mais de plus petite taille au final.

== 2) strassen ==

=== A) Fonctionnement ===

Strassen consiste à définir 7 produits intermédiaires qui, par des jeux de sommes et de différences, permettent de reconstruire les quadrants de la matrice résultante. On passe ainsi d'une complexité de O(n^3) à environ O(n^2.81)

=== B) Graphique ===

On voit bien la différence de complexité sur la multiplication de grande matrice entre l'approche naïve et l'approche récursive qui est beaucoup plus rapide.

[[Fichier:Analyse matrices.png]]

= Conclusion =

L'étude de ces algorithmes de multiplication nous a clairement montré l'évolution de la complexité algorithmique permettant de gagner en efficacité lorsque la taille des données augmente.

La multiplication classiqe, en <math>\mathcal{O}(n^2)</math>, résulte d'une approche naïve qui devient rapidement inefficace pour les grands entiers ou les grandes matrices. L'algorithme de Karatsuba nous montre qu'organiser de manière intelligente ses calculs algébrique permet parfois de gagner beaucoup de multiplications, et donc de temps. Nous avons ainsi réussi à passer d'une complexité de <math>\mathcal{O}(n^2)</math> à <math>\mathcal{O}(n^{log_2(3)})</math>, soit environ <math>\mathcal{O}(n^{1/585})</math>.

Des méthodes encore plus avancées comme utilise l'algorithme de Toom-Cook-3 continue dans cette idées de divisions d'entiers en blocs plus petits, tandis que la transformée de Fourier rapide change complètement de point de vue. En effet la FFT n'utilise pas la représentation classique des entiers mais fait appel à une vision polynomiale, ce qui transforme la convolution classique en multiplication terme à terme, ce qui lui permet d'atteindre une complexité de <math>\mathcal{O}(n \times log n)</math>.

Dans le cas des matrices, les mêmes logiques apparaissent comme par exemple avec l'algorithme de Strassen qui se rapproche très fortement de Karatsuba en combinant de manière astucieuse les parties d'entiers qui avaient été précédemment découpée.

On remarque néanmoins que la majorité des algorithmes efficaces s'orientent vers une approche récursive et non itérative. Néanmoins, nous avons pu trouver certaines de ces implémentations (comme par exemple la FFT) en itérative.

Avec ces recherches, nous comprenons que la réorganisations des calculs algébriques peuvent aider à gagner en complexité mais que pour faire de réels progrès, il nous faudra surement changer notre point de vue une nouvelle fois, et aborder le problème sous un angle nouveau comme le font dors et déjà les algorithmes les plus performants.

= Mentions =

Le premier gif est le résultat du travail de 'Walké', licence ci-contre : https://fr.wikipedia.org/wiki/Fichier:Addition.gif

= Sources =

Pour karatsuba : https://www.youtube.com/watch?v=PZ2gdWdKHAA

Pour mieux comprendre la FFT, nous avons utilisé plusieurs sources d'informations :
<ul>
<li> https://www.youtube.com/watch?v=h7apO7q16V0&list=WL&index=1&t=886s </li>
<li> https://fr.wikipedia.org/wiki/Interpolation_polynomiale </li>
</ul>

Algorithmes de multiplications d'entiers et de matrices

2026-05-11T15:23:48Z

Mangala : /* Conclusion */

= Introduction =

Depuis l'apparition des ordinateurs modernes, une quantité faramineuse de calculs a dû être effectuée. Les progressions technologiques nous poussent à envisager la puissance de calcul comme une ressource qu'il faut optimiser dans les moindres détails. C'est ainsi que l'optimisation des algorithmes de calcul est devenue cruciale, surtout lorsqu'il nous faut effectuer des opérations sur de très grands entiers par exemple.

= Objectif =

L'objectif majeur de ce projet est de comprendre de manière plus approfondie ce qu'est la '''complexité algorithmique'''.
Pour atteindre cet objectif, nous implémenterons plusieurs algorithmes de multiplication qui auront pour but de calculer le produit de grands entiers ou de matrices.

= Point important : complexité =

=== Définition ===
La complexité d'un algorithme est la quantité des ressources qu'il utilise en fonction de la taille des entrées qu'on lui demande de traiter. On peut par exemple se concentrer sur le temps qu'un algorithme prend pour renvoyer un résultat ou sur la mémoire dont il a besoin. Dans le cadre de notre projet, nous nous attarderons plus particulièrement sur la quantité de calcul effectuée en fonction de la taille des entrées, ce qui est par ailleurs étroitement liée à la notion de temps. De manière générale, plus un algorithme doit faire de calcul, plus il est lent. (Attention, toutes les opérations arithmétiques de base ne se valent pas)

De manière plus familière, on dira que la complexité d'un algorithme pourrait s'apparenter à son comportement lorsqu'il doit traiter des données plus ou moins grandes.
Chaque algorithme a une complexité, et on l'exprime par une fonction qui adopte un comportement similaire au nombre de calculs nécessaires en fonction de la taille des entrées.

=== Notation ===
La complexité réelle d'un algorithme peut être décrite par une fonction <math>f(n)</math> représentant le nombre d'opérations effectuées en fonction de la taille <math>n</math> des données d'entrée.

Cependant, afin de simplifier l'étude de cette croissance, on utilise généralement une borne asymptotique notée <math>\mathcal{O}(g(n))</math>, où <math>g(n)</math> est une fonction ayant le même ordre de grandeur que <math>f(n)</math> lorsque <math>n</math> devient grand.

On dit alors que :

<math>
f(n)\in\mathcal{O}(g(n))
</math>

si et seulement s'il existe une constante <math>C>0</math> et un entier <math>n_0</math> tels que :

<math>
\forall n\ge n_0,\ f(n)\le Cg(n)
</math>

Cette notation <math>\mathcal{O}(g(n))</math> permettra de comparer beaucoup plus facilement les algorithmes entre eux.

=== Master Theorem ===

Afin de déterminer la complexité de certains algorithmes récursifs, nous utiliserons le "Master Theorem".

Ce théorème permet d'obtenir directement l'ordre de grandeur de nombreuses relations de récurrence apparaissant dans l'analyse d'algorithmes de type « diviser pour régner », comme l'algorithme de Karatsuba ou celui de Strassen.

La démonstration complète de ce théorème dépasse le cadre de notre projet et nécessite des connaissances mathématiques plus avancées. Nous l'utiliserons donc principalement comme un outil nous permettant de déterminer efficacement la complexité asymptotique des algorithmes étudiés.

=== Graphiques ===

Les complexités étant des fonctions, nous pouvons les représenter par un graphique qui affichera le temps d'exécution (ou nombre d'opérations) en fonction de la taille des entrées.

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:30px; text-align:center;">
[[Fichier:complexite.webp|500px]]
<div><b>Graphiques des complexités</b></div>
</div>
<div style="max-width:800px;">
<p>Ce graphique ci-contre compare les complexités en fonction de la taille des d'entrées.</p>
<p>On comprend ainsi que certaines complexités ne sont pas raisonnable dans la cadre de la multiplication de grands entiers.</p>
<p>C'est pourquoi l'étude de ces algorithmes s'avère nécessaire.</p>
</div>
</div>

=== Exemple ===
L'algorithme naïf d'addition que nous avons tous appris à l'école a une complexité de <math>\mathcal{O}(n)</math>.
Soit n la taille des nombres en entrée, l'algorithme doit faire environ n addition pour arriver au résultat demandé.

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Addition.gif|220px]]
<div><b>Addition naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Comme le montre l'exemple ci-contre, 786 et 467 font 3 chiffres de long donc n sera de 3.</p>
<p>Il nous faudra 3 opérations pour additionner ces entiers.</p>
<p>C'est ainsi qu'avec une taille d'entrée n, l'algorithme de l'addition naïve va devoir faire n opérations.</p>
<p>Cet algorithme a donc une complexité <math>f(n) = n</math> qui n'a pas besoin d'être approximée.</p>
<p>Ainsi sa complexité finale sera <math>\mathcal{O}(n)</math>.</p>
</div>
</div>

= Problématique =

Le calcul du produit de deux entiers de manière naïve a une complexité de <math> \mathcal{O}(n^2)</math>, et celui de deux matrices une complexité de <math> \mathcal{O}(n^3)</math>. Afin de mieux comprendre ce qu'est la complexité algorithmique, nous devrons implémenter des algorithmes ayant le même objectif, mais étant plus efficaces. Ces algorithmes s'avèreront plus complexes mais devrait aboutir à un calcul plus rapide du produit demandé.

Nous séparerons notre wiki en deux grandes parties, la première concernera nos recherche sur [[#I - Produit d'entiers|la multiplication d'entiers]], la deuxième sur [[#II - Produit de matrices|la multiplication de matrices]].

= I - Produit d'entiers =

Notre départ commence avec l'algorithme de multiplication d'entier naïf.
En effet il s'agit de l'algorithme de multiplication le plus connu, et nous l'utiliserons comme référence pour le comparer aux futurs algorithmes plus efficaces.
Intéressons nous à sa complexité.

== 1) Nos implémentations des grands entiers ==

Qui dit produit de grands entiers dit implémentation de grands entiers.

Dans le cadre de nos recherches, nous allons devoir implémenter des algorithmes qui vont manipuler des grands entiers.

Nous avons donc choisi de créer deux représentations différentes de ceux-ci (car nous travaillons sur différents langages de programmation), nous permettant à la fois une implémentation simplifié, mais aussi de nous rapprocher d'une implémentation bas niveau.

=== A) En python ===
En python, l'utilisation des "bytes" m'a grandement servi à comprendre comment les entiers étaient manipulés à bas niveau. En effet, un des objectifs secondaires de nos recherches était de manipuler des entiers directement avec leur formes stockées sur l'ordinateur, et non pas avec des int python.
En effet l'utilisation des int python nous aurait permit de passer les étapes de retenues, de signes... D'autant plus que les bytes permettent de stocker un nombre en base 256, ce qui permet de visualiser plus facilement les grands entiers.

La forme finale de la représentation des grands entiers en python sera donc la suivante :

[ signe , bytes , bytes , (...) , bytes ]

Le signe est représenté par un entier, 1 si le nombre est positif, 0 sinon.
Cette configuration rendra plus simple la gestion des signes.

=== B) En C++ ===

En C++, pour avoir une représentation de grand entiers j'ai du définir ma propre structure pour m'affranchir de la limite de taille imposé par les entiers standards: (int32 ou int64). Pour cela, j'ai une structure qui possède l'équivalent d'un array de byte (ce qui nous permet d'être en base 256 au lieu de la base 10 habituelle), et pour traiter le signe j'utilise un booléen, ainsi en mémoire j'ai une structure de n*Octets + 1 octet en taille.

[ bytes , bytes , (...) , bytes ] [ signe ]

Le booléen prend 1 octet de place mais ne touche pas aux octets qui encode le grand entier.
Cette configuration rendra plus simple la gestion des signes dans le cadre des multiplication.

== 2) La multiplication naïve ==

=== A) Fonctionnement ===
Dans le cas de la multiplication d'entiers, nous allons prendre deux nombres qui n'ont pas nécessairement la même longueur. Soit les nombre a et b, de longueur respective <math>n</math> et <math> m </math>.
<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Multiplication.png|220px]]
<div><b>Multiplication naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Prenons deux nombres de longueur 3 et 2, et cherchons combien d'opérations l'algorithme de multiplication naïve va devoir faire pour nous renvoyer leur produit.</p>
<p>Dans un premier temps, on remarque que l'on va devoir multiplier chaque chiffre du nombre du haut par le chiffre des unités du bas, qui est 6. Cela va représenter <math>n</math> opérations. (6x5, 6x1 et 6x4)</p>
<p>Dans un deuxième temps nous constatons que nous allons devoir faire la même chose avec le chiffre des dizaines du nombre du bas. Cela nous ajoute de nouveau <math>n</math> opérations.</p>
<p>On arrive assez facilement à la conclusion que pour faire notre produit, il va nous falloir faire <math>n</math> fois <math>m</math> opérations.</p>
</div>
</div>

Ainsi, la complexité de la multiplication naïve est <math>\mathcal{O}(n^2)</math>.
Il est en de même avec la multiplication naïve récursive.

=== B) Graphique ===
Montrons maintenant sa courbe sur un graphique :

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Multiplicationnaive.png|500px]]
<div><b>Multiplication naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Les points noirs sont des repères pour que les autres courbes aient une forme cohérente.</p>
<p>Ils sont tous sur l'axe des abscisses.</p>
<p>La courbe rouge représente la complexité de la multiplication naïve.</p>
<p>On remarque que la courbe a un visuel très similaire à la fonction <math>f(x) = x^2</math> </p>
</div>
</div>

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Naif_recursif.png|500px]]
<div><b>Multiplication naïve récursive</b></div>
</div>
<div style="max-width:800px;">
<p>La courbe rouge représente la complexité de la multiplication naïve récursive.</p>
<p>Elle sera utilisé pour comparer les complexités entre algorithmes car, comme tous récursifs, elle a été codé avec les mêmes biais d'implémentation qu'eux.</p>
<p>Théoriquement les deux courbes ci-contre ont la même complexité, mais encore une fois, notre implémentation n'est pas parfaitement optimale et donc ne respecte pas de manière minutieuse le Master Theorem.</p>
</div>
</div>

== 3) La multiplication karatsuba ==

=== A) Fonctionnement ===

L'algorithme de karatsuba est un algorithme récursif de type diviser pour régner.

L'idée générale de l'algorithme est de passer de 4 multiplication à 3. En effet ces opérations étant moins couteuses, il est préférable d'en ajouter si cela permet d'enlever des multiplications.

L'algorithme de multiplication naif récursif utilise la segmentation des facteurs en deux de manière successive.

Soit <math>x</math> et <math>y</math> deux facteurs, nous avons les égalités suivantes :

<div style="font-size: 20px;">
<math>x = a \times B^{n/2} + b</math>
<math>y = c \times B^{n/2} + d</math>
</div>

Avec <math>a</math> et <math>c</math> les premières moitiés des facteurs <math>x</math> et <math>y</math>,
et <math>b</math> et <math>d</math> les dernières moitiés de ces facteurs ainsi que <math>B</math> la base d'écriture du nombre (Nous sommes en base 256 avec les bytes).

Cette présentation des deux facteurs de notre multiplication n'est que la résultante d'un découpage.
Le [[#Master Theorem|Master Theorem]] nous montre que :

<div style="font-size: 20px;">
<math>T(n) = 4T(n/2) + O(n)</math>
</div>

Puisque nous avons après découpage 4 entiers de longueur <math>n/2</math>.

Ainsi, ce découpage ne permet pas de gagner du temps d'après le [[#Master Theorem|Master Theorem]].

Cependant, l'algorithme de Karatsuba réutilise ce principe en le modifiant, ce qui nous permet de baisser la complexité globale de la multiplication dans son entièreté.

Avec l'écriture ci-dessus des nombres <math>x</math> et <math>y</math>, on peut facilement en déduire l'égalité suivante :

<div style="font-size: 20px;">
<math>x \times y = (ac) \times B^n + (ad + bc) \times B^{n/2} + bd</math>
</div>

On remarque 4 multiplications longues à faire dans cette expression. Les multiplications dont <math>B</math> est l'un des facteurs sont très rapides puisqu'il s'agit de la base dans laquelle nous travaillons. De cela en résulte un décalage plutôt qu'un vrai calcul à faire.

Karatsuba développe une partie de cette expression pour pouvoir négocier une multiplication au prix d'additions et soustractions.

En effet, nous savons déjà que :

<div style="font-size: 20px;">
<math>(a + b)(c + d) = ac + ad + bc + bd</math>
</div>

En manipulant l'égalité nous obtenons :

<div style="font-size: 20px;">
<math>ad + bc = (a + b)(c + d) - ac - bd</math>
</div>

ac et bd ayant déjà été calculé précédemment, il nous reste uniquement la multiplication <math>(a + b)(c + d)</math>.

Nous venons ainsi de calculer <math>ad + bc</math> en seulement une multiplication. C'est la que repose le gain de temps de la méthode Karatsuba par rapport à la multiplication naïve.

En effet, l'algorithme n'effectuera alors plus que 3 multiplications :
<div style="font-size: 20px;">
<math>ac</math>
<math>bd</math>
<math>(a + b)(c + d)</math>
</div>

La relation de récurrence devient donc :
<div style="font-size: 20px;">
<math>T(n)=3T(n/2)+O(n)</math>
</div>

Et le Master Theorem nous dit que :
<div style="font-size: 20px;">
<math>T(n)\in O(n^{\log_2(3)})</math>
</div>

Or <math>\log_2(3)\approx 1.585</math>, donc la complexité de l'algorithme de Karatsuba est de <math> \mathcal{O}(n^{1.585})</math>. Ce qui est bien plus efficace que la multiplication classique, surtout lorsque les facteurs deviennent très grands.

=== B) Graphique ===
<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Karatsuba.png|500px]]
<div><b>Karatsuba</b></div>
</div>
<div style="max-width:800px;">
<p>Sur le graphique ci-contre nous avons utilisé la courbe de la multiplication naïve récursive (rouge) à titre de comparaison.</p>
<p>On remarque graphiquement que Karatsuba (jaune) prend moins de temps à chaque calcul de produit.</p>
<p>On en déduit donc expérimentalement que Karatsuba à une meilleure complexité que la multiplication naïve.</p>
<p>Ainsi nous vérifions donc ce que le Master Theorem prouve, c'est à dire que la complexité de karatsuba est de <math> \mathcal{O}(n^{1.585})</math> </p>
</div>
</div>

== 4) La multiplication toom-cook-3 ==

=== A) Fonctionnement ===

L'objectif est de diviser les grands entiers X et Y en trois blocs de taille égale k.
On les traite alors comme des polynômes de degré 2:

<math>P(z) = X_2 \cdot z^2 + X_1 \cdot z + X_0</math>
<math>Q(z) = Y_2 \cdot z^2 + Y_1 \cdot z + Y_0</math>

On choisit 5 points distincts pour évaluer nos polynômes.
Ce choix de 5 points est crucial car le produit de deux polynômes de degré 2 est un polynôme de degré 4, qui nécessite 5 points pour être défini.
Les points standards sont :

P(0) = X0
P(1) = X0 + X1 + X2
P(-1) = X0 - X1 + X2
P(2) = X0 + 2*X1 + 4*X2
P(inf) = X2

(On procède de manière similaire pour Q.)

Ensuite nous multiplions récursivement chaque points de P et de Q ensemble.
On effectue ainsi 5 multiplications de nombres plus petits au lieu des 9 multiplications requises par la méthode classique.

Après, nous effectuons une interpolation, cela permet de retrouver les 5 coefficients (w_0, w_1, w_2, w_3, w_4) du polynôme produit R(z) à partir des valeurs évaluées calculées précédemment.
On résout un système d'équations linéaires : <math> R(z) = w_4 z^4 + w_3 z^3 + w_2 z^2 + w_1 z + w_0 </math>
Finalement nous pouvons recomposer notre grand entier en positionnant les coefficients w_i aux bons rangs (en les décalant) et à gérer les retenues lors de l'addition finale:
<math>Résultat = w_4 B^{4k} + w_3 B^{3k} + w_2 B^{2k} + w_1 B^k + w_0</math>

=== B) Graphique ===

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Toomcook.png|500px]]
<div><b>Karatsuba</b></div>
</div>
<div style="max-width:800px;">
<p>on a reprit multi récursive (rouge)</p>
<p>on voit que Toom (vert) en dessous de karatsuba (jaune) en dessous de multi classique (rouge)</p>
<p>meilleur complexité</p>
</div>
</div>

== 5) La transformée de Fourier rapide ==

=== A) Fonctionnement ===

La transformation de Fourier rapide étant plus complexe que les autres algorithmes, nous allons essayer d'expliquer son fonctionnement malgré ne pas avoir réussi à l'implémenter.

Il faut comprendre que cet algorithme va considérer les facteurs comme des polynômes.

D'après le théorème de l'unisolvance, il n'existe qu'un seul polynôme de degré inférieur ou égal à <math> n </math> défini par <math>n + 1</math> points distincts. Cela implique non seulement que nous pouvons représenter chaque entier par un polynôme, mais également que si nous pouvons retrouver <math>n + m + 1</math> points (avec <math>n</math> et <math>m</math> la longueur des facteurs) du polynômes issue du produit entre deux facteurs, nous pourrons le retrouver.

Soit un entier quelconque, de forme :

<math>a_n a_{n-1} (...) a_1 a_0</math>

Avec <math>a_i</math>, un chiffre composant le nombre en base 10, qui vaut en réalité dans le nombre : <math>a_i \times 10^i</math>. On peut ainsi l'écrire sous la forme :

<math> P(x) = a_0 + a_1x + a_2x^2 + \dots + a_{n-1}x^{n-1} + a_nx^n </math>

Avec <math>x = 10</math> car nous sommes en base 10, nous obtenons :

<math>P(10) = a_0 + a_1 \times 10 + \dots + a_{n-1}10^{n-1} + a_n10^n </math>

Nous venons ainsi d'écrire notre nombre sous la forme d'un polynôme unique. Pour nous permettre d'évaluer en un nombre suffisant de points, nous allons devoir ajouter des 0 pour la récursion. Il nous faudra ajouter assez de 0 pour atteindre la prochaine puissance de 2 qui sera supérieure ou égale à <math>2n + 1</math>. L'ajout de 0 ne change pas le nombre car <math>0 \times x^n</math> n'ajoute pas de coefficient.

Cet algorithme est récursif et va segmenter en deux parties nos polynômes à chaque récursion. D'un coté les indice pairs et d'un coté les impaires.

Ainsi prenons les nombres 1234 et 5678, ces nombres sont respectivement représentés par les polynômes <math> P(x) = 4 + 3x + 2x^2 + x^3 </math> et <math> P(x) = 8 + 7x + 6x^2 + 5^3 </math>. Ce sont des polynômes de degré 3, ainsi leur produit donnera lieu à un polynôme de degré 6. Il nous faudra donc au minimum 7 points d'évaluation pour retrouve ce produit. De ce fait, en les représentant de la manière suivante :

<math>[4, 3, 2, 1, 0, 0, 0, 0]</math>
<math>[8, 7, 6, 5, 0, 0, 0, 0]</math>

Nous aurons assez de récursions possible pour les évaluer en un nombre suffisant de points différents car nous auront 3 récursions à faire pour atteindre notre cas de base. A chaque récursion, nous allons diviser nos polynômes en deux parties ce qui nous fait 8 feuilles à la dernière récursion.

En effet à chaque étape de la récursion nous allons séparer nos polynômes en deux tel que :

<math>P(x)=P_{\text{pair}}(x^2) + x \cdot P_{\text{impair}}(x^2)</math>

Durant les récursions, nous segmentons les polynômes mais ne les évaluons pas. C'est à la remonté des récursions que nous allons réellement évaluer nos polynômes. Lorsque l'on atteint notre cas de base, c'est à dire des polynômes de degré 0, nous remarquons qu'ils sont constants, nous n'avons donc pas besoin de les évaluer. En effet, peut importe le point en lequel nous voudrons l'évaluer, le polynôme renverra la constante. Nous la renvoyons donc seule.
Ensuite commence la remontée des récursions. A l'étape 1 de notre remontée nous allons reformer le polynôme précédemment séparé pour obtenir un polynôme de degré 1. Puis, nous évaluons ce polynôme avec les racines seconde de l'unité. Nous faisons à nouveau remonté les évaluations et recombinons à nouveau le polynôme qui sera ainsi de degré 2.
Nous l'évaluons maintenant avec les racines 4eme de l'unité. A chaque évaluation, nous réutilisons les résultats précédents, cela nous est permit par les racines de l'unité qui ont une structure récursive exploitable.

Finalement, nous arrivons à la fin de notre FFT, avec une représentation fréquentielle de la forme :

<math> [P(W_0), P(W_1), (...), P(W_n-1), P(W_n)] </math>

Cette représentation fréquentielle n'est autre que les évaluations du polynôme P aux racines nièmes de l'unité. Nous avons donc maintenant au minimum <math>2n+1</math> évaluations des polynômes facteurs. Il nous faut maintenant trouver les évaluations du produit final, c'est à dire les évaluations concernant le polynôme qui sera issue de la multiplication. On pourra ainsi le retrouver.

Soit <math>C</math> un polynome tel que <math> C = A \times B </math>, alors on a :

<math> C(x) = A(x) \times B(x) </math>

Ainsi on en déduit que <math> C(W_n^k) = A(W_n^k) \times B(W_n^k) </math>

On comprend donc que <math>FFT(C) = FFT(A) \times FFT(B)</math>

Il faut préciser que l'on fait le produit de FFT(A) et FFT(B) terme à terme, soit évaluation par évaluation.

Une fois en possession de <math>FFT(C)</math>, qui n'est autre que l'évaluation de notre polynôme final en un nombre suffisant de points pour le retrouver, nous pouvons faire l'<math>IFFT(FFT(C))</math>, qui va nous permettre de retrouver les coefficients de notre polynôme en faisant l'exacte inverse de la FFT.

Une fois les coefficients retrouvés, il nous suffit de gérer les retenues, et nous retrouvons un entier de la forme : <math>a_0 a_1 (...) a_{n-1} a_n</math>

=== B) Graphique ===

Intéressons nous maintenant à la complexité de l'algorithme utilisant la transformée de Fourier rapide. On sait que l'algorithme passe par 5 étapes importantes :

<ul>
<li>Etape 1 : Ecrire les deux facteurs sous la forme de polynômes</li>
<li>Etape 2 : Effectuer la <math>FFT</math> des deux polynômes</li>
<li>Etape 3 : Faire le produit terme à terme des <math>FFT</math> obtenues</li>
<li>Etape 4 : Faire l'<math>IFFT</math> du produit</li>
<li>Etape 5 : Gérer les retenues et écrire le nombre qui en découle</li>
</ul>

Or, parmi toutes ces étapes, certaines sont négligeable comme l'étape 1 et 5.

Pour connaitre la complexité de l'algorithme, additionnons les complexités des étapes restantes :

Une <math>FFT</math> a une complexité de <math>\mathcal{O}(n\times logn)</math> car elle fait <math>n</math> évaluation sur <math> log(n)</math> récursions. Dans le cadre de notre algorithme, nous devons faire la <math>FFT</math> de nos deux facteurs. Soit <math>2\times \mathcal{O}(n\times logn)</math>.

Pour le produit terme à terme, nous faisons naturellement <math>n</math> opérations.

Pour finir, l'<math>IFFT</math> a la même complexité que la <math>FFT</math>. Dans le cadre de notre algorithme nous l'emploierons qu'une seule fois, ce qui fait une complexité de <math>\mathcal{O}(n\times logn)</math>.

Après addition de toutes ces complexités, nous obtenons la complexité réelle de <math>3\mathcal{O}(n\times logn) + \mathcal{O}(n)</math>.

D'après le Master Theorem, nous avons donc <math> f(n) = 3(n\times logn)+n </math>, cherchons <math>f(n)\in\mathcal{O}(g(n))</math> :

Nous pouvons ignorer les expressions linéaires ainsi que les constantes multiplicatrices, nous obtenons donc <math>\mathcal{O}(g(n)) = \mathcal{O}(n \times log n)</math>.

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:30px; text-align:center;">
[[Fichier:FFT_image.webp|500px]]
<div><b>Graphiques des complexités</b></div>
</div>
<div style="max-width:800px;">
<p>Ce graphique ci-contre ne provient pas du fruit de nos recherches personnelles mais </p>
<p>On comprend ainsi que certaines complexités ne sont pas raisonnable dans la cadre de la multiplication de grands entiers.</p>
<p>C'est pourquoi l'étude de ces algorithmes s'avère nécessaire.</p>
</div>
</div>

= II - Produit de matrices =

== 1.1) naïve ==

La multiplication naïve de matrice requiert d'avoir des tailles de lignes/colonne semblable, ensuite pour chaque membre de la matrice résultat, on doit multiplier les composantes ligne de la première matrice par les composantes colonne de la deuxième et le tout sommé.

On en déduit la formule suivante:
<math>C_{i,j} = \sum_{k=1}^{n} (A_{i,k} \times B_{k,j})</math>

Et visuellement:

[[Fichier:Matricenaive.jpeg]]

On a donc un algorithme d'ordre de complexité <math>\mathcal{O}(g(n))</math>

== 1.2) naïve récursive ==

Dans un premier temps on doit découper nos deux matrices en quatres sous matrices de plus petite taille.
<math>A = \begin{pmatrix} A_{11} & A_{12} \ A_{21} & A_{22} \end{pmatrix}</math>
<math>B = \begin{pmatrix} B_{11} & B_{12} \ B_{21} & B_{22} \end{pmatrix}</math>

Ensuite on vient calculer la matrice résultat.
<math>C_{11} = (A_{11} \times B_{11}) + (A_{12} \times B_{21})</math>
<math>C_{12} = (A_{11} \times B_{12}) + (A_{12} \times B_{22})</math>
<math>C_{21} = (A_{21} \times B_{11}) + (A_{22} \times B_{21})</math>
<math>C_{22} = (A_{21} \times B_{12}) + (A_{22} \times B_{22})</math>

Le côté récursif est utile que pour les matrices de tailles <= 32 (32 valeurs stockées dedans),
si on est au dessus de cette taille alors on divisera à nouveau nos matrices en quatres.
On aura 8 multiplications mais de plus petite taille au final.

== 2) strassen ==

=== A) Fonctionnement ===

Strassen consiste à définir 7 produits intermédiaires qui, par des jeux de sommes et de différences, permettent de reconstruire les quadrants de la matrice résultante. On passe ainsi d'une complexité de O(n^3) à environ O(n^2.81)

=== B) Graphique ===

On voit bien la différence de complexité sur la multiplication de grande matrice entre l'approche naïve et l'approche récursive qui est beaucoup plus rapide.

[[Fichier:Analyse matrices.png]]

= Conclusion =

L'étude de ces algorithmes de multiplication nous a clairement montré l'évolution de la complexité algorithmique permettant de gagner en efficacité lorsque la taille des données augmente.

La multiplication naïve, en

= Mentions =

Le premier gif est le résultat du travail de 'Walké', licence ci-contre : https://fr.wikipedia.org/wiki/Fichier:Addition.gif

= Sources =

Pour karatsuba : https://www.youtube.com/watch?v=PZ2gdWdKHAA

Pour mieux comprendre la FFT, nous avons utilisé plusieurs sources d'informations :
<ul>
<li> https://www.youtube.com/watch?v=h7apO7q16V0&list=WL&index=1&t=886s </li>
<li> https://fr.wikipedia.org/wiki/Interpolation_polynomiale </li>
</ul>

Algorithmes de multiplications d'entiers et de matrices

2026-05-11T15:21:16Z

Mangala : /* 3) La multiplication karastuba */

= Introduction =

Depuis l'apparition des ordinateurs modernes, une quantité faramineuse de calculs a dû être effectuée. Les progressions technologiques nous poussent à envisager la puissance de calcul comme une ressource qu'il faut optimiser dans les moindres détails. C'est ainsi que l'optimisation des algorithmes de calcul est devenue cruciale, surtout lorsqu'il nous faut effectuer des opérations sur de très grands entiers par exemple.

= Objectif =

L'objectif majeur de ce projet est de comprendre de manière plus approfondie ce qu'est la '''complexité algorithmique'''.
Pour atteindre cet objectif, nous implémenterons plusieurs algorithmes de multiplication qui auront pour but de calculer le produit de grands entiers ou de matrices.

= Point important : complexité =

=== Définition ===
La complexité d'un algorithme est la quantité des ressources qu'il utilise en fonction de la taille des entrées qu'on lui demande de traiter. On peut par exemple se concentrer sur le temps qu'un algorithme prend pour renvoyer un résultat ou sur la mémoire dont il a besoin. Dans le cadre de notre projet, nous nous attarderons plus particulièrement sur la quantité de calcul effectuée en fonction de la taille des entrées, ce qui est par ailleurs étroitement liée à la notion de temps. De manière générale, plus un algorithme doit faire de calcul, plus il est lent. (Attention, toutes les opérations arithmétiques de base ne se valent pas)

De manière plus familière, on dira que la complexité d'un algorithme pourrait s'apparenter à son comportement lorsqu'il doit traiter des données plus ou moins grandes.
Chaque algorithme a une complexité, et on l'exprime par une fonction qui adopte un comportement similaire au nombre de calculs nécessaires en fonction de la taille des entrées.

=== Notation ===
La complexité réelle d'un algorithme peut être décrite par une fonction <math>f(n)</math> représentant le nombre d'opérations effectuées en fonction de la taille <math>n</math> des données d'entrée.

Cependant, afin de simplifier l'étude de cette croissance, on utilise généralement une borne asymptotique notée <math>\mathcal{O}(g(n))</math>, où <math>g(n)</math> est une fonction ayant le même ordre de grandeur que <math>f(n)</math> lorsque <math>n</math> devient grand.

On dit alors que :

<math>
f(n)\in\mathcal{O}(g(n))
</math>

si et seulement s'il existe une constante <math>C>0</math> et un entier <math>n_0</math> tels que :

<math>
\forall n\ge n_0,\ f(n)\le Cg(n)
</math>

Cette notation <math>\mathcal{O}(g(n))</math> permettra de comparer beaucoup plus facilement les algorithmes entre eux.

=== Master Theorem ===

Afin de déterminer la complexité de certains algorithmes récursifs, nous utiliserons le "Master Theorem".

Ce théorème permet d'obtenir directement l'ordre de grandeur de nombreuses relations de récurrence apparaissant dans l'analyse d'algorithmes de type « diviser pour régner », comme l'algorithme de Karatsuba ou celui de Strassen.

La démonstration complète de ce théorème dépasse le cadre de notre projet et nécessite des connaissances mathématiques plus avancées. Nous l'utiliserons donc principalement comme un outil nous permettant de déterminer efficacement la complexité asymptotique des algorithmes étudiés.

=== Graphiques ===

Les complexités étant des fonctions, nous pouvons les représenter par un graphique qui affichera le temps d'exécution (ou nombre d'opérations) en fonction de la taille des entrées.

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:30px; text-align:center;">
[[Fichier:complexite.webp|500px]]
<div><b>Graphiques des complexités</b></div>
</div>
<div style="max-width:800px;">
<p>Ce graphique ci-contre compare les complexités en fonction de la taille des d'entrées.</p>
<p>On comprend ainsi que certaines complexités ne sont pas raisonnable dans la cadre de la multiplication de grands entiers.</p>
<p>C'est pourquoi l'étude de ces algorithmes s'avère nécessaire.</p>
</div>
</div>

=== Exemple ===
L'algorithme naïf d'addition que nous avons tous appris à l'école a une complexité de <math>\mathcal{O}(n)</math>.
Soit n la taille des nombres en entrée, l'algorithme doit faire environ n addition pour arriver au résultat demandé.

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Addition.gif|220px]]
<div><b>Addition naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Comme le montre l'exemple ci-contre, 786 et 467 font 3 chiffres de long donc n sera de 3.</p>
<p>Il nous faudra 3 opérations pour additionner ces entiers.</p>
<p>C'est ainsi qu'avec une taille d'entrée n, l'algorithme de l'addition naïve va devoir faire n opérations.</p>
<p>Cet algorithme a donc une complexité <math>f(n) = n</math> qui n'a pas besoin d'être approximée.</p>
<p>Ainsi sa complexité finale sera <math>\mathcal{O}(n)</math>.</p>
</div>
</div>

= Problématique =

Le calcul du produit de deux entiers de manière naïve a une complexité de <math> \mathcal{O}(n^2)</math>, et celui de deux matrices une complexité de <math> \mathcal{O}(n^3)</math>. Afin de mieux comprendre ce qu'est la complexité algorithmique, nous devrons implémenter des algorithmes ayant le même objectif, mais étant plus efficaces. Ces algorithmes s'avèreront plus complexes mais devrait aboutir à un calcul plus rapide du produit demandé.

Nous séparerons notre wiki en deux grandes parties, la première concernera nos recherche sur [[#I - Produit d'entiers|la multiplication d'entiers]], la deuxième sur [[#II - Produit de matrices|la multiplication de matrices]].

= I - Produit d'entiers =

Notre départ commence avec l'algorithme de multiplication d'entier naïf.
En effet il s'agit de l'algorithme de multiplication le plus connu, et nous l'utiliserons comme référence pour le comparer aux futurs algorithmes plus efficaces.
Intéressons nous à sa complexité.

== 1) Nos implémentations des grands entiers ==

Qui dit produit de grands entiers dit implémentation de grands entiers.

Dans le cadre de nos recherches, nous allons devoir implémenter des algorithmes qui vont manipuler des grands entiers.

Nous avons donc choisi de créer deux représentations différentes de ceux-ci (car nous travaillons sur différents langages de programmation), nous permettant à la fois une implémentation simplifié, mais aussi de nous rapprocher d'une implémentation bas niveau.

=== A) En python ===
En python, l'utilisation des "bytes" m'a grandement servi à comprendre comment les entiers étaient manipulés à bas niveau. En effet, un des objectifs secondaires de nos recherches était de manipuler des entiers directement avec leur formes stockées sur l'ordinateur, et non pas avec des int python.
En effet l'utilisation des int python nous aurait permit de passer les étapes de retenues, de signes... D'autant plus que les bytes permettent de stocker un nombre en base 256, ce qui permet de visualiser plus facilement les grands entiers.

La forme finale de la représentation des grands entiers en python sera donc la suivante :

[ signe , bytes , bytes , (...) , bytes ]

Le signe est représenté par un entier, 1 si le nombre est positif, 0 sinon.
Cette configuration rendra plus simple la gestion des signes.

=== B) En C++ ===

En C++, pour avoir une représentation de grand entiers j'ai du définir ma propre structure pour m'affranchir de la limite de taille imposé par les entiers standards: (int32 ou int64). Pour cela, j'ai une structure qui possède l'équivalent d'un array de byte (ce qui nous permet d'être en base 256 au lieu de la base 10 habituelle), et pour traiter le signe j'utilise un booléen, ainsi en mémoire j'ai une structure de n*Octets + 1 octet en taille.

[ bytes , bytes , (...) , bytes ] [ signe ]

Le booléen prend 1 octet de place mais ne touche pas aux octets qui encode le grand entier.
Cette configuration rendra plus simple la gestion des signes dans le cadre des multiplication.

== 2) La multiplication naïve ==

=== A) Fonctionnement ===
Dans le cas de la multiplication d'entiers, nous allons prendre deux nombres qui n'ont pas nécessairement la même longueur. Soit les nombre a et b, de longueur respective <math>n</math> et <math> m </math>.
<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Multiplication.png|220px]]
<div><b>Multiplication naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Prenons deux nombres de longueur 3 et 2, et cherchons combien d'opérations l'algorithme de multiplication naïve va devoir faire pour nous renvoyer leur produit.</p>
<p>Dans un premier temps, on remarque que l'on va devoir multiplier chaque chiffre du nombre du haut par le chiffre des unités du bas, qui est 6. Cela va représenter <math>n</math> opérations. (6x5, 6x1 et 6x4)</p>
<p>Dans un deuxième temps nous constatons que nous allons devoir faire la même chose avec le chiffre des dizaines du nombre du bas. Cela nous ajoute de nouveau <math>n</math> opérations.</p>
<p>On arrive assez facilement à la conclusion que pour faire notre produit, il va nous falloir faire <math>n</math> fois <math>m</math> opérations.</p>
</div>
</div>

Ainsi, la complexité de la multiplication naïve est <math>\mathcal{O}(n^2)</math>.
Il est en de même avec la multiplication naïve récursive.

=== B) Graphique ===
Montrons maintenant sa courbe sur un graphique :

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Multiplicationnaive.png|500px]]
<div><b>Multiplication naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Les points noirs sont des repères pour que les autres courbes aient une forme cohérente.</p>
<p>Ils sont tous sur l'axe des abscisses.</p>
<p>La courbe rouge représente la complexité de la multiplication naïve.</p>
<p>On remarque que la courbe a un visuel très similaire à la fonction <math>f(x) = x^2</math> </p>
</div>
</div>

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Naif_recursif.png|500px]]
<div><b>Multiplication naïve récursive</b></div>
</div>
<div style="max-width:800px;">
<p>La courbe rouge représente la complexité de la multiplication naïve récursive.</p>
<p>Elle sera utilisé pour comparer les complexités entre algorithmes car, comme tous récursifs, elle a été codé avec les mêmes biais d'implémentation qu'eux.</p>
<p>Théoriquement les deux courbes ci-contre ont la même complexité, mais encore une fois, notre implémentation n'est pas parfaitement optimale et donc ne respecte pas de manière minutieuse le Master Theorem.</p>
</div>
</div>

== 3) La multiplication karatsuba ==

=== A) Fonctionnement ===

L'algorithme de karatsuba est un algorithme récursif de type diviser pour régner.

L'idée générale de l'algorithme est de passer de 4 multiplication à 3. En effet ces opérations étant moins couteuses, il est préférable d'en ajouter si cela permet d'enlever des multiplications.

L'algorithme de multiplication naif récursif utilise la segmentation des facteurs en deux de manière successive.

Soit <math>x</math> et <math>y</math> deux facteurs, nous avons les égalités suivantes :

<div style="font-size: 20px;">
<math>x = a \times B^{n/2} + b</math>
<math>y = c \times B^{n/2} + d</math>
</div>

Avec <math>a</math> et <math>c</math> les premières moitiés des facteurs <math>x</math> et <math>y</math>,
et <math>b</math> et <math>d</math> les dernières moitiés de ces facteurs ainsi que <math>B</math> la base d'écriture du nombre (Nous sommes en base 256 avec les bytes).

Cette présentation des deux facteurs de notre multiplication n'est que la résultante d'un découpage.
Le [[#Master Theorem|Master Theorem]] nous montre que :

<div style="font-size: 20px;">
<math>T(n) = 4T(n/2) + O(n)</math>
</div>

Puisque nous avons après découpage 4 entiers de longueur <math>n/2</math>.

Ainsi, ce découpage ne permet pas de gagner du temps d'après le [[#Master Theorem|Master Theorem]].

Cependant, l'algorithme de Karatsuba réutilise ce principe en le modifiant, ce qui nous permet de baisser la complexité globale de la multiplication dans son entièreté.

Avec l'écriture ci-dessus des nombres <math>x</math> et <math>y</math>, on peut facilement en déduire l'égalité suivante :

<div style="font-size: 20px;">
<math>x \times y = (ac) \times B^n + (ad + bc) \times B^{n/2} + bd</math>
</div>

On remarque 4 multiplications longues à faire dans cette expression. Les multiplications dont <math>B</math> est l'un des facteurs sont très rapides puisqu'il s'agit de la base dans laquelle nous travaillons. De cela en résulte un décalage plutôt qu'un vrai calcul à faire.

Karatsuba développe une partie de cette expression pour pouvoir négocier une multiplication au prix d'additions et soustractions.

En effet, nous savons déjà que :

<div style="font-size: 20px;">
<math>(a + b)(c + d) = ac + ad + bc + bd</math>
</div>

En manipulant l'égalité nous obtenons :

<div style="font-size: 20px;">
<math>ad + bc = (a + b)(c + d) - ac - bd</math>
</div>

ac et bd ayant déjà été calculé précédemment, il nous reste uniquement la multiplication <math>(a + b)(c + d)</math>.

Nous venons ainsi de calculer <math>ad + bc</math> en seulement une multiplication. C'est la que repose le gain de temps de la méthode Karatsuba par rapport à la multiplication naïve.

En effet, l'algorithme n'effectuera alors plus que 3 multiplications :
<div style="font-size: 20px;">
<math>ac</math>
<math>bd</math>
<math>(a + b)(c + d)</math>
</div>

La relation de récurrence devient donc :
<div style="font-size: 20px;">
<math>T(n)=3T(n/2)+O(n)</math>
</div>

Et le Master Theorem nous dit que :
<div style="font-size: 20px;">
<math>T(n)\in O(n^{\log_2(3)})</math>
</div>

Or <math>\log_2(3)\approx 1.585</math>, donc la complexité de l'algorithme de Karatsuba est de <math> \mathcal{O}(n^{1.585})</math>. Ce qui est bien plus efficace que la multiplication classique, surtout lorsque les facteurs deviennent très grands.

=== B) Graphique ===
<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Karatsuba.png|500px]]
<div><b>Karatsuba</b></div>
</div>
<div style="max-width:800px;">
<p>Sur le graphique ci-contre nous avons utilisé la courbe de la multiplication naïve récursive (rouge) à titre de comparaison.</p>
<p>On remarque graphiquement que Karatsuba (jaune) prend moins de temps à chaque calcul de produit.</p>
<p>On en déduit donc expérimentalement que Karatsuba à une meilleure complexité que la multiplication naïve.</p>
<p>Ainsi nous vérifions donc ce que le Master Theorem prouve, c'est à dire que la complexité de karatsuba est de <math> \mathcal{O}(n^{1.585})</math> </p>
</div>
</div>

== 4) La multiplication toom-cook-3 ==

=== A) Fonctionnement ===

L'objectif est de diviser les grands entiers X et Y en trois blocs de taille égale k.
On les traite alors comme des polynômes de degré 2:

<math>P(z) = X_2 \cdot z^2 + X_1 \cdot z + X_0</math>
<math>Q(z) = Y_2 \cdot z^2 + Y_1 \cdot z + Y_0</math>

On choisit 5 points distincts pour évaluer nos polynômes.
Ce choix de 5 points est crucial car le produit de deux polynômes de degré 2 est un polynôme de degré 4, qui nécessite 5 points pour être défini.
Les points standards sont :

P(0) = X0
P(1) = X0 + X1 + X2
P(-1) = X0 - X1 + X2
P(2) = X0 + 2*X1 + 4*X2
P(inf) = X2

(On procède de manière similaire pour Q.)

Ensuite nous multiplions récursivement chaque points de P et de Q ensemble.
On effectue ainsi 5 multiplications de nombres plus petits au lieu des 9 multiplications requises par la méthode classique.

Après, nous effectuons une interpolation, cela permet de retrouver les 5 coefficients (w_0, w_1, w_2, w_3, w_4) du polynôme produit R(z) à partir des valeurs évaluées calculées précédemment.
On résout un système d'équations linéaires : <math> R(z) = w_4 z^4 + w_3 z^3 + w_2 z^2 + w_1 z + w_0 </math>
Finalement nous pouvons recomposer notre grand entier en positionnant les coefficients w_i aux bons rangs (en les décalant) et à gérer les retenues lors de l'addition finale:
<math>Résultat = w_4 B^{4k} + w_3 B^{3k} + w_2 B^{2k} + w_1 B^k + w_0</math>

=== B) Graphique ===

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Toomcook.png|500px]]
<div><b>Karatsuba</b></div>
</div>
<div style="max-width:800px;">
<p>on a reprit multi récursive (rouge)</p>
<p>on voit que Toom (vert) en dessous de karatsuba (jaune) en dessous de multi classique (rouge)</p>
<p>meilleur complexité</p>
</div>
</div>

== 5) La transformée de Fourier rapide ==

=== A) Fonctionnement ===

La transformation de Fourier rapide étant plus complexe que les autres algorithmes, nous allons essayer d'expliquer son fonctionnement malgré ne pas avoir réussi à l'implémenter.

Il faut comprendre que cet algorithme va considérer les facteurs comme des polynômes.

D'après le théorème de l'unisolvance, il n'existe qu'un seul polynôme de degré inférieur ou égal à <math> n </math> défini par <math>n + 1</math> points distincts. Cela implique non seulement que nous pouvons représenter chaque entier par un polynôme, mais également que si nous pouvons retrouver <math>n + m + 1</math> points (avec <math>n</math> et <math>m</math> la longueur des facteurs) du polynômes issue du produit entre deux facteurs, nous pourrons le retrouver.

Soit un entier quelconque, de forme :

<math>a_n a_{n-1} (...) a_1 a_0</math>

Avec <math>a_i</math>, un chiffre composant le nombre en base 10, qui vaut en réalité dans le nombre : <math>a_i \times 10^i</math>. On peut ainsi l'écrire sous la forme :

<math> P(x) = a_0 + a_1x + a_2x^2 + \dots + a_{n-1}x^{n-1} + a_nx^n </math>

Avec <math>x = 10</math> car nous sommes en base 10, nous obtenons :

<math>P(10) = a_0 + a_1 \times 10 + \dots + a_{n-1}10^{n-1} + a_n10^n </math>

Nous venons ainsi d'écrire notre nombre sous la forme d'un polynôme unique. Pour nous permettre d'évaluer en un nombre suffisant de points, nous allons devoir ajouter des 0 pour la récursion. Il nous faudra ajouter assez de 0 pour atteindre la prochaine puissance de 2 qui sera supérieure ou égale à <math>2n + 1</math>. L'ajout de 0 ne change pas le nombre car <math>0 \times x^n</math> n'ajoute pas de coefficient.

Cet algorithme est récursif et va segmenter en deux parties nos polynômes à chaque récursion. D'un coté les indice pairs et d'un coté les impaires.

Ainsi prenons les nombres 1234 et 5678, ces nombres sont respectivement représentés par les polynômes <math> P(x) = 4 + 3x + 2x^2 + x^3 </math> et <math> P(x) = 8 + 7x + 6x^2 + 5^3 </math>. Ce sont des polynômes de degré 3, ainsi leur produit donnera lieu à un polynôme de degré 6. Il nous faudra donc au minimum 7 points d'évaluation pour retrouve ce produit. De ce fait, en les représentant de la manière suivante :

<math>[4, 3, 2, 1, 0, 0, 0, 0]</math>
<math>[8, 7, 6, 5, 0, 0, 0, 0]</math>

Nous aurons assez de récursions possible pour les évaluer en un nombre suffisant de points différents car nous auront 3 récursions à faire pour atteindre notre cas de base. A chaque récursion, nous allons diviser nos polynômes en deux parties ce qui nous fait 8 feuilles à la dernière récursion.

En effet à chaque étape de la récursion nous allons séparer nos polynômes en deux tel que :

<math>P(x)=P_{\text{pair}}(x^2) + x \cdot P_{\text{impair}}(x^2)</math>

Durant les récursions, nous segmentons les polynômes mais ne les évaluons pas. C'est à la remonté des récursions que nous allons réellement évaluer nos polynômes. Lorsque l'on atteint notre cas de base, c'est à dire des polynômes de degré 0, nous remarquons qu'ils sont constants, nous n'avons donc pas besoin de les évaluer. En effet, peut importe le point en lequel nous voudrons l'évaluer, le polynôme renverra la constante. Nous la renvoyons donc seule.
Ensuite commence la remontée des récursions. A l'étape 1 de notre remontée nous allons reformer le polynôme précédemment séparé pour obtenir un polynôme de degré 1. Puis, nous évaluons ce polynôme avec les racines seconde de l'unité. Nous faisons à nouveau remonté les évaluations et recombinons à nouveau le polynôme qui sera ainsi de degré 2.
Nous l'évaluons maintenant avec les racines 4eme de l'unité. A chaque évaluation, nous réutilisons les résultats précédents, cela nous est permit par les racines de l'unité qui ont une structure récursive exploitable.

Finalement, nous arrivons à la fin de notre FFT, avec une représentation fréquentielle de la forme :

<math> [P(W_0), P(W_1), (...), P(W_n-1), P(W_n)] </math>

Cette représentation fréquentielle n'est autre que les évaluations du polynôme P aux racines nièmes de l'unité. Nous avons donc maintenant au minimum <math>2n+1</math> évaluations des polynômes facteurs. Il nous faut maintenant trouver les évaluations du produit final, c'est à dire les évaluations concernant le polynôme qui sera issue de la multiplication. On pourra ainsi le retrouver.

Soit <math>C</math> un polynome tel que <math> C = A \times B </math>, alors on a :

<math> C(x) = A(x) \times B(x) </math>

Ainsi on en déduit que <math> C(W_n^k) = A(W_n^k) \times B(W_n^k) </math>

On comprend donc que <math>FFT(C) = FFT(A) \times FFT(B)</math>

Il faut préciser que l'on fait le produit de FFT(A) et FFT(B) terme à terme, soit évaluation par évaluation.

Une fois en possession de <math>FFT(C)</math>, qui n'est autre que l'évaluation de notre polynôme final en un nombre suffisant de points pour le retrouver, nous pouvons faire l'<math>IFFT(FFT(C))</math>, qui va nous permettre de retrouver les coefficients de notre polynôme en faisant l'exacte inverse de la FFT.

Une fois les coefficients retrouvés, il nous suffit de gérer les retenues, et nous retrouvons un entier de la forme : <math>a_0 a_1 (...) a_{n-1} a_n</math>

=== B) Graphique ===

Intéressons nous maintenant à la complexité de l'algorithme utilisant la transformée de Fourier rapide. On sait que l'algorithme passe par 5 étapes importantes :

<ul>
<li>Etape 1 : Ecrire les deux facteurs sous la forme de polynômes</li>
<li>Etape 2 : Effectuer la <math>FFT</math> des deux polynômes</li>
<li>Etape 3 : Faire le produit terme à terme des <math>FFT</math> obtenues</li>
<li>Etape 4 : Faire l'<math>IFFT</math> du produit</li>
<li>Etape 5 : Gérer les retenues et écrire le nombre qui en découle</li>
</ul>

Or, parmi toutes ces étapes, certaines sont négligeable comme l'étape 1 et 5.

Pour connaitre la complexité de l'algorithme, additionnons les complexités des étapes restantes :

Une <math>FFT</math> a une complexité de <math>\mathcal{O}(n\times logn)</math> car elle fait <math>n</math> évaluation sur <math> log(n)</math> récursions. Dans le cadre de notre algorithme, nous devons faire la <math>FFT</math> de nos deux facteurs. Soit <math>2\times \mathcal{O}(n\times logn)</math>.

Pour le produit terme à terme, nous faisons naturellement <math>n</math> opérations.

Pour finir, l'<math>IFFT</math> a la même complexité que la <math>FFT</math>. Dans le cadre de notre algorithme nous l'emploierons qu'une seule fois, ce qui fait une complexité de <math>\mathcal{O}(n\times logn)</math>.

Après addition de toutes ces complexités, nous obtenons la complexité réelle de <math>3\mathcal{O}(n\times logn) + \mathcal{O}(n)</math>.

D'après le Master Theorem, nous avons donc <math> f(n) = 3(n\times logn)+n </math>, cherchons <math>f(n)\in\mathcal{O}(g(n))</math> :

Nous pouvons ignorer les expressions linéaires ainsi que les constantes multiplicatrices, nous obtenons donc <math>\mathcal{O}(g(n)) = \mathcal{O}(n \times log n)</math>.

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:30px; text-align:center;">
[[Fichier:FFT_image.webp|500px]]
<div><b>Graphiques des complexités</b></div>
</div>
<div style="max-width:800px;">
<p>Ce graphique ci-contre ne provient pas du fruit de nos recherches personnelles mais </p>
<p>On comprend ainsi que certaines complexités ne sont pas raisonnable dans la cadre de la multiplication de grands entiers.</p>
<p>C'est pourquoi l'étude de ces algorithmes s'avère nécessaire.</p>
</div>
</div>

= II - Produit de matrices =

== 1.1) naïve ==

La multiplication naïve de matrice requiert d'avoir des tailles de lignes/colonne semblable, ensuite pour chaque membre de la matrice résultat, on doit multiplier les composantes ligne de la première matrice par les composantes colonne de la deuxième et le tout sommé.

On en déduit la formule suivante:
<math>C_{i,j} = \sum_{k=1}^{n} (A_{i,k} \times B_{k,j})</math>

Et visuellement:

[[Fichier:Matricenaive.jpeg]]

On a donc un algorithme d'ordre de complexité <math>\mathcal{O}(g(n))</math>

== 1.2) naïve récursive ==

Dans un premier temps on doit découper nos deux matrices en quatres sous matrices de plus petite taille.
<math>A = \begin{pmatrix} A_{11} & A_{12} \ A_{21} & A_{22} \end{pmatrix}</math>
<math>B = \begin{pmatrix} B_{11} & B_{12} \ B_{21} & B_{22} \end{pmatrix}</math>

Ensuite on vient calculer la matrice résultat.
<math>C_{11} = (A_{11} \times B_{11}) + (A_{12} \times B_{21})</math>
<math>C_{12} = (A_{11} \times B_{12}) + (A_{12} \times B_{22})</math>
<math>C_{21} = (A_{21} \times B_{11}) + (A_{22} \times B_{21})</math>
<math>C_{22} = (A_{21} \times B_{12}) + (A_{22} \times B_{22})</math>

Le côté récursif est utile que pour les matrices de tailles <= 32 (32 valeurs stockées dedans),
si on est au dessus de cette taille alors on divisera à nouveau nos matrices en quatres.
On aura 8 multiplications mais de plus petite taille au final.

== 2) strassen ==

=== A) Fonctionnement ===

Strassen consiste à définir 7 produits intermédiaires qui, par des jeux de sommes et de différences, permettent de reconstruire les quadrants de la matrice résultante. On passe ainsi d'une complexité de O(n^3) à environ O(n^2.81)

=== B) Graphique ===

On voit bien la différence de complexité sur la multiplication de grande matrice entre l'approche naïve et l'approche récursive qui est beaucoup plus rapide.

[[Fichier:Analyse matrices.png]]

= Conclusion =

( A FAIRE )

= Mentions =

Le premier gif est le résultat du travail de 'Walké', licence ci-contre : https://fr.wikipedia.org/wiki/Fichier:Addition.gif

= Sources =

Pour karatsuba : https://www.youtube.com/watch?v=PZ2gdWdKHAA

Pour mieux comprendre la FFT, nous avons utilisé plusieurs sources d'informations :
<ul>
<li> https://www.youtube.com/watch?v=h7apO7q16V0&list=WL&index=1&t=886s </li>
<li> https://fr.wikipedia.org/wiki/Interpolation_polynomiale </li>
</ul>

Algorithmes de multiplications d'entiers et de matrices

2026-05-11T15:19:52Z

Mangala : /* A) Fonctionnement */

= Introduction =

Depuis l'apparition des ordinateurs modernes, une quantité faramineuse de calculs a dû être effectuée. Les progressions technologiques nous poussent à envisager la puissance de calcul comme une ressource qu'il faut optimiser dans les moindres détails. C'est ainsi que l'optimisation des algorithmes de calcul est devenue cruciale, surtout lorsqu'il nous faut effectuer des opérations sur de très grands entiers par exemple.

= Objectif =

L'objectif majeur de ce projet est de comprendre de manière plus approfondie ce qu'est la '''complexité algorithmique'''.
Pour atteindre cet objectif, nous implémenterons plusieurs algorithmes de multiplication qui auront pour but de calculer le produit de grands entiers ou de matrices.

= Point important : complexité =

=== Définition ===
La complexité d'un algorithme est la quantité des ressources qu'il utilise en fonction de la taille des entrées qu'on lui demande de traiter. On peut par exemple se concentrer sur le temps qu'un algorithme prend pour renvoyer un résultat ou sur la mémoire dont il a besoin. Dans le cadre de notre projet, nous nous attarderons plus particulièrement sur la quantité de calcul effectuée en fonction de la taille des entrées, ce qui est par ailleurs étroitement liée à la notion de temps. De manière générale, plus un algorithme doit faire de calcul, plus il est lent. (Attention, toutes les opérations arithmétiques de base ne se valent pas)

De manière plus familière, on dira que la complexité d'un algorithme pourrait s'apparenter à son comportement lorsqu'il doit traiter des données plus ou moins grandes.
Chaque algorithme a une complexité, et on l'exprime par une fonction qui adopte un comportement similaire au nombre de calculs nécessaires en fonction de la taille des entrées.

=== Notation ===
La complexité réelle d'un algorithme peut être décrite par une fonction <math>f(n)</math> représentant le nombre d'opérations effectuées en fonction de la taille <math>n</math> des données d'entrée.

Cependant, afin de simplifier l'étude de cette croissance, on utilise généralement une borne asymptotique notée <math>\mathcal{O}(g(n))</math>, où <math>g(n)</math> est une fonction ayant le même ordre de grandeur que <math>f(n)</math> lorsque <math>n</math> devient grand.

On dit alors que :

<math>
f(n)\in\mathcal{O}(g(n))
</math>

si et seulement s'il existe une constante <math>C>0</math> et un entier <math>n_0</math> tels que :

<math>
\forall n\ge n_0,\ f(n)\le Cg(n)
</math>

Cette notation <math>\mathcal{O}(g(n))</math> permettra de comparer beaucoup plus facilement les algorithmes entre eux.

=== Master Theorem ===

Afin de déterminer la complexité de certains algorithmes récursifs, nous utiliserons le "Master Theorem".

Ce théorème permet d'obtenir directement l'ordre de grandeur de nombreuses relations de récurrence apparaissant dans l'analyse d'algorithmes de type « diviser pour régner », comme l'algorithme de Karatsuba ou celui de Strassen.

La démonstration complète de ce théorème dépasse le cadre de notre projet et nécessite des connaissances mathématiques plus avancées. Nous l'utiliserons donc principalement comme un outil nous permettant de déterminer efficacement la complexité asymptotique des algorithmes étudiés.

=== Graphiques ===

Les complexités étant des fonctions, nous pouvons les représenter par un graphique qui affichera le temps d'exécution (ou nombre d'opérations) en fonction de la taille des entrées.

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:30px; text-align:center;">
[[Fichier:complexite.webp|500px]]
<div><b>Graphiques des complexités</b></div>
</div>
<div style="max-width:800px;">
<p>Ce graphique ci-contre compare les complexités en fonction de la taille des d'entrées.</p>
<p>On comprend ainsi que certaines complexités ne sont pas raisonnable dans la cadre de la multiplication de grands entiers.</p>
<p>C'est pourquoi l'étude de ces algorithmes s'avère nécessaire.</p>
</div>
</div>

=== Exemple ===
L'algorithme naïf d'addition que nous avons tous appris à l'école a une complexité de <math>\mathcal{O}(n)</math>.
Soit n la taille des nombres en entrée, l'algorithme doit faire environ n addition pour arriver au résultat demandé.

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Addition.gif|220px]]
<div><b>Addition naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Comme le montre l'exemple ci-contre, 786 et 467 font 3 chiffres de long donc n sera de 3.</p>
<p>Il nous faudra 3 opérations pour additionner ces entiers.</p>
<p>C'est ainsi qu'avec une taille d'entrée n, l'algorithme de l'addition naïve va devoir faire n opérations.</p>
<p>Cet algorithme a donc une complexité <math>f(n) = n</math> qui n'a pas besoin d'être approximée.</p>
<p>Ainsi sa complexité finale sera <math>\mathcal{O}(n)</math>.</p>
</div>
</div>

= Problématique =

Le calcul du produit de deux entiers de manière naïve a une complexité de <math> \mathcal{O}(n^2)</math>, et celui de deux matrices une complexité de <math> \mathcal{O}(n^3)</math>. Afin de mieux comprendre ce qu'est la complexité algorithmique, nous devrons implémenter des algorithmes ayant le même objectif, mais étant plus efficaces. Ces algorithmes s'avèreront plus complexes mais devrait aboutir à un calcul plus rapide du produit demandé.

Nous séparerons notre wiki en deux grandes parties, la première concernera nos recherche sur [[#I - Produit d'entiers|la multiplication d'entiers]], la deuxième sur [[#II - Produit de matrices|la multiplication de matrices]].

= I - Produit d'entiers =

Notre départ commence avec l'algorithme de multiplication d'entier naïf.
En effet il s'agit de l'algorithme de multiplication le plus connu, et nous l'utiliserons comme référence pour le comparer aux futurs algorithmes plus efficaces.
Intéressons nous à sa complexité.

== 1) Nos implémentations des grands entiers ==

Qui dit produit de grands entiers dit implémentation de grands entiers.

Dans le cadre de nos recherches, nous allons devoir implémenter des algorithmes qui vont manipuler des grands entiers.

Nous avons donc choisi de créer deux représentations différentes de ceux-ci (car nous travaillons sur différents langages de programmation), nous permettant à la fois une implémentation simplifié, mais aussi de nous rapprocher d'une implémentation bas niveau.

=== A) En python ===
En python, l'utilisation des "bytes" m'a grandement servi à comprendre comment les entiers étaient manipulés à bas niveau. En effet, un des objectifs secondaires de nos recherches était de manipuler des entiers directement avec leur formes stockées sur l'ordinateur, et non pas avec des int python.
En effet l'utilisation des int python nous aurait permit de passer les étapes de retenues, de signes... D'autant plus que les bytes permettent de stocker un nombre en base 256, ce qui permet de visualiser plus facilement les grands entiers.

La forme finale de la représentation des grands entiers en python sera donc la suivante :

[ signe , bytes , bytes , (...) , bytes ]

Le signe est représenté par un entier, 1 si le nombre est positif, 0 sinon.
Cette configuration rendra plus simple la gestion des signes.

=== B) En C++ ===

En C++, pour avoir une représentation de grand entiers j'ai du définir ma propre structure pour m'affranchir de la limite de taille imposé par les entiers standards: (int32 ou int64). Pour cela, j'ai une structure qui possède l'équivalent d'un array de byte (ce qui nous permet d'être en base 256 au lieu de la base 10 habituelle), et pour traiter le signe j'utilise un booléen, ainsi en mémoire j'ai une structure de n*Octets + 1 octet en taille.

[ bytes , bytes , (...) , bytes ] [ signe ]

Le booléen prend 1 octet de place mais ne touche pas aux octets qui encode le grand entier.
Cette configuration rendra plus simple la gestion des signes dans le cadre des multiplication.

== 2) La multiplication naïve ==

=== A) Fonctionnement ===
Dans le cas de la multiplication d'entiers, nous allons prendre deux nombres qui n'ont pas nécessairement la même longueur. Soit les nombre a et b, de longueur respective <math>n</math> et <math> m </math>.
<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Multiplication.png|220px]]
<div><b>Multiplication naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Prenons deux nombres de longueur 3 et 2, et cherchons combien d'opérations l'algorithme de multiplication naïve va devoir faire pour nous renvoyer leur produit.</p>
<p>Dans un premier temps, on remarque que l'on va devoir multiplier chaque chiffre du nombre du haut par le chiffre des unités du bas, qui est 6. Cela va représenter <math>n</math> opérations. (6x5, 6x1 et 6x4)</p>
<p>Dans un deuxième temps nous constatons que nous allons devoir faire la même chose avec le chiffre des dizaines du nombre du bas. Cela nous ajoute de nouveau <math>n</math> opérations.</p>
<p>On arrive assez facilement à la conclusion que pour faire notre produit, il va nous falloir faire <math>n</math> fois <math>m</math> opérations.</p>
</div>
</div>

Ainsi, la complexité de la multiplication naïve est <math>\mathcal{O}(n^2)</math>.
Il est en de même avec la multiplication naïve récursive.

=== B) Graphique ===
Montrons maintenant sa courbe sur un graphique :

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Multiplicationnaive.png|500px]]
<div><b>Multiplication naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Les points noirs sont des repères pour que les autres courbes aient une forme cohérente.</p>
<p>Ils sont tous sur l'axe des abscisses.</p>
<p>La courbe rouge représente la complexité de la multiplication naïve.</p>
<p>On remarque que la courbe a un visuel très similaire à la fonction <math>f(x) = x^2</math> </p>
</div>
</div>

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Naif_recursif.png|500px]]
<div><b>Multiplication naïve récursive</b></div>
</div>
<div style="max-width:800px;">
<p>La courbe rouge représente la complexité de la multiplication naïve récursive.</p>
<p>Elle sera utilisé pour comparer les complexités entre algorithmes car, comme tous récursifs, elle a été codé avec les mêmes biais d'implémentation qu'eux.</p>
<p>Théoriquement les deux courbes ci-contre ont la même complexité, mais encore une fois, notre implémentation n'est pas parfaitement optimale et donc ne respecte pas de manière minutieuse le Master Theorem.</p>
</div>
</div>

== 3) La multiplication karastuba ==

=== A) Fonctionnement ===

L'algorithme de karatsuba est un algorithme récursif de type diviser pour régner.

L'idée générale de l'algorithme est de passer de 4 multiplication à 3. En effet ces opérations étant moins couteuses, il est préférable d'en ajouter si cela permet d'enlever des multiplications.

L'algorithme de multiplication naif récursif utilise la segmentation des facteurs en deux de manière successive.

Soit <math>x</math> et <math>y</math> deux facteurs, nous avons les égalités suivantes :

<div style="font-size: 20px;">
<math>x = a \times B^{n/2} + b</math>
<math>y = c \times B^{n/2} + d</math>
</div>

Avec <math>a</math> et <math>c</math> les premières moitiés des facteurs <math>x</math> et <math>y</math>,
et <math>b</math> et <math>d</math> les dernières moitiés de ces facteurs ainsi que <math>B</math> la base d'écriture du nombre (Nous sommes en base 256 avec les bytes).

Cette présentation des deux facteurs de notre multiplication n'est que la résultante d'un découpage.
Le [[#Master Theorem|Master Theorem]] nous montre que :

<div style="font-size: 20px;">
<math>T(n) = 4T(n/2) + O(n)</math>
</div>

Puisque nous avons après découpage 4 entiers de longueur <math>n/2</math>.

Ainsi, ce découpage ne permet pas de gagner du temps d'après le [[#Master Theorem|Master Theorem]].

Cependant, l'algorithme de Karatsuba réutilise ce principe en le modifiant, ce qui nous permet de baisser la complexité globale de la multiplication dans son entièreté.

Avec l'écriture ci-dessus des nombres <math>x</math> et <math>y</math>, on peut facilement en déduire l'égalité suivante :

<div style="font-size: 20px;">
<math>x \times y = (ac) \times B^n + (ad + bc) \times B^{n/2} + bd</math>
</div>

On remarque 4 multiplications longues à faire dans cette expression. Les multiplications dont <math>B</math> est l'un des facteurs sont très rapides puisqu'il s'agit de la base dans laquelle nous travaillons. De cela en résulte un décalage plutôt qu'un vrai calcul à faire.

Karatsuba développe une partie de cette expression pour pouvoir négocier une multiplication au prix d'additions et soustractions.

En effet, nous savons déjà que :

<div style="font-size: 20px;">
<math>(a + b)(c + d) = ac + ad + bc + bd</math>
</div>

En manipulant l'égalité nous obtenons :

<div style="font-size: 20px;">
<math>ad + bc = (a + b)(c + d) - ac - bd</math>
</div>

ac et bd ayant déjà été calculé précédemment, il nous reste uniquement la multiplication <math>(a + b)(c + d)</math>.

Nous venons ainsi de calculer <math>ad + bc</math> en seulement une multiplication. C'est la que repose le gain de temps de la méthode Karatsuba par rapport à la multiplication naïve.

En effet, l'algorithme n'effectuera alors plus que 3 multiplications :
<div style="font-size: 20px;">
<math>ac</math>
<math>bd</math>
<math>(a + b)(c + d)</math>
</div>

La relation de récurrence devient donc :
<div style="font-size: 20px;">
<math>T(n)=3T(n/2)+O(n)</math>
</div>

Et le Master Theorem nous dit que :
<div style="font-size: 20px;">
<math>T(n)\in O(n^{\log_2(3)})</math>
</div>

Or <math>\log_2(3)\approx 1.585</math>, donc la complexité de l'algorithme de Karatsuba est de <math> \mathcal{O}(n^{1.585})</math>. Ce qui est bien plus efficace que la multiplication classique, surtout lorsque les facteurs deviennent très grands.

=== B) Graphique ===
<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Karatsuba.png|500px]]
<div><b>Karatsuba</b></div>
</div>
<div style="max-width:800px;">
<p>Sur le graphique ci-contre nous avons utilisé la courbe de la multiplication naïve récursive (rouge) à titre de comparaison.</p>
<p>On remarque graphiquement que Karatsuba (jaune) prend moins de temps à chaque calcul de produit.</p>
<p>On en déduit donc expérimentalement que Karatsuba à une meilleure complexité que la multiplication naïve.</p>
<p>Ainsi nous vérifions donc ce que le Master Theorem prouve, c'est à dire que la complexité de karatsuba est de <math> \mathcal{O}(n^{1.585})</math> </p>
</div>
</div>

== 4) La multiplication toom-cook-3 ==

=== A) Fonctionnement ===

L'objectif est de diviser les grands entiers X et Y en trois blocs de taille égale k.
On les traite alors comme des polynômes de degré 2:

<math>P(z) = X_2 \cdot z^2 + X_1 \cdot z + X_0</math>
<math>Q(z) = Y_2 \cdot z^2 + Y_1 \cdot z + Y_0</math>

On choisit 5 points distincts pour évaluer nos polynômes.
Ce choix de 5 points est crucial car le produit de deux polynômes de degré 2 est un polynôme de degré 4, qui nécessite 5 points pour être défini.
Les points standards sont :

P(0) = X0
P(1) = X0 + X1 + X2
P(-1) = X0 - X1 + X2
P(2) = X0 + 2*X1 + 4*X2
P(inf) = X2

(On procède de manière similaire pour Q.)

Ensuite nous multiplions récursivement chaque points de P et de Q ensemble.
On effectue ainsi 5 multiplications de nombres plus petits au lieu des 9 multiplications requises par la méthode classique.

Après, nous effectuons une interpolation, cela permet de retrouver les 5 coefficients (w_0, w_1, w_2, w_3, w_4) du polynôme produit R(z) à partir des valeurs évaluées calculées précédemment.
On résout un système d'équations linéaires : <math> R(z) = w_4 z^4 + w_3 z^3 + w_2 z^2 + w_1 z + w_0 </math>
Finalement nous pouvons recomposer notre grand entier en positionnant les coefficients w_i aux bons rangs (en les décalant) et à gérer les retenues lors de l'addition finale:
<math>Résultat = w_4 B^{4k} + w_3 B^{3k} + w_2 B^{2k} + w_1 B^k + w_0</math>

=== B) Graphique ===

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Toomcook.png|500px]]
<div><b>Karatsuba</b></div>
</div>
<div style="max-width:800px;">
<p>on a reprit multi récursive (rouge)</p>
<p>on voit que Toom (vert) en dessous de karatsuba (jaune) en dessous de multi classique (rouge)</p>
<p>meilleur complexité</p>
</div>
</div>

== 5) La transformée de Fourier rapide ==

=== A) Fonctionnement ===

La transformation de Fourier rapide étant plus complexe que les autres algorithmes, nous allons essayer d'expliquer son fonctionnement malgré ne pas avoir réussi à l'implémenter.

Il faut comprendre que cet algorithme va considérer les facteurs comme des polynômes.

D'après le théorème de l'unisolvance, il n'existe qu'un seul polynôme de degré inférieur ou égal à <math> n </math> défini par <math>n + 1</math> points distincts. Cela implique non seulement que nous pouvons représenter chaque entier par un polynôme, mais également que si nous pouvons retrouver <math>n + m + 1</math> points (avec <math>n</math> et <math>m</math> la longueur des facteurs) du polynômes issue du produit entre deux facteurs, nous pourrons le retrouver.

Soit un entier quelconque, de forme :

<math>a_n a_{n-1} (...) a_1 a_0</math>

Avec <math>a_i</math>, un chiffre composant le nombre en base 10, qui vaut en réalité dans le nombre : <math>a_i \times 10^i</math>. On peut ainsi l'écrire sous la forme :

<math> P(x) = a_0 + a_1x + a_2x^2 + \dots + a_{n-1}x^{n-1} + a_nx^n </math>

Avec <math>x = 10</math> car nous sommes en base 10, nous obtenons :

<math>P(10) = a_0 + a_1 \times 10 + \dots + a_{n-1}10^{n-1} + a_n10^n </math>

Nous venons ainsi d'écrire notre nombre sous la forme d'un polynôme unique. Pour nous permettre d'évaluer en un nombre suffisant de points, nous allons devoir ajouter des 0 pour la récursion. Il nous faudra ajouter assez de 0 pour atteindre la prochaine puissance de 2 qui sera supérieure ou égale à <math>2n + 1</math>. L'ajout de 0 ne change pas le nombre car <math>0 \times x^n</math> n'ajoute pas de coefficient.

Cet algorithme est récursif et va segmenter en deux parties nos polynômes à chaque récursion. D'un coté les indice pairs et d'un coté les impaires.

Ainsi prenons les nombres 1234 et 5678, ces nombres sont respectivement représentés par les polynômes <math> P(x) = 4 + 3x + 2x^2 + x^3 </math> et <math> P(x) = 8 + 7x + 6x^2 + 5^3 </math>. Ce sont des polynômes de degré 3, ainsi leur produit donnera lieu à un polynôme de degré 6. Il nous faudra donc au minimum 7 points d'évaluation pour retrouve ce produit. De ce fait, en les représentant de la manière suivante :

<math>[4, 3, 2, 1, 0, 0, 0, 0]</math>
<math>[8, 7, 6, 5, 0, 0, 0, 0]</math>

Nous aurons assez de récursions possible pour les évaluer en un nombre suffisant de points différents car nous auront 3 récursions à faire pour atteindre notre cas de base. A chaque récursion, nous allons diviser nos polynômes en deux parties ce qui nous fait 8 feuilles à la dernière récursion.

En effet à chaque étape de la récursion nous allons séparer nos polynômes en deux tel que :

<math>P(x)=P_{\text{pair}}(x^2) + x \cdot P_{\text{impair}}(x^2)</math>

Durant les récursions, nous segmentons les polynômes mais ne les évaluons pas. C'est à la remonté des récursions que nous allons réellement évaluer nos polynômes. Lorsque l'on atteint notre cas de base, c'est à dire des polynômes de degré 0, nous remarquons qu'ils sont constants, nous n'avons donc pas besoin de les évaluer. En effet, peut importe le point en lequel nous voudrons l'évaluer, le polynôme renverra la constante. Nous la renvoyons donc seule.
Ensuite commence la remontée des récursions. A l'étape 1 de notre remontée nous allons reformer le polynôme précédemment séparé pour obtenir un polynôme de degré 1. Puis, nous évaluons ce polynôme avec les racines seconde de l'unité. Nous faisons à nouveau remonté les évaluations et recombinons à nouveau le polynôme qui sera ainsi de degré 2.
Nous l'évaluons maintenant avec les racines 4eme de l'unité. A chaque évaluation, nous réutilisons les résultats précédents, cela nous est permit par les racines de l'unité qui ont une structure récursive exploitable.

Finalement, nous arrivons à la fin de notre FFT, avec une représentation fréquentielle de la forme :

<math> [P(W_0), P(W_1), (...), P(W_n-1), P(W_n)] </math>

Cette représentation fréquentielle n'est autre que les évaluations du polynôme P aux racines nièmes de l'unité. Nous avons donc maintenant au minimum <math>2n+1</math> évaluations des polynômes facteurs. Il nous faut maintenant trouver les évaluations du produit final, c'est à dire les évaluations concernant le polynôme qui sera issue de la multiplication. On pourra ainsi le retrouver.

Soit <math>C</math> un polynome tel que <math> C = A \times B </math>, alors on a :

<math> C(x) = A(x) \times B(x) </math>

Ainsi on en déduit que <math> C(W_n^k) = A(W_n^k) \times B(W_n^k) </math>

On comprend donc que <math>FFT(C) = FFT(A) \times FFT(B)</math>

Il faut préciser que l'on fait le produit de FFT(A) et FFT(B) terme à terme, soit évaluation par évaluation.

Une fois en possession de <math>FFT(C)</math>, qui n'est autre que l'évaluation de notre polynôme final en un nombre suffisant de points pour le retrouver, nous pouvons faire l'<math>IFFT(FFT(C))</math>, qui va nous permettre de retrouver les coefficients de notre polynôme en faisant l'exacte inverse de la FFT.

Une fois les coefficients retrouvés, il nous suffit de gérer les retenues, et nous retrouvons un entier de la forme : <math>a_0 a_1 (...) a_{n-1} a_n</math>

=== B) Graphique ===

Intéressons nous maintenant à la complexité de l'algorithme utilisant la transformée de Fourier rapide. On sait que l'algorithme passe par 5 étapes importantes :

<ul>
<li>Etape 1 : Ecrire les deux facteurs sous la forme de polynômes</li>
<li>Etape 2 : Effectuer la <math>FFT</math> des deux polynômes</li>
<li>Etape 3 : Faire le produit terme à terme des <math>FFT</math> obtenues</li>
<li>Etape 4 : Faire l'<math>IFFT</math> du produit</li>
<li>Etape 5 : Gérer les retenues et écrire le nombre qui en découle</li>
</ul>

Or, parmi toutes ces étapes, certaines sont négligeable comme l'étape 1 et 5.

Pour connaitre la complexité de l'algorithme, additionnons les complexités des étapes restantes :

Une <math>FFT</math> a une complexité de <math>\mathcal{O}(n\times logn)</math> car elle fait <math>n</math> évaluation sur <math> log(n)</math> récursions. Dans le cadre de notre algorithme, nous devons faire la <math>FFT</math> de nos deux facteurs. Soit <math>2\times \mathcal{O}(n\times logn)</math>.

Pour le produit terme à terme, nous faisons naturellement <math>n</math> opérations.

Pour finir, l'<math>IFFT</math> a la même complexité que la <math>FFT</math>. Dans le cadre de notre algorithme nous l'emploierons qu'une seule fois, ce qui fait une complexité de <math>\mathcal{O}(n\times logn)</math>.

Après addition de toutes ces complexités, nous obtenons la complexité réelle de <math>3\mathcal{O}(n\times logn) + \mathcal{O}(n)</math>.

D'après le Master Theorem, nous avons donc <math> f(n) = 3(n\times logn)+n </math>, cherchons <math>f(n)\in\mathcal{O}(g(n))</math> :

Nous pouvons ignorer les expressions linéaires ainsi que les constantes multiplicatrices, nous obtenons donc <math>\mathcal{O}(g(n)) = \mathcal{O}(n \times log n)</math>.

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:30px; text-align:center;">
[[Fichier:FFT_image.webp|500px]]
<div><b>Graphiques des complexités</b></div>
</div>
<div style="max-width:800px;">
<p>Ce graphique ci-contre ne provient pas du fruit de nos recherches personnelles mais </p>
<p>On comprend ainsi que certaines complexités ne sont pas raisonnable dans la cadre de la multiplication de grands entiers.</p>
<p>C'est pourquoi l'étude de ces algorithmes s'avère nécessaire.</p>
</div>
</div>

= II - Produit de matrices =

== 1.1) naïve ==

La multiplication naïve de matrice requiert d'avoir des tailles de lignes/colonne semblable, ensuite pour chaque membre de la matrice résultat, on doit multiplier les composantes ligne de la première matrice par les composantes colonne de la deuxième et le tout sommé.

On en déduit la formule suivante:
<math>C_{i,j} = \sum_{k=1}^{n} (A_{i,k} \times B_{k,j})</math>

Et visuellement:

[[Fichier:Matricenaive.jpeg]]

On a donc un algorithme d'ordre de complexité <math>\mathcal{O}(g(n))</math>

== 1.2) naïve récursive ==

Dans un premier temps on doit découper nos deux matrices en quatres sous matrices de plus petite taille.
<math>A = \begin{pmatrix} A_{11} & A_{12} \ A_{21} & A_{22} \end{pmatrix}</math>
<math>B = \begin{pmatrix} B_{11} & B_{12} \ B_{21} & B_{22} \end{pmatrix}</math>

Ensuite on vient calculer la matrice résultat.
<math>C_{11} = (A_{11} \times B_{11}) + (A_{12} \times B_{21})</math>
<math>C_{12} = (A_{11} \times B_{12}) + (A_{12} \times B_{22})</math>
<math>C_{21} = (A_{21} \times B_{11}) + (A_{22} \times B_{21})</math>
<math>C_{22} = (A_{21} \times B_{12}) + (A_{22} \times B_{22})</math>

Le côté récursif est utile que pour les matrices de tailles <= 32 (32 valeurs stockées dedans),
si on est au dessus de cette taille alors on divisera à nouveau nos matrices en quatres.
On aura 8 multiplications mais de plus petite taille au final.

== 2) strassen ==

=== A) Fonctionnement ===

Strassen consiste à définir 7 produits intermédiaires qui, par des jeux de sommes et de différences, permettent de reconstruire les quadrants de la matrice résultante. On passe ainsi d'une complexité de O(n^3) à environ O(n^2.81)

=== B) Graphique ===

On voit bien la différence de complexité sur la multiplication de grande matrice entre l'approche naïve et l'approche récursive qui est beaucoup plus rapide.

[[Fichier:Analyse matrices.png]]

= Conclusion =

( A FAIRE )

= Mentions =

Le premier gif est le résultat du travail de 'Walké', licence ci-contre : https://fr.wikipedia.org/wiki/Fichier:Addition.gif

= Sources =

Pour karatsuba : https://www.youtube.com/watch?v=PZ2gdWdKHAA

Pour mieux comprendre la FFT, nous avons utilisé plusieurs sources d'informations :
<ul>
<li> https://www.youtube.com/watch?v=h7apO7q16V0&list=WL&index=1&t=886s </li>
<li> https://fr.wikipedia.org/wiki/Interpolation_polynomiale </li>
</ul>

Algorithmes de multiplications d'entiers et de matrices

2026-05-11T15:18:02Z

Mangala : /* Exemple */

= Introduction =

Depuis l'apparition des ordinateurs modernes, une quantité faramineuse de calculs a dû être effectuée. Les progressions technologiques nous poussent à envisager la puissance de calcul comme une ressource qu'il faut optimiser dans les moindres détails. C'est ainsi que l'optimisation des algorithmes de calcul est devenue cruciale, surtout lorsqu'il nous faut effectuer des opérations sur de très grands entiers par exemple.

= Objectif =

L'objectif majeur de ce projet est de comprendre de manière plus approfondie ce qu'est la '''complexité algorithmique'''.
Pour atteindre cet objectif, nous implémenterons plusieurs algorithmes de multiplication qui auront pour but de calculer le produit de grands entiers ou de matrices.

= Point important : complexité =

=== Définition ===
La complexité d'un algorithme est la quantité des ressources qu'il utilise en fonction de la taille des entrées qu'on lui demande de traiter. On peut par exemple se concentrer sur le temps qu'un algorithme prend pour renvoyer un résultat ou sur la mémoire dont il a besoin. Dans le cadre de notre projet, nous nous attarderons plus particulièrement sur la quantité de calcul effectuée en fonction de la taille des entrées, ce qui est par ailleurs étroitement liée à la notion de temps. De manière générale, plus un algorithme doit faire de calcul, plus il est lent. (Attention, toutes les opérations arithmétiques de base ne se valent pas)

De manière plus familière, on dira que la complexité d'un algorithme pourrait s'apparenter à son comportement lorsqu'il doit traiter des données plus ou moins grandes.
Chaque algorithme a une complexité, et on l'exprime par une fonction qui adopte un comportement similaire au nombre de calculs nécessaires en fonction de la taille des entrées.

=== Notation ===
La complexité réelle d'un algorithme peut être décrite par une fonction <math>f(n)</math> représentant le nombre d'opérations effectuées en fonction de la taille <math>n</math> des données d'entrée.

Cependant, afin de simplifier l'étude de cette croissance, on utilise généralement une borne asymptotique notée <math>\mathcal{O}(g(n))</math>, où <math>g(n)</math> est une fonction ayant le même ordre de grandeur que <math>f(n)</math> lorsque <math>n</math> devient grand.

On dit alors que :

<math>
f(n)\in\mathcal{O}(g(n))
</math>

si et seulement s'il existe une constante <math>C>0</math> et un entier <math>n_0</math> tels que :

<math>
\forall n\ge n_0,\ f(n)\le Cg(n)
</math>

Cette notation <math>\mathcal{O}(g(n))</math> permettra de comparer beaucoup plus facilement les algorithmes entre eux.

=== Master Theorem ===

Afin de déterminer la complexité de certains algorithmes récursifs, nous utiliserons le "Master Theorem".

Ce théorème permet d'obtenir directement l'ordre de grandeur de nombreuses relations de récurrence apparaissant dans l'analyse d'algorithmes de type « diviser pour régner », comme l'algorithme de Karatsuba ou celui de Strassen.

La démonstration complète de ce théorème dépasse le cadre de notre projet et nécessite des connaissances mathématiques plus avancées. Nous l'utiliserons donc principalement comme un outil nous permettant de déterminer efficacement la complexité asymptotique des algorithmes étudiés.

=== Graphiques ===

Les complexités étant des fonctions, nous pouvons les représenter par un graphique qui affichera le temps d'exécution (ou nombre d'opérations) en fonction de la taille des entrées.

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:30px; text-align:center;">
[[Fichier:complexite.webp|500px]]
<div><b>Graphiques des complexités</b></div>
</div>
<div style="max-width:800px;">
<p>Ce graphique ci-contre compare les complexités en fonction de la taille des d'entrées.</p>
<p>On comprend ainsi que certaines complexités ne sont pas raisonnable dans la cadre de la multiplication de grands entiers.</p>
<p>C'est pourquoi l'étude de ces algorithmes s'avère nécessaire.</p>
</div>
</div>

=== Exemple ===
L'algorithme naïf d'addition que nous avons tous appris à l'école a une complexité de <math>\mathcal{O}(n)</math>.
Soit n la taille des nombres en entrée, l'algorithme doit faire environ n addition pour arriver au résultat demandé.

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Addition.gif|220px]]
<div><b>Addition naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Comme le montre l'exemple ci-contre, 786 et 467 font 3 chiffres de long donc n sera de 3.</p>
<p>Il nous faudra 3 opérations pour additionner ces entiers.</p>
<p>C'est ainsi qu'avec une taille d'entrée n, l'algorithme de l'addition naïve va devoir faire n opérations.</p>
<p>Cet algorithme a donc une complexité <math>f(n) = n</math> qui n'a pas besoin d'être approximée.</p>
<p>Ainsi sa complexité finale sera <math>\mathcal{O}(n)</math>.</p>
</div>
</div>

= Problématique =

Le calcul du produit de deux entiers de manière naïve a une complexité de <math> \mathcal{O}(n^2)</math>, et celui de deux matrices une complexité de <math> \mathcal{O}(n^3)</math>. Afin de mieux comprendre ce qu'est la complexité algorithmique, nous devrons implémenter des algorithmes ayant le même objectif, mais étant plus efficaces. Ces algorithmes s'avèreront plus complexes mais devrait aboutir à un calcul plus rapide du produit demandé.

Nous séparerons notre wiki en deux grandes parties, la première concernera nos recherche sur [[#I - Produit d'entiers|la multiplication d'entiers]], la deuxième sur [[#II - Produit de matrices|la multiplication de matrices]].

= I - Produit d'entiers =

Notre départ commence avec l'algorithme de multiplication d'entier naïf.
En effet il s'agit de l'algorithme de multiplication le plus connu, et nous l'utiliserons comme référence pour le comparer aux futurs algorithmes plus efficaces.
Intéressons nous à sa complexité.

== 1) Nos implémentations des grands entiers ==

Qui dit produit de grands entiers dit implémentation de grands entiers.

Dans le cadre de nos recherches, nous allons devoir implémenter des algorithmes qui vont manipuler des grands entiers.

Nous avons donc choisi de créer deux représentations différentes de ceux-ci (car nous travaillons sur différents langages de programmation), nous permettant à la fois une implémentation simplifié, mais aussi de nous rapprocher d'une implémentation bas niveau.

=== A) En python ===
En python, l'utilisation des "bytes" m'a grandement servi à comprendre comment les entiers étaient manipulés à bas niveau. En effet, un des objectifs secondaires de nos recherches était de manipuler des entiers directement avec leur formes stockées sur l'ordinateur, et non pas avec des int python.
En effet l'utilisation des int python nous aurait permit de passer les étapes de retenues, de signes... D'autant plus que les bytes permettent de stocker un nombre en base 256, ce qui permet de visualiser plus facilement les grands entiers.

La forme finale de la représentation des grands entiers en python sera donc la suivante :

[ signe , bytes , bytes , (...) , bytes ]

Le signe est représenté par un entier, 1 si le nombre est positif, 0 sinon.
Cette configuration rendra plus simple la gestion des signes.

=== B) En C++ ===

En C++, pour avoir une représentation de grand entiers j'ai du définir ma propre structure pour m'affranchir de la limite de taille imposé par les entiers standards: (int32 ou int64). Pour cela, j'ai une structure qui possède l'équivalent d'un array de byte (ce qui nous permet d'être en base 256 au lieu de la base 10 habituelle), et pour traiter le signe j'utilise un booléen, ainsi en mémoire j'ai une structure de n*Octets + 1 octet en taille.

[ bytes , bytes , (...) , bytes ] [ signe ]

Le booléen prend 1 octet de place mais ne touche pas aux octets qui encode le grand entier.
Cette configuration rendra plus simple la gestion des signes dans le cadre des multiplication.

== 2) La multiplication naïve ==

=== A) Fonctionnement ===
Dans le cas de la multiplication d'entiers, nous allons prendre deux nombres qui n'ont pas nécessairement la même longueur. Soit les nombre a et b, de longueur respective <math>n</math> et <math> m </math>.
<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Multiplication.png|220px]]
<div><b>Multiplication naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Prenons deux nombres de longueur 3 et 2, et cherchons combien d'opérations l'algorithme de multiplication naïve va devoir faire pour nous renvoyer leur produit.</p>
<p>Dans un premier temps, on remarque que l'on va devoir multiplier chaque chiffre du nombre du haut par le chiffre des unités du bas, qui est 6. Cela va représenter <math>n</math> opérations. (6x5, 6x1 et 6x4)</p>
<p>Dans un deuxième temps nous constatons que nous allons devoir faire la même chose avec le chiffre des dizaines du nombre du bas. Cela nous ajoute de nouveau <math>n</math> opérations.</p>
<p>On arrive assez facilement à la conclusion que pour faire notre produit, il va nous falloir faire <math>n</math> fois <math>m</math> opérations.</p>
</div>
</div>

Ainsi, la complexité de la multiplication naïve est <math>\mathcal{O}(n^2)</math>.
Il est en de même avec la multiplication naïve récursive.

=== B) Graphique ===
Montrons maintenant sa courbe sur un graphique :

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Multiplicationnaive.png|500px]]
<div><b>Multiplication naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Les points noirs sont des repères pour que les autres courbes aient une forme cohérente.</p>
<p>Ils sont tous sur l'axe des abscisses.</p>
<p>La courbe rouge représente la complexité de la multiplication naïve.</p>
<p>On remarque que la courbe a un visuel très similaire à la fonction <math>f(x) = x^2</math> </p>
</div>
</div>

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Naif_recursif.png|500px]]
<div><b>Multiplication naïve récursive</b></div>
</div>
<div style="max-width:800px;">
<p>La courbe rouge représente la complexité de la multiplication naïve récursive.</p>
<p>Elle sera utilisé pour comparer les complexités entre algorithmes car, comme tous récursifs, elle a été codé avec les mêmes biais d'implémentation qu'eux.</p>
<p>Théoriquement les deux courbes ci-contre ont la même complexité, mais encore une fois, notre implémentation n'est pas parfaitement optimale et donc ne respecte pas de manière minutieuse le Master Theorem.</p>
</div>
</div>

== 3) La multiplication karastuba ==

=== A) Fonctionnement ===

L'algorithme de karatsuba est un algorithme récursif de type diviser pour régner.

L'idée générale de l'algorithme est de passer de 4 multiplication à 3. En effet ces opérations étant moins couteuses, il est préférable d'en ajouter si cela permet d'enlever des multiplications.

L'algorithme de multiplication naif récursif utilise la segmentation des facteurs en deux de manière successive.

Soit <math>x</math> et <math>y</math> deux facteurs, nous avons les égalités suivantes :

<div style="font-size: 20px;">
<math>x = a \times B^{n/2} + b</math>
<math>y = c \times B^{n/2} + d</math>
</div>

Avec <math>a</math> et <math>c</math> les premières moitiés des facteurs <math>x</math> et <math>y</math>,
et <math>b</math> et <math>d</math> les dernières moitiés de ces facteurs ainsi que <math>B</math> la base d'écriture du nombre (Nous sommes en base 256 avec les bytes).

Cette présentation des deux facteurs de notre multiplication n'est que la résultante d'un découpage.
Le [[#Master Theorem|Master Theorem]] nous montre que :

<div style="font-size: 20px;">
<math>T(n) = 4T(n/2) + O(n)</math>
</div>

Puisque nous avons après découpage 4 entiers de longueur <math>n/2</math>.

Ainsi, ce découpage ne permet pas de gagner du temps d'après le [[#Master Theorem|Master Theorem]].

Cependant, l'algorithme de Karatsuba réutilise ce principe en le modifiant, ce qui nous permet de baisser la complexité globale de la multiplication dans son entièreté.

Avec l'écriture ci-dessus des nombres <math>x</math> et <math>y</math>, on peut facilement en déduire l'égalité suivante :

<div style="font-size: 20px;">
<math>x \times y = (ac) \times B^n + (ad + bc) \times B^{n/2} + bd</math>
</div>

On remarque 4 multiplications longues à faire dans cette expression. Les multiplications dont <math>B</math> est l'un des facteurs sont très rapides puisqu'il s'agit de la base dans laquelle nous travaillons. De cela en résulte un décalage plutôt qu'un vrai calcul à faire.

Karatsuba développe une partie de cette expression pour pouvoir négocier une multiplication au prix d'additions et soustractions.

En effet, nous savons déjà que :

<div style="font-size: 20px;">
<math>(a + b)(c + d) = ac + ad + bc + bd</math>
</div>

En manipulant l'égalité nous obtenons :

<div style="font-size: 20px;">
<math>ad + bc = (a + b)(c + d) - ac - bd</math>
</div>

ac et bd ayant déjà été calculé précédemment, il nous reste uniquement la multiplication <math>(a + b)(c + d)</math>.

Nous venons ainsi de calculer <math>ad + bc</math> en seulement une multiplication. C'est la que repose le gain de temps de la méthode Karatsuba par rapport à la multiplication naïve.

En effet, l'algorithme n'effectuera alors plus que 3 multiplications :
<div style="font-size: 20px;">
<math>ac</math>
<math>bd</math>
<math>(a + b)(c + d)</math>
</div>

La relation de récurrence devient donc :
<div style="font-size: 20px;">
<math>T(n)=3T(n/2)+O(n)</math>
</div>

Et le Master Theorem nous dit que :
<div style="font-size: 20px;">
<math>T(n)\in O(n^{\log_2(3)})</math>
</div>

Or <math>\log_2(3)\approx 1.585</math>, donc la complexité de l'algorithme de Karatsuba est de <math> \mathcal{O}(n^{1.585})</math>. Ce qui est bien plus efficace que la multiplication classique, surtout lorsque les facteurs deviennent très grands.

=== B) Graphique ===
<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Karatsuba.png|500px]]
<div><b>Karatsuba</b></div>
</div>
<div style="max-width:800px;">
<p>Sur le graphique ci-contre nous avons utilisé la courbe de la multiplication naïve récursive (rouge) à titre de comparaison.</p>
<p>On remarque graphiquement que Karatsuba (jaune) prend moins de temps à chaque calcul de produit.</p>
<p>On en déduit donc expérimentalement que Karatsuba à une meilleure complexité que la multiplication naïve.</p>
<p>Ainsi nous vérifions donc ce que le Master Theorem prouve, c'est à dire que la complexité de karatsuba est de <math> \mathcal{O}(n^{1.585})</math> </p>
</div>
</div>

== 4) La multiplication toom-cook-3 ==

=== A) Fonctionnement ===

L'objectif est de diviser les grands entiers X et Y en trois blocs de taille égale k.
On les traite alors comme des polynômes de degré 2:

<math>P(z) = X_2 \cdot z^2 + X_1 \cdot z + X_0</math>
<math>Q(z) = Y_2 \cdot z^2 + Y_1 \cdot z + Y_0</math>

On choisit 5 points distincts pour évaluer nos polynômes.
Ce choix de 5 points est crucial car le produit de deux polynômes de degré 2 est un polynôme de degré 4, qui nécessite 5 points pour être défini.
Les points standards sont :

P(0) = X0
P(1) = X0 + X1 + X2
P(-1) = X0 - X1 + X2
P(2) = X0 + 2*X1 + 4*X2
P(inf) = X2

(On procède de manière similaire pour Q.)

Ensuite nous multiplions récursivement chaque points de P et de Q ensemble.
On effectue ainsi 5 multiplications de nombres plus petits au lieu des 9 multiplications requises par la méthode classique.

Après, nous effectuons une interpolation, cela permet de retrouver les 5 coefficients (w_0, w_1, w_2, w_3, w_4) du polynôme produit R(z) à partir des valeurs évaluées calculées précédemment.
On résout un système d'équations linéaires : <math> R(z) = w_4 z^4 + w_3 z^3 + w_2 z^2 + w_1 z + w_0 </math>
Finalement nous pouvons recomposer notre grand entier en positionnant les coefficients w_i aux bons rangs (en les décalant) et à gérer les retenues lors de l'addition finale:
<math>Résultat = w_4 B^{4k} + w_3 B^{3k} + w_2 B^{2k} + w_1 B^k + w_0</math>

=== B) Graphique ===

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Toomcook.png|500px]]
<div><b>Karatsuba</b></div>
</div>
<div style="max-width:800px;">
<p>on a reprit multi récursive (rouge)</p>
<p>on voit que Toom (vert) en dessous de karatsuba (jaune) en dessous de multi classique (rouge)</p>
<p>meilleur complexité</p>
</div>
</div>

== 5) La transformée de Fourier rapide ==

=== A) Fonctionnement ===

La transformation de Fourier rapide étant plus complexe que les autres algorithmes, nous allons essayer d'expliquer son fonctionnement malgré ne pas avoir réussi à l'implémenter.

Il faut comprendre que cet algorithme va considérer les facteurs comme des polynômes.

D'après le théorème de l'unisolvance, il n'existe qu'un seul polynôme de degré inférieur ou égal à <math> n </math> défini par <math>n + 1</math> points distincts. Cela implique non seulement que nous pouvons représenter chaque entier par un polynôme, mais également que si nous pouvons retrouver <math>n + m + 1</math> points (avec <math>n</math> et <math>m</math> la longueur des facteurs) du polynômes issue du produit entre deux facteurs, nous pourrons le retrouver.

Soit un entier quelconque, de forme :

<math>a_n a_{n-1} (...) a_1 a_0</math>

Avec <math>a_i</math>, un chiffre composant le nombre en base 10, qui vaut en réalité dans le nombre : <math>a_i \times 10^i</math>. On peut ainsi l'écrire sous la forme :

<math> P(x) = a_0 + a_1x + a_2x^2 + \dots + a_{n-1}x^{n-1} + a_nx^n </math>

Avec <math>x = 10</math> car nous sommes en base 10, nous obtenons :

<math>P(10) = a_0 + a_1 \times 10 + \dots + a_{n-1}10^{n-1} + a_n10^n </math>

Nous venons ainsi d'écrire notre nombre sous la forme d'un polynôme unique. Pour nous permettre d'évaluer en un nombre suffisant de points, nous allons devoir ajouter des 0 pour la récursion. Il nous faudra ajouter assez de 0 pour atteindre la prochaine puissance de 2 qui sera supérieure ou égale à <math>2n + 1</math>. L'ajout de 0 ne change pas le nombre car <math>0 \times x^n</math> n'ajoute pas de coefficient.

Cet algorithme est récursif et va segmenter en deux parties nos polynômes à chaque récursion. D'un coté les indice paires et d'un coté les impaires.

Ainsi prenons les nombres 1234 et 5678, ces nombres sont respectivement représentés par les polynômes <math> P(x) = 4 + 3x + 2x^2 + x^3 </math> et <math> P(x) = 8 + 7x + 6x^2 + 5^3 </math>. Ce sont des polynômes de degré 3, ainsi leur produit donnera lieu à un polynôme de degré 6. Il nous faudra donc au minimum 7 points d'évaluation pour retrouve ce produit. De ce fait, en les représentant de la manière suivante :

<math>[4, 3, 2, 1, 0, 0, 0, 0]</math>
<math>[8, 7, 6, 5, 0, 0, 0, 0]</math>

Nous aurons assez de récursions possible pour les évaluer en un nombre suffisant de points différents car nous auront 3 récursions à faire pour atteindre notre cas de base. A chaque récursion, nous allons diviser nos polynômes en deux parties ce qui nous fait 8 feuilles à la dernière récursion.

En effet à chaque étape de la récursion nous allons séparer nos polynômes en deux tel que :

<math>P(x)=P_{\text{pair}}(x^2) + x \cdot P_{\text{impair}}(x^2)</math>

Durant les récursions, nous segmentons les polynômes mais ne les évaluons pas. C'est à la remonté des récursions que nous allons réellement évaluer nos polynômes. Lorsque l'on atteint notre cas de base, c'est à dire des polynômes de degré 0, nous remarquons qu'ils sont constants, nous n'avons donc pas besoin de les évaluer. En effet, peut importe le point en lequel nous voudrons l'évaluer, le polynôme renverra la constante. Nous la renvoyons donc seule.
Ensuite commence la remontée des récursions. A l'étape 1 de notre remontée nous allons reformer le polynôme précédemment séparé pour obtenir un polynôme de degré 1. Puis, nous évaluons ce polynôme avec les racines seconde de l'unité. Nous faisons à nouveau remonté les évaluations et recombinons à nouveau le polynôme qui sera ainsi de degré 2.
Nous l'évaluons maintenant avec les racines 4eme de l'unité. A chaque évaluation, nous réutilisons les résultats précédents, cela nous est permit par les racines de l'unité qui ont une structure récursive exploitable.

Finalement, nous arrivons à la fin de notre FFT, avec une représentation fréquentielle de la forme :

<math> [P(W_0), P(W_1), (...), P(W_n-1), P(W_n)] </math>

Cette représentation fréquentielle n'est autre que les évaluations du polynôme P aux racines nièmes de l'unité. Nous avons donc maintenant au minimum <math>2n+1</math> évaluations des polynômes facteurs. Il nous faut maintenant trouver les évaluations du produit final, c'est à dire les évaluations concernant le polynôme qui sera issue de la multiplication. On pourra ainsi le retrouver.

Soit <math>C</math> un polynome tel que <math> C = A \times B </math>, alors on a :

<math> C(x) = A(x) \times B(x) </math>

Ainsi on en déduit que <math> C(W_n^k) = A(W_n^k) \times B(W_n^k) </math>

On comprend donc que <math>FFT(C) = FFT(A) \times FFT(B)</math>

Il faut préciser que l'on fait le produit de FFT(A) et FFT(B) terme à terme, soit évaluation par évaluation.

Une fois en possession de <math>FFT(C)</math>, qui n'est autre que l'évaluation de notre polynôme final en un nombre suffisant de points pour le retrouver, nous pouvons faire l'<math>IFFT(FFT(C))</math>, qui va nous permettre de retrouver les coefficients de notre polynôme en faisant l'exacte inverse de la FFT.

Une fois les coefficients retrouvés, il nous suffit de gérer les retenues, et nous retrouvons un entier de la forme : <math>a_0 a_1 (...) a_{n-1} a_n</math>

=== B) Graphique ===

Intéressons nous maintenant à la complexité de l'algorithme utilisant la transformée de Fourier rapide. On sait que l'algorithme passe par 5 étapes importantes :

<ul>
<li>Etape 1 : Ecrire les deux facteurs sous la forme de polynômes</li>
<li>Etape 2 : Effectuer la <math>FFT</math> des deux polynômes</li>
<li>Etape 3 : Faire le produit terme à terme des <math>FFT</math> obtenues</li>
<li>Etape 4 : Faire l'<math>IFFT</math> du produit</li>
<li>Etape 5 : Gérer les retenues et écrire le nombre qui en découle</li>
</ul>

Or, parmi toutes ces étapes, certaines sont négligeable comme l'étape 1 et 5.

Pour connaitre la complexité de l'algorithme, additionnons les complexités des étapes restantes :

Une <math>FFT</math> a une complexité de <math>\mathcal{O}(n\times logn)</math> car elle fait <math>n</math> évaluation sur <math> log(n)</math> récursions. Dans le cadre de notre algorithme, nous devons faire la <math>FFT</math> de nos deux facteurs. Soit <math>2\times \mathcal{O}(n\times logn)</math>.

Pour le produit terme à terme, nous faisons naturellement <math>n</math> opérations.

Pour finir, l'<math>IFFT</math> a la même complexité que la <math>FFT</math>. Dans le cadre de notre algorithme nous l'emploierons qu'une seule fois, ce qui fait une complexité de <math>\mathcal{O}(n\times logn)</math>.

Après addition de toutes ces complexités, nous obtenons la complexité réelle de <math>3\mathcal{O}(n\times logn) + \mathcal{O}(n)</math>.

D'après le Master Theorem, nous avons donc <math> f(n) = 3(n\times logn)+n </math>, cherchons <math>f(n)\in\mathcal{O}(g(n))</math> :

Nous pouvons ignorer les expressions linéaires ainsi que les constantes multiplicatrices, nous obtenons donc <math>\mathcal{O}(g(n)) = \mathcal{O}(n \times log n)</math>.

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:30px; text-align:center;">
[[Fichier:FFT_image.webp|500px]]
<div><b>Graphiques des complexités</b></div>
</div>
<div style="max-width:800px;">
<p>Ce graphique ci-contre ne provient pas du fruit de nos recherches personnelles mais </p>
<p>On comprend ainsi que certaines complexités ne sont pas raisonnable dans la cadre de la multiplication de grands entiers.</p>
<p>C'est pourquoi l'étude de ces algorithmes s'avère nécessaire.</p>
</div>
</div>

= II - Produit de matrices =

== 1.1) naïve ==

La multiplication naïve de matrice requiert d'avoir des tailles de lignes/colonne semblable, ensuite pour chaque membre de la matrice résultat, on doit multiplier les composantes ligne de la première matrice par les composantes colonne de la deuxième et le tout sommé.

On en déduit la formule suivante:
<math>C_{i,j} = \sum_{k=1}^{n} (A_{i,k} \times B_{k,j})</math>

Et visuellement:

[[Fichier:Matricenaive.jpeg]]

On a donc un algorithme d'ordre de complexité <math>\mathcal{O}(g(n))</math>

== 1.2) naïve récursive ==

Dans un premier temps on doit découper nos deux matrices en quatres sous matrices de plus petite taille.
<math>A = \begin{pmatrix} A_{11} & A_{12} \ A_{21} & A_{22} \end{pmatrix}</math>
<math>B = \begin{pmatrix} B_{11} & B_{12} \ B_{21} & B_{22} \end{pmatrix}</math>

Ensuite on vient calculer la matrice résultat.
<math>C_{11} = (A_{11} \times B_{11}) + (A_{12} \times B_{21})</math>
<math>C_{12} = (A_{11} \times B_{12}) + (A_{12} \times B_{22})</math>
<math>C_{21} = (A_{21} \times B_{11}) + (A_{22} \times B_{21})</math>
<math>C_{22} = (A_{21} \times B_{12}) + (A_{22} \times B_{22})</math>

Le côté récursif est utile que pour les matrices de tailles <= 32 (32 valeurs stockées dedans),
si on est au dessus de cette taille alors on divisera à nouveau nos matrices en quatres.
On aura 8 multiplications mais de plus petite taille au final.

== 2) strassen ==

=== A) Fonctionnement ===

Strassen consiste à définir 7 produits intermédiaires qui, par des jeux de sommes et de différences, permettent de reconstruire les quadrants de la matrice résultante. On passe ainsi d'une complexité de O(n^3) à environ O(n^2.81)

=== B) Graphique ===

On voit bien la différence de complexité sur la multiplication de grande matrice entre l'approche naïve et l'approche récursive qui est beaucoup plus rapide.

[[Fichier:Analyse matrices.png]]

= Conclusion =

( A FAIRE )

= Mentions =

Le premier gif est le résultat du travail de 'Walké', licence ci-contre : https://fr.wikipedia.org/wiki/Fichier:Addition.gif

= Sources =

Pour karatsuba : https://www.youtube.com/watch?v=PZ2gdWdKHAA

Pour mieux comprendre la FFT, nous avons utilisé plusieurs sources d'informations :
<ul>
<li> https://www.youtube.com/watch?v=h7apO7q16V0&list=WL&index=1&t=886s </li>
<li> https://fr.wikipedia.org/wiki/Interpolation_polynomiale </li>
</ul>

Algorithmes de multiplications d'entiers et de matrices

2026-05-11T15:17:43Z

Mangala : /* Exemple */

= Introduction =

Depuis l'apparition des ordinateurs modernes, une quantité faramineuse de calculs a dû être effectuée. Les progressions technologiques nous poussent à envisager la puissance de calcul comme une ressource qu'il faut optimiser dans les moindres détails. C'est ainsi que l'optimisation des algorithmes de calcul est devenue cruciale, surtout lorsqu'il nous faut effectuer des opérations sur de très grands entiers par exemple.

= Objectif =

L'objectif majeur de ce projet est de comprendre de manière plus approfondie ce qu'est la '''complexité algorithmique'''.
Pour atteindre cet objectif, nous implémenterons plusieurs algorithmes de multiplication qui auront pour but de calculer le produit de grands entiers ou de matrices.

= Point important : complexité =

=== Définition ===
La complexité d'un algorithme est la quantité des ressources qu'il utilise en fonction de la taille des entrées qu'on lui demande de traiter. On peut par exemple se concentrer sur le temps qu'un algorithme prend pour renvoyer un résultat ou sur la mémoire dont il a besoin. Dans le cadre de notre projet, nous nous attarderons plus particulièrement sur la quantité de calcul effectuée en fonction de la taille des entrées, ce qui est par ailleurs étroitement liée à la notion de temps. De manière générale, plus un algorithme doit faire de calcul, plus il est lent. (Attention, toutes les opérations arithmétiques de base ne se valent pas)

De manière plus familière, on dira que la complexité d'un algorithme pourrait s'apparenter à son comportement lorsqu'il doit traiter des données plus ou moins grandes.
Chaque algorithme a une complexité, et on l'exprime par une fonction qui adopte un comportement similaire au nombre de calculs nécessaires en fonction de la taille des entrées.

=== Notation ===
La complexité réelle d'un algorithme peut être décrite par une fonction <math>f(n)</math> représentant le nombre d'opérations effectuées en fonction de la taille <math>n</math> des données d'entrée.

Cependant, afin de simplifier l'étude de cette croissance, on utilise généralement une borne asymptotique notée <math>\mathcal{O}(g(n))</math>, où <math>g(n)</math> est une fonction ayant le même ordre de grandeur que <math>f(n)</math> lorsque <math>n</math> devient grand.

On dit alors que :

<math>
f(n)\in\mathcal{O}(g(n))
</math>

si et seulement s'il existe une constante <math>C>0</math> et un entier <math>n_0</math> tels que :

<math>
\forall n\ge n_0,\ f(n)\le Cg(n)
</math>

Cette notation <math>\mathcal{O}(g(n))</math> permettra de comparer beaucoup plus facilement les algorithmes entre eux.

=== Master Theorem ===

Afin de déterminer la complexité de certains algorithmes récursifs, nous utiliserons le "Master Theorem".

Ce théorème permet d'obtenir directement l'ordre de grandeur de nombreuses relations de récurrence apparaissant dans l'analyse d'algorithmes de type « diviser pour régner », comme l'algorithme de Karatsuba ou celui de Strassen.

La démonstration complète de ce théorème dépasse le cadre de notre projet et nécessite des connaissances mathématiques plus avancées. Nous l'utiliserons donc principalement comme un outil nous permettant de déterminer efficacement la complexité asymptotique des algorithmes étudiés.

=== Graphiques ===

Les complexités étant des fonctions, nous pouvons les représenter par un graphique qui affichera le temps d'exécution (ou nombre d'opérations) en fonction de la taille des entrées.

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:30px; text-align:center;">
[[Fichier:complexite.webp|500px]]
<div><b>Graphiques des complexités</b></div>
</div>
<div style="max-width:800px;">
<p>Ce graphique ci-contre compare les complexités en fonction de la taille des d'entrées.</p>
<p>On comprend ainsi que certaines complexités ne sont pas raisonnable dans la cadre de la multiplication de grands entiers.</p>
<p>C'est pourquoi l'étude de ces algorithmes s'avère nécessaire.</p>
</div>
</div>

=== Exemple ===
L'algorithme naïf d'addition que nous avons tous appris à l'école a une complexité de <math>\mathcal{O}(n)</math>.
Soit n la taille des nombres en entrée, l'algorithme doit faire environ n addition pour arriver au résultat demandé.

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Addition.gif|220px]]
<div><b>Addition naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Comme le montre l'exemple ci-contre, 786 et 467 font 3 chiffres de long donc n sera de 3.</p>
<p>Il nous faudra 3 opérations pour additionner ces entiers.</p>
<p>C'est ainsi qu'avec une taille d'entrée n, l'algorithme de l'addition naïve va devoir faire n opérations.</p>
<p>Cette algorithme a donc une complexité <math>f(n) = n</math> qui n'a pas besoin d'être approximée.</p>
<p>Ainsi sa complexité finale sera <math>\mathcal{O}(n)</math>.</p>
</div>
</div>

= Problématique =

Le calcul du produit de deux entiers de manière naïve a une complexité de <math> \mathcal{O}(n^2)</math>, et celui de deux matrices une complexité de <math> \mathcal{O}(n^3)</math>. Afin de mieux comprendre ce qu'est la complexité algorithmique, nous devrons implémenter des algorithmes ayant le même objectif, mais étant plus efficaces. Ces algorithmes s'avèreront plus complexes mais devrait aboutir à un calcul plus rapide du produit demandé.

Nous séparerons notre wiki en deux grandes parties, la première concernera nos recherche sur [[#I - Produit d'entiers|la multiplication d'entiers]], la deuxième sur [[#II - Produit de matrices|la multiplication de matrices]].

= I - Produit d'entiers =

Notre départ commence avec l'algorithme de multiplication d'entier naïf.
En effet il s'agit de l'algorithme de multiplication le plus connu, et nous l'utiliserons comme référence pour le comparer aux futurs algorithmes plus efficaces.
Intéressons nous à sa complexité.

== 1) Nos implémentations des grands entiers ==

Qui dit produit de grands entiers dit implémentation de grands entiers.

Dans le cadre de nos recherches, nous allons devoir implémenter des algorithmes qui vont manipuler des grands entiers.

Nous avons donc choisi de créer deux représentations différentes de ceux-ci (car nous travaillons sur différents langages de programmation), nous permettant à la fois une implémentation simplifié, mais aussi de nous rapprocher d'une implémentation bas niveau.

=== A) En python ===
En python, l'utilisation des "bytes" m'a grandement servi à comprendre comment les entiers étaient manipulés à bas niveau. En effet, un des objectifs secondaires de nos recherches était de manipuler des entiers directement avec leur formes stockées sur l'ordinateur, et non pas avec des int python.
En effet l'utilisation des int python nous aurait permit de passer les étapes de retenues, de signes... D'autant plus que les bytes permettent de stocker un nombre en base 256, ce qui permet de visualiser plus facilement les grands entiers.

La forme finale de la représentation des grands entiers en python sera donc la suivante :

[ signe , bytes , bytes , (...) , bytes ]

Le signe est représenté par un entier, 1 si le nombre est positif, 0 sinon.
Cette configuration rendra plus simple la gestion des signes.

=== B) En C++ ===

En C++, pour avoir une représentation de grand entiers j'ai du définir ma propre structure pour m'affranchir de la limite de taille imposé par les entiers standards: (int32 ou int64). Pour cela, j'ai une structure qui possède l'équivalent d'un array de byte (ce qui nous permet d'être en base 256 au lieu de la base 10 habituelle), et pour traiter le signe j'utilise un booléen, ainsi en mémoire j'ai une structure de n*Octets + 1 octet en taille.

[ bytes , bytes , (...) , bytes ] [ signe ]

Le booléen prend 1 octet de place mais ne touche pas aux octets qui encode le grand entier.
Cette configuration rendra plus simple la gestion des signes dans le cadre des multiplication.

== 2) La multiplication naïve ==

=== A) Fonctionnement ===
Dans le cas de la multiplication d'entiers, nous allons prendre deux nombres qui n'ont pas nécessairement la même longueur. Soit les nombre a et b, de longueur respective <math>n</math> et <math> m </math>.
<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Multiplication.png|220px]]
<div><b>Multiplication naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Prenons deux nombres de longueur 3 et 2, et cherchons combien d'opérations l'algorithme de multiplication naïve va devoir faire pour nous renvoyer leur produit.</p>
<p>Dans un premier temps, on remarque que l'on va devoir multiplier chaque chiffre du nombre du haut par le chiffre des unités du bas, qui est 6. Cela va représenter <math>n</math> opérations. (6x5, 6x1 et 6x4)</p>
<p>Dans un deuxième temps nous constatons que nous allons devoir faire la même chose avec le chiffre des dizaines du nombre du bas. Cela nous ajoute de nouveau <math>n</math> opérations.</p>
<p>On arrive assez facilement à la conclusion que pour faire notre produit, il va nous falloir faire <math>n</math> fois <math>m</math> opérations.</p>
</div>
</div>

Ainsi, la complexité de la multiplication naïve est <math>\mathcal{O}(n^2)</math>.
Il est en de même avec la multiplication naïve récursive.

=== B) Graphique ===
Montrons maintenant sa courbe sur un graphique :

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Multiplicationnaive.png|500px]]
<div><b>Multiplication naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Les points noirs sont des repères pour que les autres courbes aient une forme cohérente.</p>
<p>Ils sont tous sur l'axe des abscisses.</p>
<p>La courbe rouge représente la complexité de la multiplication naïve.</p>
<p>On remarque que la courbe a un visuel très similaire à la fonction <math>f(x) = x^2</math> </p>
</div>
</div>

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Naif_recursif.png|500px]]
<div><b>Multiplication naïve récursive</b></div>
</div>
<div style="max-width:800px;">
<p>La courbe rouge représente la complexité de la multiplication naïve récursive.</p>
<p>Elle sera utilisé pour comparer les complexités entre algorithmes car, comme tous récursifs, elle a été codé avec les mêmes biais d'implémentation qu'eux.</p>
<p>Théoriquement les deux courbes ci-contre ont la même complexité, mais encore une fois, notre implémentation n'est pas parfaitement optimale et donc ne respecte pas de manière minutieuse le Master Theorem.</p>
</div>
</div>

== 3) La multiplication karastuba ==

=== A) Fonctionnement ===

L'algorithme de karatsuba est un algorithme récursif de type diviser pour régner.

L'idée générale de l'algorithme est de passer de 4 multiplication à 3. En effet ces opérations étant moins couteuses, il est préférable d'en ajouter si cela permet d'enlever des multiplications.

L'algorithme de multiplication naif récursif utilise la segmentation des facteurs en deux de manière successive.

Soit <math>x</math> et <math>y</math> deux facteurs, nous avons les égalités suivantes :

<div style="font-size: 20px;">
<math>x = a \times B^{n/2} + b</math>
<math>y = c \times B^{n/2} + d</math>
</div>

Avec <math>a</math> et <math>c</math> les premières moitiés des facteurs <math>x</math> et <math>y</math>,
et <math>b</math> et <math>d</math> les dernières moitiés de ces facteurs ainsi que <math>B</math> la base d'écriture du nombre (Nous sommes en base 256 avec les bytes).

Cette présentation des deux facteurs de notre multiplication n'est que la résultante d'un découpage.
Le [[#Master Theorem|Master Theorem]] nous montre que :

<div style="font-size: 20px;">
<math>T(n) = 4T(n/2) + O(n)</math>
</div>

Puisque nous avons après découpage 4 entiers de longueur <math>n/2</math>.

Ainsi, ce découpage ne permet pas de gagner du temps d'après le [[#Master Theorem|Master Theorem]].

Cependant, l'algorithme de Karatsuba réutilise ce principe en le modifiant, ce qui nous permet de baisser la complexité globale de la multiplication dans son entièreté.

Avec l'écriture ci-dessus des nombres <math>x</math> et <math>y</math>, on peut facilement en déduire l'égalité suivante :

<div style="font-size: 20px;">
<math>x \times y = (ac) \times B^n + (ad + bc) \times B^{n/2} + bd</math>
</div>

On remarque 4 multiplications longues à faire dans cette expression. Les multiplications dont <math>B</math> est l'un des facteurs sont très rapides puisqu'il s'agit de la base dans laquelle nous travaillons. De cela en résulte un décalage plutôt qu'un vrai calcul à faire.

Karatsuba développe une partie de cette expression pour pouvoir négocier une multiplication au prix d'additions et soustractions.

En effet, nous savons déjà que :

<div style="font-size: 20px;">
<math>(a + b)(c + d) = ac + ad + bc + bd</math>
</div>

En manipulant l'égalité nous obtenons :

<div style="font-size: 20px;">
<math>ad + bc = (a + b)(c + d) - ac - bd</math>
</div>

ac et bd ayant déjà été calculé précédemment, il nous reste uniquement la multiplication <math>(a + b)(c + d)</math>.

Nous venons ainsi de calculer <math>ad + bc</math> en seulement une multiplication. C'est la que repose le gain de temps de la méthode Karatsuba par rapport à la multiplication naïve.

En effet, l'algorithme n'effectuera alors plus que 3 multiplications :
<div style="font-size: 20px;">
<math>ac</math>
<math>bd</math>
<math>(a + b)(c + d)</math>
</div>

La relation de récurrence devient donc :
<div style="font-size: 20px;">
<math>T(n)=3T(n/2)+O(n)</math>
</div>

Et le Master Theorem nous dit que :
<div style="font-size: 20px;">
<math>T(n)\in O(n^{\log_2(3)})</math>
</div>

Or <math>\log_2(3)\approx 1.585</math>, donc la complexité de l'algorithme de Karatsuba est de <math> \mathcal{O}(n^{1.585})</math>. Ce qui est bien plus efficace que la multiplication classique, surtout lorsque les facteurs deviennent très grands.

=== B) Graphique ===
<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Karatsuba.png|500px]]
<div><b>Karatsuba</b></div>
</div>
<div style="max-width:800px;">
<p>Sur le graphique ci-contre nous avons utilisé la courbe de la multiplication naïve récursive (rouge) à titre de comparaison.</p>
<p>On remarque graphiquement que Karatsuba (jaune) prend moins de temps à chaque calcul de produit.</p>
<p>On en déduit donc expérimentalement que Karatsuba à une meilleure complexité que la multiplication naïve.</p>
<p>Ainsi nous vérifions donc ce que le Master Theorem prouve, c'est à dire que la complexité de karatsuba est de <math> \mathcal{O}(n^{1.585})</math> </p>
</div>
</div>

== 4) La multiplication toom-cook-3 ==

=== A) Fonctionnement ===

L'objectif est de diviser les grands entiers X et Y en trois blocs de taille égale k.
On les traite alors comme des polynômes de degré 2:

<math>P(z) = X_2 \cdot z^2 + X_1 \cdot z + X_0</math>
<math>Q(z) = Y_2 \cdot z^2 + Y_1 \cdot z + Y_0</math>

On choisit 5 points distincts pour évaluer nos polynômes.
Ce choix de 5 points est crucial car le produit de deux polynômes de degré 2 est un polynôme de degré 4, qui nécessite 5 points pour être défini.
Les points standards sont :

P(0) = X0
P(1) = X0 + X1 + X2
P(-1) = X0 - X1 + X2
P(2) = X0 + 2*X1 + 4*X2
P(inf) = X2

(On procède de manière similaire pour Q.)

Ensuite nous multiplions récursivement chaque points de P et de Q ensemble.
On effectue ainsi 5 multiplications de nombres plus petits au lieu des 9 multiplications requises par la méthode classique.

Après, nous effectuons une interpolation, cela permet de retrouver les 5 coefficients (w_0, w_1, w_2, w_3, w_4) du polynôme produit R(z) à partir des valeurs évaluées calculées précédemment.
On résout un système d'équations linéaires : <math> R(z) = w_4 z^4 + w_3 z^3 + w_2 z^2 + w_1 z + w_0 </math>
Finalement nous pouvons recomposer notre grand entier en positionnant les coefficients w_i aux bons rangs (en les décalant) et à gérer les retenues lors de l'addition finale:
<math>Résultat = w_4 B^{4k} + w_3 B^{3k} + w_2 B^{2k} + w_1 B^k + w_0</math>

=== B) Graphique ===

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Toomcook.png|500px]]
<div><b>Karatsuba</b></div>
</div>
<div style="max-width:800px;">
<p>on a reprit multi récursive (rouge)</p>
<p>on voit que Toom (vert) en dessous de karatsuba (jaune) en dessous de multi classique (rouge)</p>
<p>meilleur complexité</p>
</div>
</div>

== 5) La transformée de Fourier rapide ==

=== A) Fonctionnement ===

La transformation de Fourier rapide étant plus complexe que les autres algorithmes, nous allons essayer d'expliquer son fonctionnement malgré ne pas avoir réussi à l'implémenter.

Il faut comprendre que cet algorithme va considérer les facteurs comme des polynômes.

D'après le théorème de l'unisolvance, il n'existe qu'un seul polynôme de degré inférieur ou égal à <math> n </math> défini par <math>n + 1</math> points distincts. Cela implique non seulement que nous pouvons représenter chaque entier par un polynôme, mais également que si nous pouvons retrouver <math>n + m + 1</math> points (avec <math>n</math> et <math>m</math> la longueur des facteurs) du polynômes issue du produit entre deux facteurs, nous pourrons le retrouver.

Soit un entier quelconque, de forme :

<math>a_n a_{n-1} (...) a_1 a_0</math>

Avec <math>a_i</math>, un chiffre composant le nombre en base 10, qui vaut en réalité dans le nombre : <math>a_i \times 10^i</math>. On peut ainsi l'écrire sous la forme :

<math> P(x) = a_0 + a_1x + a_2x^2 + \dots + a_{n-1}x^{n-1} + a_nx^n </math>

Avec <math>x = 10</math> car nous sommes en base 10, nous obtenons :

<math>P(10) = a_0 + a_1 \times 10 + \dots + a_{n-1}10^{n-1} + a_n10^n </math>

Nous venons ainsi d'écrire notre nombre sous la forme d'un polynôme unique. Pour nous permettre d'évaluer en un nombre suffisant de points, nous allons devoir ajouter des 0 pour la récursion. Il nous faudra ajouter assez de 0 pour atteindre la prochaine puissance de 2 qui sera supérieure ou égale à <math>2n + 1</math>. L'ajout de 0 ne change pas le nombre car <math>0 \times x^n</math> n'ajoute pas de coefficient.

Cet algorithme est récursif et va segmenter en deux parties nos polynômes à chaque récursion. D'un coté les indice paires et d'un coté les impaires.

Ainsi prenons les nombres 1234 et 5678, ces nombres sont respectivement représentés par les polynômes <math> P(x) = 4 + 3x + 2x^2 + x^3 </math> et <math> P(x) = 8 + 7x + 6x^2 + 5^3 </math>. Ce sont des polynômes de degré 3, ainsi leur produit donnera lieu à un polynôme de degré 6. Il nous faudra donc au minimum 7 points d'évaluation pour retrouve ce produit. De ce fait, en les représentant de la manière suivante :

<math>[4, 3, 2, 1, 0, 0, 0, 0]</math>
<math>[8, 7, 6, 5, 0, 0, 0, 0]</math>

Nous aurons assez de récursions possible pour les évaluer en un nombre suffisant de points différents car nous auront 3 récursions à faire pour atteindre notre cas de base. A chaque récursion, nous allons diviser nos polynômes en deux parties ce qui nous fait 8 feuilles à la dernière récursion.

En effet à chaque étape de la récursion nous allons séparer nos polynômes en deux tel que :

<math>P(x)=P_{\text{pair}}(x^2) + x \cdot P_{\text{impair}}(x^2)</math>

Durant les récursions, nous segmentons les polynômes mais ne les évaluons pas. C'est à la remonté des récursions que nous allons réellement évaluer nos polynômes. Lorsque l'on atteint notre cas de base, c'est à dire des polynômes de degré 0, nous remarquons qu'ils sont constants, nous n'avons donc pas besoin de les évaluer. En effet, peut importe le point en lequel nous voudrons l'évaluer, le polynôme renverra la constante. Nous la renvoyons donc seule.
Ensuite commence la remontée des récursions. A l'étape 1 de notre remontée nous allons reformer le polynôme précédemment séparé pour obtenir un polynôme de degré 1. Puis, nous évaluons ce polynôme avec les racines seconde de l'unité. Nous faisons à nouveau remonté les évaluations et recombinons à nouveau le polynôme qui sera ainsi de degré 2.
Nous l'évaluons maintenant avec les racines 4eme de l'unité. A chaque évaluation, nous réutilisons les résultats précédents, cela nous est permit par les racines de l'unité qui ont une structure récursive exploitable.

Finalement, nous arrivons à la fin de notre FFT, avec une représentation fréquentielle de la forme :

<math> [P(W_0), P(W_1), (...), P(W_n-1), P(W_n)] </math>

Cette représentation fréquentielle n'est autre que les évaluations du polynôme P aux racines nièmes de l'unité. Nous avons donc maintenant au minimum <math>2n+1</math> évaluations des polynômes facteurs. Il nous faut maintenant trouver les évaluations du produit final, c'est à dire les évaluations concernant le polynôme qui sera issue de la multiplication. On pourra ainsi le retrouver.

Soit <math>C</math> un polynome tel que <math> C = A \times B </math>, alors on a :

<math> C(x) = A(x) \times B(x) </math>

Ainsi on en déduit que <math> C(W_n^k) = A(W_n^k) \times B(W_n^k) </math>

On comprend donc que <math>FFT(C) = FFT(A) \times FFT(B)</math>

Il faut préciser que l'on fait le produit de FFT(A) et FFT(B) terme à terme, soit évaluation par évaluation.

Une fois en possession de <math>FFT(C)</math>, qui n'est autre que l'évaluation de notre polynôme final en un nombre suffisant de points pour le retrouver, nous pouvons faire l'<math>IFFT(FFT(C))</math>, qui va nous permettre de retrouver les coefficients de notre polynôme en faisant l'exacte inverse de la FFT.

Une fois les coefficients retrouvés, il nous suffit de gérer les retenues, et nous retrouvons un entier de la forme : <math>a_0 a_1 (...) a_{n-1} a_n</math>

=== B) Graphique ===

Intéressons nous maintenant à la complexité de l'algorithme utilisant la transformée de Fourier rapide. On sait que l'algorithme passe par 5 étapes importantes :

<ul>
<li>Etape 1 : Ecrire les deux facteurs sous la forme de polynômes</li>
<li>Etape 2 : Effectuer la <math>FFT</math> des deux polynômes</li>
<li>Etape 3 : Faire le produit terme à terme des <math>FFT</math> obtenues</li>
<li>Etape 4 : Faire l'<math>IFFT</math> du produit</li>
<li>Etape 5 : Gérer les retenues et écrire le nombre qui en découle</li>
</ul>

Or, parmi toutes ces étapes, certaines sont négligeable comme l'étape 1 et 5.

Pour connaitre la complexité de l'algorithme, additionnons les complexités des étapes restantes :

Une <math>FFT</math> a une complexité de <math>\mathcal{O}(n\times logn)</math> car elle fait <math>n</math> évaluation sur <math> log(n)</math> récursions. Dans le cadre de notre algorithme, nous devons faire la <math>FFT</math> de nos deux facteurs. Soit <math>2\times \mathcal{O}(n\times logn)</math>.

Pour le produit terme à terme, nous faisons naturellement <math>n</math> opérations.

Pour finir, l'<math>IFFT</math> a la même complexité que la <math>FFT</math>. Dans le cadre de notre algorithme nous l'emploierons qu'une seule fois, ce qui fait une complexité de <math>\mathcal{O}(n\times logn)</math>.

Après addition de toutes ces complexités, nous obtenons la complexité réelle de <math>3\mathcal{O}(n\times logn) + \mathcal{O}(n)</math>.

D'après le Master Theorem, nous avons donc <math> f(n) = 3(n\times logn)+n </math>, cherchons <math>f(n)\in\mathcal{O}(g(n))</math> :

Nous pouvons ignorer les expressions linéaires ainsi que les constantes multiplicatrices, nous obtenons donc <math>\mathcal{O}(g(n)) = \mathcal{O}(n \times log n)</math>.

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:30px; text-align:center;">
[[Fichier:FFT_image.webp|500px]]
<div><b>Graphiques des complexités</b></div>
</div>
<div style="max-width:800px;">
<p>Ce graphique ci-contre ne provient pas du fruit de nos recherches personnelles mais </p>
<p>On comprend ainsi que certaines complexités ne sont pas raisonnable dans la cadre de la multiplication de grands entiers.</p>
<p>C'est pourquoi l'étude de ces algorithmes s'avère nécessaire.</p>
</div>
</div>

= II - Produit de matrices =

== 1.1) naïve ==

La multiplication naïve de matrice requiert d'avoir des tailles de lignes/colonne semblable, ensuite pour chaque membre de la matrice résultat, on doit multiplier les composantes ligne de la première matrice par les composantes colonne de la deuxième et le tout sommé.

On en déduit la formule suivante:
<math>C_{i,j} = \sum_{k=1}^{n} (A_{i,k} \times B_{k,j})</math>

Et visuellement:

[[Fichier:Matricenaive.jpeg]]

On a donc un algorithme d'ordre de complexité <math>\mathcal{O}(g(n))</math>

== 1.2) naïve récursive ==

Dans un premier temps on doit découper nos deux matrices en quatres sous matrices de plus petite taille.
<math>A = \begin{pmatrix} A_{11} & A_{12} \ A_{21} & A_{22} \end{pmatrix}</math>
<math>B = \begin{pmatrix} B_{11} & B_{12} \ B_{21} & B_{22} \end{pmatrix}</math>

Ensuite on vient calculer la matrice résultat.
<math>C_{11} = (A_{11} \times B_{11}) + (A_{12} \times B_{21})</math>
<math>C_{12} = (A_{11} \times B_{12}) + (A_{12} \times B_{22})</math>
<math>C_{21} = (A_{21} \times B_{11}) + (A_{22} \times B_{21})</math>
<math>C_{22} = (A_{21} \times B_{12}) + (A_{22} \times B_{22})</math>

Le côté récursif est utile que pour les matrices de tailles <= 32 (32 valeurs stockées dedans),
si on est au dessus de cette taille alors on divisera à nouveau nos matrices en quatres.
On aura 8 multiplications mais de plus petite taille au final.

== 2) strassen ==

=== A) Fonctionnement ===

Strassen consiste à définir 7 produits intermédiaires qui, par des jeux de sommes et de différences, permettent de reconstruire les quadrants de la matrice résultante. On passe ainsi d'une complexité de O(n^3) à environ O(n^2.81)

=== B) Graphique ===

On voit bien la différence de complexité sur la multiplication de grande matrice entre l'approche naïve et l'approche récursive qui est beaucoup plus rapide.

[[Fichier:Analyse matrices.png]]

= Conclusion =

( A FAIRE )

= Mentions =

Le premier gif est le résultat du travail de 'Walké', licence ci-contre : https://fr.wikipedia.org/wiki/Fichier:Addition.gif

= Sources =

Pour karatsuba : https://www.youtube.com/watch?v=PZ2gdWdKHAA

Pour mieux comprendre la FFT, nous avons utilisé plusieurs sources d'informations :
<ul>
<li> https://www.youtube.com/watch?v=h7apO7q16V0&list=WL&index=1&t=886s </li>
<li> https://fr.wikipedia.org/wiki/Interpolation_polynomiale </li>
</ul>

Algorithmes de multiplications d'entiers et de matrices

2026-05-11T15:16:58Z

Mangala : /* Définition */

= Introduction =

Depuis l'apparition des ordinateurs modernes, une quantité faramineuse de calculs a dû être effectuée. Les progressions technologiques nous poussent à envisager la puissance de calcul comme une ressource qu'il faut optimiser dans les moindres détails. C'est ainsi que l'optimisation des algorithmes de calcul est devenue cruciale, surtout lorsqu'il nous faut effectuer des opérations sur de très grands entiers par exemple.

= Objectif =

L'objectif majeur de ce projet est de comprendre de manière plus approfondie ce qu'est la '''complexité algorithmique'''.
Pour atteindre cet objectif, nous implémenterons plusieurs algorithmes de multiplication qui auront pour but de calculer le produit de grands entiers ou de matrices.

= Point important : complexité =

=== Définition ===
La complexité d'un algorithme est la quantité des ressources qu'il utilise en fonction de la taille des entrées qu'on lui demande de traiter. On peut par exemple se concentrer sur le temps qu'un algorithme prend pour renvoyer un résultat ou sur la mémoire dont il a besoin. Dans le cadre de notre projet, nous nous attarderons plus particulièrement sur la quantité de calcul effectuée en fonction de la taille des entrées, ce qui est par ailleurs étroitement liée à la notion de temps. De manière générale, plus un algorithme doit faire de calcul, plus il est lent. (Attention, toutes les opérations arithmétiques de base ne se valent pas)

De manière plus familière, on dira que la complexité d'un algorithme pourrait s'apparenter à son comportement lorsqu'il doit traiter des données plus ou moins grandes.
Chaque algorithme a une complexité, et on l'exprime par une fonction qui adopte un comportement similaire au nombre de calculs nécessaires en fonction de la taille des entrées.

=== Notation ===
La complexité réelle d'un algorithme peut être décrite par une fonction <math>f(n)</math> représentant le nombre d'opérations effectuées en fonction de la taille <math>n</math> des données d'entrée.

Cependant, afin de simplifier l'étude de cette croissance, on utilise généralement une borne asymptotique notée <math>\mathcal{O}(g(n))</math>, où <math>g(n)</math> est une fonction ayant le même ordre de grandeur que <math>f(n)</math> lorsque <math>n</math> devient grand.

On dit alors que :

<math>
f(n)\in\mathcal{O}(g(n))
</math>

si et seulement s'il existe une constante <math>C>0</math> et un entier <math>n_0</math> tels que :

<math>
\forall n\ge n_0,\ f(n)\le Cg(n)
</math>

Cette notation <math>\mathcal{O}(g(n))</math> permettra de comparer beaucoup plus facilement les algorithmes entre eux.

=== Master Theorem ===

Afin de déterminer la complexité de certains algorithmes récursifs, nous utiliserons le "Master Theorem".

Ce théorème permet d'obtenir directement l'ordre de grandeur de nombreuses relations de récurrence apparaissant dans l'analyse d'algorithmes de type « diviser pour régner », comme l'algorithme de Karatsuba ou celui de Strassen.

La démonstration complète de ce théorème dépasse le cadre de notre projet et nécessite des connaissances mathématiques plus avancées. Nous l'utiliserons donc principalement comme un outil nous permettant de déterminer efficacement la complexité asymptotique des algorithmes étudiés.

=== Graphiques ===

Les complexités étant des fonctions, nous pouvons les représenter par un graphique qui affichera le temps d'exécution (ou nombre d'opérations) en fonction de la taille des entrées.

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:30px; text-align:center;">
[[Fichier:complexite.webp|500px]]
<div><b>Graphiques des complexités</b></div>
</div>
<div style="max-width:800px;">
<p>Ce graphique ci-contre compare les complexités en fonction de la taille des d'entrées.</p>
<p>On comprend ainsi que certaines complexités ne sont pas raisonnable dans la cadre de la multiplication de grands entiers.</p>
<p>C'est pourquoi l'étude de ces algorithmes s'avère nécessaire.</p>
</div>
</div>

=== Exemple ===
L'algorithme naïf d'addition que nous avons tous appris à l'école a une complexité de <math>\mathcal{O}(n)</math>.
Soit n la taille des nombres en entrée, l'algorithme doit faire environ n addition pour arriver au résultat demandé.

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Addition.gif|220px]]
<div><b>Addition naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Comme le montre l'exemple ci-contre, 786 et 467 font 3 chiffres de long donc n sera de 3.</p>
<p>Il nous faudra 3 opérations pour additionner ces deux nombres.</p>
<p>C'est ainsi qu'avec une taille d'entrée n, l'algorithme de l'addition naïve va devoir faire n opérations.</p>
<p>Cette algorithme a donc une complexité <math>f(n) = n</math> qui n'a pas besoin d'être approximée.</p>
<p>Ainsi sa complexité finale sera <math>\mathcal{O}(n)</math>.</p>
</div>
</div>

= Problématique =

Le calcul du produit de deux entiers de manière naïve a une complexité de <math> \mathcal{O}(n^2)</math>, et celui de deux matrices une complexité de <math> \mathcal{O}(n^3)</math>. Afin de mieux comprendre ce qu'est la complexité algorithmique, nous devrons implémenter des algorithmes ayant le même objectif, mais étant plus efficaces. Ces algorithmes s'avèreront plus complexes mais devrait aboutir à un calcul plus rapide du produit demandé.

Nous séparerons notre wiki en deux grandes parties, la première concernera nos recherche sur [[#I - Produit d'entiers|la multiplication d'entiers]], la deuxième sur [[#II - Produit de matrices|la multiplication de matrices]].

= I - Produit d'entiers =

Notre départ commence avec l'algorithme de multiplication d'entier naïf.
En effet il s'agit de l'algorithme de multiplication le plus connu, et nous l'utiliserons comme référence pour le comparer aux futurs algorithmes plus efficaces.
Intéressons nous à sa complexité.

== 1) Nos implémentations des grands entiers ==

Qui dit produit de grands entiers dit implémentation de grands entiers.

Dans le cadre de nos recherches, nous allons devoir implémenter des algorithmes qui vont manipuler des grands entiers.

Nous avons donc choisi de créer deux représentations différentes de ceux-ci (car nous travaillons sur différents langages de programmation), nous permettant à la fois une implémentation simplifié, mais aussi de nous rapprocher d'une implémentation bas niveau.

=== A) En python ===
En python, l'utilisation des "bytes" m'a grandement servi à comprendre comment les entiers étaient manipulés à bas niveau. En effet, un des objectifs secondaires de nos recherches était de manipuler des entiers directement avec leur formes stockées sur l'ordinateur, et non pas avec des int python.
En effet l'utilisation des int python nous aurait permit de passer les étapes de retenues, de signes... D'autant plus que les bytes permettent de stocker un nombre en base 256, ce qui permet de visualiser plus facilement les grands entiers.

La forme finale de la représentation des grands entiers en python sera donc la suivante :

[ signe , bytes , bytes , (...) , bytes ]

Le signe est représenté par un entier, 1 si le nombre est positif, 0 sinon.
Cette configuration rendra plus simple la gestion des signes.

=== B) En C++ ===

En C++, pour avoir une représentation de grand entiers j'ai du définir ma propre structure pour m'affranchir de la limite de taille imposé par les entiers standards: (int32 ou int64). Pour cela, j'ai une structure qui possède l'équivalent d'un array de byte (ce qui nous permet d'être en base 256 au lieu de la base 10 habituelle), et pour traiter le signe j'utilise un booléen, ainsi en mémoire j'ai une structure de n*Octets + 1 octet en taille.

[ bytes , bytes , (...) , bytes ] [ signe ]

Le booléen prend 1 octet de place mais ne touche pas aux octets qui encode le grand entier.
Cette configuration rendra plus simple la gestion des signes dans le cadre des multiplication.

== 2) La multiplication naïve ==

=== A) Fonctionnement ===
Dans le cas de la multiplication d'entiers, nous allons prendre deux nombres qui n'ont pas nécessairement la même longueur. Soit les nombre a et b, de longueur respective <math>n</math> et <math> m </math>.
<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Multiplication.png|220px]]
<div><b>Multiplication naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Prenons deux nombres de longueur 3 et 2, et cherchons combien d'opérations l'algorithme de multiplication naïve va devoir faire pour nous renvoyer leur produit.</p>
<p>Dans un premier temps, on remarque que l'on va devoir multiplier chaque chiffre du nombre du haut par le chiffre des unités du bas, qui est 6. Cela va représenter <math>n</math> opérations. (6x5, 6x1 et 6x4)</p>
<p>Dans un deuxième temps nous constatons que nous allons devoir faire la même chose avec le chiffre des dizaines du nombre du bas. Cela nous ajoute de nouveau <math>n</math> opérations.</p>
<p>On arrive assez facilement à la conclusion que pour faire notre produit, il va nous falloir faire <math>n</math> fois <math>m</math> opérations.</p>
</div>
</div>

Ainsi, la complexité de la multiplication naïve est <math>\mathcal{O}(n^2)</math>.
Il est en de même avec la multiplication naïve récursive.

=== B) Graphique ===
Montrons maintenant sa courbe sur un graphique :

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Multiplicationnaive.png|500px]]
<div><b>Multiplication naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Les points noirs sont des repères pour que les autres courbes aient une forme cohérente.</p>
<p>Ils sont tous sur l'axe des abscisses.</p>
<p>La courbe rouge représente la complexité de la multiplication naïve.</p>
<p>On remarque que la courbe a un visuel très similaire à la fonction <math>f(x) = x^2</math> </p>
</div>
</div>

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Naif_recursif.png|500px]]
<div><b>Multiplication naïve récursive</b></div>
</div>
<div style="max-width:800px;">
<p>La courbe rouge représente la complexité de la multiplication naïve récursive.</p>
<p>Elle sera utilisé pour comparer les complexités entre algorithmes car, comme tous récursifs, elle a été codé avec les mêmes biais d'implémentation qu'eux.</p>
<p>Théoriquement les deux courbes ci-contre ont la même complexité, mais encore une fois, notre implémentation n'est pas parfaitement optimale et donc ne respecte pas de manière minutieuse le Master Theorem.</p>
</div>
</div>

== 3) La multiplication karastuba ==

=== A) Fonctionnement ===

L'algorithme de karatsuba est un algorithme récursif de type diviser pour régner.

L'idée générale de l'algorithme est de passer de 4 multiplication à 3. En effet ces opérations étant moins couteuses, il est préférable d'en ajouter si cela permet d'enlever des multiplications.

L'algorithme de multiplication naif récursif utilise la segmentation des facteurs en deux de manière successive.

Soit <math>x</math> et <math>y</math> deux facteurs, nous avons les égalités suivantes :

<div style="font-size: 20px;">
<math>x = a \times B^{n/2} + b</math>
<math>y = c \times B^{n/2} + d</math>
</div>

Avec <math>a</math> et <math>c</math> les premières moitiés des facteurs <math>x</math> et <math>y</math>,
et <math>b</math> et <math>d</math> les dernières moitiés de ces facteurs ainsi que <math>B</math> la base d'écriture du nombre (Nous sommes en base 256 avec les bytes).

Cette présentation des deux facteurs de notre multiplication n'est que la résultante d'un découpage.
Le [[#Master Theorem|Master Theorem]] nous montre que :

<div style="font-size: 20px;">
<math>T(n) = 4T(n/2) + O(n)</math>
</div>

Puisque nous avons après découpage 4 entiers de longueur <math>n/2</math>.

Ainsi, ce découpage ne permet pas de gagner du temps d'après le [[#Master Theorem|Master Theorem]].

Cependant, l'algorithme de Karatsuba réutilise ce principe en le modifiant, ce qui nous permet de baisser la complexité globale de la multiplication dans son entièreté.

Avec l'écriture ci-dessus des nombres <math>x</math> et <math>y</math>, on peut facilement en déduire l'égalité suivante :

<div style="font-size: 20px;">
<math>x \times y = (ac) \times B^n + (ad + bc) \times B^{n/2} + bd</math>
</div>

On remarque 4 multiplications longues à faire dans cette expression. Les multiplications dont <math>B</math> est l'un des facteurs sont très rapides puisqu'il s'agit de la base dans laquelle nous travaillons. De cela en résulte un décalage plutôt qu'un vrai calcul à faire.

Karatsuba développe une partie de cette expression pour pouvoir négocier une multiplication au prix d'additions et soustractions.

En effet, nous savons déjà que :

<div style="font-size: 20px;">
<math>(a + b)(c + d) = ac + ad + bc + bd</math>
</div>

En manipulant l'égalité nous obtenons :

<div style="font-size: 20px;">
<math>ad + bc = (a + b)(c + d) - ac - bd</math>
</div>

ac et bd ayant déjà été calculé précédemment, il nous reste uniquement la multiplication <math>(a + b)(c + d)</math>.

Nous venons ainsi de calculer <math>ad + bc</math> en seulement une multiplication. C'est la que repose le gain de temps de la méthode Karatsuba par rapport à la multiplication naïve.

En effet, l'algorithme n'effectuera alors plus que 3 multiplications :
<div style="font-size: 20px;">
<math>ac</math>
<math>bd</math>
<math>(a + b)(c + d)</math>
</div>

La relation de récurrence devient donc :
<div style="font-size: 20px;">
<math>T(n)=3T(n/2)+O(n)</math>
</div>

Et le Master Theorem nous dit que :
<div style="font-size: 20px;">
<math>T(n)\in O(n^{\log_2(3)})</math>
</div>

Or <math>\log_2(3)\approx 1.585</math>, donc la complexité de l'algorithme de Karatsuba est de <math> \mathcal{O}(n^{1.585})</math>. Ce qui est bien plus efficace que la multiplication classique, surtout lorsque les facteurs deviennent très grands.

=== B) Graphique ===
<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Karatsuba.png|500px]]
<div><b>Karatsuba</b></div>
</div>
<div style="max-width:800px;">
<p>Sur le graphique ci-contre nous avons utilisé la courbe de la multiplication naïve récursive (rouge) à titre de comparaison.</p>
<p>On remarque graphiquement que Karatsuba (jaune) prend moins de temps à chaque calcul de produit.</p>
<p>On en déduit donc expérimentalement que Karatsuba à une meilleure complexité que la multiplication naïve.</p>
<p>Ainsi nous vérifions donc ce que le Master Theorem prouve, c'est à dire que la complexité de karatsuba est de <math> \mathcal{O}(n^{1.585})</math> </p>
</div>
</div>

== 4) La multiplication toom-cook-3 ==

=== A) Fonctionnement ===

L'objectif est de diviser les grands entiers X et Y en trois blocs de taille égale k.
On les traite alors comme des polynômes de degré 2:

<math>P(z) = X_2 \cdot z^2 + X_1 \cdot z + X_0</math>
<math>Q(z) = Y_2 \cdot z^2 + Y_1 \cdot z + Y_0</math>

On choisit 5 points distincts pour évaluer nos polynômes.
Ce choix de 5 points est crucial car le produit de deux polynômes de degré 2 est un polynôme de degré 4, qui nécessite 5 points pour être défini.
Les points standards sont :

P(0) = X0
P(1) = X0 + X1 + X2
P(-1) = X0 - X1 + X2
P(2) = X0 + 2*X1 + 4*X2
P(inf) = X2

(On procède de manière similaire pour Q.)

Ensuite nous multiplions récursivement chaque points de P et de Q ensemble.
On effectue ainsi 5 multiplications de nombres plus petits au lieu des 9 multiplications requises par la méthode classique.

Après, nous effectuons une interpolation, cela permet de retrouver les 5 coefficients (w_0, w_1, w_2, w_3, w_4) du polynôme produit R(z) à partir des valeurs évaluées calculées précédemment.
On résout un système d'équations linéaires : <math> R(z) = w_4 z^4 + w_3 z^3 + w_2 z^2 + w_1 z + w_0 </math>
Finalement nous pouvons recomposer notre grand entier en positionnant les coefficients w_i aux bons rangs (en les décalant) et à gérer les retenues lors de l'addition finale:
<math>Résultat = w_4 B^{4k} + w_3 B^{3k} + w_2 B^{2k} + w_1 B^k + w_0</math>

=== B) Graphique ===

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Toomcook.png|500px]]
<div><b>Karatsuba</b></div>
</div>
<div style="max-width:800px;">
<p>on a reprit multi récursive (rouge)</p>
<p>on voit que Toom (vert) en dessous de karatsuba (jaune) en dessous de multi classique (rouge)</p>
<p>meilleur complexité</p>
</div>
</div>

== 5) La transformée de Fourier rapide ==

=== A) Fonctionnement ===

La transformation de Fourier rapide étant plus complexe que les autres algorithmes, nous allons essayer d'expliquer son fonctionnement malgré ne pas avoir réussi à l'implémenter.

Il faut comprendre que cet algorithme va considérer les facteurs comme des polynômes.

D'après le théorème de l'unisolvance, il n'existe qu'un seul polynôme de degré inférieur ou égal à <math> n </math> défini par <math>n + 1</math> points distincts. Cela implique non seulement que nous pouvons représenter chaque entier par un polynôme, mais également que si nous pouvons retrouver <math>n + m + 1</math> points (avec <math>n</math> et <math>m</math> la longueur des facteurs) du polynômes issue du produit entre deux facteurs, nous pourrons le retrouver.

Soit un entier quelconque, de forme :

<math>a_n a_{n-1} (...) a_1 a_0</math>

Avec <math>a_i</math>, un chiffre composant le nombre en base 10, qui vaut en réalité dans le nombre : <math>a_i \times 10^i</math>. On peut ainsi l'écrire sous la forme :

<math> P(x) = a_0 + a_1x + a_2x^2 + \dots + a_{n-1}x^{n-1} + a_nx^n </math>

Avec <math>x = 10</math> car nous sommes en base 10, nous obtenons :

<math>P(10) = a_0 + a_1 \times 10 + \dots + a_{n-1}10^{n-1} + a_n10^n </math>

Nous venons ainsi d'écrire notre nombre sous la forme d'un polynôme unique. Pour nous permettre d'évaluer en un nombre suffisant de points, nous allons devoir ajouter des 0 pour la récursion. Il nous faudra ajouter assez de 0 pour atteindre la prochaine puissance de 2 qui sera supérieure ou égale à <math>2n + 1</math>. L'ajout de 0 ne change pas le nombre car <math>0 \times x^n</math> n'ajoute pas de coefficient.

Cet algorithme est récursif et va segmenter en deux parties nos polynômes à chaque récursion. D'un coté les indice paires et d'un coté les impaires.

Ainsi prenons les nombres 1234 et 5678, ces nombres sont respectivement représentés par les polynômes <math> P(x) = 4 + 3x + 2x^2 + x^3 </math> et <math> P(x) = 8 + 7x + 6x^2 + 5^3 </math>. Ce sont des polynômes de degré 3, ainsi leur produit donnera lieu à un polynôme de degré 6. Il nous faudra donc au minimum 7 points d'évaluation pour retrouve ce produit. De ce fait, en les représentant de la manière suivante :

<math>[4, 3, 2, 1, 0, 0, 0, 0]</math>
<math>[8, 7, 6, 5, 0, 0, 0, 0]</math>

Nous aurons assez de récursions possible pour les évaluer en un nombre suffisant de points différents car nous auront 3 récursions à faire pour atteindre notre cas de base. A chaque récursion, nous allons diviser nos polynômes en deux parties ce qui nous fait 8 feuilles à la dernière récursion.

En effet à chaque étape de la récursion nous allons séparer nos polynômes en deux tel que :

<math>P(x)=P_{\text{pair}}(x^2) + x \cdot P_{\text{impair}}(x^2)</math>

Durant les récursions, nous segmentons les polynômes mais ne les évaluons pas. C'est à la remonté des récursions que nous allons réellement évaluer nos polynômes. Lorsque l'on atteint notre cas de base, c'est à dire des polynômes de degré 0, nous remarquons qu'ils sont constants, nous n'avons donc pas besoin de les évaluer. En effet, peut importe le point en lequel nous voudrons l'évaluer, le polynôme renverra la constante. Nous la renvoyons donc seule.
Ensuite commence la remontée des récursions. A l'étape 1 de notre remontée nous allons reformer le polynôme précédemment séparé pour obtenir un polynôme de degré 1. Puis, nous évaluons ce polynôme avec les racines seconde de l'unité. Nous faisons à nouveau remonté les évaluations et recombinons à nouveau le polynôme qui sera ainsi de degré 2.
Nous l'évaluons maintenant avec les racines 4eme de l'unité. A chaque évaluation, nous réutilisons les résultats précédents, cela nous est permit par les racines de l'unité qui ont une structure récursive exploitable.

Finalement, nous arrivons à la fin de notre FFT, avec une représentation fréquentielle de la forme :

<math> [P(W_0), P(W_1), (...), P(W_n-1), P(W_n)] </math>

Cette représentation fréquentielle n'est autre que les évaluations du polynôme P aux racines nièmes de l'unité. Nous avons donc maintenant au minimum <math>2n+1</math> évaluations des polynômes facteurs. Il nous faut maintenant trouver les évaluations du produit final, c'est à dire les évaluations concernant le polynôme qui sera issue de la multiplication. On pourra ainsi le retrouver.

Soit <math>C</math> un polynome tel que <math> C = A \times B </math>, alors on a :

<math> C(x) = A(x) \times B(x) </math>

Ainsi on en déduit que <math> C(W_n^k) = A(W_n^k) \times B(W_n^k) </math>

On comprend donc que <math>FFT(C) = FFT(A) \times FFT(B)</math>

Il faut préciser que l'on fait le produit de FFT(A) et FFT(B) terme à terme, soit évaluation par évaluation.

Une fois en possession de <math>FFT(C)</math>, qui n'est autre que l'évaluation de notre polynôme final en un nombre suffisant de points pour le retrouver, nous pouvons faire l'<math>IFFT(FFT(C))</math>, qui va nous permettre de retrouver les coefficients de notre polynôme en faisant l'exacte inverse de la FFT.

Une fois les coefficients retrouvés, il nous suffit de gérer les retenues, et nous retrouvons un entier de la forme : <math>a_0 a_1 (...) a_{n-1} a_n</math>

=== B) Graphique ===

Intéressons nous maintenant à la complexité de l'algorithme utilisant la transformée de Fourier rapide. On sait que l'algorithme passe par 5 étapes importantes :

<ul>
<li>Etape 1 : Ecrire les deux facteurs sous la forme de polynômes</li>
<li>Etape 2 : Effectuer la <math>FFT</math> des deux polynômes</li>
<li>Etape 3 : Faire le produit terme à terme des <math>FFT</math> obtenues</li>
<li>Etape 4 : Faire l'<math>IFFT</math> du produit</li>
<li>Etape 5 : Gérer les retenues et écrire le nombre qui en découle</li>
</ul>

Or, parmi toutes ces étapes, certaines sont négligeable comme l'étape 1 et 5.

Pour connaitre la complexité de l'algorithme, additionnons les complexités des étapes restantes :

Une <math>FFT</math> a une complexité de <math>\mathcal{O}(n\times logn)</math> car elle fait <math>n</math> évaluation sur <math> log(n)</math> récursions. Dans le cadre de notre algorithme, nous devons faire la <math>FFT</math> de nos deux facteurs. Soit <math>2\times \mathcal{O}(n\times logn)</math>.

Pour le produit terme à terme, nous faisons naturellement <math>n</math> opérations.

Pour finir, l'<math>IFFT</math> a la même complexité que la <math>FFT</math>. Dans le cadre de notre algorithme nous l'emploierons qu'une seule fois, ce qui fait une complexité de <math>\mathcal{O}(n\times logn)</math>.

Après addition de toutes ces complexités, nous obtenons la complexité réelle de <math>3\mathcal{O}(n\times logn) + \mathcal{O}(n)</math>.

D'après le Master Theorem, nous avons donc <math> f(n) = 3(n\times logn)+n </math>, cherchons <math>f(n)\in\mathcal{O}(g(n))</math> :

Nous pouvons ignorer les expressions linéaires ainsi que les constantes multiplicatrices, nous obtenons donc <math>\mathcal{O}(g(n)) = \mathcal{O}(n \times log n)</math>.

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:30px; text-align:center;">
[[Fichier:FFT_image.webp|500px]]
<div><b>Graphiques des complexités</b></div>
</div>
<div style="max-width:800px;">
<p>Ce graphique ci-contre ne provient pas du fruit de nos recherches personnelles mais </p>
<p>On comprend ainsi que certaines complexités ne sont pas raisonnable dans la cadre de la multiplication de grands entiers.</p>
<p>C'est pourquoi l'étude de ces algorithmes s'avère nécessaire.</p>
</div>
</div>

= II - Produit de matrices =

== 1.1) naïve ==

La multiplication naïve de matrice requiert d'avoir des tailles de lignes/colonne semblable, ensuite pour chaque membre de la matrice résultat, on doit multiplier les composantes ligne de la première matrice par les composantes colonne de la deuxième et le tout sommé.

On en déduit la formule suivante:
<math>C_{i,j} = \sum_{k=1}^{n} (A_{i,k} \times B_{k,j})</math>

Et visuellement:

[[Fichier:Matricenaive.jpeg]]

On a donc un algorithme d'ordre de complexité <math>\mathcal{O}(g(n))</math>

== 1.2) naïve récursive ==

Dans un premier temps on doit découper nos deux matrices en quatres sous matrices de plus petite taille.
<math>A = \begin{pmatrix} A_{11} & A_{12} \ A_{21} & A_{22} \end{pmatrix}</math>
<math>B = \begin{pmatrix} B_{11} & B_{12} \ B_{21} & B_{22} \end{pmatrix}</math>

Ensuite on vient calculer la matrice résultat.
<math>C_{11} = (A_{11} \times B_{11}) + (A_{12} \times B_{21})</math>
<math>C_{12} = (A_{11} \times B_{12}) + (A_{12} \times B_{22})</math>
<math>C_{21} = (A_{21} \times B_{11}) + (A_{22} \times B_{21})</math>
<math>C_{22} = (A_{21} \times B_{12}) + (A_{22} \times B_{22})</math>

Le côté récursif est utile que pour les matrices de tailles <= 32 (32 valeurs stockées dedans),
si on est au dessus de cette taille alors on divisera à nouveau nos matrices en quatres.
On aura 8 multiplications mais de plus petite taille au final.

== 2) strassen ==

=== A) Fonctionnement ===

Strassen consiste à définir 7 produits intermédiaires qui, par des jeux de sommes et de différences, permettent de reconstruire les quadrants de la matrice résultante. On passe ainsi d'une complexité de O(n^3) à environ O(n^2.81)

=== B) Graphique ===

On voit bien la différence de complexité sur la multiplication de grande matrice entre l'approche naïve et l'approche récursive qui est beaucoup plus rapide.

[[Fichier:Analyse matrices.png]]

= Conclusion =

( A FAIRE )

= Mentions =

Le premier gif est le résultat du travail de 'Walké', licence ci-contre : https://fr.wikipedia.org/wiki/Fichier:Addition.gif

= Sources =

Pour karatsuba : https://www.youtube.com/watch?v=PZ2gdWdKHAA

Pour mieux comprendre la FFT, nous avons utilisé plusieurs sources d'informations :
<ul>
<li> https://www.youtube.com/watch?v=h7apO7q16V0&list=WL&index=1&t=886s </li>
<li> https://fr.wikipedia.org/wiki/Interpolation_polynomiale </li>
</ul>

Algorithmes de multiplications d'entiers et de matrices

2026-05-11T15:16:07Z

Mangala : /* Définition */

= Introduction =

Depuis l'apparition des ordinateurs modernes, une quantité faramineuse de calculs a dû être effectuée. Les progressions technologiques nous poussent à envisager la puissance de calcul comme une ressource qu'il faut optimiser dans les moindres détails. C'est ainsi que l'optimisation des algorithmes de calcul est devenue cruciale, surtout lorsqu'il nous faut effectuer des opérations sur de très grands entiers par exemple.

= Objectif =

L'objectif majeur de ce projet est de comprendre de manière plus approfondie ce qu'est la '''complexité algorithmique'''.
Pour atteindre cet objectif, nous implémenterons plusieurs algorithmes de multiplication qui auront pour but de calculer le produit de grands entiers ou de matrices.

= Point important : complexité =

=== Définition ===
La complexité d'un algorithme est la quantité des ressources qu'il utilise en fonction de la taille des entrées qu'on lui demande de traiter. On peut par exemple se concentrer sur le temps qu'un algorithme prend pour renvoyer un résultat ou sur la mémoire dont il a besoin. Dans le cadre de notre projet, nous nous attarderons plus particulièrement sur la quantité de calcul effectuée en fonction de la taille des entrées, ce qui est par ailleurs étroitement liée à la notion de temps. De manière générale, plus un algorithme doit faire de calcul, plus il est lent. (Attention, toutes les opérations arithmétiques de base ne se valent pas)

De manière plus familière, on dira que la complexité d'un algorithme pourrait s'apparenter à son comportement lorsqu'il doit traiter des données plus ou moins grandes.
Chaque algorithme a une complexité, et on l'exprime par une fonction qui adopte un comportement similaire au nombre de calcul nécessaire en fonction de la taille des entrées.

=== Notation ===
La complexité réelle d'un algorithme peut être décrite par une fonction <math>f(n)</math> représentant le nombre d'opérations effectuées en fonction de la taille <math>n</math> des données d'entrée.

Cependant, afin de simplifier l'étude de cette croissance, on utilise généralement une borne asymptotique notée <math>\mathcal{O}(g(n))</math>, où <math>g(n)</math> est une fonction ayant le même ordre de grandeur que <math>f(n)</math> lorsque <math>n</math> devient grand.

On dit alors que :

<math>
f(n)\in\mathcal{O}(g(n))
</math>

si et seulement s'il existe une constante <math>C>0</math> et un entier <math>n_0</math> tels que :

<math>
\forall n\ge n_0,\ f(n)\le Cg(n)
</math>

Cette notation <math>\mathcal{O}(g(n))</math> permettra de comparer beaucoup plus facilement les algorithmes entre eux.

=== Master Theorem ===

Afin de déterminer la complexité de certains algorithmes récursifs, nous utiliserons le "Master Theorem".

Ce théorème permet d'obtenir directement l'ordre de grandeur de nombreuses relations de récurrence apparaissant dans l'analyse d'algorithmes de type « diviser pour régner », comme l'algorithme de Karatsuba ou celui de Strassen.

La démonstration complète de ce théorème dépasse le cadre de notre projet et nécessite des connaissances mathématiques plus avancées. Nous l'utiliserons donc principalement comme un outil nous permettant de déterminer efficacement la complexité asymptotique des algorithmes étudiés.

=== Graphiques ===

Les complexités étant des fonctions, nous pouvons les représenter par un graphique qui affichera le temps d'exécution (ou nombre d'opérations) en fonction de la taille des entrées.

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:30px; text-align:center;">
[[Fichier:complexite.webp|500px]]
<div><b>Graphiques des complexités</b></div>
</div>
<div style="max-width:800px;">
<p>Ce graphique ci-contre compare les complexités en fonction de la taille des d'entrées.</p>
<p>On comprend ainsi que certaines complexités ne sont pas raisonnable dans la cadre de la multiplication de grands entiers.</p>
<p>C'est pourquoi l'étude de ces algorithmes s'avère nécessaire.</p>
</div>
</div>

=== Exemple ===
L'algorithme naïf d'addition que nous avons tous appris à l'école a une complexité de <math>\mathcal{O}(n)</math>.
Soit n la taille des nombres en entrée, l'algorithme doit faire environ n addition pour arriver au résultat demandé.

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Addition.gif|220px]]
<div><b>Addition naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Comme le montre l'exemple ci-contre, 786 et 467 font 3 chiffres de long donc n sera de 3.</p>
<p>Il nous faudra 3 opérations pour additionner ces deux nombres.</p>
<p>C'est ainsi qu'avec une taille d'entrée n, l'algorithme de l'addition naïve va devoir faire n opérations.</p>
<p>Cette algorithme a donc une complexité <math>f(n) = n</math> qui n'a pas besoin d'être approximée.</p>
<p>Ainsi sa complexité finale sera <math>\mathcal{O}(n)</math>.</p>
</div>
</div>

= Problématique =

Le calcul du produit de deux entiers de manière naïve a une complexité de <math> \mathcal{O}(n^2)</math>, et celui de deux matrices une complexité de <math> \mathcal{O}(n^3)</math>. Afin de mieux comprendre ce qu'est la complexité algorithmique, nous devrons implémenter des algorithmes ayant le même objectif, mais étant plus efficaces. Ces algorithmes s'avèreront plus complexes mais devrait aboutir à un calcul plus rapide du produit demandé.

Nous séparerons notre wiki en deux grandes parties, la première concernera nos recherche sur [[#I - Produit d'entiers|la multiplication d'entiers]], la deuxième sur [[#II - Produit de matrices|la multiplication de matrices]].

= I - Produit d'entiers =

Notre départ commence avec l'algorithme de multiplication d'entier naïf.
En effet il s'agit de l'algorithme de multiplication le plus connu, et nous l'utiliserons comme référence pour le comparer aux futurs algorithmes plus efficaces.
Intéressons nous à sa complexité.

== 1) Nos implémentations des grands entiers ==

Qui dit produit de grands entiers dit implémentation de grands entiers.

Dans le cadre de nos recherches, nous allons devoir implémenter des algorithmes qui vont manipuler des grands entiers.

Nous avons donc choisi de créer deux représentations différentes de ceux-ci (car nous travaillons sur différents langages de programmation), nous permettant à la fois une implémentation simplifié, mais aussi de nous rapprocher d'une implémentation bas niveau.

=== A) En python ===
En python, l'utilisation des "bytes" m'a grandement servi à comprendre comment les entiers étaient manipulés à bas niveau. En effet, un des objectifs secondaires de nos recherches était de manipuler des entiers directement avec leur formes stockées sur l'ordinateur, et non pas avec des int python.
En effet l'utilisation des int python nous aurait permit de passer les étapes de retenues, de signes... D'autant plus que les bytes permettent de stocker un nombre en base 256, ce qui permet de visualiser plus facilement les grands entiers.

La forme finale de la représentation des grands entiers en python sera donc la suivante :

[ signe , bytes , bytes , (...) , bytes ]

Le signe est représenté par un entier, 1 si le nombre est positif, 0 sinon.
Cette configuration rendra plus simple la gestion des signes.

=== B) En C++ ===

En C++, pour avoir une représentation de grand entiers j'ai du définir ma propre structure pour m'affranchir de la limite de taille imposé par les entiers standards: (int32 ou int64). Pour cela, j'ai une structure qui possède l'équivalent d'un array de byte (ce qui nous permet d'être en base 256 au lieu de la base 10 habituelle), et pour traiter le signe j'utilise un booléen, ainsi en mémoire j'ai une structure de n*Octets + 1 octet en taille.

[ bytes , bytes , (...) , bytes ] [ signe ]

Le booléen prend 1 octet de place mais ne touche pas aux octets qui encode le grand entier.
Cette configuration rendra plus simple la gestion des signes dans le cadre des multiplication.

== 2) La multiplication naïve ==

=== A) Fonctionnement ===
Dans le cas de la multiplication d'entiers, nous allons prendre deux nombres qui n'ont pas nécessairement la même longueur. Soit les nombre a et b, de longueur respective <math>n</math> et <math> m </math>.
<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Multiplication.png|220px]]
<div><b>Multiplication naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Prenons deux nombres de longueur 3 et 2, et cherchons combien d'opérations l'algorithme de multiplication naïve va devoir faire pour nous renvoyer leur produit.</p>
<p>Dans un premier temps, on remarque que l'on va devoir multiplier chaque chiffre du nombre du haut par le chiffre des unités du bas, qui est 6. Cela va représenter <math>n</math> opérations. (6x5, 6x1 et 6x4)</p>
<p>Dans un deuxième temps nous constatons que nous allons devoir faire la même chose avec le chiffre des dizaines du nombre du bas. Cela nous ajoute de nouveau <math>n</math> opérations.</p>
<p>On arrive assez facilement à la conclusion que pour faire notre produit, il va nous falloir faire <math>n</math> fois <math>m</math> opérations.</p>
</div>
</div>

Ainsi, la complexité de la multiplication naïve est <math>\mathcal{O}(n^2)</math>.
Il est en de même avec la multiplication naïve récursive.

=== B) Graphique ===
Montrons maintenant sa courbe sur un graphique :

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Multiplicationnaive.png|500px]]
<div><b>Multiplication naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Les points noirs sont des repères pour que les autres courbes aient une forme cohérente.</p>
<p>Ils sont tous sur l'axe des abscisses.</p>
<p>La courbe rouge représente la complexité de la multiplication naïve.</p>
<p>On remarque que la courbe a un visuel très similaire à la fonction <math>f(x) = x^2</math> </p>
</div>
</div>

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Naif_recursif.png|500px]]
<div><b>Multiplication naïve récursive</b></div>
</div>
<div style="max-width:800px;">
<p>La courbe rouge représente la complexité de la multiplication naïve récursive.</p>
<p>Elle sera utilisé pour comparer les complexités entre algorithmes car, comme tous récursifs, elle a été codé avec les mêmes biais d'implémentation qu'eux.</p>
<p>Théoriquement les deux courbes ci-contre ont la même complexité, mais encore une fois, notre implémentation n'est pas parfaitement optimale et donc ne respecte pas de manière minutieuse le Master Theorem.</p>
</div>
</div>

== 3) La multiplication karastuba ==

=== A) Fonctionnement ===

L'algorithme de karatsuba est un algorithme récursif de type diviser pour régner.

L'idée générale de l'algorithme est de passer de 4 multiplication à 3. En effet ces opérations étant moins couteuses, il est préférable d'en ajouter si cela permet d'enlever des multiplications.

L'algorithme de multiplication naif récursif utilise la segmentation des facteurs en deux de manière successive.

Soit <math>x</math> et <math>y</math> deux facteurs, nous avons les égalités suivantes :

<div style="font-size: 20px;">
<math>x = a \times B^{n/2} + b</math>
<math>y = c \times B^{n/2} + d</math>
</div>

Avec <math>a</math> et <math>c</math> les premières moitiés des facteurs <math>x</math> et <math>y</math>,
et <math>b</math> et <math>d</math> les dernières moitiés de ces facteurs ainsi que <math>B</math> la base d'écriture du nombre (Nous sommes en base 256 avec les bytes).

Cette présentation des deux facteurs de notre multiplication n'est que la résultante d'un découpage.
Le [[#Master Theorem|Master Theorem]] nous montre que :

<div style="font-size: 20px;">
<math>T(n) = 4T(n/2) + O(n)</math>
</div>

Puisque nous avons après découpage 4 entiers de longueur <math>n/2</math>.

Ainsi, ce découpage ne permet pas de gagner du temps d'après le [[#Master Theorem|Master Theorem]].

Cependant, l'algorithme de Karatsuba réutilise ce principe en le modifiant, ce qui nous permet de baisser la complexité globale de la multiplication dans son entièreté.

Avec l'écriture ci-dessus des nombres <math>x</math> et <math>y</math>, on peut facilement en déduire l'égalité suivante :

<div style="font-size: 20px;">
<math>x \times y = (ac) \times B^n + (ad + bc) \times B^{n/2} + bd</math>
</div>

On remarque 4 multiplications longues à faire dans cette expression. Les multiplications dont <math>B</math> est l'un des facteurs sont très rapides puisqu'il s'agit de la base dans laquelle nous travaillons. De cela en résulte un décalage plutôt qu'un vrai calcul à faire.

Karatsuba développe une partie de cette expression pour pouvoir négocier une multiplication au prix d'additions et soustractions.

En effet, nous savons déjà que :

<div style="font-size: 20px;">
<math>(a + b)(c + d) = ac + ad + bc + bd</math>
</div>

En manipulant l'égalité nous obtenons :

<div style="font-size: 20px;">
<math>ad + bc = (a + b)(c + d) - ac - bd</math>
</div>

ac et bd ayant déjà été calculé précédemment, il nous reste uniquement la multiplication <math>(a + b)(c + d)</math>.

Nous venons ainsi de calculer <math>ad + bc</math> en seulement une multiplication. C'est la que repose le gain de temps de la méthode Karatsuba par rapport à la multiplication naïve.

En effet, l'algorithme n'effectuera alors plus que 3 multiplications :
<div style="font-size: 20px;">
<math>ac</math>
<math>bd</math>
<math>(a + b)(c + d)</math>
</div>

La relation de récurrence devient donc :
<div style="font-size: 20px;">
<math>T(n)=3T(n/2)+O(n)</math>
</div>

Et le Master Theorem nous dit que :
<div style="font-size: 20px;">
<math>T(n)\in O(n^{\log_2(3)})</math>
</div>

Or <math>\log_2(3)\approx 1.585</math>, donc la complexité de l'algorithme de Karatsuba est de <math> \mathcal{O}(n^{1.585})</math>. Ce qui est bien plus efficace que la multiplication classique, surtout lorsque les facteurs deviennent très grands.

=== B) Graphique ===
<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Karatsuba.png|500px]]
<div><b>Karatsuba</b></div>
</div>
<div style="max-width:800px;">
<p>Sur le graphique ci-contre nous avons utilisé la courbe de la multiplication naïve récursive (rouge) à titre de comparaison.</p>
<p>On remarque graphiquement que Karatsuba (jaune) prend moins de temps à chaque calcul de produit.</p>
<p>On en déduit donc expérimentalement que Karatsuba à une meilleure complexité que la multiplication naïve.</p>
<p>Ainsi nous vérifions donc ce que le Master Theorem prouve, c'est à dire que la complexité de karatsuba est de <math> \mathcal{O}(n^{1.585})</math> </p>
</div>
</div>

== 4) La multiplication toom-cook-3 ==

=== A) Fonctionnement ===

L'objectif est de diviser les grands entiers X et Y en trois blocs de taille égale k.
On les traite alors comme des polynômes de degré 2:

<math>P(z) = X_2 \cdot z^2 + X_1 \cdot z + X_0</math>
<math>Q(z) = Y_2 \cdot z^2 + Y_1 \cdot z + Y_0</math>

On choisit 5 points distincts pour évaluer nos polynômes.
Ce choix de 5 points est crucial car le produit de deux polynômes de degré 2 est un polynôme de degré 4, qui nécessite 5 points pour être défini.
Les points standards sont :

P(0) = X0
P(1) = X0 + X1 + X2
P(-1) = X0 - X1 + X2
P(2) = X0 + 2*X1 + 4*X2
P(inf) = X2

(On procède de manière similaire pour Q.)

Ensuite nous multiplions récursivement chaque points de P et de Q ensemble.
On effectue ainsi 5 multiplications de nombres plus petits au lieu des 9 multiplications requises par la méthode classique.

Après, nous effectuons une interpolation, cela permet de retrouver les 5 coefficients (w_0, w_1, w_2, w_3, w_4) du polynôme produit R(z) à partir des valeurs évaluées calculées précédemment.
On résout un système d'équations linéaires : <math> R(z) = w_4 z^4 + w_3 z^3 + w_2 z^2 + w_1 z + w_0 </math>
Finalement nous pouvons recomposer notre grand entier en positionnant les coefficients w_i aux bons rangs (en les décalant) et à gérer les retenues lors de l'addition finale:
<math>Résultat = w_4 B^{4k} + w_3 B^{3k} + w_2 B^{2k} + w_1 B^k + w_0</math>

=== B) Graphique ===

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Toomcook.png|500px]]
<div><b>Karatsuba</b></div>
</div>
<div style="max-width:800px;">
<p>on a reprit multi récursive (rouge)</p>
<p>on voit que Toom (vert) en dessous de karatsuba (jaune) en dessous de multi classique (rouge)</p>
<p>meilleur complexité</p>
</div>
</div>

== 5) La transformée de Fourier rapide ==

=== A) Fonctionnement ===

La transformation de Fourier rapide étant plus complexe que les autres algorithmes, nous allons essayer d'expliquer son fonctionnement malgré ne pas avoir réussi à l'implémenter.

Il faut comprendre que cet algorithme va considérer les facteurs comme des polynômes.

D'après le théorème de l'unisolvance, il n'existe qu'un seul polynôme de degré inférieur ou égal à <math> n </math> défini par <math>n + 1</math> points distincts. Cela implique non seulement que nous pouvons représenter chaque entier par un polynôme, mais également que si nous pouvons retrouver <math>n + m + 1</math> points (avec <math>n</math> et <math>m</math> la longueur des facteurs) du polynômes issue du produit entre deux facteurs, nous pourrons le retrouver.

Soit un entier quelconque, de forme :

<math>a_n a_{n-1} (...) a_1 a_0</math>

Avec <math>a_i</math>, un chiffre composant le nombre en base 10, qui vaut en réalité dans le nombre : <math>a_i \times 10^i</math>. On peut ainsi l'écrire sous la forme :

<math> P(x) = a_0 + a_1x + a_2x^2 + \dots + a_{n-1}x^{n-1} + a_nx^n </math>

Avec <math>x = 10</math> car nous sommes en base 10, nous obtenons :

<math>P(10) = a_0 + a_1 \times 10 + \dots + a_{n-1}10^{n-1} + a_n10^n </math>

Nous venons ainsi d'écrire notre nombre sous la forme d'un polynôme unique. Pour nous permettre d'évaluer en un nombre suffisant de points, nous allons devoir ajouter des 0 pour la récursion. Il nous faudra ajouter assez de 0 pour atteindre la prochaine puissance de 2 qui sera supérieure ou égale à <math>2n + 1</math>. L'ajout de 0 ne change pas le nombre car <math>0 \times x^n</math> n'ajoute pas de coefficient.

Cet algorithme est récursif et va segmenter en deux parties nos polynômes à chaque récursion. D'un coté les indice paires et d'un coté les impaires.

Ainsi prenons les nombres 1234 et 5678, ces nombres sont respectivement représentés par les polynômes <math> P(x) = 4 + 3x + 2x^2 + x^3 </math> et <math> P(x) = 8 + 7x + 6x^2 + 5^3 </math>. Ce sont des polynômes de degré 3, ainsi leur produit donnera lieu à un polynôme de degré 6. Il nous faudra donc au minimum 7 points d'évaluation pour retrouve ce produit. De ce fait, en les représentant de la manière suivante :

<math>[4, 3, 2, 1, 0, 0, 0, 0]</math>
<math>[8, 7, 6, 5, 0, 0, 0, 0]</math>

Nous aurons assez de récursions possible pour les évaluer en un nombre suffisant de points différents car nous auront 3 récursions à faire pour atteindre notre cas de base. A chaque récursion, nous allons diviser nos polynômes en deux parties ce qui nous fait 8 feuilles à la dernière récursion.

En effet à chaque étape de la récursion nous allons séparer nos polynômes en deux tel que :

<math>P(x)=P_{\text{pair}}(x^2) + x \cdot P_{\text{impair}}(x^2)</math>

Durant les récursions, nous segmentons les polynômes mais ne les évaluons pas. C'est à la remonté des récursions que nous allons réellement évaluer nos polynômes. Lorsque l'on atteint notre cas de base, c'est à dire des polynômes de degré 0, nous remarquons qu'ils sont constants, nous n'avons donc pas besoin de les évaluer. En effet, peut importe le point en lequel nous voudrons l'évaluer, le polynôme renverra la constante. Nous la renvoyons donc seule.
Ensuite commence la remontée des récursions. A l'étape 1 de notre remontée nous allons reformer le polynôme précédemment séparé pour obtenir un polynôme de degré 1. Puis, nous évaluons ce polynôme avec les racines seconde de l'unité. Nous faisons à nouveau remonté les évaluations et recombinons à nouveau le polynôme qui sera ainsi de degré 2.
Nous l'évaluons maintenant avec les racines 4eme de l'unité. A chaque évaluation, nous réutilisons les résultats précédents, cela nous est permit par les racines de l'unité qui ont une structure récursive exploitable.

Finalement, nous arrivons à la fin de notre FFT, avec une représentation fréquentielle de la forme :

<math> [P(W_0), P(W_1), (...), P(W_n-1), P(W_n)] </math>

Cette représentation fréquentielle n'est autre que les évaluations du polynôme P aux racines nièmes de l'unité. Nous avons donc maintenant au minimum <math>2n+1</math> évaluations des polynômes facteurs. Il nous faut maintenant trouver les évaluations du produit final, c'est à dire les évaluations concernant le polynôme qui sera issue de la multiplication. On pourra ainsi le retrouver.

Soit <math>C</math> un polynome tel que <math> C = A \times B </math>, alors on a :

<math> C(x) = A(x) \times B(x) </math>

Ainsi on en déduit que <math> C(W_n^k) = A(W_n^k) \times B(W_n^k) </math>

On comprend donc que <math>FFT(C) = FFT(A) \times FFT(B)</math>

Il faut préciser que l'on fait le produit de FFT(A) et FFT(B) terme à terme, soit évaluation par évaluation.

Une fois en possession de <math>FFT(C)</math>, qui n'est autre que l'évaluation de notre polynôme final en un nombre suffisant de points pour le retrouver, nous pouvons faire l'<math>IFFT(FFT(C))</math>, qui va nous permettre de retrouver les coefficients de notre polynôme en faisant l'exacte inverse de la FFT.

Une fois les coefficients retrouvés, il nous suffit de gérer les retenues, et nous retrouvons un entier de la forme : <math>a_0 a_1 (...) a_{n-1} a_n</math>

=== B) Graphique ===

Intéressons nous maintenant à la complexité de l'algorithme utilisant la transformée de Fourier rapide. On sait que l'algorithme passe par 5 étapes importantes :

<ul>
<li>Etape 1 : Ecrire les deux facteurs sous la forme de polynômes</li>
<li>Etape 2 : Effectuer la <math>FFT</math> des deux polynômes</li>
<li>Etape 3 : Faire le produit terme à terme des <math>FFT</math> obtenues</li>
<li>Etape 4 : Faire l'<math>IFFT</math> du produit</li>
<li>Etape 5 : Gérer les retenues et écrire le nombre qui en découle</li>
</ul>

Or, parmi toutes ces étapes, certaines sont négligeable comme l'étape 1 et 5.

Pour connaitre la complexité de l'algorithme, additionnons les complexités des étapes restantes :

Une <math>FFT</math> a une complexité de <math>\mathcal{O}(n\times logn)</math> car elle fait <math>n</math> évaluation sur <math> log(n)</math> récursions. Dans le cadre de notre algorithme, nous devons faire la <math>FFT</math> de nos deux facteurs. Soit <math>2\times \mathcal{O}(n\times logn)</math>.

Pour le produit terme à terme, nous faisons naturellement <math>n</math> opérations.

Pour finir, l'<math>IFFT</math> a la même complexité que la <math>FFT</math>. Dans le cadre de notre algorithme nous l'emploierons qu'une seule fois, ce qui fait une complexité de <math>\mathcal{O}(n\times logn)</math>.

Après addition de toutes ces complexités, nous obtenons la complexité réelle de <math>3\mathcal{O}(n\times logn) + \mathcal{O}(n)</math>.

D'après le Master Theorem, nous avons donc <math> f(n) = 3(n\times logn)+n </math>, cherchons <math>f(n)\in\mathcal{O}(g(n))</math> :

Nous pouvons ignorer les expressions linéaires ainsi que les constantes multiplicatrices, nous obtenons donc <math>\mathcal{O}(g(n)) = \mathcal{O}(n \times log n)</math>.

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:30px; text-align:center;">
[[Fichier:FFT_image.webp|500px]]
<div><b>Graphiques des complexités</b></div>
</div>
<div style="max-width:800px;">
<p>Ce graphique ci-contre ne provient pas du fruit de nos recherches personnelles mais </p>
<p>On comprend ainsi que certaines complexités ne sont pas raisonnable dans la cadre de la multiplication de grands entiers.</p>
<p>C'est pourquoi l'étude de ces algorithmes s'avère nécessaire.</p>
</div>
</div>

= II - Produit de matrices =

== 1.1) naïve ==

La multiplication naïve de matrice requiert d'avoir des tailles de lignes/colonne semblable, ensuite pour chaque membre de la matrice résultat, on doit multiplier les composantes ligne de la première matrice par les composantes colonne de la deuxième et le tout sommé.

On en déduit la formule suivante:
<math>C_{i,j} = \sum_{k=1}^{n} (A_{i,k} \times B_{k,j})</math>

Et visuellement:

[[Fichier:Matricenaive.jpeg]]

On a donc un algorithme d'ordre de complexité <math>\mathcal{O}(g(n))</math>

== 1.2) naïve récursive ==

Dans un premier temps on doit découper nos deux matrices en quatres sous matrices de plus petite taille.
<math>A = \begin{pmatrix} A_{11} & A_{12} \ A_{21} & A_{22} \end{pmatrix}</math>
<math>B = \begin{pmatrix} B_{11} & B_{12} \ B_{21} & B_{22} \end{pmatrix}</math>

Ensuite on vient calculer la matrice résultat.
<math>C_{11} = (A_{11} \times B_{11}) + (A_{12} \times B_{21})</math>
<math>C_{12} = (A_{11} \times B_{12}) + (A_{12} \times B_{22})</math>
<math>C_{21} = (A_{21} \times B_{11}) + (A_{22} \times B_{21})</math>
<math>C_{22} = (A_{21} \times B_{12}) + (A_{22} \times B_{22})</math>

Le côté récursif est utile que pour les matrices de tailles <= 32 (32 valeurs stockées dedans),
si on est au dessus de cette taille alors on divisera à nouveau nos matrices en quatres.
On aura 8 multiplications mais de plus petite taille au final.

== 2) strassen ==

=== A) Fonctionnement ===

Strassen consiste à définir 7 produits intermédiaires qui, par des jeux de sommes et de différences, permettent de reconstruire les quadrants de la matrice résultante. On passe ainsi d'une complexité de O(n^3) à environ O(n^2.81)

=== B) Graphique ===

On voit bien la différence de complexité sur la multiplication de grande matrice entre l'approche naïve et l'approche récursive qui est beaucoup plus rapide.

[[Fichier:Analyse matrices.png]]

= Conclusion =

( A FAIRE )

= Mentions =

Le premier gif est le résultat du travail de 'Walké', licence ci-contre : https://fr.wikipedia.org/wiki/Fichier:Addition.gif

= Sources =

Pour karatsuba : https://www.youtube.com/watch?v=PZ2gdWdKHAA

Pour mieux comprendre la FFT, nous avons utilisé plusieurs sources d'informations :
<ul>
<li> https://www.youtube.com/watch?v=h7apO7q16V0&list=WL&index=1&t=886s </li>
<li> https://fr.wikipedia.org/wiki/Interpolation_polynomiale </li>
</ul>

Algorithmes de multiplications d'entiers et de matrices

2026-05-11T15:15:36Z

Mangala : /* Définition */

= Introduction =

Depuis l'apparition des ordinateurs modernes, une quantité faramineuse de calculs a dû être effectuée. Les progressions technologiques nous poussent à envisager la puissance de calcul comme une ressource qu'il faut optimiser dans les moindres détails. C'est ainsi que l'optimisation des algorithmes de calcul est devenue cruciale, surtout lorsqu'il nous faut effectuer des opérations sur de très grands entiers par exemple.

= Objectif =

L'objectif majeur de ce projet est de comprendre de manière plus approfondie ce qu'est la '''complexité algorithmique'''.
Pour atteindre cet objectif, nous implémenterons plusieurs algorithmes de multiplication qui auront pour but de calculer le produit de grands entiers ou de matrices.

= Point important : complexité =

=== Définition ===
La complexité d'un algorithme est la quantité des ressources qu'il utilise en fonction de la taille des entrées qu'on lui demande de traiter. On peut par exemple se concentrer sur le temps qu'un algorithme prend pour renvoyer un résultat ou sur la mémoire dont il a besoin. Dans le cadre de notre projet, nous nous attarderons plus particulièrement sur la quantité de calcul effectuée en fonction de la taille des entrées, ce qui est par ailleurs fortement liée à la notion de temps. De manière générale, plus un algorithme doit faire de calcul, plus il est lent. (Attention, toutes les opérations arithmétiques de base ne se valent pas)

De manière plus familière, on dira que la complexité d'un algorithme pourrait s'apparenter à son comportement lorsqu'il doit traiter des données plus ou moins grandes.
Chaque algorithme a une complexité, et on l'exprime par une fonction qui adopte un comportement similaire au nombre de calcul nécessaire en fonction de la taille des entrées.

=== Notation ===
La complexité réelle d'un algorithme peut être décrite par une fonction <math>f(n)</math> représentant le nombre d'opérations effectuées en fonction de la taille <math>n</math> des données d'entrée.

Cependant, afin de simplifier l'étude de cette croissance, on utilise généralement une borne asymptotique notée <math>\mathcal{O}(g(n))</math>, où <math>g(n)</math> est une fonction ayant le même ordre de grandeur que <math>f(n)</math> lorsque <math>n</math> devient grand.

On dit alors que :

<math>
f(n)\in\mathcal{O}(g(n))
</math>

si et seulement s'il existe une constante <math>C>0</math> et un entier <math>n_0</math> tels que :

<math>
\forall n\ge n_0,\ f(n)\le Cg(n)
</math>

Cette notation <math>\mathcal{O}(g(n))</math> permettra de comparer beaucoup plus facilement les algorithmes entre eux.

=== Master Theorem ===

Afin de déterminer la complexité de certains algorithmes récursifs, nous utiliserons le "Master Theorem".

Ce théorème permet d'obtenir directement l'ordre de grandeur de nombreuses relations de récurrence apparaissant dans l'analyse d'algorithmes de type « diviser pour régner », comme l'algorithme de Karatsuba ou celui de Strassen.

La démonstration complète de ce théorème dépasse le cadre de notre projet et nécessite des connaissances mathématiques plus avancées. Nous l'utiliserons donc principalement comme un outil nous permettant de déterminer efficacement la complexité asymptotique des algorithmes étudiés.

=== Graphiques ===

Les complexités étant des fonctions, nous pouvons les représenter par un graphique qui affichera le temps d'exécution (ou nombre d'opérations) en fonction de la taille des entrées.

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:30px; text-align:center;">
[[Fichier:complexite.webp|500px]]
<div><b>Graphiques des complexités</b></div>
</div>
<div style="max-width:800px;">
<p>Ce graphique ci-contre compare les complexités en fonction de la taille des d'entrées.</p>
<p>On comprend ainsi que certaines complexités ne sont pas raisonnable dans la cadre de la multiplication de grands entiers.</p>
<p>C'est pourquoi l'étude de ces algorithmes s'avère nécessaire.</p>
</div>
</div>

=== Exemple ===
L'algorithme naïf d'addition que nous avons tous appris à l'école a une complexité de <math>\mathcal{O}(n)</math>.
Soit n la taille des nombres en entrée, l'algorithme doit faire environ n addition pour arriver au résultat demandé.

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Addition.gif|220px]]
<div><b>Addition naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Comme le montre l'exemple ci-contre, 786 et 467 font 3 chiffres de long donc n sera de 3.</p>
<p>Il nous faudra 3 opérations pour additionner ces deux nombres.</p>
<p>C'est ainsi qu'avec une taille d'entrée n, l'algorithme de l'addition naïve va devoir faire n opérations.</p>
<p>Cette algorithme a donc une complexité <math>f(n) = n</math> qui n'a pas besoin d'être approximée.</p>
<p>Ainsi sa complexité finale sera <math>\mathcal{O}(n)</math>.</p>
</div>
</div>

= Problématique =

Le calcul du produit de deux entiers de manière naïve a une complexité de <math> \mathcal{O}(n^2)</math>, et celui de deux matrices une complexité de <math> \mathcal{O}(n^3)</math>. Afin de mieux comprendre ce qu'est la complexité algorithmique, nous devrons implémenter des algorithmes ayant le même objectif, mais étant plus efficaces. Ces algorithmes s'avèreront plus complexes mais devrait aboutir à un calcul plus rapide du produit demandé.

Nous séparerons notre wiki en deux grandes parties, la première concernera nos recherche sur [[#I - Produit d'entiers|la multiplication d'entiers]], la deuxième sur [[#II - Produit de matrices|la multiplication de matrices]].

= I - Produit d'entiers =

Notre départ commence avec l'algorithme de multiplication d'entier naïf.
En effet il s'agit de l'algorithme de multiplication le plus connu, et nous l'utiliserons comme référence pour le comparer aux futurs algorithmes plus efficaces.
Intéressons nous à sa complexité.

== 1) Nos implémentations des grands entiers ==

Qui dit produit de grands entiers dit implémentation de grands entiers.

Dans le cadre de nos recherches, nous allons devoir implémenter des algorithmes qui vont manipuler des grands entiers.

Nous avons donc choisi de créer deux représentations différentes de ceux-ci (car nous travaillons sur différents langages de programmation), nous permettant à la fois une implémentation simplifié, mais aussi de nous rapprocher d'une implémentation bas niveau.

=== A) En python ===
En python, l'utilisation des "bytes" m'a grandement servi à comprendre comment les entiers étaient manipulés à bas niveau. En effet, un des objectifs secondaires de nos recherches était de manipuler des entiers directement avec leur formes stockées sur l'ordinateur, et non pas avec des int python.
En effet l'utilisation des int python nous aurait permit de passer les étapes de retenues, de signes... D'autant plus que les bytes permettent de stocker un nombre en base 256, ce qui permet de visualiser plus facilement les grands entiers.

La forme finale de la représentation des grands entiers en python sera donc la suivante :

[ signe , bytes , bytes , (...) , bytes ]

Le signe est représenté par un entier, 1 si le nombre est positif, 0 sinon.
Cette configuration rendra plus simple la gestion des signes.

=== B) En C++ ===

En C++, pour avoir une représentation de grand entiers j'ai du définir ma propre structure pour m'affranchir de la limite de taille imposé par les entiers standards: (int32 ou int64). Pour cela, j'ai une structure qui possède l'équivalent d'un array de byte (ce qui nous permet d'être en base 256 au lieu de la base 10 habituelle), et pour traiter le signe j'utilise un booléen, ainsi en mémoire j'ai une structure de n*Octets + 1 octet en taille.

[ bytes , bytes , (...) , bytes ] [ signe ]

Le booléen prend 1 octet de place mais ne touche pas aux octets qui encode le grand entier.
Cette configuration rendra plus simple la gestion des signes dans le cadre des multiplication.

== 2) La multiplication naïve ==

=== A) Fonctionnement ===
Dans le cas de la multiplication d'entiers, nous allons prendre deux nombres qui n'ont pas nécessairement la même longueur. Soit les nombre a et b, de longueur respective <math>n</math> et <math> m </math>.
<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Multiplication.png|220px]]
<div><b>Multiplication naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Prenons deux nombres de longueur 3 et 2, et cherchons combien d'opérations l'algorithme de multiplication naïve va devoir faire pour nous renvoyer leur produit.</p>
<p>Dans un premier temps, on remarque que l'on va devoir multiplier chaque chiffre du nombre du haut par le chiffre des unités du bas, qui est 6. Cela va représenter <math>n</math> opérations. (6x5, 6x1 et 6x4)</p>
<p>Dans un deuxième temps nous constatons que nous allons devoir faire la même chose avec le chiffre des dizaines du nombre du bas. Cela nous ajoute de nouveau <math>n</math> opérations.</p>
<p>On arrive assez facilement à la conclusion que pour faire notre produit, il va nous falloir faire <math>n</math> fois <math>m</math> opérations.</p>
</div>
</div>

Ainsi, la complexité de la multiplication naïve est <math>\mathcal{O}(n^2)</math>.
Il est en de même avec la multiplication naïve récursive.

=== B) Graphique ===
Montrons maintenant sa courbe sur un graphique :

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Multiplicationnaive.png|500px]]
<div><b>Multiplication naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Les points noirs sont des repères pour que les autres courbes aient une forme cohérente.</p>
<p>Ils sont tous sur l'axe des abscisses.</p>
<p>La courbe rouge représente la complexité de la multiplication naïve.</p>
<p>On remarque que la courbe a un visuel très similaire à la fonction <math>f(x) = x^2</math> </p>
</div>
</div>

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Naif_recursif.png|500px]]
<div><b>Multiplication naïve récursive</b></div>
</div>
<div style="max-width:800px;">
<p>La courbe rouge représente la complexité de la multiplication naïve récursive.</p>
<p>Elle sera utilisé pour comparer les complexités entre algorithmes car, comme tous récursifs, elle a été codé avec les mêmes biais d'implémentation qu'eux.</p>
<p>Théoriquement les deux courbes ci-contre ont la même complexité, mais encore une fois, notre implémentation n'est pas parfaitement optimale et donc ne respecte pas de manière minutieuse le Master Theorem.</p>
</div>
</div>

== 3) La multiplication karastuba ==

=== A) Fonctionnement ===

L'algorithme de karatsuba est un algorithme récursif de type diviser pour régner.

L'idée générale de l'algorithme est de passer de 4 multiplication à 3. En effet ces opérations étant moins couteuses, il est préférable d'en ajouter si cela permet d'enlever des multiplications.

L'algorithme de multiplication naif récursif utilise la segmentation des facteurs en deux de manière successive.

Soit <math>x</math> et <math>y</math> deux facteurs, nous avons les égalités suivantes :

<div style="font-size: 20px;">
<math>x = a \times B^{n/2} + b</math>
<math>y = c \times B^{n/2} + d</math>
</div>

Avec <math>a</math> et <math>c</math> les premières moitiés des facteurs <math>x</math> et <math>y</math>,
et <math>b</math> et <math>d</math> les dernières moitiés de ces facteurs ainsi que <math>B</math> la base d'écriture du nombre (Nous sommes en base 256 avec les bytes).

Cette présentation des deux facteurs de notre multiplication n'est que la résultante d'un découpage.
Le [[#Master Theorem|Master Theorem]] nous montre que :

<div style="font-size: 20px;">
<math>T(n) = 4T(n/2) + O(n)</math>
</div>

Puisque nous avons après découpage 4 entiers de longueur <math>n/2</math>.

Ainsi, ce découpage ne permet pas de gagner du temps d'après le [[#Master Theorem|Master Theorem]].

Cependant, l'algorithme de Karatsuba réutilise ce principe en le modifiant, ce qui nous permet de baisser la complexité globale de la multiplication dans son entièreté.

Avec l'écriture ci-dessus des nombres <math>x</math> et <math>y</math>, on peut facilement en déduire l'égalité suivante :

<div style="font-size: 20px;">
<math>x \times y = (ac) \times B^n + (ad + bc) \times B^{n/2} + bd</math>
</div>

On remarque 4 multiplications longues à faire dans cette expression. Les multiplications dont <math>B</math> est l'un des facteurs sont très rapides puisqu'il s'agit de la base dans laquelle nous travaillons. De cela en résulte un décalage plutôt qu'un vrai calcul à faire.

Karatsuba développe une partie de cette expression pour pouvoir négocier une multiplication au prix d'additions et soustractions.

En effet, nous savons déjà que :

<div style="font-size: 20px;">
<math>(a + b)(c + d) = ac + ad + bc + bd</math>
</div>

En manipulant l'égalité nous obtenons :

<div style="font-size: 20px;">
<math>ad + bc = (a + b)(c + d) - ac - bd</math>
</div>

ac et bd ayant déjà été calculé précédemment, il nous reste uniquement la multiplication <math>(a + b)(c + d)</math>.

Nous venons ainsi de calculer <math>ad + bc</math> en seulement une multiplication. C'est la que repose le gain de temps de la méthode Karatsuba par rapport à la multiplication naïve.

En effet, l'algorithme n'effectuera alors plus que 3 multiplications :
<div style="font-size: 20px;">
<math>ac</math>
<math>bd</math>
<math>(a + b)(c + d)</math>
</div>

La relation de récurrence devient donc :
<div style="font-size: 20px;">
<math>T(n)=3T(n/2)+O(n)</math>
</div>

Et le Master Theorem nous dit que :
<div style="font-size: 20px;">
<math>T(n)\in O(n^{\log_2(3)})</math>
</div>

Or <math>\log_2(3)\approx 1.585</math>, donc la complexité de l'algorithme de Karatsuba est de <math> \mathcal{O}(n^{1.585})</math>. Ce qui est bien plus efficace que la multiplication classique, surtout lorsque les facteurs deviennent très grands.

=== B) Graphique ===
<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Karatsuba.png|500px]]
<div><b>Karatsuba</b></div>
</div>
<div style="max-width:800px;">
<p>Sur le graphique ci-contre nous avons utilisé la courbe de la multiplication naïve récursive (rouge) à titre de comparaison.</p>
<p>On remarque graphiquement que Karatsuba (jaune) prend moins de temps à chaque calcul de produit.</p>
<p>On en déduit donc expérimentalement que Karatsuba à une meilleure complexité que la multiplication naïve.</p>
<p>Ainsi nous vérifions donc ce que le Master Theorem prouve, c'est à dire que la complexité de karatsuba est de <math> \mathcal{O}(n^{1.585})</math> </p>
</div>
</div>

== 4) La multiplication toom-cook-3 ==

=== A) Fonctionnement ===

L'objectif est de diviser les grands entiers X et Y en trois blocs de taille égale k.
On les traite alors comme des polynômes de degré 2:

<math>P(z) = X_2 \cdot z^2 + X_1 \cdot z + X_0</math>
<math>Q(z) = Y_2 \cdot z^2 + Y_1 \cdot z + Y_0</math>

On choisit 5 points distincts pour évaluer nos polynômes.
Ce choix de 5 points est crucial car le produit de deux polynômes de degré 2 est un polynôme de degré 4, qui nécessite 5 points pour être défini.
Les points standards sont :

P(0) = X0
P(1) = X0 + X1 + X2
P(-1) = X0 - X1 + X2
P(2) = X0 + 2*X1 + 4*X2
P(inf) = X2

(On procède de manière similaire pour Q.)

Ensuite nous multiplions récursivement chaque points de P et de Q ensemble.
On effectue ainsi 5 multiplications de nombres plus petits au lieu des 9 multiplications requises par la méthode classique.

Après, nous effectuons une interpolation, cela permet de retrouver les 5 coefficients (w_0, w_1, w_2, w_3, w_4) du polynôme produit R(z) à partir des valeurs évaluées calculées précédemment.
On résout un système d'équations linéaires : <math> R(z) = w_4 z^4 + w_3 z^3 + w_2 z^2 + w_1 z + w_0 </math>
Finalement nous pouvons recomposer notre grand entier en positionnant les coefficients w_i aux bons rangs (en les décalant) et à gérer les retenues lors de l'addition finale:
<math>Résultat = w_4 B^{4k} + w_3 B^{3k} + w_2 B^{2k} + w_1 B^k + w_0</math>

=== B) Graphique ===

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Toomcook.png|500px]]
<div><b>Karatsuba</b></div>
</div>
<div style="max-width:800px;">
<p>on a reprit multi récursive (rouge)</p>
<p>on voit que Toom (vert) en dessous de karatsuba (jaune) en dessous de multi classique (rouge)</p>
<p>meilleur complexité</p>
</div>
</div>

== 5) La transformée de Fourier rapide ==

=== A) Fonctionnement ===

La transformation de Fourier rapide étant plus complexe que les autres algorithmes, nous allons essayer d'expliquer son fonctionnement malgré ne pas avoir réussi à l'implémenter.

Il faut comprendre que cet algorithme va considérer les facteurs comme des polynômes.

D'après le théorème de l'unisolvance, il n'existe qu'un seul polynôme de degré inférieur ou égal à <math> n </math> défini par <math>n + 1</math> points distincts. Cela implique non seulement que nous pouvons représenter chaque entier par un polynôme, mais également que si nous pouvons retrouver <math>n + m + 1</math> points (avec <math>n</math> et <math>m</math> la longueur des facteurs) du polynômes issue du produit entre deux facteurs, nous pourrons le retrouver.

Soit un entier quelconque, de forme :

<math>a_n a_{n-1} (...) a_1 a_0</math>

Avec <math>a_i</math>, un chiffre composant le nombre en base 10, qui vaut en réalité dans le nombre : <math>a_i \times 10^i</math>. On peut ainsi l'écrire sous la forme :

<math> P(x) = a_0 + a_1x + a_2x^2 + \dots + a_{n-1}x^{n-1} + a_nx^n </math>

Avec <math>x = 10</math> car nous sommes en base 10, nous obtenons :

<math>P(10) = a_0 + a_1 \times 10 + \dots + a_{n-1}10^{n-1} + a_n10^n </math>

Nous venons ainsi d'écrire notre nombre sous la forme d'un polynôme unique. Pour nous permettre d'évaluer en un nombre suffisant de points, nous allons devoir ajouter des 0 pour la récursion. Il nous faudra ajouter assez de 0 pour atteindre la prochaine puissance de 2 qui sera supérieure ou égale à <math>2n + 1</math>. L'ajout de 0 ne change pas le nombre car <math>0 \times x^n</math> n'ajoute pas de coefficient.

Cet algorithme est récursif et va segmenter en deux parties nos polynômes à chaque récursion. D'un coté les indice paires et d'un coté les impaires.

Ainsi prenons les nombres 1234 et 5678, ces nombres sont respectivement représentés par les polynômes <math> P(x) = 4 + 3x + 2x^2 + x^3 </math> et <math> P(x) = 8 + 7x + 6x^2 + 5^3 </math>. Ce sont des polynômes de degré 3, ainsi leur produit donnera lieu à un polynôme de degré 6. Il nous faudra donc au minimum 7 points d'évaluation pour retrouve ce produit. De ce fait, en les représentant de la manière suivante :

<math>[4, 3, 2, 1, 0, 0, 0, 0]</math>
<math>[8, 7, 6, 5, 0, 0, 0, 0]</math>

Nous aurons assez de récursions possible pour les évaluer en un nombre suffisant de points différents car nous auront 3 récursions à faire pour atteindre notre cas de base. A chaque récursion, nous allons diviser nos polynômes en deux parties ce qui nous fait 8 feuilles à la dernière récursion.

En effet à chaque étape de la récursion nous allons séparer nos polynômes en deux tel que :

<math>P(x)=P_{\text{pair}}(x^2) + x \cdot P_{\text{impair}}(x^2)</math>

Durant les récursions, nous segmentons les polynômes mais ne les évaluons pas. C'est à la remonté des récursions que nous allons réellement évaluer nos polynômes. Lorsque l'on atteint notre cas de base, c'est à dire des polynômes de degré 0, nous remarquons qu'ils sont constants, nous n'avons donc pas besoin de les évaluer. En effet, peut importe le point en lequel nous voudrons l'évaluer, le polynôme renverra la constante. Nous la renvoyons donc seule.
Ensuite commence la remontée des récursions. A l'étape 1 de notre remontée nous allons reformer le polynôme précédemment séparé pour obtenir un polynôme de degré 1. Puis, nous évaluons ce polynôme avec les racines seconde de l'unité. Nous faisons à nouveau remonté les évaluations et recombinons à nouveau le polynôme qui sera ainsi de degré 2.
Nous l'évaluons maintenant avec les racines 4eme de l'unité. A chaque évaluation, nous réutilisons les résultats précédents, cela nous est permit par les racines de l'unité qui ont une structure récursive exploitable.

Finalement, nous arrivons à la fin de notre FFT, avec une représentation fréquentielle de la forme :

<math> [P(W_0), P(W_1), (...), P(W_n-1), P(W_n)] </math>

Cette représentation fréquentielle n'est autre que les évaluations du polynôme P aux racines nièmes de l'unité. Nous avons donc maintenant au minimum <math>2n+1</math> évaluations des polynômes facteurs. Il nous faut maintenant trouver les évaluations du produit final, c'est à dire les évaluations concernant le polynôme qui sera issue de la multiplication. On pourra ainsi le retrouver.

Soit <math>C</math> un polynome tel que <math> C = A \times B </math>, alors on a :

<math> C(x) = A(x) \times B(x) </math>

Ainsi on en déduit que <math> C(W_n^k) = A(W_n^k) \times B(W_n^k) </math>

On comprend donc que <math>FFT(C) = FFT(A) \times FFT(B)</math>

Il faut préciser que l'on fait le produit de FFT(A) et FFT(B) terme à terme, soit évaluation par évaluation.

Une fois en possession de <math>FFT(C)</math>, qui n'est autre que l'évaluation de notre polynôme final en un nombre suffisant de points pour le retrouver, nous pouvons faire l'<math>IFFT(FFT(C))</math>, qui va nous permettre de retrouver les coefficients de notre polynôme en faisant l'exacte inverse de la FFT.

Une fois les coefficients retrouvés, il nous suffit de gérer les retenues, et nous retrouvons un entier de la forme : <math>a_0 a_1 (...) a_{n-1} a_n</math>

=== B) Graphique ===

Intéressons nous maintenant à la complexité de l'algorithme utilisant la transformée de Fourier rapide. On sait que l'algorithme passe par 5 étapes importantes :

<ul>
<li>Etape 1 : Ecrire les deux facteurs sous la forme de polynômes</li>
<li>Etape 2 : Effectuer la <math>FFT</math> des deux polynômes</li>
<li>Etape 3 : Faire le produit terme à terme des <math>FFT</math> obtenues</li>
<li>Etape 4 : Faire l'<math>IFFT</math> du produit</li>
<li>Etape 5 : Gérer les retenues et écrire le nombre qui en découle</li>
</ul>

Or, parmi toutes ces étapes, certaines sont négligeable comme l'étape 1 et 5.

Pour connaitre la complexité de l'algorithme, additionnons les complexités des étapes restantes :

Une <math>FFT</math> a une complexité de <math>\mathcal{O}(n\times logn)</math> car elle fait <math>n</math> évaluation sur <math> log(n)</math> récursions. Dans le cadre de notre algorithme, nous devons faire la <math>FFT</math> de nos deux facteurs. Soit <math>2\times \mathcal{O}(n\times logn)</math>.

Pour le produit terme à terme, nous faisons naturellement <math>n</math> opérations.

Pour finir, l'<math>IFFT</math> a la même complexité que la <math>FFT</math>. Dans le cadre de notre algorithme nous l'emploierons qu'une seule fois, ce qui fait une complexité de <math>\mathcal{O}(n\times logn)</math>.

Après addition de toutes ces complexités, nous obtenons la complexité réelle de <math>3\mathcal{O}(n\times logn) + \mathcal{O}(n)</math>.

D'après le Master Theorem, nous avons donc <math> f(n) = 3(n\times logn)+n </math>, cherchons <math>f(n)\in\mathcal{O}(g(n))</math> :

Nous pouvons ignorer les expressions linéaires ainsi que les constantes multiplicatrices, nous obtenons donc <math>\mathcal{O}(g(n)) = \mathcal{O}(n \times log n)</math>.

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:30px; text-align:center;">
[[Fichier:FFT_image.webp|500px]]
<div><b>Graphiques des complexités</b></div>
</div>
<div style="max-width:800px;">
<p>Ce graphique ci-contre ne provient pas du fruit de nos recherches personnelles mais </p>
<p>On comprend ainsi que certaines complexités ne sont pas raisonnable dans la cadre de la multiplication de grands entiers.</p>
<p>C'est pourquoi l'étude de ces algorithmes s'avère nécessaire.</p>
</div>
</div>

= II - Produit de matrices =

== 1.1) naïve ==

La multiplication naïve de matrice requiert d'avoir des tailles de lignes/colonne semblable, ensuite pour chaque membre de la matrice résultat, on doit multiplier les composantes ligne de la première matrice par les composantes colonne de la deuxième et le tout sommé.

On en déduit la formule suivante:
<math>C_{i,j} = \sum_{k=1}^{n} (A_{i,k} \times B_{k,j})</math>

Et visuellement:

[[Fichier:Matricenaive.jpeg]]

On a donc un algorithme d'ordre de complexité <math>\mathcal{O}(g(n))</math>

== 1.2) naïve récursive ==

Dans un premier temps on doit découper nos deux matrices en quatres sous matrices de plus petite taille.
<math>A = \begin{pmatrix} A_{11} & A_{12} \ A_{21} & A_{22} \end{pmatrix}</math>
<math>B = \begin{pmatrix} B_{11} & B_{12} \ B_{21} & B_{22} \end{pmatrix}</math>

Ensuite on vient calculer la matrice résultat.
<math>C_{11} = (A_{11} \times B_{11}) + (A_{12} \times B_{21})</math>
<math>C_{12} = (A_{11} \times B_{12}) + (A_{12} \times B_{22})</math>
<math>C_{21} = (A_{21} \times B_{11}) + (A_{22} \times B_{21})</math>
<math>C_{22} = (A_{21} \times B_{12}) + (A_{22} \times B_{22})</math>

Le côté récursif est utile que pour les matrices de tailles <= 32 (32 valeurs stockées dedans),
si on est au dessus de cette taille alors on divisera à nouveau nos matrices en quatres.
On aura 8 multiplications mais de plus petite taille au final.

== 2) strassen ==

=== A) Fonctionnement ===

Strassen consiste à définir 7 produits intermédiaires qui, par des jeux de sommes et de différences, permettent de reconstruire les quadrants de la matrice résultante. On passe ainsi d'une complexité de O(n^3) à environ O(n^2.81)

=== B) Graphique ===

On voit bien la différence de complexité sur la multiplication de grande matrice entre l'approche naïve et l'approche récursive qui est beaucoup plus rapide.

[[Fichier:Analyse matrices.png]]

= Conclusion =

( A FAIRE )

= Mentions =

Le premier gif est le résultat du travail de 'Walké', licence ci-contre : https://fr.wikipedia.org/wiki/Fichier:Addition.gif

= Sources =

Pour karatsuba : https://www.youtube.com/watch?v=PZ2gdWdKHAA

Pour mieux comprendre la FFT, nous avons utilisé plusieurs sources d'informations :
<ul>
<li> https://www.youtube.com/watch?v=h7apO7q16V0&list=WL&index=1&t=886s </li>
<li> https://fr.wikipedia.org/wiki/Interpolation_polynomiale </li>
</ul>

Algorithmes de multiplications d'entiers et de matrices

2026-05-11T15:14:48Z

Mangala : /* Introduction */

= Introduction =

Depuis l'apparition des ordinateurs modernes, une quantité faramineuse de calculs a dû être effectuée. Les progressions technologiques nous poussent à envisager la puissance de calcul comme une ressource qu'il faut optimiser dans les moindres détails. C'est ainsi que l'optimisation des algorithmes de calcul est devenue cruciale, surtout lorsqu'il nous faut effectuer des opérations sur de très grands entiers par exemple.

= Objectif =

L'objectif majeur de ce projet est de comprendre de manière plus approfondie ce qu'est la '''complexité algorithmique'''.
Pour atteindre cet objectif, nous implémenterons plusieurs algorithmes de multiplication qui auront pour but de calculer le produit de grands entiers ou de matrices.

= Point important : complexité =

=== Définition ===
La complexité d'un algorithme est la quantité des ressources qu'il utilise en fonction de la taille des entrée qu'on lui demande de traiter. On peut par exemple se concentrer sur le temps qu'un algorithme prend pour renvoyer un résultat ou sur la mémoire dont il a besoin. Dans le cadre de notre projet, nous nous attarderons plus particulièrement sur la quantité de calcul effectuée en fonction de la taille des entrées, ce qui est par ailleurs fortement liée à la notion de temps. De manière générale, plus un algorithme doit faire de calcul, plus il est lent. (Attention, toutes les opérations arithmétiques de base ne se valent pas)

De manière plus familière, on dira que la complexité d'un algorithme pourrait s'apparenter à son comportement lorsqu'il doit traiter des données plus ou moins grandes.
Chaque algorithme a une complexité, et on l'exprime par une fonction qui adopte un comportement similaire au nombre de calcul nécessaire en fonction de la taille des entrées.

=== Notation ===
La complexité réelle d'un algorithme peut être décrite par une fonction <math>f(n)</math> représentant le nombre d'opérations effectuées en fonction de la taille <math>n</math> des données d'entrée.

Cependant, afin de simplifier l'étude de cette croissance, on utilise généralement une borne asymptotique notée <math>\mathcal{O}(g(n))</math>, où <math>g(n)</math> est une fonction ayant le même ordre de grandeur que <math>f(n)</math> lorsque <math>n</math> devient grand.

On dit alors que :

<math>
f(n)\in\mathcal{O}(g(n))
</math>

si et seulement s'il existe une constante <math>C>0</math> et un entier <math>n_0</math> tels que :

<math>
\forall n\ge n_0,\ f(n)\le Cg(n)
</math>

Cette notation <math>\mathcal{O}(g(n))</math> permettra de comparer beaucoup plus facilement les algorithmes entre eux.

=== Master Theorem ===

Afin de déterminer la complexité de certains algorithmes récursifs, nous utiliserons le "Master Theorem".

Ce théorème permet d'obtenir directement l'ordre de grandeur de nombreuses relations de récurrence apparaissant dans l'analyse d'algorithmes de type « diviser pour régner », comme l'algorithme de Karatsuba ou celui de Strassen.

La démonstration complète de ce théorème dépasse le cadre de notre projet et nécessite des connaissances mathématiques plus avancées. Nous l'utiliserons donc principalement comme un outil nous permettant de déterminer efficacement la complexité asymptotique des algorithmes étudiés.

=== Graphiques ===

Les complexités étant des fonctions, nous pouvons les représenter par un graphique qui affichera le temps d'exécution (ou nombre d'opérations) en fonction de la taille des entrées.

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:30px; text-align:center;">
[[Fichier:complexite.webp|500px]]
<div><b>Graphiques des complexités</b></div>
</div>
<div style="max-width:800px;">
<p>Ce graphique ci-contre compare les complexités en fonction de la taille des d'entrées.</p>
<p>On comprend ainsi que certaines complexités ne sont pas raisonnable dans la cadre de la multiplication de grands entiers.</p>
<p>C'est pourquoi l'étude de ces algorithmes s'avère nécessaire.</p>
</div>
</div>

=== Exemple ===
L'algorithme naïf d'addition que nous avons tous appris à l'école a une complexité de <math>\mathcal{O}(n)</math>.
Soit n la taille des nombres en entrée, l'algorithme doit faire environ n addition pour arriver au résultat demandé.

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Addition.gif|220px]]
<div><b>Addition naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Comme le montre l'exemple ci-contre, 786 et 467 font 3 chiffres de long donc n sera de 3.</p>
<p>Il nous faudra 3 opérations pour additionner ces deux nombres.</p>
<p>C'est ainsi qu'avec une taille d'entrée n, l'algorithme de l'addition naïve va devoir faire n opérations.</p>
<p>Cette algorithme a donc une complexité <math>f(n) = n</math> qui n'a pas besoin d'être approximée.</p>
<p>Ainsi sa complexité finale sera <math>\mathcal{O}(n)</math>.</p>
</div>
</div>

= Problématique =

Le calcul du produit de deux entiers de manière naïve a une complexité de <math> \mathcal{O}(n^2)</math>, et celui de deux matrices une complexité de <math> \mathcal{O}(n^3)</math>. Afin de mieux comprendre ce qu'est la complexité algorithmique, nous devrons implémenter des algorithmes ayant le même objectif, mais étant plus efficaces. Ces algorithmes s'avèreront plus complexes mais devrait aboutir à un calcul plus rapide du produit demandé.

Nous séparerons notre wiki en deux grandes parties, la première concernera nos recherche sur [[#I - Produit d'entiers|la multiplication d'entiers]], la deuxième sur [[#II - Produit de matrices|la multiplication de matrices]].

= I - Produit d'entiers =

Notre départ commence avec l'algorithme de multiplication d'entier naïf.
En effet il s'agit de l'algorithme de multiplication le plus connu, et nous l'utiliserons comme référence pour le comparer aux futurs algorithmes plus efficaces.
Intéressons nous à sa complexité.

== 1) Nos implémentations des grands entiers ==

Qui dit produit de grands entiers dit implémentation de grands entiers.

Dans le cadre de nos recherches, nous allons devoir implémenter des algorithmes qui vont manipuler des grands entiers.

Nous avons donc choisi de créer deux représentations différentes de ceux-ci (car nous travaillons sur différents langages de programmation), nous permettant à la fois une implémentation simplifié, mais aussi de nous rapprocher d'une implémentation bas niveau.

=== A) En python ===
En python, l'utilisation des "bytes" m'a grandement servi à comprendre comment les entiers étaient manipulés à bas niveau. En effet, un des objectifs secondaires de nos recherches était de manipuler des entiers directement avec leur formes stockées sur l'ordinateur, et non pas avec des int python.
En effet l'utilisation des int python nous aurait permit de passer les étapes de retenues, de signes... D'autant plus que les bytes permettent de stocker un nombre en base 256, ce qui permet de visualiser plus facilement les grands entiers.

La forme finale de la représentation des grands entiers en python sera donc la suivante :

[ signe , bytes , bytes , (...) , bytes ]

Le signe est représenté par un entier, 1 si le nombre est positif, 0 sinon.
Cette configuration rendra plus simple la gestion des signes.

=== B) En C++ ===

En C++, pour avoir une représentation de grand entiers j'ai du définir ma propre structure pour m'affranchir de la limite de taille imposé par les entiers standards: (int32 ou int64). Pour cela, j'ai une structure qui possède l'équivalent d'un array de byte (ce qui nous permet d'être en base 256 au lieu de la base 10 habituelle), et pour traiter le signe j'utilise un booléen, ainsi en mémoire j'ai une structure de n*Octets + 1 octet en taille.

[ bytes , bytes , (...) , bytes ] [ signe ]

Le booléen prend 1 octet de place mais ne touche pas aux octets qui encode le grand entier.
Cette configuration rendra plus simple la gestion des signes dans le cadre des multiplication.

== 2) La multiplication naïve ==

=== A) Fonctionnement ===
Dans le cas de la multiplication d'entiers, nous allons prendre deux nombres qui n'ont pas nécessairement la même longueur. Soit les nombre a et b, de longueur respective <math>n</math> et <math> m </math>.
<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Multiplication.png|220px]]
<div><b>Multiplication naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Prenons deux nombres de longueur 3 et 2, et cherchons combien d'opérations l'algorithme de multiplication naïve va devoir faire pour nous renvoyer leur produit.</p>
<p>Dans un premier temps, on remarque que l'on va devoir multiplier chaque chiffre du nombre du haut par le chiffre des unités du bas, qui est 6. Cela va représenter <math>n</math> opérations. (6x5, 6x1 et 6x4)</p>
<p>Dans un deuxième temps nous constatons que nous allons devoir faire la même chose avec le chiffre des dizaines du nombre du bas. Cela nous ajoute de nouveau <math>n</math> opérations.</p>
<p>On arrive assez facilement à la conclusion que pour faire notre produit, il va nous falloir faire <math>n</math> fois <math>m</math> opérations.</p>
</div>
</div>

Ainsi, la complexité de la multiplication naïve est <math>\mathcal{O}(n^2)</math>.
Il est en de même avec la multiplication naïve récursive.

=== B) Graphique ===
Montrons maintenant sa courbe sur un graphique :

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Multiplicationnaive.png|500px]]
<div><b>Multiplication naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Les points noirs sont des repères pour que les autres courbes aient une forme cohérente.</p>
<p>Ils sont tous sur l'axe des abscisses.</p>
<p>La courbe rouge représente la complexité de la multiplication naïve.</p>
<p>On remarque que la courbe a un visuel très similaire à la fonction <math>f(x) = x^2</math> </p>
</div>
</div>

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Naif_recursif.png|500px]]
<div><b>Multiplication naïve récursive</b></div>
</div>
<div style="max-width:800px;">
<p>La courbe rouge représente la complexité de la multiplication naïve récursive.</p>
<p>Elle sera utilisé pour comparer les complexités entre algorithmes car, comme tous récursifs, elle a été codé avec les mêmes biais d'implémentation qu'eux.</p>
<p>Théoriquement les deux courbes ci-contre ont la même complexité, mais encore une fois, notre implémentation n'est pas parfaitement optimale et donc ne respecte pas de manière minutieuse le Master Theorem.</p>
</div>
</div>

== 3) La multiplication karastuba ==

=== A) Fonctionnement ===

L'algorithme de karatsuba est un algorithme récursif de type diviser pour régner.

L'idée générale de l'algorithme est de passer de 4 multiplication à 3. En effet ces opérations étant moins couteuses, il est préférable d'en ajouter si cela permet d'enlever des multiplications.

L'algorithme de multiplication naif récursif utilise la segmentation des facteurs en deux de manière successive.

Soit <math>x</math> et <math>y</math> deux facteurs, nous avons les égalités suivantes :

<div style="font-size: 20px;">
<math>x = a \times B^{n/2} + b</math>
<math>y = c \times B^{n/2} + d</math>
</div>

Avec <math>a</math> et <math>c</math> les premières moitiés des facteurs <math>x</math> et <math>y</math>,
et <math>b</math> et <math>d</math> les dernières moitiés de ces facteurs ainsi que <math>B</math> la base d'écriture du nombre (Nous sommes en base 256 avec les bytes).

Cette présentation des deux facteurs de notre multiplication n'est que la résultante d'un découpage.
Le [[#Master Theorem|Master Theorem]] nous montre que :

<div style="font-size: 20px;">
<math>T(n) = 4T(n/2) + O(n)</math>
</div>

Puisque nous avons après découpage 4 entiers de longueur <math>n/2</math>.

Ainsi, ce découpage ne permet pas de gagner du temps d'après le [[#Master Theorem|Master Theorem]].

Cependant, l'algorithme de Karatsuba réutilise ce principe en le modifiant, ce qui nous permet de baisser la complexité globale de la multiplication dans son entièreté.

Avec l'écriture ci-dessus des nombres <math>x</math> et <math>y</math>, on peut facilement en déduire l'égalité suivante :

<div style="font-size: 20px;">
<math>x \times y = (ac) \times B^n + (ad + bc) \times B^{n/2} + bd</math>
</div>

On remarque 4 multiplications longues à faire dans cette expression. Les multiplications dont <math>B</math> est l'un des facteurs sont très rapides puisqu'il s'agit de la base dans laquelle nous travaillons. De cela en résulte un décalage plutôt qu'un vrai calcul à faire.

Karatsuba développe une partie de cette expression pour pouvoir négocier une multiplication au prix d'additions et soustractions.

En effet, nous savons déjà que :

<div style="font-size: 20px;">
<math>(a + b)(c + d) = ac + ad + bc + bd</math>
</div>

En manipulant l'égalité nous obtenons :

<div style="font-size: 20px;">
<math>ad + bc = (a + b)(c + d) - ac - bd</math>
</div>

ac et bd ayant déjà été calculé précédemment, il nous reste uniquement la multiplication <math>(a + b)(c + d)</math>.

Nous venons ainsi de calculer <math>ad + bc</math> en seulement une multiplication. C'est la que repose le gain de temps de la méthode Karatsuba par rapport à la multiplication naïve.

En effet, l'algorithme n'effectuera alors plus que 3 multiplications :
<div style="font-size: 20px;">
<math>ac</math>
<math>bd</math>
<math>(a + b)(c + d)</math>
</div>

La relation de récurrence devient donc :
<div style="font-size: 20px;">
<math>T(n)=3T(n/2)+O(n)</math>
</div>

Et le Master Theorem nous dit que :
<div style="font-size: 20px;">
<math>T(n)\in O(n^{\log_2(3)})</math>
</div>

Or <math>\log_2(3)\approx 1.585</math>, donc la complexité de l'algorithme de Karatsuba est de <math> \mathcal{O}(n^{1.585})</math>. Ce qui est bien plus efficace que la multiplication classique, surtout lorsque les facteurs deviennent très grands.

=== B) Graphique ===
<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Karatsuba.png|500px]]
<div><b>Karatsuba</b></div>
</div>
<div style="max-width:800px;">
<p>Sur le graphique ci-contre nous avons utilisé la courbe de la multiplication naïve récursive (rouge) à titre de comparaison.</p>
<p>On remarque graphiquement que Karatsuba (jaune) prend moins de temps à chaque calcul de produit.</p>
<p>On en déduit donc expérimentalement que Karatsuba à une meilleure complexité que la multiplication naïve.</p>
<p>Ainsi nous vérifions donc ce que le Master Theorem prouve, c'est à dire que la complexité de karatsuba est de <math> \mathcal{O}(n^{1.585})</math> </p>
</div>
</div>

== 4) La multiplication toom-cook-3 ==

=== A) Fonctionnement ===

L'objectif est de diviser les grands entiers X et Y en trois blocs de taille égale k.
On les traite alors comme des polynômes de degré 2:

<math>P(z) = X_2 \cdot z^2 + X_1 \cdot z + X_0</math>
<math>Q(z) = Y_2 \cdot z^2 + Y_1 \cdot z + Y_0</math>

On choisit 5 points distincts pour évaluer nos polynômes.
Ce choix de 5 points est crucial car le produit de deux polynômes de degré 2 est un polynôme de degré 4, qui nécessite 5 points pour être défini.
Les points standards sont :

P(0) = X0
P(1) = X0 + X1 + X2
P(-1) = X0 - X1 + X2
P(2) = X0 + 2*X1 + 4*X2
P(inf) = X2

(On procède de manière similaire pour Q.)

Ensuite nous multiplions récursivement chaque points de P et de Q ensemble.
On effectue ainsi 5 multiplications de nombres plus petits au lieu des 9 multiplications requises par la méthode classique.

Après, nous effectuons une interpolation, cela permet de retrouver les 5 coefficients (w_0, w_1, w_2, w_3, w_4) du polynôme produit R(z) à partir des valeurs évaluées calculées précédemment.
On résout un système d'équations linéaires : <math> R(z) = w_4 z^4 + w_3 z^3 + w_2 z^2 + w_1 z + w_0 </math>
Finalement nous pouvons recomposer notre grand entier en positionnant les coefficients w_i aux bons rangs (en les décalant) et à gérer les retenues lors de l'addition finale:
<math>Résultat = w_4 B^{4k} + w_3 B^{3k} + w_2 B^{2k} + w_1 B^k + w_0</math>

=== B) Graphique ===

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Toomcook.png|500px]]
<div><b>Karatsuba</b></div>
</div>
<div style="max-width:800px;">
<p>on a reprit multi récursive (rouge)</p>
<p>on voit que Toom (vert) en dessous de karatsuba (jaune) en dessous de multi classique (rouge)</p>
<p>meilleur complexité</p>
</div>
</div>

== 5) La transformée de Fourier rapide ==

=== A) Fonctionnement ===

La transformation de Fourier rapide étant plus complexe que les autres algorithmes, nous allons essayer d'expliquer son fonctionnement malgré ne pas avoir réussi à l'implémenter.

Il faut comprendre que cet algorithme va considérer les facteurs comme des polynômes.

D'après le théorème de l'unisolvance, il n'existe qu'un seul polynôme de degré inférieur ou égal à <math> n </math> défini par <math>n + 1</math> points distincts. Cela implique non seulement que nous pouvons représenter chaque entier par un polynôme, mais également que si nous pouvons retrouver <math>n + m + 1</math> points (avec <math>n</math> et <math>m</math> la longueur des facteurs) du polynômes issue du produit entre deux facteurs, nous pourrons le retrouver.

Soit un entier quelconque, de forme :

<math>a_n a_{n-1} (...) a_1 a_0</math>

Avec <math>a_i</math>, un chiffre composant le nombre en base 10, qui vaut en réalité dans le nombre : <math>a_i \times 10^i</math>. On peut ainsi l'écrire sous la forme :

<math> P(x) = a_0 + a_1x + a_2x^2 + \dots + a_{n-1}x^{n-1} + a_nx^n </math>

Avec <math>x = 10</math> car nous sommes en base 10, nous obtenons :

<math>P(10) = a_0 + a_1 \times 10 + \dots + a_{n-1}10^{n-1} + a_n10^n </math>

Nous venons ainsi d'écrire notre nombre sous la forme d'un polynôme unique. Pour nous permettre d'évaluer en un nombre suffisant de points, nous allons devoir ajouter des 0 pour la récursion. Il nous faudra ajouter assez de 0 pour atteindre la prochaine puissance de 2 qui sera supérieure ou égale à <math>2n + 1</math>. L'ajout de 0 ne change pas le nombre car <math>0 \times x^n</math> n'ajoute pas de coefficient.

Cet algorithme est récursif et va segmenter en deux parties nos polynômes à chaque récursion. D'un coté les indice paires et d'un coté les impaires.

Ainsi prenons les nombres 1234 et 5678, ces nombres sont respectivement représentés par les polynômes <math> P(x) = 4 + 3x + 2x^2 + x^3 </math> et <math> P(x) = 8 + 7x + 6x^2 + 5^3 </math>. Ce sont des polynômes de degré 3, ainsi leur produit donnera lieu à un polynôme de degré 6. Il nous faudra donc au minimum 7 points d'évaluation pour retrouve ce produit. De ce fait, en les représentant de la manière suivante :

<math>[4, 3, 2, 1, 0, 0, 0, 0]</math>
<math>[8, 7, 6, 5, 0, 0, 0, 0]</math>

Nous aurons assez de récursions possible pour les évaluer en un nombre suffisant de points différents car nous auront 3 récursions à faire pour atteindre notre cas de base. A chaque récursion, nous allons diviser nos polynômes en deux parties ce qui nous fait 8 feuilles à la dernière récursion.

En effet à chaque étape de la récursion nous allons séparer nos polynômes en deux tel que :

<math>P(x)=P_{\text{pair}}(x^2) + x \cdot P_{\text{impair}}(x^2)</math>

Durant les récursions, nous segmentons les polynômes mais ne les évaluons pas. C'est à la remonté des récursions que nous allons réellement évaluer nos polynômes. Lorsque l'on atteint notre cas de base, c'est à dire des polynômes de degré 0, nous remarquons qu'ils sont constants, nous n'avons donc pas besoin de les évaluer. En effet, peut importe le point en lequel nous voudrons l'évaluer, le polynôme renverra la constante. Nous la renvoyons donc seule.
Ensuite commence la remontée des récursions. A l'étape 1 de notre remontée nous allons reformer le polynôme précédemment séparé pour obtenir un polynôme de degré 1. Puis, nous évaluons ce polynôme avec les racines seconde de l'unité. Nous faisons à nouveau remonté les évaluations et recombinons à nouveau le polynôme qui sera ainsi de degré 2.
Nous l'évaluons maintenant avec les racines 4eme de l'unité. A chaque évaluation, nous réutilisons les résultats précédents, cela nous est permit par les racines de l'unité qui ont une structure récursive exploitable.

Finalement, nous arrivons à la fin de notre FFT, avec une représentation fréquentielle de la forme :

<math> [P(W_0), P(W_1), (...), P(W_n-1), P(W_n)] </math>

Cette représentation fréquentielle n'est autre que les évaluations du polynôme P aux racines nièmes de l'unité. Nous avons donc maintenant au minimum <math>2n+1</math> évaluations des polynômes facteurs. Il nous faut maintenant trouver les évaluations du produit final, c'est à dire les évaluations concernant le polynôme qui sera issue de la multiplication. On pourra ainsi le retrouver.

Soit <math>C</math> un polynome tel que <math> C = A \times B </math>, alors on a :

<math> C(x) = A(x) \times B(x) </math>

Ainsi on en déduit que <math> C(W_n^k) = A(W_n^k) \times B(W_n^k) </math>

On comprend donc que <math>FFT(C) = FFT(A) \times FFT(B)</math>

Il faut préciser que l'on fait le produit de FFT(A) et FFT(B) terme à terme, soit évaluation par évaluation.

Une fois en possession de <math>FFT(C)</math>, qui n'est autre que l'évaluation de notre polynôme final en un nombre suffisant de points pour le retrouver, nous pouvons faire l'<math>IFFT(FFT(C))</math>, qui va nous permettre de retrouver les coefficients de notre polynôme en faisant l'exacte inverse de la FFT.

Une fois les coefficients retrouvés, il nous suffit de gérer les retenues, et nous retrouvons un entier de la forme : <math>a_0 a_1 (...) a_{n-1} a_n</math>

=== B) Graphique ===

Intéressons nous maintenant à la complexité de l'algorithme utilisant la transformée de Fourier rapide. On sait que l'algorithme passe par 5 étapes importantes :

<ul>
<li>Etape 1 : Ecrire les deux facteurs sous la forme de polynômes</li>
<li>Etape 2 : Effectuer la <math>FFT</math> des deux polynômes</li>
<li>Etape 3 : Faire le produit terme à terme des <math>FFT</math> obtenues</li>
<li>Etape 4 : Faire l'<math>IFFT</math> du produit</li>
<li>Etape 5 : Gérer les retenues et écrire le nombre qui en découle</li>
</ul>

Or, parmi toutes ces étapes, certaines sont négligeable comme l'étape 1 et 5.

Pour connaitre la complexité de l'algorithme, additionnons les complexités des étapes restantes :

Une <math>FFT</math> a une complexité de <math>\mathcal{O}(n\times logn)</math> car elle fait <math>n</math> évaluation sur <math> log(n)</math> récursions. Dans le cadre de notre algorithme, nous devons faire la <math>FFT</math> de nos deux facteurs. Soit <math>2\times \mathcal{O}(n\times logn)</math>.

Pour le produit terme à terme, nous faisons naturellement <math>n</math> opérations.

Pour finir, l'<math>IFFT</math> a la même complexité que la <math>FFT</math>. Dans le cadre de notre algorithme nous l'emploierons qu'une seule fois, ce qui fait une complexité de <math>\mathcal{O}(n\times logn)</math>.

Après addition de toutes ces complexités, nous obtenons la complexité réelle de <math>3\mathcal{O}(n\times logn) + \mathcal{O}(n)</math>.

D'après le Master Theorem, nous avons donc <math> f(n) = 3(n\times logn)+n </math>, cherchons <math>f(n)\in\mathcal{O}(g(n))</math> :

Nous pouvons ignorer les expressions linéaires ainsi que les constantes multiplicatrices, nous obtenons donc <math>\mathcal{O}(g(n)) = \mathcal{O}(n \times log n)</math>.

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:30px; text-align:center;">
[[Fichier:FFT_image.webp|500px]]
<div><b>Graphiques des complexités</b></div>
</div>
<div style="max-width:800px;">
<p>Ce graphique ci-contre ne provient pas du fruit de nos recherches personnelles mais </p>
<p>On comprend ainsi que certaines complexités ne sont pas raisonnable dans la cadre de la multiplication de grands entiers.</p>
<p>C'est pourquoi l'étude de ces algorithmes s'avère nécessaire.</p>
</div>
</div>

= II - Produit de matrices =

== 1.1) naïve ==

La multiplication naïve de matrice requiert d'avoir des tailles de lignes/colonne semblable, ensuite pour chaque membre de la matrice résultat, on doit multiplier les composantes ligne de la première matrice par les composantes colonne de la deuxième et le tout sommé.

On en déduit la formule suivante:
<math>C_{i,j} = \sum_{k=1}^{n} (A_{i,k} \times B_{k,j})</math>

Et visuellement:

[[Fichier:Matricenaive.jpeg]]

On a donc un algorithme d'ordre de complexité <math>\mathcal{O}(g(n))</math>

== 1.2) naïve récursive ==

Dans un premier temps on doit découper nos deux matrices en quatres sous matrices de plus petite taille.
<math>A = \begin{pmatrix} A_{11} & A_{12} \ A_{21} & A_{22} \end{pmatrix}</math>
<math>B = \begin{pmatrix} B_{11} & B_{12} \ B_{21} & B_{22} \end{pmatrix}</math>

Ensuite on vient calculer la matrice résultat.
<math>C_{11} = (A_{11} \times B_{11}) + (A_{12} \times B_{21})</math>
<math>C_{12} = (A_{11} \times B_{12}) + (A_{12} \times B_{22})</math>
<math>C_{21} = (A_{21} \times B_{11}) + (A_{22} \times B_{21})</math>
<math>C_{22} = (A_{21} \times B_{12}) + (A_{22} \times B_{22})</math>

Le côté récursif est utile que pour les matrices de tailles <= 32 (32 valeurs stockées dedans),
si on est au dessus de cette taille alors on divisera à nouveau nos matrices en quatres.
On aura 8 multiplications mais de plus petite taille au final.

== 2) strassen ==

=== A) Fonctionnement ===

Strassen consiste à définir 7 produits intermédiaires qui, par des jeux de sommes et de différences, permettent de reconstruire les quadrants de la matrice résultante. On passe ainsi d'une complexité de O(n^3) à environ O(n^2.81)

=== B) Graphique ===

On voit bien la différence de complexité sur la multiplication de grande matrice entre l'approche naïve et l'approche récursive qui est beaucoup plus rapide.

[[Fichier:Analyse matrices.png]]

= Conclusion =

( A FAIRE )

= Mentions =

Le premier gif est le résultat du travail de 'Walké', licence ci-contre : https://fr.wikipedia.org/wiki/Fichier:Addition.gif

= Sources =

Pour karatsuba : https://www.youtube.com/watch?v=PZ2gdWdKHAA

Pour mieux comprendre la FFT, nous avons utilisé plusieurs sources d'informations :
<ul>
<li> https://www.youtube.com/watch?v=h7apO7q16V0&list=WL&index=1&t=886s </li>
<li> https://fr.wikipedia.org/wiki/Interpolation_polynomiale </li>
</ul>

Algorithmes de multiplications d'entiers et de matrices

2026-05-11T15:12:49Z

Mangala : /* A) Fonctionnement */

= Introduction =

Depuis l'apparition des ordinateurs modernes, une quantité faramineuse de calcul a dû être effectuée. Les progressions technologiques nous poussent à envisager la puissance de calcul comme une ressource qu'il faut optimiser dans les moindres détails. C'est ainsi que l'optimisation des algorithmes de calcul est devenue cruciale, surtout lorsqu'il nous faut effectuer des opérations sur de très grands entiers par exemple.

= Objectif =

L'objectif majeur de ce projet est de comprendre de manière plus approfondie ce qu'est la '''complexité algorithmique'''.
Pour atteindre cet objectif, nous implémenterons plusieurs algorithmes de multiplication qui auront pour but de calculer le produit de grands entiers ou de matrices.

= Point important : complexité =

=== Définition ===
La complexité d'un algorithme est la quantité des ressources qu'il utilise en fonction de la taille des entrée qu'on lui demande de traiter. On peut par exemple se concentrer sur le temps qu'un algorithme prend pour renvoyer un résultat ou sur la mémoire dont il a besoin. Dans le cadre de notre projet, nous nous attarderons plus particulièrement sur la quantité de calcul effectuée en fonction de la taille des entrées, ce qui est par ailleurs fortement liée à la notion de temps. De manière générale, plus un algorithme doit faire de calcul, plus il est lent. (Attention, toutes les opérations arithmétiques de base ne se valent pas)

De manière plus familière, on dira que la complexité d'un algorithme pourrait s'apparenter à son comportement lorsqu'il doit traiter des données plus ou moins grandes.
Chaque algorithme a une complexité, et on l'exprime par une fonction qui adopte un comportement similaire au nombre de calcul nécessaire en fonction de la taille des entrées.

=== Notation ===
La complexité réelle d'un algorithme peut être décrite par une fonction <math>f(n)</math> représentant le nombre d'opérations effectuées en fonction de la taille <math>n</math> des données d'entrée.

Cependant, afin de simplifier l'étude de cette croissance, on utilise généralement une borne asymptotique notée <math>\mathcal{O}(g(n))</math>, où <math>g(n)</math> est une fonction ayant le même ordre de grandeur que <math>f(n)</math> lorsque <math>n</math> devient grand.

On dit alors que :

<math>
f(n)\in\mathcal{O}(g(n))
</math>

si et seulement s'il existe une constante <math>C>0</math> et un entier <math>n_0</math> tels que :

<math>
\forall n\ge n_0,\ f(n)\le Cg(n)
</math>

Cette notation <math>\mathcal{O}(g(n))</math> permettra de comparer beaucoup plus facilement les algorithmes entre eux.

=== Master Theorem ===

Afin de déterminer la complexité de certains algorithmes récursifs, nous utiliserons le "Master Theorem".

Ce théorème permet d'obtenir directement l'ordre de grandeur de nombreuses relations de récurrence apparaissant dans l'analyse d'algorithmes de type « diviser pour régner », comme l'algorithme de Karatsuba ou celui de Strassen.

La démonstration complète de ce théorème dépasse le cadre de notre projet et nécessite des connaissances mathématiques plus avancées. Nous l'utiliserons donc principalement comme un outil nous permettant de déterminer efficacement la complexité asymptotique des algorithmes étudiés.

=== Graphiques ===

Les complexités étant des fonctions, nous pouvons les représenter par un graphique qui affichera le temps d'exécution (ou nombre d'opérations) en fonction de la taille des entrées.

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:30px; text-align:center;">
[[Fichier:complexite.webp|500px]]
<div><b>Graphiques des complexités</b></div>
</div>
<div style="max-width:800px;">
<p>Ce graphique ci-contre compare les complexités en fonction de la taille des d'entrées.</p>
<p>On comprend ainsi que certaines complexités ne sont pas raisonnable dans la cadre de la multiplication de grands entiers.</p>
<p>C'est pourquoi l'étude de ces algorithmes s'avère nécessaire.</p>
</div>
</div>

=== Exemple ===
L'algorithme naïf d'addition que nous avons tous appris à l'école a une complexité de <math>\mathcal{O}(n)</math>.
Soit n la taille des nombres en entrée, l'algorithme doit faire environ n addition pour arriver au résultat demandé.

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Addition.gif|220px]]
<div><b>Addition naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Comme le montre l'exemple ci-contre, 786 et 467 font 3 chiffres de long donc n sera de 3.</p>
<p>Il nous faudra 3 opérations pour additionner ces deux nombres.</p>
<p>C'est ainsi qu'avec une taille d'entrée n, l'algorithme de l'addition naïve va devoir faire n opérations.</p>
<p>Cette algorithme a donc une complexité <math>f(n) = n</math> qui n'a pas besoin d'être approximée.</p>
<p>Ainsi sa complexité finale sera <math>\mathcal{O}(n)</math>.</p>
</div>
</div>

= Problématique =

Le calcul du produit de deux entiers de manière naïve a une complexité de <math> \mathcal{O}(n^2)</math>, et celui de deux matrices une complexité de <math> \mathcal{O}(n^3)</math>. Afin de mieux comprendre ce qu'est la complexité algorithmique, nous devrons implémenter des algorithmes ayant le même objectif, mais étant plus efficaces. Ces algorithmes s'avèreront plus complexes mais devrait aboutir à un calcul plus rapide du produit demandé.

Nous séparerons notre wiki en deux grandes parties, la première concernera nos recherche sur [[#I - Produit d'entiers|la multiplication d'entiers]], la deuxième sur [[#II - Produit de matrices|la multiplication de matrices]].

= I - Produit d'entiers =

Notre départ commence avec l'algorithme de multiplication d'entier naïf.
En effet il s'agit de l'algorithme de multiplication le plus connu, et nous l'utiliserons comme référence pour le comparer aux futurs algorithmes plus efficaces.
Intéressons nous à sa complexité.

== 1) Nos implémentations des grands entiers ==

Qui dit produit de grands entiers dit implémentation de grands entiers.

Dans le cadre de nos recherches, nous allons devoir implémenter des algorithmes qui vont manipuler des grands entiers.

Nous avons donc choisi de créer deux représentations différentes de ceux-ci (car nous travaillons sur différents langages de programmation), nous permettant à la fois une implémentation simplifié, mais aussi de nous rapprocher d'une implémentation bas niveau.

=== A) En python ===
En python, l'utilisation des "bytes" m'a grandement servi à comprendre comment les entiers étaient manipulés à bas niveau. En effet, un des objectifs secondaires de nos recherches était de manipuler des entiers directement avec leur formes stockées sur l'ordinateur, et non pas avec des int python.
En effet l'utilisation des int python nous aurait permit de passer les étapes de retenues, de signes... D'autant plus que les bytes permettent de stocker un nombre en base 256, ce qui permet de visualiser plus facilement les grands entiers.

La forme finale de la représentation des grands entiers en python sera donc la suivante :

[ signe , bytes , bytes , (...) , bytes ]

Le signe est représenté par un entier, 1 si le nombre est positif, 0 sinon.
Cette configuration rendra plus simple la gestion des signes.

=== B) En C++ ===

En C++, pour avoir une représentation de grand entiers j'ai du définir ma propre structure pour m'affranchir de la limite de taille imposé par les entiers standards: (int32 ou int64). Pour cela, j'ai une structure qui possède l'équivalent d'un array de byte (ce qui nous permet d'être en base 256 au lieu de la base 10 habituelle), et pour traiter le signe j'utilise un booléen, ainsi en mémoire j'ai une structure de n*Octets + 1 octet en taille.

[ bytes , bytes , (...) , bytes ] [ signe ]

Le booléen prend 1 octet de place mais ne touche pas aux octets qui encode le grand entier.
Cette configuration rendra plus simple la gestion des signes dans le cadre des multiplication.

== 2) La multiplication naïve ==

=== A) Fonctionnement ===
Dans le cas de la multiplication d'entiers, nous allons prendre deux nombres qui n'ont pas nécessairement la même longueur. Soit les nombre a et b, de longueur respective <math>n</math> et <math> m </math>.
<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Multiplication.png|220px]]
<div><b>Multiplication naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Prenons deux nombres de longueur 3 et 2, et cherchons combien d'opérations l'algorithme de multiplication naïve va devoir faire pour nous renvoyer leur produit.</p>
<p>Dans un premier temps, on remarque que l'on va devoir multiplier chaque chiffre du nombre du haut par le chiffre des unités du bas, qui est 6. Cela va représenter <math>n</math> opérations. (6x5, 6x1 et 6x4)</p>
<p>Dans un deuxième temps nous constatons que nous allons devoir faire la même chose avec le chiffre des dizaines du nombre du bas. Cela nous ajoute de nouveau <math>n</math> opérations.</p>
<p>On arrive assez facilement à la conclusion que pour faire notre produit, il va nous falloir faire <math>n</math> fois <math>m</math> opérations.</p>
</div>
</div>

Ainsi, la complexité de la multiplication naïve est <math>\mathcal{O}(n^2)</math>.
Il est en de même avec la multiplication naïve récursive.

=== B) Graphique ===
Montrons maintenant sa courbe sur un graphique :

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Multiplicationnaive.png|500px]]
<div><b>Multiplication naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Les points noirs sont des repères pour que les autres courbes aient une forme cohérente.</p>
<p>Ils sont tous sur l'axe des abscisses.</p>
<p>La courbe rouge représente la complexité de la multiplication naïve.</p>
<p>On remarque que la courbe a un visuel très similaire à la fonction <math>f(x) = x^2</math> </p>
</div>
</div>

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Naif_recursif.png|500px]]
<div><b>Multiplication naïve récursive</b></div>
</div>
<div style="max-width:800px;">
<p>La courbe rouge représente la complexité de la multiplication naïve récursive.</p>
<p>Elle sera utilisé pour comparer les complexités entre algorithmes car, comme tous récursifs, elle a été codé avec les mêmes biais d'implémentation qu'eux.</p>
<p>Théoriquement les deux courbes ci-contre ont la même complexité, mais encore une fois, notre implémentation n'est pas parfaitement optimale et donc ne respecte pas de manière minutieuse le Master Theorem.</p>
</div>
</div>

== 3) La multiplication karastuba ==

=== A) Fonctionnement ===

L'algorithme de karatsuba est un algorithme récursif de type diviser pour régner.

L'idée générale de l'algorithme est de passer de 4 multiplication à 3. En effet ces opérations étant moins couteuses, il est préférable d'en ajouter si cela permet d'enlever des multiplications.

L'algorithme de multiplication naif récursif utilise la segmentation des facteurs en deux de manière successive.

Soit <math>x</math> et <math>y</math> deux facteurs, nous avons les égalités suivantes :

<div style="font-size: 20px;">
<math>x = a \times B^{n/2} + b</math>
<math>y = c \times B^{n/2} + d</math>
</div>

Avec <math>a</math> et <math>c</math> les premières moitiés des facteurs <math>x</math> et <math>y</math>,
et <math>b</math> et <math>d</math> les dernières moitiés de ces facteurs ainsi que <math>B</math> la base d'écriture du nombre (Nous sommes en base 256 avec les bytes).

Cette présentation des deux facteurs de notre multiplication n'est que la résultante d'un découpage.
Le [[#Master Theorem|Master Theorem]] nous montre que :

<div style="font-size: 20px;">
<math>T(n) = 4T(n/2) + O(n)</math>
</div>

Puisque nous avons après découpage 4 entiers de longueur <math>n/2</math>.

Ainsi, ce découpage ne permet pas de gagner du temps d'après le [[#Master Theorem|Master Theorem]].

Cependant, l'algorithme de Karatsuba réutilise ce principe en le modifiant, ce qui nous permet de baisser la complexité globale de la multiplication dans son entièreté.

Avec l'écriture ci-dessus des nombres <math>x</math> et <math>y</math>, on peut facilement en déduire l'égalité suivante :

<div style="font-size: 20px;">
<math>x \times y = (ac) \times B^n + (ad + bc) \times B^{n/2} + bd</math>
</div>

On remarque 4 multiplications longues à faire dans cette expression. Les multiplications dont <math>B</math> est l'un des facteurs sont très rapides puisqu'il s'agit de la base dans laquelle nous travaillons. De cela en résulte un décalage plutôt qu'un vrai calcul à faire.

Karatsuba développe une partie de cette expression pour pouvoir négocier une multiplication au prix d'additions et soustractions.

En effet, nous savons déjà que :

<div style="font-size: 20px;">
<math>(a + b)(c + d) = ac + ad + bc + bd</math>
</div>

En manipulant l'égalité nous obtenons :

<div style="font-size: 20px;">
<math>ad + bc = (a + b)(c + d) - ac - bd</math>
</div>

ac et bd ayant déjà été calculé précédemment, il nous reste uniquement la multiplication <math>(a + b)(c + d)</math>.

Nous venons ainsi de calculer <math>ad + bc</math> en seulement une multiplication. C'est la que repose le gain de temps de la méthode Karatsuba par rapport à la multiplication naïve.

En effet, l'algorithme n'effectuera alors plus que 3 multiplications :
<div style="font-size: 20px;">
<math>ac</math>
<math>bd</math>
<math>(a + b)(c + d)</math>
</div>

La relation de récurrence devient donc :
<div style="font-size: 20px;">
<math>T(n)=3T(n/2)+O(n)</math>
</div>

Et le Master Theorem nous dit que :
<div style="font-size: 20px;">
<math>T(n)\in O(n^{\log_2(3)})</math>
</div>

Or <math>\log_2(3)\approx 1.585</math>, donc la complexité de l'algorithme de Karatsuba est de <math> \mathcal{O}(n^{1.585})</math>. Ce qui est bien plus efficace que la multiplication classique, surtout lorsque les facteurs deviennent très grands.

=== B) Graphique ===
<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Karatsuba.png|500px]]
<div><b>Karatsuba</b></div>
</div>
<div style="max-width:800px;">
<p>Sur le graphique ci-contre nous avons utilisé la courbe de la multiplication naïve récursive (rouge) à titre de comparaison.</p>
<p>On remarque graphiquement que Karatsuba (jaune) prend moins de temps à chaque calcul de produit.</p>
<p>On en déduit donc expérimentalement que Karatsuba à une meilleure complexité que la multiplication naïve.</p>
<p>Ainsi nous vérifions donc ce que le Master Theorem prouve, c'est à dire que la complexité de karatsuba est de <math> \mathcal{O}(n^{1.585})</math> </p>
</div>
</div>

== 4) La multiplication toom-cook-3 ==

=== A) Fonctionnement ===

L'objectif est de diviser les grands entiers X et Y en trois blocs de taille égale k.
On les traite alors comme des polynômes de degré 2:

<math>P(z) = X_2 \cdot z^2 + X_1 \cdot z + X_0</math>
<math>Q(z) = Y_2 \cdot z^2 + Y_1 \cdot z + Y_0</math>

On choisit 5 points distincts pour évaluer nos polynômes.
Ce choix de 5 points est crucial car le produit de deux polynômes de degré 2 est un polynôme de degré 4, qui nécessite 5 points pour être défini.
Les points standards sont :

P(0) = X0
P(1) = X0 + X1 + X2
P(-1) = X0 - X1 + X2
P(2) = X0 + 2*X1 + 4*X2
P(inf) = X2

(On procède de manière similaire pour Q.)

Ensuite nous multiplions récursivement chaque points de P et de Q ensemble.
On effectue ainsi 5 multiplications de nombres plus petits au lieu des 9 multiplications requises par la méthode classique.

Après, nous effectuons une interpolation, cela permet de retrouver les 5 coefficients (w_0, w_1, w_2, w_3, w_4) du polynôme produit R(z) à partir des valeurs évaluées calculées précédemment.
On résout un système d'équations linéaires : <math> R(z) = w_4 z^4 + w_3 z^3 + w_2 z^2 + w_1 z + w_0 </math>
Finalement nous pouvons recomposer notre grand entier en positionnant les coefficients w_i aux bons rangs (en les décalant) et à gérer les retenues lors de l'addition finale:
<math>Résultat = w_4 B^{4k} + w_3 B^{3k} + w_2 B^{2k} + w_1 B^k + w_0</math>

=== B) Graphique ===

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Toomcook.png|500px]]
<div><b>Karatsuba</b></div>
</div>
<div style="max-width:800px;">
<p>on a reprit multi récursive (rouge)</p>
<p>on voit que Toom (vert) en dessous de karatsuba (jaune) en dessous de multi classique (rouge)</p>
<p>meilleur complexité</p>
</div>
</div>

== 5) La transformée de Fourier rapide ==

=== A) Fonctionnement ===

La transformation de Fourier rapide étant plus complexe que les autres algorithmes, nous allons essayer d'expliquer son fonctionnement malgré ne pas avoir réussi à l'implémenter.

Il faut comprendre que cet algorithme va considérer les facteurs comme des polynômes.

D'après le théorème de l'unisolvance, il n'existe qu'un seul polynôme de degré inférieur ou égal à <math> n </math> défini par <math>n + 1</math> points distincts. Cela implique non seulement que nous pouvons représenter chaque entier par un polynôme, mais également que si nous pouvons retrouver <math>n + m + 1</math> points (avec <math>n</math> et <math>m</math> la longueur des facteurs) du polynômes issue du produit entre deux facteurs, nous pourrons le retrouver.

Soit un entier quelconque, de forme :

<math>a_n a_{n-1} (...) a_1 a_0</math>

Avec <math>a_i</math>, un chiffre composant le nombre en base 10, qui vaut en réalité dans le nombre : <math>a_i \times 10^i</math>. On peut ainsi l'écrire sous la forme :

<math> P(x) = a_0 + a_1x + a_2x^2 + \dots + a_{n-1}x^{n-1} + a_nx^n </math>

Avec <math>x = 10</math> car nous sommes en base 10, nous obtenons :

<math>P(10) = a_0 + a_1 \times 10 + \dots + a_{n-1}10^{n-1} + a_n10^n </math>

Nous venons ainsi d'écrire notre nombre sous la forme d'un polynôme unique. Pour nous permettre d'évaluer en un nombre suffisant de points, nous allons devoir ajouter des 0 pour la récursion. Il nous faudra ajouter assez de 0 pour atteindre la prochaine puissance de 2 qui sera supérieure ou égale à <math>2n + 1</math>. L'ajout de 0 ne change pas le nombre car <math>0 \times x^n</math> n'ajoute pas de coefficient.

Cet algorithme est récursif et va segmenter en deux parties nos polynômes à chaque récursion. D'un coté les indice paires et d'un coté les impaires.

Ainsi prenons les nombres 1234 et 5678, ces nombres sont respectivement représentés par les polynômes <math> P(x) = 4 + 3x + 2x^2 + x^3 </math> et <math> P(x) = 8 + 7x + 6x^2 + 5^3 </math>. Ce sont des polynômes de degré 3, ainsi leur produit donnera lieu à un polynôme de degré 6. Il nous faudra donc au minimum 7 points d'évaluation pour retrouve ce produit. De ce fait, en les représentant de la manière suivante :

<math>[4, 3, 2, 1, 0, 0, 0, 0]</math>
<math>[8, 7, 6, 5, 0, 0, 0, 0]</math>

Nous aurons assez de récursions possible pour les évaluer en un nombre suffisant de points différents car nous auront 3 récursions à faire pour atteindre notre cas de base. A chaque récursion, nous allons diviser nos polynômes en deux parties ce qui nous fait 8 feuilles à la dernière récursion.

En effet à chaque étape de la récursion nous allons séparer nos polynômes en deux tel que :

<math>P(x)=P_{\text{pair}}(x^2) + x \cdot P_{\text{impair}}(x^2)</math>

Durant les récursions, nous segmentons les polynômes mais ne les évaluons pas. C'est à la remonté des récursions que nous allons réellement évaluer nos polynômes. Lorsque l'on atteint notre cas de base, c'est à dire des polynômes de degré 0, nous remarquons qu'ils sont constants, nous n'avons donc pas besoin de les évaluer. En effet, peut importe le point en lequel nous voudrons l'évaluer, le polynôme renverra la constante. Nous la renvoyons donc seule.
Ensuite commence la remontée des récursions. A l'étape 1 de notre remontée nous allons reformer le polynôme précédemment séparé pour obtenir un polynôme de degré 1. Puis, nous évaluons ce polynôme avec les racines seconde de l'unité. Nous faisons à nouveau remonté les évaluations et recombinons à nouveau le polynôme qui sera ainsi de degré 2.
Nous l'évaluons maintenant avec les racines 4eme de l'unité. A chaque évaluation, nous réutilisons les résultats précédents, cela nous est permit par les racines de l'unité qui ont une structure récursive exploitable.

Finalement, nous arrivons à la fin de notre FFT, avec une représentation fréquentielle de la forme :

<math> [P(W_0), P(W_1), (...), P(W_n-1), P(W_n)] </math>

Cette représentation fréquentielle n'est autre que les évaluations du polynôme P aux racines nièmes de l'unité. Nous avons donc maintenant au minimum <math>2n+1</math> évaluations des polynômes facteurs. Il nous faut maintenant trouver les évaluations du produit final, c'est à dire les évaluations concernant le polynôme qui sera issue de la multiplication. On pourra ainsi le retrouver.

Soit <math>C</math> un polynome tel que <math> C = A \times B </math>, alors on a :

<math> C(x) = A(x) \times B(x) </math>

Ainsi on en déduit que <math> C(W_n^k) = A(W_n^k) \times B(W_n^k) </math>

On comprend donc que <math>FFT(C) = FFT(A) \times FFT(B)</math>

Il faut préciser que l'on fait le produit de FFT(A) et FFT(B) terme à terme, soit évaluation par évaluation.

Une fois en possession de <math>FFT(C)</math>, qui n'est autre que l'évaluation de notre polynôme final en un nombre suffisant de points pour le retrouver, nous pouvons faire l'<math>IFFT(FFT(C))</math>, qui va nous permettre de retrouver les coefficients de notre polynôme en faisant l'exacte inverse de la FFT.

Une fois les coefficients retrouvés, il nous suffit de gérer les retenues, et nous retrouvons un entier de la forme : <math>a_0 a_1 (...) a_{n-1} a_n</math>

=== B) Graphique ===

Intéressons nous maintenant à la complexité de l'algorithme utilisant la transformée de Fourier rapide. On sait que l'algorithme passe par 5 étapes importantes :

<ul>
<li>Etape 1 : Ecrire les deux facteurs sous la forme de polynômes</li>
<li>Etape 2 : Effectuer la <math>FFT</math> des deux polynômes</li>
<li>Etape 3 : Faire le produit terme à terme des <math>FFT</math> obtenues</li>
<li>Etape 4 : Faire l'<math>IFFT</math> du produit</li>
<li>Etape 5 : Gérer les retenues et écrire le nombre qui en découle</li>
</ul>

Or, parmi toutes ces étapes, certaines sont négligeable comme l'étape 1 et 5.

Pour connaitre la complexité de l'algorithme, additionnons les complexités des étapes restantes :

Une <math>FFT</math> a une complexité de <math>\mathcal{O}(n\times logn)</math> car elle fait <math>n</math> évaluation sur <math> log(n)</math> récursions. Dans le cadre de notre algorithme, nous devons faire la <math>FFT</math> de nos deux facteurs. Soit <math>2\times \mathcal{O}(n\times logn)</math>.

Pour le produit terme à terme, nous faisons naturellement <math>n</math> opérations.

Pour finir, l'<math>IFFT</math> a la même complexité que la <math>FFT</math>. Dans le cadre de notre algorithme nous l'emploierons qu'une seule fois, ce qui fait une complexité de <math>\mathcal{O}(n\times logn)</math>.

Après addition de toutes ces complexités, nous obtenons la complexité réelle de <math>3\mathcal{O}(n\times logn) + \mathcal{O}(n)</math>.

D'après le Master Theorem, nous avons donc <math> f(n) = 3(n\times logn)+n </math>, cherchons <math>f(n)\in\mathcal{O}(g(n))</math> :

Nous pouvons ignorer les expressions linéaires ainsi que les constantes multiplicatrices, nous obtenons donc <math>\mathcal{O}(g(n)) = \mathcal{O}(n \times log n)</math>.

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:30px; text-align:center;">
[[Fichier:FFT_image.webp|500px]]
<div><b>Graphiques des complexités</b></div>
</div>
<div style="max-width:800px;">
<p>Ce graphique ci-contre ne provient pas du fruit de nos recherches personnelles mais </p>
<p>On comprend ainsi que certaines complexités ne sont pas raisonnable dans la cadre de la multiplication de grands entiers.</p>
<p>C'est pourquoi l'étude de ces algorithmes s'avère nécessaire.</p>
</div>
</div>

= II - Produit de matrices =

== 1.1) naïve ==

La multiplication naïve de matrice requiert d'avoir des tailles de lignes/colonne semblable, ensuite pour chaque membre de la matrice résultat, on doit multiplier les composantes ligne de la première matrice par les composantes colonne de la deuxième et le tout sommé.

On en déduit la formule suivante:
<math>C_{i,j} = \sum_{k=1}^{n} (A_{i,k} \times B_{k,j})</math>

Et visuellement:

[[Fichier:Matricenaive.jpeg]]

On a donc un algorithme d'ordre de complexité <math>\mathcal{O}(g(n))</math>

== 1.2) naïve récursive ==

Dans un premier temps on doit découper nos deux matrices en quatres sous matrices de plus petite taille.
<math>A = \begin{pmatrix} A_{11} & A_{12} \ A_{21} & A_{22} \end{pmatrix}</math>
<math>B = \begin{pmatrix} B_{11} & B_{12} \ B_{21} & B_{22} \end{pmatrix}</math>

Ensuite on vient calculer la matrice résultat.
<math>C_{11} = (A_{11} \times B_{11}) + (A_{12} \times B_{21})</math>
<math>C_{12} = (A_{11} \times B_{12}) + (A_{12} \times B_{22})</math>
<math>C_{21} = (A_{21} \times B_{11}) + (A_{22} \times B_{21})</math>
<math>C_{22} = (A_{21} \times B_{12}) + (A_{22} \times B_{22})</math>

Le côté récursif est utile que pour les matrices de tailles <= 32 (32 valeurs stockées dedans),
si on est au dessus de cette taille alors on divisera à nouveau nos matrices en quatres.
On aura 8 multiplications mais de plus petite taille au final.

== 2) strassen ==

=== A) Fonctionnement ===

Strassen consiste à définir 7 produits intermédiaires qui, par des jeux de sommes et de différences, permettent de reconstruire les quadrants de la matrice résultante. On passe ainsi d'une complexité de O(n^3) à environ O(n^2.81)

=== B) Graphique ===

On voit bien la différence de complexité sur la multiplication de grande matrice entre l'approche naïve et l'approche récursive qui est beaucoup plus rapide.

[[Fichier:Analyse matrices.png]]

= Conclusion =

( A FAIRE )

= Mentions =

Le premier gif est le résultat du travail de 'Walké', licence ci-contre : https://fr.wikipedia.org/wiki/Fichier:Addition.gif

= Sources =

Pour karatsuba : https://www.youtube.com/watch?v=PZ2gdWdKHAA

Pour mieux comprendre la FFT, nous avons utilisé plusieurs sources d'informations :
<ul>
<li> https://www.youtube.com/watch?v=h7apO7q16V0&list=WL&index=1&t=886s </li>
<li> https://fr.wikipedia.org/wiki/Interpolation_polynomiale </li>
</ul>

Algorithmes de multiplications d'entiers et de matrices

2026-05-11T15:10:07Z

Mangala : /* B) Graphique */

= Introduction =

Depuis l'apparition des ordinateurs modernes, une quantité faramineuse de calcul a dû être effectuée. Les progressions technologiques nous poussent à envisager la puissance de calcul comme une ressource qu'il faut optimiser dans les moindres détails. C'est ainsi que l'optimisation des algorithmes de calcul est devenue cruciale, surtout lorsqu'il nous faut effectuer des opérations sur de très grands entiers par exemple.

= Objectif =

L'objectif majeur de ce projet est de comprendre de manière plus approfondie ce qu'est la '''complexité algorithmique'''.
Pour atteindre cet objectif, nous implémenterons plusieurs algorithmes de multiplication qui auront pour but de calculer le produit de grands entiers ou de matrices.

= Point important : complexité =

=== Définition ===
La complexité d'un algorithme est la quantité des ressources qu'il utilise en fonction de la taille des entrée qu'on lui demande de traiter. On peut par exemple se concentrer sur le temps qu'un algorithme prend pour renvoyer un résultat ou sur la mémoire dont il a besoin. Dans le cadre de notre projet, nous nous attarderons plus particulièrement sur la quantité de calcul effectuée en fonction de la taille des entrées, ce qui est par ailleurs fortement liée à la notion de temps. De manière générale, plus un algorithme doit faire de calcul, plus il est lent. (Attention, toutes les opérations arithmétiques de base ne se valent pas)

De manière plus familière, on dira que la complexité d'un algorithme pourrait s'apparenter à son comportement lorsqu'il doit traiter des données plus ou moins grandes.
Chaque algorithme a une complexité, et on l'exprime par une fonction qui adopte un comportement similaire au nombre de calcul nécessaire en fonction de la taille des entrées.

=== Notation ===
La complexité réelle d'un algorithme peut être décrite par une fonction <math>f(n)</math> représentant le nombre d'opérations effectuées en fonction de la taille <math>n</math> des données d'entrée.

Cependant, afin de simplifier l'étude de cette croissance, on utilise généralement une borne asymptotique notée <math>\mathcal{O}(g(n))</math>, où <math>g(n)</math> est une fonction ayant le même ordre de grandeur que <math>f(n)</math> lorsque <math>n</math> devient grand.

On dit alors que :

<math>
f(n)\in\mathcal{O}(g(n))
</math>

si et seulement s'il existe une constante <math>C>0</math> et un entier <math>n_0</math> tels que :

<math>
\forall n\ge n_0,\ f(n)\le Cg(n)
</math>

Cette notation <math>\mathcal{O}(g(n))</math> permettra de comparer beaucoup plus facilement les algorithmes entre eux.

=== Master Theorem ===

Afin de déterminer la complexité de certains algorithmes récursifs, nous utiliserons le "Master Theorem".

Ce théorème permet d'obtenir directement l'ordre de grandeur de nombreuses relations de récurrence apparaissant dans l'analyse d'algorithmes de type « diviser pour régner », comme l'algorithme de Karatsuba ou celui de Strassen.

La démonstration complète de ce théorème dépasse le cadre de notre projet et nécessite des connaissances mathématiques plus avancées. Nous l'utiliserons donc principalement comme un outil nous permettant de déterminer efficacement la complexité asymptotique des algorithmes étudiés.

=== Graphiques ===

Les complexités étant des fonctions, nous pouvons les représenter par un graphique qui affichera le temps d'exécution (ou nombre d'opérations) en fonction de la taille des entrées.

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:30px; text-align:center;">
[[Fichier:complexite.webp|500px]]
<div><b>Graphiques des complexités</b></div>
</div>
<div style="max-width:800px;">
<p>Ce graphique ci-contre compare les complexités en fonction de la taille des d'entrées.</p>
<p>On comprend ainsi que certaines complexités ne sont pas raisonnable dans la cadre de la multiplication de grands entiers.</p>
<p>C'est pourquoi l'étude de ces algorithmes s'avère nécessaire.</p>
</div>
</div>

=== Exemple ===
L'algorithme naïf d'addition que nous avons tous appris à l'école a une complexité de <math>\mathcal{O}(n)</math>.
Soit n la taille des nombres en entrée, l'algorithme doit faire environ n addition pour arriver au résultat demandé.

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Addition.gif|220px]]
<div><b>Addition naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Comme le montre l'exemple ci-contre, 786 et 467 font 3 chiffres de long donc n sera de 3.</p>
<p>Il nous faudra 3 opérations pour additionner ces deux nombres.</p>
<p>C'est ainsi qu'avec une taille d'entrée n, l'algorithme de l'addition naïve va devoir faire n opérations.</p>
<p>Cette algorithme a donc une complexité <math>f(n) = n</math> qui n'a pas besoin d'être approximée.</p>
<p>Ainsi sa complexité finale sera <math>\mathcal{O}(n)</math>.</p>
</div>
</div>

= Problématique =

Le calcul du produit de deux entiers de manière naïve a une complexité de <math> \mathcal{O}(n^2)</math>, et celui de deux matrices une complexité de <math> \mathcal{O}(n^3)</math>. Afin de mieux comprendre ce qu'est la complexité algorithmique, nous devrons implémenter des algorithmes ayant le même objectif, mais étant plus efficaces. Ces algorithmes s'avèreront plus complexes mais devrait aboutir à un calcul plus rapide du produit demandé.

Nous séparerons notre wiki en deux grandes parties, la première concernera nos recherche sur [[#I - Produit d'entiers|la multiplication d'entiers]], la deuxième sur [[#II - Produit de matrices|la multiplication de matrices]].

= I - Produit d'entiers =

Notre départ commence avec l'algorithme de multiplication d'entier naïf.
En effet il s'agit de l'algorithme de multiplication le plus connu, et nous l'utiliserons comme référence pour le comparer aux futurs algorithmes plus efficaces.
Intéressons nous à sa complexité.

== 1) Nos implémentations des grands entiers ==

Qui dit produit de grands entiers dit implémentation de grands entiers.

Dans le cadre de nos recherches, nous allons devoir implémenter des algorithmes qui vont manipuler des grands entiers.

Nous avons donc choisi de créer deux représentations différentes de ceux-ci (car nous travaillons sur différents langages de programmation), nous permettant à la fois une implémentation simplifié, mais aussi de nous rapprocher d'une implémentation bas niveau.

=== A) En python ===
En python, l'utilisation des "bytes" m'a grandement servi à comprendre comment les entiers étaient manipulés à bas niveau. En effet, un des objectifs secondaires de nos recherches était de manipuler des entiers directement avec leur formes stockées sur l'ordinateur, et non pas avec des int python.
En effet l'utilisation des int python nous aurait permit de passer les étapes de retenues, de signes... D'autant plus que les bytes permettent de stocker un nombre en base 256, ce qui permet de visualiser plus facilement les grands entiers.

La forme finale de la représentation des grands entiers en python sera donc la suivante :

[ signe , bytes , bytes , (...) , bytes ]

Le signe est représenté par un entier, 1 si le nombre est positif, 0 sinon.
Cette configuration rendra plus simple la gestion des signes.

=== B) En C++ ===

En C++, pour avoir une représentation de grand entiers j'ai du définir ma propre structure pour m'affranchir de la limite de taille imposé par les entiers standards: (int32 ou int64). Pour cela, j'ai une structure qui possède l'équivalent d'un array de byte (ce qui nous permet d'être en base 256 au lieu de la base 10 habituelle), et pour traiter le signe j'utilise un booléen, ainsi en mémoire j'ai une structure de n*Octets + 1 octet en taille.

[ bytes , bytes , (...) , bytes ] [ signe ]

Le booléen prend 1 octet de place mais ne touche pas aux octets qui encode le grand entier.
Cette configuration rendra plus simple la gestion des signes dans le cadre des multiplication.

== 2) La multiplication naïve ==

=== A) Fonctionnement ===
Dans le cas de la multiplication d'entiers, nous allons prendre deux nombres qui n'ont pas nécessairement la même longueur. Soit les nombre a et b, de longueur respective <math>n</math> et <math> m </math>.
<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Multiplication.png|220px]]
<div><b>Multiplication naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Prenons deux nombres de longueur 3 et 2, et cherchons combien d'opérations l'algorithme de multiplication naïve va devoir faire pour nous renvoyer leur produit.</p>
<p>Dans un premier temps, on remarque que l'on va devoir multiplier chaque chiffre du nombre du haut par le chiffre des unités du bas, qui est 6. Cela va représenter <math>n</math> opérations. (6x5, 6x1 et 6x4)</p>
<p>Dans un deuxième temps nous constatons que nous allons devoir faire la même chose avec le chiffre des dizaines du nombre du bas. Cela nous ajoute de nouveau <math>n</math> opérations.</p>
<p>On arrive assez facilement à la conclusion que pour faire notre produit, il va nous falloir faire <math>n</math> fois <math>m</math> opérations.</p>
</div>
</div>

Ainsi, la complexité de la multiplication naïve est <math>\mathcal{O}(n^2)</math>.
Il est en de même avec la multiplication naïve récursive.

=== B) Graphique ===
Montrons maintenant sa courbe sur un graphique :

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Multiplicationnaive.png|500px]]
<div><b>Multiplication naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Les points noirs sont des repères pour que les autres courbes aient une forme cohérente.</p>
<p>Ils sont tous sur l'axe des abscisses.</p>
<p>La courbe rouge représente la complexité de la multiplication naïve.</p>
<p>On remarque que la courbe a un visuel très similaire à la fonction <math>f(x) = x^2</math> </p>
</div>
</div>

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Naif_recursif.png|500px]]
<div><b>Multiplication naïve récursive</b></div>
</div>
<div style="max-width:800px;">
<p>La courbe rouge représente la complexité de la multiplication naïve récursive.</p>
<p>Elle sera utilisé pour comparer les complexités entre algorithmes car, comme tous récursifs, elle a été codé avec les mêmes biais d'implémentation qu'eux.</p>
<p>Théoriquement les deux courbes ci-contre ont la même complexité, mais encore une fois, notre implémentation n'est pas parfaitement optimale et donc ne respecte pas de manière minutieuse le Master Theorem.</p>
</div>
</div>

== 3) La multiplication karastuba ==

=== A) Fonctionnement ===

L'algorithme de karatsuba est un algorithme récursif de type diviser pour régner.

L'idée générale de l'algorithme est de passer de 4 multiplication à 3. En effet ces opérations étant moins couteuses, il est préférable d'en ajouter si cela permet d'enlever des multiplications.

L'algorithme de multiplication naif récursif utilise la segmentation des facteurs en deux de manière successive.

Soit <math>x</math> et <math>y</math> deux facteurs, nous avons les égalités suivantes :

<div style="font-size: 20px;">
<math>x = a \times B^{n/2} + b</math>
<math>y = c \times B^{n/2} + d</math>
</div>

Avec <math>a</math> et <math>c</math> les premières moitiés des facteurs <math>x</math> et <math>y</math>,
et <math>b</math> et <math>d</math> les dernières moitiés de ces facteurs ainsi que <math>B</math> la base d'écriture du nombre (Nous sommes en base 256 avec les bytes).

Cette présentation des deux facteurs de notre multiplication n'est que la résultante d'un découpage.
Le [[#Master Theorem|Master Theorem]] nous montre que :

<div style="font-size: 20px;">
<math>T(n) = 4T(n/2) + O(n)</math>
</div>

Puisque nous avons après découpage 4 entiers de longueur <math>n/2</math>.

Ainsi, ce découpage ne permet pas de gagner du temps d'après le [[#Master Theorem|Master Theorem]].

Cependant, l'algorithme de Karatsuba réutilise ce principe en le modifiant, ce qui nous permet de baisser la complexité globale de la multiplication dans son entièreté.

Avec l'écriture ci-dessus des nombres <math>x</math> et <math>y</math>, on peut facilement en déduire l'égalité suivante :

<div style="font-size: 20px;">
<math>x \times y = (ac) \times B^n + (ad + bc) \times B^{n/2} + bd</math>
</div>

On remarque 4 multiplications longues à faire dans cette expression. Les multiplications dont <math>B</math> est l'un des facteurs sont très rapides puisqu'il s'agit de la base dans laquelle nous travaillons. De cela en résulte un décalage plutôt qu'un vrai calcul à faire.

Karatsuba développe une partie de cette expression pour pouvoir négocier une multiplication au prix d'additions et soustractions.

En effet, nous savons déjà que :

<div style="font-size: 20px;">
<math>(a + b)(c + d) = ac + ad + bc + bd</math>
</div>

En manipulant l'égalité nous obtenons :

<div style="font-size: 20px;">
<math>ad + bc = (a + b)(c + d) - ac - bd</math>
</div>

ac et bd ayant déjà été calculé précédemment, il nous reste uniquement la multiplication <math>(a + b)(c + d)</math>.

Nous venons ainsi de calculer <math>ad + bc</math> en seulement une multiplication. C'est la que repose le gain de temps de la méthode Karatsuba par rapport à la multiplication naïve.

En effet, l'algorithme n'effectuera alors plus que 3 multiplications :
<div style="font-size: 20px;">
<math>ac</math>
<math>bd</math>
<math>(a + b)(c + d)</math>
</div>

La relation de récurrence devient donc :
<div style="font-size: 20px;">
<math>T(n)=3T(n/2)+O(n)</math>
</div>

Et le Master Theorem nous dit que :
<div style="font-size: 20px;">
<math>T(n)\in O(n^{\log_2(3)})</math>
</div>

Or <math>\log_2(3)\approx 1.585</math>, donc la complexité de l'algorithme de Karatsuba est de <math> \mathcal{O}(n^{1.585})</math>. Ce qui est bien plus efficace que la multiplication classique, surtout lorsque les facteurs deviennent très grands.

=== B) Graphique ===
<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Karatsuba.png|500px]]
<div><b>Karatsuba</b></div>
</div>
<div style="max-width:800px;">
<p>Sur le graphique ci-contre nous avons utilisé la courbe de la multiplication naïve récursive (rouge) à titre de comparaison.</p>
<p>On remarque graphiquement que Karatsuba (jaune) prend moins de temps à chaque calcul de produit.</p>
<p>On en déduit donc expérimentalement que Karatsuba à une meilleure complexité que la multiplication naïve.</p>
<p>Ainsi nous vérifions donc ce que le Master Theorem prouve, c'est à dire que la complexité de karatsuba est de <math> \mathcal{O}(n^{1.585})</math> </p>
</div>
</div>

== 4) La multiplication toom-cook-3 ==

=== A) Fonctionnement ===

L'objectif est de diviser les grands entiers X et Y en trois blocs de taille égale k.
On les traite alors comme des polynômes de degré 2:

<math>P(z) = X_2 \cdot z^2 + X_1 \cdot z + X_0</math>
<math>Q(z) = Y_2 \cdot z^2 + Y_1 \cdot z + Y_0</math>

On choisit 5 points distincts pour évaluer nos polynômes.
Ce choix de 5 points est crucial car le produit de deux polynômes de degré 2 est un polynôme de degré 4, qui nécessite 5 points pour être défini.
Les points standards sont :

P(0) = X0
P(1) = X0 + X1 + X2
P(-1) = X0 - X1 + X2
P(2) = X0 + 2*X1 + 4*X2
P(inf) = X2

(On procède de manière similaire pour Q.)

Ensuite nous multiplions récursivement chaque points de P et de Q ensemble.
On effectue ainsi 5 multiplications de nombres plus petits au lieu des 9 multiplications requises par la méthode classique.

Après, nous effectuons une interpolation, cela permet de retrouver les 5 coefficients (w_0, w_1, w_2, w_3, w_4) du polynôme produit R(z) à partir des valeurs évaluées calculées précédemment.
On résout un système d'équations linéaires : <math> R(z) = w_4 z^4 + w_3 z^3 + w_2 z^2 + w_1 z + w_0 </math>
Finalement nous pouvons recomposer notre grand entier en positionnant les coefficients w_i aux bons rangs (en les décalant) et à gérer les retenues lors de l'addition finale:
<math>Résultat = w_4 B^{4k} + w_3 B^{3k} + w_2 B^{2k} + w_1 B^k + w_0</math>

=== B) Graphique ===

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Toomcook.png|500px]]
<div><b>Karatsuba</b></div>
</div>
<div style="max-width:800px;">
<p>on a reprit multi récursive (rouge)</p>
<p>on voit que Toom (vert) en dessous de karatsuba (jaune) en dessous de multi classique (rouge)</p>
<p>meilleur complexité</p>
</div>
</div>

== 5) La transformée de Fourier rapide ==

=== A) Fonctionnement ===

La transformation de Fourier rapide étant plus complexe que les autres algorithmes, nous allons essayer d'expliquer son fonctionnement malgré ne pas avoir réussi à l'implémenter.

Il faut comprendre que cet algorithme va considérer les facteurs comme des polynômes.

D'après le théorème de l'unisolvance, il n'existe qu'un seul polynôme de degré inférieur ou égal à <math> n </math> défini par <math>n + 1</math> points distincts. Cela implique non seulement que nous pouvons représenter chaque entier par un polynôme, mais également que si nous pouvons retrouver <math>n + m + 1</math> points (avec <math>n</math> et <math>m</math> la longueur des facteurs) du polynômes issue du produit entre deux facteurs, nous pourrons le retrouver.

Soit un entier quelconque, de forme :

<math>a_n a_{n-1} (...) a_1 a_0</math>

Avec <math>a_i</math>, un chiffre composant le nombre en base 10, qui vaut en réalité dans le nombre : <math>a_i \times 10^i</math>. On peut ainsi l'écrire sous la forme :

<math> P(x) = a_0 + a_1x + a_2x^2 + \dots + a_{n-1}x^{n-1} + a_nx^n </math>

Avec <math>x = 10</math> car nous sommes en base 10, nous obtenons :

<math>P(10) = a_0 + a_1 \times 10 + \dots + a_{n-1}10^{n-1} + a_n10^n </math>

Nous venons ainsi d'écrire notre nombre sous la forme d'un polynôme unique. Pour nous permettre d'évaluer en un nombre suffisant de points, nous allons devoir ajouter des 0 pour la récursion. Il nous faudra ajouter assez de 0 pour atteindre la prochaine puissance de 2 qui sera supérieure ou égale à <math>2n + 1</math>. L'ajout de 0 ne change pas le nombre car <math>0 \times x^n</math> n'ajoute pas de coefficient.

Cet algorithme est récursif et va segmenter en deux parties nos polynômes à chaque récursion. D'un coté les indice paires et d'un coté les impaires.

Ainsi prenons les nombres 1234 et 5678, ces nombres sont respectivement représentés par les polynômes <math> P(x) = 4 + 3x + 2x^2 + x^3 </math> et <math> P(x) = 8 + 7x + 6x^2 + 5^3 </math>. Ce sont des polynômes de degré 3, ainsi leur produit donnera lieu à un polynôme de degré 6. Il nous faudra donc au minimum 7 points d'évaluation pour retrouve ce produit. De ce fait, en les représentant de la manière suivante :

<math>[4, 3, 2, 1, 0, 0, 0, 0]</math>
<math>[8, 7, 6, 5, 0, 0, 0, 0]</math>

Nous aurons assez de récursions possible pour les évaluer en un nombre suffisant de points différents car nous auront 3 récursions à faire pour atteindre notre cas de base. A chaque récursion, nous allons diviser nos polynômes en deux parties ce qui nous fait 8 feuilles à la dernière récursion.

En effet à chaque étape de la récursion nous allons séparer nos polynômes en deux tel que :

<math> P(x)=P_{pair}x^2 + x \times P_{impair}x^2 </math>

Durant les récursions, nous segmentons les polynômes mais ne les évaluons pas. C'est à la remonté des récursions que nous allons réellement évaluer nos polynômes. Lorsque l'on atteint notre cas de base, c'est à dire des polynômes de degré 0, nous remarquons qu'ils sont constants, nous n'avons donc pas besoin de les évaluer. En effet, peut importe le point en lequel nous voudrons l'évaluer, le polynôme renverra la constante. Nous la renvoyons donc seule.
Ensuite commence la remontée des récursions. A l'étape 1 de notre remontée nous allons reformer le polynôme précédemment séparé pour obtenir un polynôme de degré 1. Puis, nous évaluons ce polynôme avec les racines seconde de l'unité. Nous faisons à nouveau remonté les évaluations et recombinons à nouveau le polynôme qui sera ainsi de degré 2.
Nous l'évaluons maintenant avec les racines 4eme de l'unité. A chaque évaluation, nous réutilisons les résultats précédents, cela nous est permit par les racines de l'unité qui ont une structure récursive exploitable.

Finalement, nous arrivons à la fin de notre FFT, avec une représentation fréquentielle de la forme :

<math> [P(W_0), P(W_1), (...), P(W_n-1), P(W_n)] </math>

Cette représentation fréquentielle n'est autre que les évaluations du polynôme P aux racines nièmes de l'unité. Nous avons donc maintenant au minimum <math>2n+1</math> évaluations des polynômes facteurs. Il nous faut maintenant trouver les évaluations du produit final, c'est à dire les évaluations concernant le polynôme qui sera issue de la multiplication. On pourra ainsi le retrouver.

Soit <math>C</math> un polynome tel que <math> C = A \times B </math>, alors on a :

<math> C(x) = A(x) \times B(x) </math>

Ainsi on en déduit que <math> C(W_n^k) = A(W_n^k) \times B(W_n^k) </math>

On comprend donc que <math>FFT(C) = FFT(A) \times FFT(B)</math>

Il faut préciser que l'on fait le produit de FFT(A) et FFT(B) terme à terme, soit évaluation par évaluation.

Une fois en possession de <math>FFT(C)</math>, qui n'est autre que l'évaluation de notre polynôme final en un nombre suffisant de points pour le retrouver, nous pouvons faire l'<math>IFFT(FFT(C))</math>, qui va nous permettre de retrouver les coefficients de notre polynôme en faisant l'exacte inverse de la FFT.

Une fois les coefficients retrouvés, il nous suffit de gérer les retenues, et nous retrouvons un entier de la forme : <math>a_0 a_1 (...) a_{n-1} a_n</math>

=== B) Graphique ===

Intéressons nous maintenant à la complexité de l'algorithme utilisant la transformée de Fourier rapide. On sait que l'algorithme passe par 5 étapes importantes :

<ul>
<li>Etape 1 : Ecrire les deux facteurs sous la forme de polynômes</li>
<li>Etape 2 : Effectuer la <math>FFT</math> des deux polynômes</li>
<li>Etape 3 : Faire le produit terme à terme des <math>FFT</math> obtenues</li>
<li>Etape 4 : Faire l'<math>IFFT</math> du produit</li>
<li>Etape 5 : Gérer les retenues et écrire le nombre qui en découle</li>
</ul>

Or, parmi toutes ces étapes, certaines sont négligeable comme l'étape 1 et 5.

Pour connaitre la complexité de l'algorithme, additionnons les complexités des étapes restantes :

Une <math>FFT</math> a une complexité de <math>\mathcal{O}(n\times logn)</math> car elle fait <math>n</math> évaluation sur <math> log(n)</math> récursions. Dans le cadre de notre algorithme, nous devons faire la <math>FFT</math> de nos deux facteurs. Soit <math>2\times \mathcal{O}(n\times logn)</math>.

Pour le produit terme à terme, nous faisons naturellement <math>n</math> opérations.

Pour finir, l'<math>IFFT</math> a la même complexité que la <math>FFT</math>. Dans le cadre de notre algorithme nous l'emploierons qu'une seule fois, ce qui fait une complexité de <math>\mathcal{O}(n\times logn)</math>.

Après addition de toutes ces complexités, nous obtenons la complexité réelle de <math>3\mathcal{O}(n\times logn) + \mathcal{O}(n)</math>.

D'après le Master Theorem, nous avons donc <math> f(n) = 3(n\times logn)+n </math>, cherchons <math>f(n)\in\mathcal{O}(g(n))</math> :

Nous pouvons ignorer les expressions linéaires ainsi que les constantes multiplicatrices, nous obtenons donc <math>\mathcal{O}(g(n)) = \mathcal{O}(n \times log n)</math>.

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:30px; text-align:center;">
[[Fichier:FFT_image.webp|500px]]
<div><b>Graphiques des complexités</b></div>
</div>
<div style="max-width:800px;">
<p>Ce graphique ci-contre ne provient pas du fruit de nos recherches personnelles mais </p>
<p>On comprend ainsi que certaines complexités ne sont pas raisonnable dans la cadre de la multiplication de grands entiers.</p>
<p>C'est pourquoi l'étude de ces algorithmes s'avère nécessaire.</p>
</div>
</div>

= II - Produit de matrices =

== 1.1) naïve ==

La multiplication naïve de matrice requiert d'avoir des tailles de lignes/colonne semblable, ensuite pour chaque membre de la matrice résultat, on doit multiplier les composantes ligne de la première matrice par les composantes colonne de la deuxième et le tout sommé.

On en déduit la formule suivante:
<math>C_{i,j} = \sum_{k=1}^{n} (A_{i,k} \times B_{k,j})</math>

Et visuellement:

[[Fichier:Matricenaive.jpeg]]

On a donc un algorithme d'ordre de complexité <math>\mathcal{O}(g(n))</math>

== 1.2) naïve récursive ==

Dans un premier temps on doit découper nos deux matrices en quatres sous matrices de plus petite taille.
<math>A = \begin{pmatrix} A_{11} & A_{12} \ A_{21} & A_{22} \end{pmatrix}</math>
<math>B = \begin{pmatrix} B_{11} & B_{12} \ B_{21} & B_{22} \end{pmatrix}</math>

Ensuite on vient calculer la matrice résultat.
<math>C_{11} = (A_{11} \times B_{11}) + (A_{12} \times B_{21})</math>
<math>C_{12} = (A_{11} \times B_{12}) + (A_{12} \times B_{22})</math>
<math>C_{21} = (A_{21} \times B_{11}) + (A_{22} \times B_{21})</math>
<math>C_{22} = (A_{21} \times B_{12}) + (A_{22} \times B_{22})</math>

Le côté récursif est utile que pour les matrices de tailles <= 32 (32 valeurs stockées dedans),
si on est au dessus de cette taille alors on divisera à nouveau nos matrices en quatres.
On aura 8 multiplications mais de plus petite taille au final.

== 2) strassen ==

=== A) Fonctionnement ===

Strassen consiste à définir 7 produits intermédiaires qui, par des jeux de sommes et de différences, permettent de reconstruire les quadrants de la matrice résultante. On passe ainsi d'une complexité de O(n^3) à environ O(n^2.81)

=== B) Graphique ===

On voit bien la différence de complexité sur la multiplication de grande matrice entre l'approche naïve et l'approche récursive qui est beaucoup plus rapide.

[[Fichier:Analyse matrices.png]]

= Conclusion =

( A FAIRE )

= Mentions =

Le premier gif est le résultat du travail de 'Walké', licence ci-contre : https://fr.wikipedia.org/wiki/Fichier:Addition.gif

= Sources =

Pour karatsuba : https://www.youtube.com/watch?v=PZ2gdWdKHAA

Pour mieux comprendre la FFT, nous avons utilisé plusieurs sources d'informations :
<ul>
<li> https://www.youtube.com/watch?v=h7apO7q16V0&list=WL&index=1&t=886s </li>
<li> https://fr.wikipedia.org/wiki/Interpolation_polynomiale </li>
</ul>

Algorithmes de multiplications d'entiers et de matrices

2026-05-11T15:05:04Z

Mangala : /* 5) La transformée de Fourier rapide */

= Introduction =

Depuis l'apparition des ordinateurs modernes, une quantité faramineuse de calcul a dû être effectuée. Les progressions technologiques nous poussent à envisager la puissance de calcul comme une ressource qu'il faut optimiser dans les moindres détails. C'est ainsi que l'optimisation des algorithmes de calcul est devenue cruciale, surtout lorsqu'il nous faut effectuer des opérations sur de très grands entiers par exemple.

= Objectif =

L'objectif majeur de ce projet est de comprendre de manière plus approfondie ce qu'est la '''complexité algorithmique'''.
Pour atteindre cet objectif, nous implémenterons plusieurs algorithmes de multiplication qui auront pour but de calculer le produit de grands entiers ou de matrices.

= Point important : complexité =

=== Définition ===
La complexité d'un algorithme est la quantité des ressources qu'il utilise en fonction de la taille des entrée qu'on lui demande de traiter. On peut par exemple se concentrer sur le temps qu'un algorithme prend pour renvoyer un résultat ou sur la mémoire dont il a besoin. Dans le cadre de notre projet, nous nous attarderons plus particulièrement sur la quantité de calcul effectuée en fonction de la taille des entrées, ce qui est par ailleurs fortement liée à la notion de temps. De manière générale, plus un algorithme doit faire de calcul, plus il est lent. (Attention, toutes les opérations arithmétiques de base ne se valent pas)

De manière plus familière, on dira que la complexité d'un algorithme pourrait s'apparenter à son comportement lorsqu'il doit traiter des données plus ou moins grandes.
Chaque algorithme a une complexité, et on l'exprime par une fonction qui adopte un comportement similaire au nombre de calcul nécessaire en fonction de la taille des entrées.

=== Notation ===
La complexité réelle d'un algorithme peut être décrite par une fonction <math>f(n)</math> représentant le nombre d'opérations effectuées en fonction de la taille <math>n</math> des données d'entrée.

Cependant, afin de simplifier l'étude de cette croissance, on utilise généralement une borne asymptotique notée <math>\mathcal{O}(g(n))</math>, où <math>g(n)</math> est une fonction ayant le même ordre de grandeur que <math>f(n)</math> lorsque <math>n</math> devient grand.

On dit alors que :

<math>
f(n)\in\mathcal{O}(g(n))
</math>

si et seulement s'il existe une constante <math>C>0</math> et un entier <math>n_0</math> tels que :

<math>
\forall n\ge n_0,\ f(n)\le Cg(n)
</math>

Cette notation <math>\mathcal{O}(g(n))</math> permettra de comparer beaucoup plus facilement les algorithmes entre eux.

=== Master Theorem ===

Afin de déterminer la complexité de certains algorithmes récursifs, nous utiliserons le "Master Theorem".

Ce théorème permet d'obtenir directement l'ordre de grandeur de nombreuses relations de récurrence apparaissant dans l'analyse d'algorithmes de type « diviser pour régner », comme l'algorithme de Karatsuba ou celui de Strassen.

La démonstration complète de ce théorème dépasse le cadre de notre projet et nécessite des connaissances mathématiques plus avancées. Nous l'utiliserons donc principalement comme un outil nous permettant de déterminer efficacement la complexité asymptotique des algorithmes étudiés.

=== Graphiques ===

Les complexités étant des fonctions, nous pouvons les représenter par un graphique qui affichera le temps d'exécution (ou nombre d'opérations) en fonction de la taille des entrées.

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:30px; text-align:center;">
[[Fichier:complexite.webp|500px]]
<div><b>Graphiques des complexités</b></div>
</div>
<div style="max-width:800px;">
<p>Ce graphique ci-contre compare les complexités en fonction de la taille des d'entrées.</p>
<p>On comprend ainsi que certaines complexités ne sont pas raisonnable dans la cadre de la multiplication de grands entiers.</p>
<p>C'est pourquoi l'étude de ces algorithmes s'avère nécessaire.</p>
</div>
</div>

=== Exemple ===
L'algorithme naïf d'addition que nous avons tous appris à l'école a une complexité de <math>\mathcal{O}(n)</math>.
Soit n la taille des nombres en entrée, l'algorithme doit faire environ n addition pour arriver au résultat demandé.

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Addition.gif|220px]]
<div><b>Addition naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Comme le montre l'exemple ci-contre, 786 et 467 font 3 chiffres de long donc n sera de 3.</p>
<p>Il nous faudra 3 opérations pour additionner ces deux nombres.</p>
<p>C'est ainsi qu'avec une taille d'entrée n, l'algorithme de l'addition naïve va devoir faire n opérations.</p>
<p>Cette algorithme a donc une complexité <math>f(n) = n</math> qui n'a pas besoin d'être approximée.</p>
<p>Ainsi sa complexité finale sera <math>\mathcal{O}(n)</math>.</p>
</div>
</div>

= Problématique =

Le calcul du produit de deux entiers de manière naïve a une complexité de <math> \mathcal{O}(n^2)</math>, et celui de deux matrices une complexité de <math> \mathcal{O}(n^3)</math>. Afin de mieux comprendre ce qu'est la complexité algorithmique, nous devrons implémenter des algorithmes ayant le même objectif, mais étant plus efficaces. Ces algorithmes s'avèreront plus complexes mais devrait aboutir à un calcul plus rapide du produit demandé.

Nous séparerons notre wiki en deux grandes parties, la première concernera nos recherche sur [[#I - Produit d'entiers|la multiplication d'entiers]], la deuxième sur [[#II - Produit de matrices|la multiplication de matrices]].

= I - Produit d'entiers =

Notre départ commence avec l'algorithme de multiplication d'entier naïf.
En effet il s'agit de l'algorithme de multiplication le plus connu, et nous l'utiliserons comme référence pour le comparer aux futurs algorithmes plus efficaces.
Intéressons nous à sa complexité.

== 1) Nos implémentations des grands entiers ==

Qui dit produit de grands entiers dit implémentation de grands entiers.

Dans le cadre de nos recherches, nous allons devoir implémenter des algorithmes qui vont manipuler des grands entiers.

Nous avons donc choisi de créer deux représentations différentes de ceux-ci (car nous travaillons sur différents langages de programmation), nous permettant à la fois une implémentation simplifié, mais aussi de nous rapprocher d'une implémentation bas niveau.

=== A) En python ===
En python, l'utilisation des "bytes" m'a grandement servi à comprendre comment les entiers étaient manipulés à bas niveau. En effet, un des objectifs secondaires de nos recherches était de manipuler des entiers directement avec leur formes stockées sur l'ordinateur, et non pas avec des int python.
En effet l'utilisation des int python nous aurait permit de passer les étapes de retenues, de signes... D'autant plus que les bytes permettent de stocker un nombre en base 256, ce qui permet de visualiser plus facilement les grands entiers.

La forme finale de la représentation des grands entiers en python sera donc la suivante :

[ signe , bytes , bytes , (...) , bytes ]

Le signe est représenté par un entier, 1 si le nombre est positif, 0 sinon.
Cette configuration rendra plus simple la gestion des signes.

=== B) En C++ ===

En C++, pour avoir une représentation de grand entiers j'ai du définir ma propre structure pour m'affranchir de la limite de taille imposé par les entiers standards: (int32 ou int64). Pour cela, j'ai une structure qui possède l'équivalent d'un array de byte (ce qui nous permet d'être en base 256 au lieu de la base 10 habituelle), et pour traiter le signe j'utilise un booléen, ainsi en mémoire j'ai une structure de n*Octets + 1 octet en taille.

[ bytes , bytes , (...) , bytes ] [ signe ]

Le booléen prend 1 octet de place mais ne touche pas aux octets qui encode le grand entier.
Cette configuration rendra plus simple la gestion des signes dans le cadre des multiplication.

== 2) La multiplication naïve ==

=== A) Fonctionnement ===
Dans le cas de la multiplication d'entiers, nous allons prendre deux nombres qui n'ont pas nécessairement la même longueur. Soit les nombre a et b, de longueur respective <math>n</math> et <math> m </math>.
<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Multiplication.png|220px]]
<div><b>Multiplication naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Prenons deux nombres de longueur 3 et 2, et cherchons combien d'opérations l'algorithme de multiplication naïve va devoir faire pour nous renvoyer leur produit.</p>
<p>Dans un premier temps, on remarque que l'on va devoir multiplier chaque chiffre du nombre du haut par le chiffre des unités du bas, qui est 6. Cela va représenter <math>n</math> opérations. (6x5, 6x1 et 6x4)</p>
<p>Dans un deuxième temps nous constatons que nous allons devoir faire la même chose avec le chiffre des dizaines du nombre du bas. Cela nous ajoute de nouveau <math>n</math> opérations.</p>
<p>On arrive assez facilement à la conclusion que pour faire notre produit, il va nous falloir faire <math>n</math> fois <math>m</math> opérations.</p>
</div>
</div>

Ainsi, la complexité de la multiplication naïve est <math>\mathcal{O}(n^2)</math>.
Il est en de même avec la multiplication naïve récursive.

=== B) Graphique ===
Montrons maintenant sa courbe sur un graphique :

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Multiplicationnaive.png|500px]]
<div><b>Multiplication naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Les points noirs sont des repères pour que les autres courbes aient une forme cohérente.</p>
<p>Ils sont tous sur l'axe des abscisses.</p>
<p>La courbe rouge représente la complexité de la multiplication naïve.</p>
<p>On remarque que la courbe a un visuel très similaire à la fonction <math>f(x) = x^2</math> </p>
</div>
</div>

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Naif_recursif.png|500px]]
<div><b>Multiplication naïve récursive</b></div>
</div>
<div style="max-width:800px;">
<p>La courbe rouge représente la complexité de la multiplication naïve récursive.</p>
<p>Elle sera utilisé pour comparer les complexités entre algorithmes car, comme tous récursifs, elle a été codé avec les mêmes biais d'implémentation qu'eux.</p>
<p>Théoriquement les deux courbes ci-contre ont la même complexité, mais encore une fois, notre implémentation n'est pas parfaitement optimale et donc ne respecte pas de manière minutieuse le Master Theorem.</p>
</div>
</div>

== 3) La multiplication karastuba ==

=== A) Fonctionnement ===

L'algorithme de karatsuba est un algorithme récursif de type diviser pour régner.

L'idée générale de l'algorithme est de passer de 4 multiplication à 3. En effet ces opérations étant moins couteuses, il est préférable d'en ajouter si cela permet d'enlever des multiplications.

L'algorithme de multiplication naif récursif utilise la segmentation des facteurs en deux de manière successive.

Soit <math>x</math> et <math>y</math> deux facteurs, nous avons les égalités suivantes :

<div style="font-size: 20px;">
<math>x = a \times B^{n/2} + b</math>
<math>y = c \times B^{n/2} + d</math>
</div>

Avec <math>a</math> et <math>c</math> les premières moitiés des facteurs <math>x</math> et <math>y</math>,
et <math>b</math> et <math>d</math> les dernières moitiés de ces facteurs ainsi que <math>B</math> la base d'écriture du nombre (Nous sommes en base 256 avec les bytes).

Cette présentation des deux facteurs de notre multiplication n'est que la résultante d'un découpage.
Le [[#Master Theorem|Master Theorem]] nous montre que :

<div style="font-size: 20px;">
<math>T(n) = 4T(n/2) + O(n)</math>
</div>

Puisque nous avons après découpage 4 entiers de longueur <math>n/2</math>.

Ainsi, ce découpage ne permet pas de gagner du temps d'après le [[#Master Theorem|Master Theorem]].

Cependant, l'algorithme de Karatsuba réutilise ce principe en le modifiant, ce qui nous permet de baisser la complexité globale de la multiplication dans son entièreté.

Avec l'écriture ci-dessus des nombres <math>x</math> et <math>y</math>, on peut facilement en déduire l'égalité suivante :

<div style="font-size: 20px;">
<math>x \times y = (ac) \times B^n + (ad + bc) \times B^{n/2} + bd</math>
</div>

On remarque 4 multiplications longues à faire dans cette expression. Les multiplications dont <math>B</math> est l'un des facteurs sont très rapides puisqu'il s'agit de la base dans laquelle nous travaillons. De cela en résulte un décalage plutôt qu'un vrai calcul à faire.

Karatsuba développe une partie de cette expression pour pouvoir négocier une multiplication au prix d'additions et soustractions.

En effet, nous savons déjà que :

<div style="font-size: 20px;">
<math>(a + b)(c + d) = ac + ad + bc + bd</math>
</div>

En manipulant l'égalité nous obtenons :

<div style="font-size: 20px;">
<math>ad + bc = (a + b)(c + d) - ac - bd</math>
</div>

ac et bd ayant déjà été calculé précédemment, il nous reste uniquement la multiplication <math>(a + b)(c + d)</math>.

Nous venons ainsi de calculer <math>ad + bc</math> en seulement une multiplication. C'est la que repose le gain de temps de la méthode Karatsuba par rapport à la multiplication naïve.

En effet, l'algorithme n'effectuera alors plus que 3 multiplications :
<div style="font-size: 20px;">
<math>ac</math>
<math>bd</math>
<math>(a + b)(c + d)</math>
</div>

La relation de récurrence devient donc :
<div style="font-size: 20px;">
<math>T(n)=3T(n/2)+O(n)</math>
</div>

Et le Master Theorem nous dit que :
<div style="font-size: 20px;">
<math>T(n)\in O(n^{\log_2(3)})</math>
</div>

Or <math>\log_2(3)\approx 1.585</math>, donc la complexité de l'algorithme de Karatsuba est de <math> \mathcal{O}(n^{1.585})</math>. Ce qui est bien plus efficace que la multiplication classique, surtout lorsque les facteurs deviennent très grands.

=== B) Graphique ===
<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Karatsuba.png|500px]]
<div><b>Karatsuba</b></div>
</div>
<div style="max-width:800px;">
<p>Sur le graphique ci-contre nous avons utilisé la courbe de la multiplication naïve récursive (rouge) à titre de comparaison.</p>
<p>On remarque graphiquement que Karatsuba (jaune) prend moins de temps à chaque calcul de produit.</p>
<p>On en déduit donc expérimentalement que Karatsuba à une meilleure complexité que la multiplication naïve.</p>
<p>Ainsi nous vérifions donc ce que le Master Theorem prouve, c'est à dire que la complexité de karatsuba est de <math> \mathcal{O}(n^{1.585})</math> </p>
</div>
</div>

== 4) La multiplication toom-cook-3 ==

=== A) Fonctionnement ===

L'objectif est de diviser les grands entiers X et Y en trois blocs de taille égale k.
On les traite alors comme des polynômes de degré 2:

<math>P(z) = X_2 \cdot z^2 + X_1 \cdot z + X_0</math>
<math>Q(z) = Y_2 \cdot z^2 + Y_1 \cdot z + Y_0</math>

On choisit 5 points distincts pour évaluer nos polynômes.
Ce choix de 5 points est crucial car le produit de deux polynômes de degré 2 est un polynôme de degré 4, qui nécessite 5 points pour être défini.
Les points standards sont :

P(0) = X0
P(1) = X0 + X1 + X2
P(-1) = X0 - X1 + X2
P(2) = X0 + 2*X1 + 4*X2
P(inf) = X2

(On procède de manière similaire pour Q.)

Ensuite nous multiplions récursivement chaque points de P et de Q ensemble.
On effectue ainsi 5 multiplications de nombres plus petits au lieu des 9 multiplications requises par la méthode classique.

Après, nous effectuons une interpolation, cela permet de retrouver les 5 coefficients (w_0, w_1, w_2, w_3, w_4) du polynôme produit R(z) à partir des valeurs évaluées calculées précédemment.
On résout un système d'équations linéaires : <math> R(z) = w_4 z^4 + w_3 z^3 + w_2 z^2 + w_1 z + w_0 </math>
Finalement nous pouvons recomposer notre grand entier en positionnant les coefficients w_i aux bons rangs (en les décalant) et à gérer les retenues lors de l'addition finale:
<math>Résultat = w_4 B^{4k} + w_3 B^{3k} + w_2 B^{2k} + w_1 B^k + w_0</math>

=== B) Graphique ===

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Toomcook.png|500px]]
<div><b>Karatsuba</b></div>
</div>
<div style="max-width:800px;">
<p>on a reprit multi récursive (rouge)</p>
<p>on voit que Toom (vert) en dessous de karatsuba (jaune) en dessous de multi classique (rouge)</p>
<p>meilleur complexité</p>
</div>
</div>

== 5) La transformée de Fourier rapide ==

=== A) Fonctionnement ===

La transformation de Fourier rapide étant plus complexe que les autres algorithmes, nous allons essayer d'expliquer son fonctionnement malgré ne pas avoir réussi à l'implémenter.

Il faut comprendre que cet algorithme va considérer les facteurs comme des polynômes.

D'après le théorème de l'unisolvance, il n'existe qu'un seul polynôme de degré inférieur ou égal à <math> n </math> défini par <math>n + 1</math> points distincts. Cela implique non seulement que nous pouvons représenter chaque entier par un polynôme, mais également que si nous pouvons retrouver <math>n + m + 1</math> points (avec <math>n</math> et <math>m</math> la longueur des facteurs) du polynômes issue du produit entre deux facteurs, nous pourrons le retrouver.

Soit un entier quelconque, de forme :

<math>a_n a_{n-1} (...) a_1 a_0</math>

Avec <math>a_i</math>, un chiffre composant le nombre en base 10, qui vaut en réalité dans le nombre : <math>a_i \times 10^i</math>. On peut ainsi l'écrire sous la forme :

<math> P(x) = a_0 + a_1x + a_2x^2 + \dots + a_{n-1}x^{n-1} + a_nx^n </math>

Avec <math>x = 10</math> car nous sommes en base 10, nous obtenons :

<math>P(10) = a_0 + a_1 \times 10 + \dots + a_{n-1}10^{n-1} + a_n10^n </math>

Nous venons ainsi d'écrire notre nombre sous la forme d'un polynôme unique. Pour nous permettre d'évaluer en un nombre suffisant de points, nous allons devoir ajouter des 0 pour la récursion. Il nous faudra ajouter assez de 0 pour atteindre la prochaine puissance de 2 qui sera supérieure ou égale à <math>2n + 1</math>. L'ajout de 0 ne change pas le nombre car <math>0 \times x^n</math> n'ajoute pas de coefficient.

Cet algorithme est récursif et va segmenter en deux parties nos polynômes à chaque récursion. D'un coté les indice paires et d'un coté les impaires.

Ainsi prenons les nombres 1234 et 5678, ces nombres sont respectivement représentés par les polynômes <math> P(x) = 4 + 3x + 2x^2 + x^3 </math> et <math> P(x) = 8 + 7x + 6x^2 + 5^3 </math>. Ce sont des polynômes de degré 3, ainsi leur produit donnera lieu à un polynôme de degré 6. Il nous faudra donc au minimum 7 points d'évaluation pour retrouve ce produit. De ce fait, en les représentant de la manière suivante :

<math>[4, 3, 2, 1, 0, 0, 0, 0]</math>
<math>[8, 7, 6, 5, 0, 0, 0, 0]</math>

Nous aurons assez de récursions possible pour les évaluer en un nombre suffisant de points différents car nous auront 3 récursions à faire pour atteindre notre cas de base. A chaque récursion, nous allons diviser nos polynômes en deux parties ce qui nous fait 8 feuilles à la dernière récursion.

En effet à chaque étape de la récursion nous allons séparer nos polynômes en deux tel que :

<math> P(x)=P_{pair}x^2 + x \times P_{impair}x^2 </math>

Durant les récursions, nous segmentons les polynômes mais ne les évaluons pas. C'est à la remonté des récursions que nous allons réellement évaluer nos polynômes. Lorsque l'on atteint notre cas de base, c'est à dire des polynômes de degré 0, nous remarquons qu'ils sont constants, nous n'avons donc pas besoin de les évaluer. En effet, peut importe le point en lequel nous voudrons l'évaluer, le polynôme renverra la constante. Nous la renvoyons donc seule.
Ensuite commence la remontée des récursions. A l'étape 1 de notre remontée nous allons reformer le polynôme précédemment séparé pour obtenir un polynôme de degré 1. Puis, nous évaluons ce polynôme avec les racines seconde de l'unité. Nous faisons à nouveau remonté les évaluations et recombinons à nouveau le polynôme qui sera ainsi de degré 2.
Nous l'évaluons maintenant avec les racines 4eme de l'unité. A chaque évaluation, nous réutilisons les résultats précédents, cela nous est permit par les racines de l'unité qui ont une structure récursive exploitable.

Finalement, nous arrivons à la fin de notre FFT, avec une représentation fréquentielle de la forme :

<math> [P(W_0), P(W_1), (...), P(W_n-1), P(W_n)] </math>

Cette représentation fréquentielle n'est autre que les évaluations du polynôme P aux racines nièmes de l'unité. Nous avons donc maintenant au minimum <math>2n+1</math> évaluations des polynômes facteurs. Il nous faut maintenant trouver les évaluations du produit final, c'est à dire les évaluations concernant le polynôme qui sera issue de la multiplication. On pourra ainsi le retrouver.

Soit <math>C</math> un polynome tel que <math> C = A \times B </math>, alors on a :

<math> C(x) = A(x) \times B(x) </math>

Ainsi on en déduit que <math> C(W_n^k) = A(W_n^k) \times B(W_n^k) </math>

On comprend donc que <math>FFT(C) = FFT(A) \times FFT(B)</math>

Il faut préciser que l'on fait le produit de FFT(A) et FFT(B) terme à terme, soit évaluation par évaluation.

Une fois en possession de <math>FFT(C)</math>, qui n'est autre que l'évaluation de notre polynôme final en un nombre suffisant de points pour le retrouver, nous pouvons faire l'<math>IFFT(FFT(C))</math>, qui va nous permettre de retrouver les coefficients de notre polynôme en faisant l'exacte inverse de la FFT.

Une fois les coefficients retrouvés, il nous suffit de gérer les retenues, et nous retrouvons un entier de la forme : <math>a_0 a_1 (...) a_{n-1} a_n</math>

=== B) Graphique ===

Intéressons nous maintenant à la complexité de l'algorithme utilisant la transformée de Fourier rapide. On sait que l'algorithme passe par 5 étapes importantes :

<ul>
<li>Etape 1 : Ecrire les deux facteurs sous la forme de polynômes</li>
<li>Etape 2 : Effectuer la <math>FFT</math> des deux polynômes</li>
<li>Etape 3 : Faire le produit terme à terme des <math>FFT</math> obtenues</li>
<li>Etape 4 : Faire l'<math>IFFT</math> du produit</li>
<li>Etape 5 : Gérer les retenues et écrire le nombre qui en découle</li>
</ul>

Or, parmi toutes ces étapes, certaines sont négligeable comme l'étape 1 et 5.

Pour connaitre la complexité de l'algorithme, additionnons les complexités des étapes restantes :

Une <math>FFT</math> a une complexité de <math>\mathcal{O}(n\times logn)</math> car elle fait <math>n</math> évaluation sur <math> log(n)</math> récursions. Dans le cadre de notre algorithme, nous devons faire la <math>FFT</math> de nos deux facteurs. Soit <math>2\times \mathcal{O}(n\times logn)</math>.

Pour le produit terme à terme, nous faisons naturellement <math>n</math> opérations.

Pour finir, l'<math>IFFT</math> a la même complexité que la <math>FFT</math>. Dans le cadre de notre algorithme nous l'emploierons qu'une seule fois, ce qui fait une complexité de <math>\mathcal{O}(n\times logn)</math>.

Après addition de toutes ces complexités, nous obtenons la complexité réelle de <math>3\mathcal{O}(n\times logn) + \mathcal{O}(n)</math>.

D'après le Master Theorem, nous avons donc <math> f(x) = 3(x\timeslogx)+x </math>

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:30px; text-align:center;">
[[Fichier:FFT_image.webp|500px]]
<div><b>Graphiques des complexités</b></div>
</div>
<div style="max-width:800px;">
<p>Ce graphique ci-contre compare les complexités en fonction de la taille des d'entrées.</p>
<p>On comprend ainsi que certaines complexités ne sont pas raisonnable dans la cadre de la multiplication de grands entiers.</p>
<p>C'est pourquoi l'étude de ces algorithmes s'avère nécessaire.</p>
</div>
</div>

= II - Produit de matrices =

== 1.1) naïve ==

La multiplication naïve de matrice requiert d'avoir des tailles de lignes/colonne semblable, ensuite pour chaque membre de la matrice résultat, on doit multiplier les composantes ligne de la première matrice par les composantes colonne de la deuxième et le tout sommé.

On en déduit la formule suivante:
<math>C_{i,j} = \sum_{k=1}^{n} (A_{i,k} \times B_{k,j})</math>

Et visuellement:

[[Fichier:Matricenaive.jpeg]]

On a donc un algorithme d'ordre de complexité <math>\mathcal{O}(g(n))</math>

== 1.2) naïve récursive ==

Dans un premier temps on doit découper nos deux matrices en quatres sous matrices de plus petite taille.
<math>A = \begin{pmatrix} A_{11} & A_{12} \ A_{21} & A_{22} \end{pmatrix}</math>
<math>B = \begin{pmatrix} B_{11} & B_{12} \ B_{21} & B_{22} \end{pmatrix}</math>

Ensuite on vient calculer la matrice résultat.
<math>C_{11} = (A_{11} \times B_{11}) + (A_{12} \times B_{21})</math>
<math>C_{12} = (A_{11} \times B_{12}) + (A_{12} \times B_{22})</math>
<math>C_{21} = (A_{21} \times B_{11}) + (A_{22} \times B_{21})</math>
<math>C_{22} = (A_{21} \times B_{12}) + (A_{22} \times B_{22})</math>

Le côté récursif est utile que pour les matrices de tailles <= 32 (32 valeurs stockées dedans),
si on est au dessus de cette taille alors on divisera à nouveau nos matrices en quatres.
On aura 8 multiplications mais de plus petite taille au final.

== 2) strassen ==

=== A) Fonctionnement ===

Strassen consiste à définir 7 produits intermédiaires qui, par des jeux de sommes et de différences, permettent de reconstruire les quadrants de la matrice résultante. On passe ainsi d'une complexité de O(n^3) à environ O(n^2.81)

=== B) Graphique ===

On voit bien la différence de complexité sur la multiplication de grande matrice entre l'approche naïve et l'approche récursive qui est beaucoup plus rapide.

[[Fichier:Analyse matrices.png]]

= Conclusion =

( A FAIRE )

= Mentions =

Le premier gif est le résultat du travail de 'Walké', licence ci-contre : https://fr.wikipedia.org/wiki/Fichier:Addition.gif

= Sources =

Pour karatsuba : https://www.youtube.com/watch?v=PZ2gdWdKHAA

Pour mieux comprendre la FFT, nous avons utilisé plusieurs sources d'informations :
<ul>
<li> https://www.youtube.com/watch?v=h7apO7q16V0&list=WL&index=1&t=886s </li>
<li> https://fr.wikipedia.org/wiki/Interpolation_polynomiale </li>
</ul>

Algorithmes de multiplications d'entiers et de matrices

2026-05-11T12:18:18Z

Mangala : /* B) Graphique */

= Introduction =

Depuis l'apparition des ordinateurs modernes, une quantité faramineuse de calcul a dû être effectuée. Les progressions technologiques nous poussent à envisager la puissance de calcul comme une ressource qu'il faut optimiser dans les moindres détails. C'est ainsi que l'optimisation des algorithmes de calcul est devenue cruciale, surtout lorsqu'il nous faut effectuer des opérations sur de très grands entiers par exemple.

= Objectif =

L'objectif majeur de ce projet est de comprendre de manière plus approfondie ce qu'est la '''complexité algorithmique'''.
Pour atteindre cet objectif, nous implémenterons plusieurs algorithmes de multiplication qui auront pour but de calculer le produit de grands entiers ou de matrices.

= Point important : complexité =

=== Définition ===
La complexité d'un algorithme est la quantité des ressources qu'il utilise en fonction de la taille des entrée qu'on lui demande de traiter. On peut par exemple se concentrer sur le temps qu'un algorithme prend pour renvoyer un résultat ou sur la mémoire dont il a besoin. Dans le cadre de notre projet, nous nous attarderons plus particulièrement sur la quantité de calcul effectuée en fonction de la taille des entrées, ce qui est par ailleurs fortement liée à la notion de temps. De manière générale, plus un algorithme doit faire de calcul, plus il est lent. (Attention, toutes les opérations arithmétiques de base ne se valent pas)

De manière plus familière, on dira que la complexité d'un algorithme pourrait s'apparenter à son comportement lorsqu'il doit traiter des données plus ou moins grandes.
Chaque algorithme a une complexité, et on l'exprime par une fonction qui adopte un comportement similaire au nombre de calcul nécessaire en fonction de la taille des entrées.

=== Notation ===
La complexité réelle d'un algorithme peut être décrite par une fonction <math>f(n)</math> représentant le nombre d'opérations effectuées en fonction de la taille <math>n</math> des données d'entrée.

Cependant, afin de simplifier l'étude de cette croissance, on utilise généralement une borne asymptotique notée <math>\mathcal{O}(g(n))</math>, où <math>g(n)</math> est une fonction ayant le même ordre de grandeur que <math>f(n)</math> lorsque <math>n</math> devient grand.

On dit alors que :

<math>
f(n)\in\mathcal{O}(g(n))
</math>

si et seulement s'il existe une constante <math>C>0</math> et un entier <math>n_0</math> tels que :

<math>
\forall n\ge n_0,\ f(n)\le Cg(n)
</math>

Cette notation <math>\mathcal{O}(g(n))</math> permettra de comparer beaucoup plus facilement les algorithmes entre eux.

=== Master Theorem ===

Afin de déterminer la complexité de certains algorithmes récursifs, nous utiliserons le "Master Theorem".

Ce théorème permet d'obtenir directement l'ordre de grandeur de nombreuses relations de récurrence apparaissant dans l'analyse d'algorithmes de type « diviser pour régner », comme l'algorithme de Karatsuba ou celui de Strassen.

La démonstration complète de ce théorème dépasse le cadre de notre projet et nécessite des connaissances mathématiques plus avancées. Nous l'utiliserons donc principalement comme un outil nous permettant de déterminer efficacement la complexité asymptotique des algorithmes étudiés.

=== Graphiques ===

Les complexités étant des fonctions, nous pouvons les représenter par un graphique qui affichera le temps d'exécution (ou nombre d'opérations) en fonction de la taille des entrées.

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:30px; text-align:center;">
[[Fichier:complexite.webp|500px]]
<div><b>Graphiques des complexités</b></div>
</div>
<div style="max-width:800px;">
<p>Ce graphique ci-contre compare les complexités en fonction de la taille des d'entrées.</p>
<p>On comprend ainsi que certaines complexités ne sont pas raisonnable dans la cadre de la multiplication de grands entiers.</p>
<p>C'est pourquoi l'étude de ces algorithmes s'avère nécessaire.</p>
</div>
</div>

=== Exemple ===
L'algorithme naïf d'addition que nous avons tous appris à l'école a une complexité de <math>\mathcal{O}(n)</math>.
Soit n la taille des nombres en entrée, l'algorithme doit faire environ n addition pour arriver au résultat demandé.

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Addition.gif|220px]]
<div><b>Addition naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Comme le montre l'exemple ci-contre, 786 et 467 font 3 chiffres de long donc n sera de 3.</p>
<p>Il nous faudra 3 opérations pour additionner ces deux nombres.</p>
<p>C'est ainsi qu'avec une taille d'entrée n, l'algorithme de l'addition naïve va devoir faire n opérations.</p>
<p>Cette algorithme a donc une complexité <math>f(n) = n</math> qui n'a pas besoin d'être approximée.</p>
<p>Ainsi sa complexité finale sera <math>\mathcal{O}(n)</math>.</p>
</div>
</div>

= Problématique =

Le calcul du produit de deux entiers de manière naïve a une complexité de <math> \mathcal{O}(n^2)</math>, et celui de deux matrices une complexité de <math> \mathcal{O}(n^3)</math>. Afin de mieux comprendre ce qu'est la complexité algorithmique, nous devrons implémenter des algorithmes ayant le même objectif, mais étant plus efficaces. Ces algorithmes s'avèreront plus complexes mais devrait aboutir à un calcul plus rapide du produit demandé.

Nous séparerons notre wiki en deux grandes parties, la première concernera nos recherche sur [[#I - Produit d'entiers|la multiplication d'entiers]], la deuxième sur [[#II - Produit de matrices|la multiplication de matrices]].

= I - Produit d'entiers =

Notre départ commence avec l'algorithme de multiplication d'entier naïf.
En effet il s'agit de l'algorithme de multiplication le plus connu, et nous l'utiliserons comme référence pour le comparer aux futurs algorithmes plus efficaces.
Intéressons nous à sa complexité.

== 1) Nos implémentations des grands entiers ==

Qui dit produit de grands entiers dit implémentation de grands entiers.

Dans le cadre de nos recherches, nous allons devoir implémenter des algorithmes qui vont manipuler des grands entiers.

Nous avons donc choisi de créer deux représentations différentes de ceux-ci (car nous travaillons sur différents langages de programmation), nous permettant à la fois une implémentation simplifié, mais aussi de nous rapprocher d'une implémentation bas niveau.

=== A) En python ===
En python, l'utilisation des "bytes" m'a grandement servi à comprendre comment les entiers étaient manipulés à bas niveau. En effet, un des objectifs secondaires de nos recherches était de manipuler des entiers directement avec leur formes stockées sur l'ordinateur, et non pas avec des int python.
En effet l'utilisation des int python nous aurait permit de passer les étapes de retenues, de signes... D'autant plus que les bytes permettent de stocker un nombre en base 256, ce qui permet de visualiser plus facilement les grands entiers.

La forme finale de la représentation des grands entiers en python sera donc la suivante :

[ signe , bytes , bytes , (...) , bytes ]

Le signe est représenté par un entier, 1 si le nombre est positif, 0 sinon.
Cette configuration rendra plus simple la gestion des signes.

=== B) En C++ ===

En C++, pour avoir une représentation de grand entiers j'ai du définir ma propre structure pour m'affranchir de la limite de taille imposé par les entiers standards: (int32 ou int64). Pour cela, j'ai une structure qui possède l'équivalent d'un array de byte (ce qui nous permet d'être en base 256 au lieu de la base 10 habituelle), et pour traiter le signe j'utilise un booléen, ainsi en mémoire j'ai une structure de n*Octets + 1 octet en taille.

[ bytes , bytes , (...) , bytes ] [ signe ]

Le booléen prend 1 octet de place mais ne touche pas aux octets qui encode le grand entier.
Cette configuration rendra plus simple la gestion des signes dans le cadre des multiplication.

== 2) La multiplication naïve ==

=== A) Fonctionnement ===
Dans le cas de la multiplication d'entiers, nous allons prendre deux nombres qui n'ont pas nécessairement la même longueur. Soit les nombre a et b, de longueur respective <math>n</math> et <math> m </math>.
<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Multiplication.png|220px]]
<div><b>Multiplication naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Prenons deux nombres de longueur 3 et 2, et cherchons combien d'opérations l'algorithme de multiplication naïve va devoir faire pour nous renvoyer leur produit.</p>
<p>Dans un premier temps, on remarque que l'on va devoir multiplier chaque chiffre du nombre du haut par le chiffre des unités du bas, qui est 6. Cela va représenter <math>n</math> opérations. (6x5, 6x1 et 6x4)</p>
<p>Dans un deuxième temps nous constatons que nous allons devoir faire la même chose avec le chiffre des dizaines du nombre du bas. Cela nous ajoute de nouveau <math>n</math> opérations.</p>
<p>On arrive assez facilement à la conclusion que pour faire notre produit, il va nous falloir faire <math>n</math> fois <math>m</math> opérations.</p>
</div>
</div>

Ainsi, la complexité de la multiplication naïve est <math>\mathcal{O}(n^2)</math>.
Il est en de même avec la multiplication naïve récursive.

=== B) Graphique ===
Montrons maintenant sa courbe sur un graphique :

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Multiplicationnaive.png|500px]]
<div><b>Multiplication naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Les points noirs sont des repères pour que les autres courbes aient une forme cohérente.</p>
<p>Ils sont tous sur l'axe des abscisses.</p>
<p>La courbe rouge représente la complexité de la multiplication naïve.</p>
<p>On remarque que la courbe a un visuel très similaire à la fonction <math>f(x) = x^2</math> </p>
</div>
</div>

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Naif_recursif.png|500px]]
<div><b>Multiplication naïve récursive</b></div>
</div>
<div style="max-width:800px;">
<p>La courbe rouge représente la complexité de la multiplication naïve récursive.</p>
<p>Elle sera utilisé pour comparer les complexités entre algorithmes car, comme tous récursifs, elle a été codé avec les mêmes biais d'implémentation qu'eux.</p>
<p>Théoriquement les deux courbes ci-contre ont la même complexité, mais encore une fois, notre implémentation n'est pas parfaitement optimale et donc ne respecte pas de manière minutieuse le Master Theorem.</p>
</div>
</div>

== 3) La multiplication karastuba ==

=== A) Fonctionnement ===

L'algorithme de karatsuba est un algorithme récursif de type diviser pour régner.

L'idée générale de l'algorithme est de passer de 4 multiplication à 3. En effet ces opérations étant moins couteuses, il est préférable d'en ajouter si cela permet d'enlever des multiplications.

L'algorithme de multiplication naif récursif utilise la segmentation des facteurs en deux de manière successive.

Soit <math>x</math> et <math>y</math> deux facteurs, nous avons les égalités suivantes :

<div style="font-size: 20px;">
<math>x = a \times B^{n/2} + b</math>
<math>y = c \times B^{n/2} + d</math>
</div>

Avec <math>a</math> et <math>c</math> les premières moitiés des facteurs <math>x</math> et <math>y</math>,
et <math>b</math> et <math>d</math> les dernières moitiés de ces facteurs ainsi que <math>B</math> la base d'écriture du nombre (Nous sommes en base 256 avec les bytes).

Cette présentation des deux facteurs de notre multiplication n'est que la résultante d'un découpage.
Le [[#Master Theorem|Master Theorem]] nous montre que :

<div style="font-size: 20px;">
<math>T(n) = 4T(n/2) + O(n)</math>
</div>

Puisque nous avons après découpage 4 entiers de longueur <math>n/2</math>.

Ainsi, ce découpage ne permet pas de gagner du temps d'après le [[#Master Theorem|Master Theorem]].

Cependant, l'algorithme de Karatsuba réutilise ce principe en le modifiant, ce qui nous permet de baisser la complexité globale de la multiplication dans son entièreté.

Avec l'écriture ci-dessus des nombres <math>x</math> et <math>y</math>, on peut facilement en déduire l'égalité suivante :

<div style="font-size: 20px;">
<math>x \times y = (ac) \times B^n + (ad + bc) \times B^{n/2} + bd</math>
</div>

On remarque 4 multiplications longues à faire dans cette expression. Les multiplications dont <math>B</math> est l'un des facteurs sont très rapides puisqu'il s'agit de la base dans laquelle nous travaillons. De cela en résulte un décalage plutôt qu'un vrai calcul à faire.

Karatsuba développe une partie de cette expression pour pouvoir négocier une multiplication au prix d'additions et soustractions.

En effet, nous savons déjà que :

<div style="font-size: 20px;">
<math>(a + b)(c + d) = ac + ad + bc + bd</math>
</div>

En manipulant l'égalité nous obtenons :

<div style="font-size: 20px;">
<math>ad + bc = (a + b)(c + d) - ac - bd</math>
</div>

ac et bd ayant déjà été calculé précédemment, il nous reste uniquement la multiplication <math>(a + b)(c + d)</math>.

Nous venons ainsi de calculer <math>ad + bc</math> en seulement une multiplication. C'est la que repose le gain de temps de la méthode Karatsuba par rapport à la multiplication naïve.

En effet, l'algorithme n'effectuera alors plus que 3 multiplications :
<div style="font-size: 20px;">
<math>ac</math>
<math>bd</math>
<math>(a + b)(c + d)</math>
</div>

La relation de récurrence devient donc :
<div style="font-size: 20px;">
<math>T(n)=3T(n/2)+O(n)</math>
</div>

Et le Master Theorem nous dit que :
<div style="font-size: 20px;">
<math>T(n)\in O(n^{\log_2(3)})</math>
</div>

Or <math>\log_2(3)\approx 1.585</math>, donc la complexité de l'algorithme de Karatsuba est de <math> \mathcal{O}(n^{1.585})</math>. Ce qui est bien plus efficace que la multiplication classique, surtout lorsque les facteurs deviennent très grands.

=== B) Graphique ===
<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Karatsuba.png|500px]]
<div><b>Karatsuba</b></div>
</div>
<div style="max-width:800px;">
<p>Sur le graphique ci-contre nous avons utilisé la courbe de la multiplication naïve récursive (rouge) à titre de comparaison.</p>
<p>On remarque graphiquement que Karatsuba (jaune) prend moins de temps à chaque calcul de produit.</p>
<p>On en déduit donc expérimentalement que Karatsuba à une meilleure complexité que la multiplication naïve.</p>
<p>Ainsi nous vérifions donc ce que le Master Theorem prouve, c'est à dire que la complexité de karatsuba est de <math> \mathcal{O}(n^{1.585})</math> </p>
</div>
</div>

== 4) La multiplication toom-cook-3 ==

=== A) Fonctionnement ===

L'objectif est de diviser les grands entiers X et Y en trois blocs de taille égale k.
On les traite alors comme des polynômes de degré 2:

<math>P(z) = X_2 \cdot z^2 + X_1 \cdot z + X_0</math>
<math>Q(z) = Y_2 \cdot z^2 + Y_1 \cdot z + Y_0</math>

On choisit 5 points distincts pour évaluer nos polynômes.
Ce choix de 5 points est crucial car le produit de deux polynômes de degré 2 est un polynôme de degré 4, qui nécessite 5 points pour être défini.
Les points standards sont :

P(0) = X0
P(1) = X0 + X1 + X2
P(-1) = X0 - X1 + X2
P(2) = X0 + 2*X1 + 4*X2
P(inf) = X2

(On procède de manière similaire pour Q.)

Ensuite nous multiplions récursivement chaque points de P et de Q ensemble.
On effectue ainsi 5 multiplications de nombres plus petits au lieu des 9 multiplications requises par la méthode classique.

Après, nous effectuons une interpolation, cela permet de retrouver les 5 coefficients (w_0, w_1, w_2, w_3, w_4) du polynôme produit R(z) à partir des valeurs évaluées calculées précédemment.
On résout un système d'équations linéaires : <math> R(z) = w_4 z^4 + w_3 z^3 + w_2 z^2 + w_1 z + w_0 </math>
Finalement nous pouvons recomposer notre grand entier en positionnant les coefficients w_i aux bons rangs (en les décalant) et à gérer les retenues lors de l'addition finale:
<math>Résultat = w_4 B^{4k} + w_3 B^{3k} + w_2 B^{2k} + w_1 B^k + w_0</math>

=== B) Graphique ===

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Toomcook.png|500px]]
<div><b>Karatsuba</b></div>
</div>
<div style="max-width:800px;">
<p>on a reprit multi récursive (rouge)</p>
<p>on voit que Toom (vert) en dessous de karatsuba (jaune) en dessous de multi classique (rouge)</p>
<p>meilleur complexité</p>
</div>
</div>

== 5) La transformée de Fourier rapide ==

=== A) Fonctionnement ===

La transformation de Fourier rapide étant plus complexe que les autres algorithmes, nous allons essayer d'expliquer son fonctionnement malgré ne pas avoir réussi à l'implémenter.

Il faut comprendre que cet algorithme va considérer les facteurs comme des polynômes.

D'après le théorème de l'unisolvance, il n'existe qu'un seul polynôme de degré inférieur ou égal à <math> n </math> défini par <math>n + 1</math> points distincts. Cela implique non seulement que nous pouvons représenter chaque entier par un polynôme, mais également que si nous pouvons retrouver <math>n + m + 1</math> points (avec <math>n</math> et <math>m</math> la longueur des facteurs) du polynômes issue du produit entre deux facteurs, nous pourrons le retrouver.

Soit un entier quelconque, de forme :

<math>a_n a_{n-1} (...) a_1 a_0</math>

Avec <math>a_i</math>, un chiffre composant le nombre en base 10, qui vaut en réalité dans le nombre : <math>a_i \times 10^i</math>. On peut ainsi l'écrire sous la forme :

<math> P(x) = a_0 + a_1x + a_2x^2 + \dots + a_{n-1}x^{n-1} + a_nx^n </math>

Avec <math>x = 10</math> car nous sommes en base 10, nous obtenons :

<math>P(10) = a_0 + a_1 \times 10 + \dots + a_{n-1}10^{n-1} + a_n10^n </math>

Nous venons ainsi d'écrire notre nombre sous la forme d'un polynôme unique. Pour nous permettre d'évaluer en un nombre suffisant de points, nous allons devoir ajouter des 0 pour la récursion. Il nous faudra ajouter assez de 0 pour atteindre la prochaine puissance de 2 qui sera supérieure ou égale à <math>2n + 1</math>. L'ajout de 0 ne change pas le nombre car <math>0 \times x^n</math> n'ajoute pas de coefficient.

Cet algorithme est récursif et va segmenter en deux parties nos polynômes à chaque récursion. D'un coté les indice paires et d'un coté les impaires.

Ainsi prenons les nombres 1234 et 5678, ces nombres sont respectivement représentés par les polynômes <math> P(x) = 4 + 3x + 2x^2 + x^3 </math> et <math> P(x) = 8 + 7x + 6x^2 + 5^3 </math>. Ce sont des polynômes de degré 3, ainsi leur produit donnera lieu à un polynôme de degré 6. Il nous faudra donc au minimum 7 points d'évaluation pour retrouve ce produit. De ce fait, en les représentant de la manière suivante :

<math>[4, 3, 2, 1, 0, 0, 0, 0]</math>
<math>[8, 7, 6, 5, 0, 0, 0, 0]</math>

Nous aurons assez de récursions possible pour les évaluer en un nombre suffisant de points différents car nous auront 3 récursions à faire pour atteindre notre cas de base. A chaque récursion, nous allons diviser nos polynômes en deux parties ce qui nous fait 8 feuilles à la dernière récursion.

En effet à chaque étape de la récursion nous allons séparer nos polynômes en deux tel que :

<math> P(x)=P_{pair}x^2 + x \times P_{impair}x^2 </math>

Durant les récursions, nous segmentons les polynômes mais ne les évaluons pas. C'est à la remonté des récursions que nous allons réellement évaluer nos polynômes. Lorsque l'on atteint notre cas de base, c'est à dire des polynômes de degré 0, nous remarquons qu'ils sont constants, nous n'avons donc pas besoin de les évaluer. En effet, peut importe le point en lequel nous voudrons l'évaluer, le polynôme renverra la constante. Nous la renvoyons donc seule.
Ensuite commence la remontée des récursions. A l'étape 1 de notre remontée nous allons reformer le polynôme précédemment séparé pour obtenir un polynôme de degré 1. Puis, nous évaluons ce polynôme avec les racines seconde de l'unité. Nous faisons à nouveau remonté les évaluations et recombinons à nouveau le polynôme qui sera ainsi de degré 2.
Nous l'évaluons maintenant avec les racines 4eme de l'unité. A chaque évaluation, nous réutilisons les résultats précédents, cela nous est permit par les racines de l'unité qui ont une structure récursive exploitable.

Finalement, nous arrivons à la fin de notre FFT, avec une représentation fréquentielle de la forme :

<math> [P(W_0), P(W_1), (...), P(W_n-1), P(W_n)] </math>

Cette représentation fréquentielle n'est autre que les évaluations du polynôme P aux racines nièmes de l'unité. Nous avons donc maintenant au minimum <math>2n+1</math> évaluations des polynômes facteurs. Il nous faut maintenant trouver les évaluations du produit final, c'est à dire les évaluations concernant le polynôme qui sera issue de la multiplication. On pourra ainsi le retrouver.

Soit <math>C</math> un polynome tel que <math> C = A \times B </math>, alors on a :

<math> C(x) = A(x) \times B(x) </math>

Ainsi on en déduit que <math> C(W_n^k) = A(W_n^k) \times B(W_n^k) </math>

On comprend donc que <math>FFT(C) = FFT(A) \times FFT(B)</math>

Il faut préciser que l'on fait le produit de FFT(A) et FFT(B) terme à terme, soit évaluation par évaluation.

Une fois en possession de <math>FFT(C)</math>, qui n'est autre que l'évaluation de notre polynôme final en un nombre suffisant de points pour le retrouver, nous pouvons faire l'<math>IFFT(FFT(C))</math>, qui va nous permettre de retrouver les coefficients de notre polynôme en faisant l'exacte inverse de la FFT.

Une fois les coefficients retrouvés, il nous suffit de gérer les retenues, et nous retrouvons un entier de la forme : <math>a_0 a_1 (...) a_{n-1} a_n</math>

=== B) Graphique ===

Intéressons nous maintenant à la complexité de l'algorithme utilisant la transformée de Fourier rapide. On sait que l'algorithme passe par 5 étapes importantes :

<ul>
<li>Etape 1 : Ecrire les deux facteurs sous la forme de polynômes</li>
<li>Etape 2 : Effectuer la <math>FFT</math> des deux polynômes</li>
<li>Etape 3 : Faire le produit terme à terme des <math>FFT</math> obtenues</li>
<li>Etape 4 : Faire l'<math>IFFT</math> du produit</li>
<li>Etape 5 : Gérer les retenues et écrire le nombre qui en découle</li>
</ul>

Or, parmi toutes ces étapes, certaines sont négligeable comme l'étape 1 et 5.

Pour connaitre la complexité de l'algorithme, additionnons les complexités des étapes restantes :

Une <math>FFT</math> a une complexité de REMPLIRRRRRR car elle fait <math>n</math> évaluation sur REMPLIRRRRRR couches. Dans le cadre de notre algorithme, nous devons faire la <math>FFT</math> de nos deux facteurs. Soit 2(REMPLIRRRRRRR).

Pour le produit terme à terme, nous faisons naturellement <math>n</math> opérations.

Pour finir, l'<math>IFFT</math> a la même complexité que la <math>FFT</math>. Dans le cadre de notre algorithme nous l'emploierons qu'une seule fois, ce qui fait une complexité de REMPLIRRRRRR.

Après addition de toutes ces complexités, nous obtenons la complexité réelle de REMPLIRRRRRRR.

D'après le Master Theorem, nous avons

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:30px; text-align:center;">
[[Fichier:FFT_image.webp|500px]]
<div><b>Graphiques des complexités</b></div>
</div>
<div style="max-width:800px;">
<p>Ce graphique ci-contre compare les complexités en fonction de la taille des d'entrées.</p>
<p>On comprend ainsi que certaines complexités ne sont pas raisonnable dans la cadre de la multiplication de grands entiers.</p>
<p>C'est pourquoi l'étude de ces algorithmes s'avère nécessaire.</p>
</div>
</div>

= II - Produit de matrices =

== 1.1) naïve ==

La multiplication naïve de matrice requiert d'avoir des tailles de lignes/colonne semblable, ensuite pour chaque membre de la matrice résultat, on doit multiplier les composantes ligne de la première matrice par les composantes colonne de la deuxième et le tout sommé.

On en déduit la formule suivante:
<math>C_{i,j} = \sum_{k=1}^{n} (A_{i,k} \times B_{k,j})</math>

Et visuellement:

[[Fichier:Matricenaive.jpeg]]

On a donc un algorithme d'ordre de complexité <math>\mathcal{O}(g(n))</math>

== 1.2) naïve récursive ==

Dans un premier temps on doit découper nos deux matrices en quatres sous matrices de plus petite taille.
<math>A = \begin{pmatrix} A_{11} & A_{12} \ A_{21} & A_{22} \end{pmatrix}</math>
<math>B = \begin{pmatrix} B_{11} & B_{12} \ B_{21} & B_{22} \end{pmatrix}</math>

Ensuite on vient calculer la matrice résultat.
<math>C_{11} = (A_{11} \times B_{11}) + (A_{12} \times B_{21})</math>
<math>C_{12} = (A_{11} \times B_{12}) + (A_{12} \times B_{22})</math>
<math>C_{21} = (A_{21} \times B_{11}) + (A_{22} \times B_{21})</math>
<math>C_{22} = (A_{21} \times B_{12}) + (A_{22} \times B_{22})</math>

Le côté récursif est utile que pour les matrices de tailles <= 32 (32 valeurs stockées dedans),
si on est au dessus de cette taille alors on divisera à nouveau nos matrices en quatres.
On aura 8 multiplications mais de plus petite taille au final.

== 2) strassen ==

=== A) Fonctionnement ===

Strassen consiste à définir 7 produits intermédiaires qui, par des jeux de sommes et de différences, permettent de reconstruire les quadrants de la matrice résultante. On passe ainsi d'une complexité de O(n^3) à environ O(n^2.81)

=== B) Graphique ===

On voit bien la différence de complexité sur la multiplication de grande matrice entre l'approche naïve et l'approche récursive qui est beaucoup plus rapide.

[[Fichier:Analyse matrices.png]]

= Conclusion =

( A FAIRE )

= Mentions =

Le premier gif est le résultat du travail de 'Walké', licence ci-contre : https://fr.wikipedia.org/wiki/Fichier:Addition.gif

= Sources =

Pour karatsuba : https://www.youtube.com/watch?v=PZ2gdWdKHAA

Pour mieux comprendre la FFT, nous avons utilisé plusieurs sources d'informations :
<ul>
<li> https://www.youtube.com/watch?v=h7apO7q16V0&list=WL&index=1&t=886s </li>
<li> https://fr.wikipedia.org/wiki/Interpolation_polynomiale </li>
</ul>

Algorithmes de multiplications d'entiers et de matrices

2026-05-11T12:05:54Z

Mangala : /* B) Graphique */

= Introduction =

Depuis l'apparition des ordinateurs modernes, une quantité faramineuse de calcul a dû être effectuée. Les progressions technologiques nous poussent à envisager la puissance de calcul comme une ressource qu'il faut optimiser dans les moindres détails. C'est ainsi que l'optimisation des algorithmes de calcul est devenue cruciale, surtout lorsqu'il nous faut effectuer des opérations sur de très grands entiers par exemple.

= Objectif =

L'objectif majeur de ce projet est de comprendre de manière plus approfondie ce qu'est la '''complexité algorithmique'''.
Pour atteindre cet objectif, nous implémenterons plusieurs algorithmes de multiplication qui auront pour but de calculer le produit de grands entiers ou de matrices.

= Point important : complexité =

=== Définition ===
La complexité d'un algorithme est la quantité des ressources qu'il utilise en fonction de la taille des entrée qu'on lui demande de traiter. On peut par exemple se concentrer sur le temps qu'un algorithme prend pour renvoyer un résultat ou sur la mémoire dont il a besoin. Dans le cadre de notre projet, nous nous attarderons plus particulièrement sur la quantité de calcul effectuée en fonction de la taille des entrées, ce qui est par ailleurs fortement liée à la notion de temps. De manière générale, plus un algorithme doit faire de calcul, plus il est lent. (Attention, toutes les opérations arithmétiques de base ne se valent pas)

De manière plus familière, on dira que la complexité d'un algorithme pourrait s'apparenter à son comportement lorsqu'il doit traiter des données plus ou moins grandes.
Chaque algorithme a une complexité, et on l'exprime par une fonction qui adopte un comportement similaire au nombre de calcul nécessaire en fonction de la taille des entrées.

=== Notation ===
La complexité réelle d'un algorithme peut être décrite par une fonction <math>f(n)</math> représentant le nombre d'opérations effectuées en fonction de la taille <math>n</math> des données d'entrée.

Cependant, afin de simplifier l'étude de cette croissance, on utilise généralement une borne asymptotique notée <math>\mathcal{O}(g(n))</math>, où <math>g(n)</math> est une fonction ayant le même ordre de grandeur que <math>f(n)</math> lorsque <math>n</math> devient grand.

On dit alors que :

<math>
f(n)\in\mathcal{O}(g(n))
</math>

si et seulement s'il existe une constante <math>C>0</math> et un entier <math>n_0</math> tels que :

<math>
\forall n\ge n_0,\ f(n)\le Cg(n)
</math>

Cette notation <math>\mathcal{O}(g(n))</math> permettra de comparer beaucoup plus facilement les algorithmes entre eux.

=== Master Theorem ===

Afin de déterminer la complexité de certains algorithmes récursifs, nous utiliserons le "Master Theorem".

Ce théorème permet d'obtenir directement l'ordre de grandeur de nombreuses relations de récurrence apparaissant dans l'analyse d'algorithmes de type « diviser pour régner », comme l'algorithme de Karatsuba ou celui de Strassen.

La démonstration complète de ce théorème dépasse le cadre de notre projet et nécessite des connaissances mathématiques plus avancées. Nous l'utiliserons donc principalement comme un outil nous permettant de déterminer efficacement la complexité asymptotique des algorithmes étudiés.

=== Graphiques ===

Les complexités étant des fonctions, nous pouvons les représenter par un graphique qui affichera le temps d'exécution (ou nombre d'opérations) en fonction de la taille des entrées.

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:30px; text-align:center;">
[[Fichier:complexite.webp|500px]]
<div><b>Graphiques des complexités</b></div>
</div>
<div style="max-width:800px;">
<p>Ce graphique ci-contre compare les complexités en fonction de la taille des d'entrées.</p>
<p>On comprend ainsi que certaines complexités ne sont pas raisonnable dans la cadre de la multiplication de grands entiers.</p>
<p>C'est pourquoi l'étude de ces algorithmes s'avère nécessaire.</p>
</div>
</div>

=== Exemple ===
L'algorithme naïf d'addition que nous avons tous appris à l'école a une complexité de <math>\mathcal{O}(n)</math>.
Soit n la taille des nombres en entrée, l'algorithme doit faire environ n addition pour arriver au résultat demandé.

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Addition.gif|220px]]
<div><b>Addition naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Comme le montre l'exemple ci-contre, 786 et 467 font 3 chiffres de long donc n sera de 3.</p>
<p>Il nous faudra 3 opérations pour additionner ces deux nombres.</p>
<p>C'est ainsi qu'avec une taille d'entrée n, l'algorithme de l'addition naïve va devoir faire n opérations.</p>
<p>Cette algorithme a donc une complexité <math>f(n) = n</math> qui n'a pas besoin d'être approximée.</p>
<p>Ainsi sa complexité finale sera <math>\mathcal{O}(n)</math>.</p>
</div>
</div>

= Problématique =

Le calcul du produit de deux entiers de manière naïve a une complexité de <math> \mathcal{O}(n^2)</math>, et celui de deux matrices une complexité de <math> \mathcal{O}(n^3)</math>. Afin de mieux comprendre ce qu'est la complexité algorithmique, nous devrons implémenter des algorithmes ayant le même objectif, mais étant plus efficaces. Ces algorithmes s'avèreront plus complexes mais devrait aboutir à un calcul plus rapide du produit demandé.

Nous séparerons notre wiki en deux grandes parties, la première concernera nos recherche sur [[#I - Produit d'entiers|la multiplication d'entiers]], la deuxième sur [[#II - Produit de matrices|la multiplication de matrices]].

= I - Produit d'entiers =

Notre départ commence avec l'algorithme de multiplication d'entier naïf.
En effet il s'agit de l'algorithme de multiplication le plus connu, et nous l'utiliserons comme référence pour le comparer aux futurs algorithmes plus efficaces.
Intéressons nous à sa complexité.

== 1) Nos implémentations des grands entiers ==

Qui dit produit de grands entiers dit implémentation de grands entiers.

Dans le cadre de nos recherches, nous allons devoir implémenter des algorithmes qui vont manipuler des grands entiers.

Nous avons donc choisi de créer deux représentations différentes de ceux-ci (car nous travaillons sur différents langages de programmation), nous permettant à la fois une implémentation simplifié, mais aussi de nous rapprocher d'une implémentation bas niveau.

=== A) En python ===
En python, l'utilisation des "bytes" m'a grandement servi à comprendre comment les entiers étaient manipulés à bas niveau. En effet, un des objectifs secondaires de nos recherches était de manipuler des entiers directement avec leur formes stockées sur l'ordinateur, et non pas avec des int python.
En effet l'utilisation des int python nous aurait permit de passer les étapes de retenues, de signes... D'autant plus que les bytes permettent de stocker un nombre en base 256, ce qui permet de visualiser plus facilement les grands entiers.

La forme finale de la représentation des grands entiers en python sera donc la suivante :

[ signe , bytes , bytes , (...) , bytes ]

Le signe est représenté par un entier, 1 si le nombre est positif, 0 sinon.
Cette configuration rendra plus simple la gestion des signes.

=== B) En C++ ===

En C++, pour avoir une représentation de grand entiers j'ai du définir ma propre structure pour m'affranchir de la limite de taille imposé par les entiers standards: (int32 ou int64). Pour cela, j'ai une structure qui possède l'équivalent d'un array de byte (ce qui nous permet d'être en base 256 au lieu de la base 10 habituelle), et pour traiter le signe j'utilise un booléen, ainsi en mémoire j'ai une structure de n*Octets + 1 octet en taille.

[ bytes , bytes , (...) , bytes ] [ signe ]

Le booléen prend 1 octet de place mais ne touche pas aux octets qui encode le grand entier.
Cette configuration rendra plus simple la gestion des signes dans le cadre des multiplication.

== 2) La multiplication naïve ==

=== A) Fonctionnement ===
Dans le cas de la multiplication d'entiers, nous allons prendre deux nombres qui n'ont pas nécessairement la même longueur. Soit les nombre a et b, de longueur respective <math>n</math> et <math> m </math>.
<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Multiplication.png|220px]]
<div><b>Multiplication naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Prenons deux nombres de longueur 3 et 2, et cherchons combien d'opérations l'algorithme de multiplication naïve va devoir faire pour nous renvoyer leur produit.</p>
<p>Dans un premier temps, on remarque que l'on va devoir multiplier chaque chiffre du nombre du haut par le chiffre des unités du bas, qui est 6. Cela va représenter <math>n</math> opérations. (6x5, 6x1 et 6x4)</p>
<p>Dans un deuxième temps nous constatons que nous allons devoir faire la même chose avec le chiffre des dizaines du nombre du bas. Cela nous ajoute de nouveau <math>n</math> opérations.</p>
<p>On arrive assez facilement à la conclusion que pour faire notre produit, il va nous falloir faire <math>n</math> fois <math>m</math> opérations.</p>
</div>
</div>

Ainsi, la complexité de la multiplication naïve est <math>\mathcal{O}(n^2)</math>.
Il est en de même avec la multiplication naïve récursive.

=== B) Graphique ===
Montrons maintenant sa courbe sur un graphique :

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Multiplicationnaive.png|500px]]
<div><b>Multiplication naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Les points noirs sont des repères pour que les autres courbes aient une forme cohérente.</p>
<p>Ils sont tous sur l'axe des abscisses.</p>
<p>La courbe rouge représente la complexité de la multiplication naïve.</p>
<p>On remarque que la courbe a un visuel très similaire à la fonction <math>f(x) = x^2</math> </p>
</div>
</div>

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Naif_recursif.png|500px]]
<div><b>Multiplication naïve récursive</b></div>
</div>
<div style="max-width:800px;">
<p>La courbe rouge représente la complexité de la multiplication naïve récursive.</p>
<p>Elle sera utilisé pour comparer les complexités entre algorithmes car, comme tous récursifs, elle a été codé avec les mêmes biais d'implémentation qu'eux.</p>
<p>Théoriquement les deux courbes ci-contre ont la même complexité, mais encore une fois, notre implémentation n'est pas parfaitement optimale et donc ne respecte pas de manière minutieuse le Master Theorem.</p>
</div>
</div>

== 3) La multiplication karastuba ==

=== A) Fonctionnement ===

L'algorithme de karatsuba est un algorithme récursif de type diviser pour régner.

L'idée générale de l'algorithme est de passer de 4 multiplication à 3. En effet ces opérations étant moins couteuses, il est préférable d'en ajouter si cela permet d'enlever des multiplications.

L'algorithme de multiplication naif récursif utilise la segmentation des facteurs en deux de manière successive.

Soit <math>x</math> et <math>y</math> deux facteurs, nous avons les égalités suivantes :

<div style="font-size: 20px;">
<math>x = a \times B^{n/2} + b</math>
<math>y = c \times B^{n/2} + d</math>
</div>

Avec <math>a</math> et <math>c</math> les premières moitiés des facteurs <math>x</math> et <math>y</math>,
et <math>b</math> et <math>d</math> les dernières moitiés de ces facteurs ainsi que <math>B</math> la base d'écriture du nombre (Nous sommes en base 256 avec les bytes).

Cette présentation des deux facteurs de notre multiplication n'est que la résultante d'un découpage.
Le [[#Master Theorem|Master Theorem]] nous montre que :

<div style="font-size: 20px;">
<math>T(n) = 4T(n/2) + O(n)</math>
</div>

Puisque nous avons après découpage 4 entiers de longueur <math>n/2</math>.

Ainsi, ce découpage ne permet pas de gagner du temps d'après le [[#Master Theorem|Master Theorem]].

Cependant, l'algorithme de Karatsuba réutilise ce principe en le modifiant, ce qui nous permet de baisser la complexité globale de la multiplication dans son entièreté.

Avec l'écriture ci-dessus des nombres <math>x</math> et <math>y</math>, on peut facilement en déduire l'égalité suivante :

<div style="font-size: 20px;">
<math>x \times y = (ac) \times B^n + (ad + bc) \times B^{n/2} + bd</math>
</div>

On remarque 4 multiplications longues à faire dans cette expression. Les multiplications dont <math>B</math> est l'un des facteurs sont très rapides puisqu'il s'agit de la base dans laquelle nous travaillons. De cela en résulte un décalage plutôt qu'un vrai calcul à faire.

Karatsuba développe une partie de cette expression pour pouvoir négocier une multiplication au prix d'additions et soustractions.

En effet, nous savons déjà que :

<div style="font-size: 20px;">
<math>(a + b)(c + d) = ac + ad + bc + bd</math>
</div>

En manipulant l'égalité nous obtenons :

<div style="font-size: 20px;">
<math>ad + bc = (a + b)(c + d) - ac - bd</math>
</div>

ac et bd ayant déjà été calculé précédemment, il nous reste uniquement la multiplication <math>(a + b)(c + d)</math>.

Nous venons ainsi de calculer <math>ad + bc</math> en seulement une multiplication. C'est la que repose le gain de temps de la méthode Karatsuba par rapport à la multiplication naïve.

En effet, l'algorithme n'effectuera alors plus que 3 multiplications :
<div style="font-size: 20px;">
<math>ac</math>
<math>bd</math>
<math>(a + b)(c + d)</math>
</div>

La relation de récurrence devient donc :
<div style="font-size: 20px;">
<math>T(n)=3T(n/2)+O(n)</math>
</div>

Et le Master Theorem nous dit que :
<div style="font-size: 20px;">
<math>T(n)\in O(n^{\log_2(3)})</math>
</div>

Or <math>\log_2(3)\approx 1.585</math>, donc la complexité de l'algorithme de Karatsuba est de <math> \mathcal{O}(n^{1.585})</math>. Ce qui est bien plus efficace que la multiplication classique, surtout lorsque les facteurs deviennent très grands.

=== B) Graphique ===
<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Karatsuba.png|500px]]
<div><b>Karatsuba</b></div>
</div>
<div style="max-width:800px;">
<p>Sur le graphique ci-contre nous avons utilisé la courbe de la multiplication naïve récursive (rouge) à titre de comparaison.</p>
<p>On remarque graphiquement que Karatsuba (jaune) prend moins de temps à chaque calcul de produit.</p>
<p>On en déduit donc expérimentalement que Karatsuba à une meilleure complexité que la multiplication naïve.</p>
<p>Ainsi nous vérifions donc ce que le Master Theorem prouve, c'est à dire que la complexité de karatsuba est de <math> \mathcal{O}(n^{1.585})</math> </p>
</div>
</div>

== 4) La multiplication toom-cook-3 ==

=== A) Fonctionnement ===

L'objectif est de diviser les grands entiers X et Y en trois blocs de taille égale k.
On les traite alors comme des polynômes de degré 2:

<math>P(z) = X_2 \cdot z^2 + X_1 \cdot z + X_0</math>
<math>Q(z) = Y_2 \cdot z^2 + Y_1 \cdot z + Y_0</math>

On choisit 5 points distincts pour évaluer nos polynômes.
Ce choix de 5 points est crucial car le produit de deux polynômes de degré 2 est un polynôme de degré 4, qui nécessite 5 points pour être défini.
Les points standards sont :

P(0) = X0
P(1) = X0 + X1 + X2
P(-1) = X0 - X1 + X2
P(2) = X0 + 2*X1 + 4*X2
P(inf) = X2

(On procède de manière similaire pour Q.)

Ensuite nous multiplions récursivement chaque points de P et de Q ensemble.
On effectue ainsi 5 multiplications de nombres plus petits au lieu des 9 multiplications requises par la méthode classique.

Après, nous effectuons une interpolation, cela permet de retrouver les 5 coefficients (w_0, w_1, w_2, w_3, w_4) du polynôme produit R(z) à partir des valeurs évaluées calculées précédemment.
On résout un système d'équations linéaires : <math> R(z) = w_4 z^4 + w_3 z^3 + w_2 z^2 + w_1 z + w_0 </math>
Finalement nous pouvons recomposer notre grand entier en positionnant les coefficients w_i aux bons rangs (en les décalant) et à gérer les retenues lors de l'addition finale:
<math>Résultat = w_4 B^{4k} + w_3 B^{3k} + w_2 B^{2k} + w_1 B^k + w_0</math>

=== B) Graphique ===

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Toomcook.png|500px]]
<div><b>Karatsuba</b></div>
</div>
<div style="max-width:800px;">
<p>on a reprit multi récursive (rouge)</p>
<p>on voit que Toom (vert) en dessous de karatsuba (jaune) en dessous de multi classique (rouge)</p>
<p>meilleur complexité</p>
</div>
</div>

== 5) La transformée de Fourier rapide ==

=== A) Fonctionnement ===

La transformation de Fourier rapide étant plus complexe que les autres algorithmes, nous allons essayer d'expliquer son fonctionnement malgré ne pas avoir réussi à l'implémenter.

Il faut comprendre que cet algorithme va considérer les facteurs comme des polynômes.

D'après le théorème de l'unisolvance, il n'existe qu'un seul polynôme de degré inférieur ou égal à <math> n </math> défini par <math>n + 1</math> points distincts. Cela implique non seulement que nous pouvons représenter chaque entier par un polynôme, mais également que si nous pouvons retrouver <math>n + m + 1</math> points (avec <math>n</math> et <math>m</math> la longueur des facteurs) du polynômes issue du produit entre deux facteurs, nous pourrons le retrouver.

Soit un entier quelconque, de forme :

<math>a_n a_{n-1} (...) a_1 a_0</math>

Avec <math>a_i</math>, un chiffre composant le nombre en base 10, qui vaut en réalité dans le nombre : <math>a_i \times 10^i</math>. On peut ainsi l'écrire sous la forme :

<math> P(x) = a_0 + a_1x + a_2x^2 + \dots + a_{n-1}x^{n-1} + a_nx^n </math>

Avec <math>x = 10</math> car nous sommes en base 10, nous obtenons :

<math>P(10) = a_0 + a_1 \times 10 + \dots + a_{n-1}10^{n-1} + a_n10^n </math>

Nous venons ainsi d'écrire notre nombre sous la forme d'un polynôme unique. Pour nous permettre d'évaluer en un nombre suffisant de points, nous allons devoir ajouter des 0 pour la récursion. Il nous faudra ajouter assez de 0 pour atteindre la prochaine puissance de 2 qui sera supérieure ou égale à <math>2n + 1</math>. L'ajout de 0 ne change pas le nombre car <math>0 \times x^n</math> n'ajoute pas de coefficient.

Cet algorithme est récursif et va segmenter en deux parties nos polynômes à chaque récursion. D'un coté les indice paires et d'un coté les impaires.

Ainsi prenons les nombres 1234 et 5678, ces nombres sont respectivement représentés par les polynômes <math> P(x) = 4 + 3x + 2x^2 + x^3 </math> et <math> P(x) = 8 + 7x + 6x^2 + 5^3 </math>. Ce sont des polynômes de degré 3, ainsi leur produit donnera lieu à un polynôme de degré 6. Il nous faudra donc au minimum 7 points d'évaluation pour retrouve ce produit. De ce fait, en les représentant de la manière suivante :

<math>[4, 3, 2, 1, 0, 0, 0, 0]</math>
<math>[8, 7, 6, 5, 0, 0, 0, 0]</math>

Nous aurons assez de récursions possible pour les évaluer en un nombre suffisant de points différents car nous auront 3 récursions à faire pour atteindre notre cas de base. A chaque récursion, nous allons diviser nos polynômes en deux parties ce qui nous fait 8 feuilles à la dernière récursion.

En effet à chaque étape de la récursion nous allons séparer nos polynômes en deux tel que :

<math> P(x)=P_{pair}x^2 + x \times P_{impair}x^2 </math>

Durant les récursions, nous segmentons les polynômes mais ne les évaluons pas. C'est à la remonté des récursions que nous allons réellement évaluer nos polynômes. Lorsque l'on atteint notre cas de base, c'est à dire des polynômes de degré 0, nous remarquons qu'ils sont constants, nous n'avons donc pas besoin de les évaluer. En effet, peut importe le point en lequel nous voudrons l'évaluer, le polynôme renverra la constante. Nous la renvoyons donc seule.
Ensuite commence la remontée des récursions. A l'étape 1 de notre remontée nous allons reformer le polynôme précédemment séparé pour obtenir un polynôme de degré 1. Puis, nous évaluons ce polynôme avec les racines seconde de l'unité. Nous faisons à nouveau remonté les évaluations et recombinons à nouveau le polynôme qui sera ainsi de degré 2.
Nous l'évaluons maintenant avec les racines 4eme de l'unité. A chaque évaluation, nous réutilisons les résultats précédents, cela nous est permit par les racines de l'unité qui ont une structure récursive exploitable.

Finalement, nous arrivons à la fin de notre FFT, avec une représentation fréquentielle de la forme :

<math> [P(W_0), P(W_1), (...), P(W_n-1), P(W_n)] </math>

Cette représentation fréquentielle n'est autre que les évaluations du polynôme P aux racines nièmes de l'unité. Nous avons donc maintenant au minimum <math>2n+1</math> évaluations des polynômes facteurs. Il nous faut maintenant trouver les évaluations du produit final, c'est à dire les évaluations concernant le polynôme qui sera issue de la multiplication. On pourra ainsi le retrouver.

Soit <math>C</math> un polynome tel que <math> C = A \times B </math>, alors on a :

<math> C(x) = A(x) \times B(x) </math>

Ainsi on en déduit que <math> C(W_n^k) = A(W_n^k) \times B(W_n^k) </math>

On comprend donc que <math>FFT(C) = FFT(A) \times FFT(B)</math>

Il faut préciser que l'on fait le produit de FFT(A) et FFT(B) terme à terme, soit évaluation par évaluation.

Une fois en possession de <math>FFT(C)</math>, qui n'est autre que l'évaluation de notre polynôme final en un nombre suffisant de points pour le retrouver, nous pouvons faire l'<math>IFFT(FFT(C))</math>, qui va nous permettre de retrouver les coefficients de notre polynôme en faisant l'exacte inverse de la FFT.

Une fois les coefficients retrouvés, il nous suffit de gérer les retenues, et nous retrouvons un entier de la forme : <math>a_0 a_1 (...) a_{n-1} a_n</math>

=== B) Graphique ===

Intéressons nous maintenant à la complexité de l'algorithme utilisant la transformée de Fourier rapide. On sait que l'algorithme passe par 5 étapes importantes :

<ul>
<li>Ecrire les deux facteurs sous la forme de polynômes</li>
<li>Effectuer la <math>FFT</math> des deux polynômes</li>
<li>Faire le produit terme à terme des <math>FFT</math> obtenues</li>
<li>Faire l'<math>IFFT</math> du produit</li>
<li>Gérer les retenues et écrire le nombre qui en découle</li>
</ul>

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:30px; text-align:center;">
[[Fichier:FFT_image.webp|500px]]
<div><b>Graphiques des complexités</b></div>
</div>
<div style="max-width:800px;">
<p>Ce graphique ci-contre compare les complexités en fonction de la taille des d'entrées.</p>
<p>On comprend ainsi que certaines complexités ne sont pas raisonnable dans la cadre de la multiplication de grands entiers.</p>
<p>C'est pourquoi l'étude de ces algorithmes s'avère nécessaire.</p>
</div>
</div>

= II - Produit de matrices =

== 1.1) naïve ==

La multiplication naïve de matrice requiert d'avoir des tailles de lignes/colonne semblable, ensuite pour chaque membre de la matrice résultat, on doit multiplier les composantes ligne de la première matrice par les composantes colonne de la deuxième et le tout sommé.

On en déduit la formule suivante:
<math>C_{i,j} = \sum_{k=1}^{n} (A_{i,k} \times B_{k,j})</math>

Et visuellement:

[[Fichier:Matricenaive.jpeg]]

On a donc un algorithme d'ordre de complexité <math>\mathcal{O}(g(n))</math>

== 1.2) naïve récursive ==

Dans un premier temps on doit découper nos deux matrices en quatres sous matrices de plus petite taille.
<math>A = \begin{pmatrix} A_{11} & A_{12} \ A_{21} & A_{22} \end{pmatrix}</math>
<math>B = \begin{pmatrix} B_{11} & B_{12} \ B_{21} & B_{22} \end{pmatrix}</math>

Ensuite on vient calculer la matrice résultat.
<math>C_{11} = (A_{11} \times B_{11}) + (A_{12} \times B_{21})</math>
<math>C_{12} = (A_{11} \times B_{12}) + (A_{12} \times B_{22})</math>
<math>C_{21} = (A_{21} \times B_{11}) + (A_{22} \times B_{21})</math>
<math>C_{22} = (A_{21} \times B_{12}) + (A_{22} \times B_{22})</math>

Le côté récursif est utile que pour les matrices de tailles <= 32 (32 valeurs stockées dedans),
si on est au dessus de cette taille alors on divisera à nouveau nos matrices en quatres.
On aura 8 multiplications mais de plus petite taille au final.

== 2) strassen ==

=== A) Fonctionnement ===

Strassen consiste à définir 7 produits intermédiaires qui, par des jeux de sommes et de différences, permettent de reconstruire les quadrants de la matrice résultante. On passe ainsi d'une complexité de O(n^3) à environ O(n^2.81)

=== B) Graphique ===

On voit bien la différence de complexité sur la multiplication de grande matrice entre l'approche naïve et l'approche récursive qui est beaucoup plus rapide.

[[Fichier:Analyse matrices.png]]

= Conclusion =

( A FAIRE )

= Mentions =

Le premier gif est le résultat du travail de 'Walké', licence ci-contre : https://fr.wikipedia.org/wiki/Fichier:Addition.gif

= Sources =

Pour karatsuba : https://www.youtube.com/watch?v=PZ2gdWdKHAA

Pour mieux comprendre la FFT, nous avons utilisé plusieurs sources d'informations :
<ul>
<li> https://www.youtube.com/watch?v=h7apO7q16V0&list=WL&index=1&t=886s </li>
<li> https://fr.wikipedia.org/wiki/Interpolation_polynomiale </li>
</ul>

Algorithmes de multiplications d'entiers et de matrices

2026-05-11T12:02:58Z

Mangala : /* B) Graphique */

= Introduction =

Depuis l'apparition des ordinateurs modernes, une quantité faramineuse de calcul a dû être effectuée. Les progressions technologiques nous poussent à envisager la puissance de calcul comme une ressource qu'il faut optimiser dans les moindres détails. C'est ainsi que l'optimisation des algorithmes de calcul est devenue cruciale, surtout lorsqu'il nous faut effectuer des opérations sur de très grands entiers par exemple.

= Objectif =

L'objectif majeur de ce projet est de comprendre de manière plus approfondie ce qu'est la '''complexité algorithmique'''.
Pour atteindre cet objectif, nous implémenterons plusieurs algorithmes de multiplication qui auront pour but de calculer le produit de grands entiers ou de matrices.

= Point important : complexité =

=== Définition ===
La complexité d'un algorithme est la quantité des ressources qu'il utilise en fonction de la taille des entrée qu'on lui demande de traiter. On peut par exemple se concentrer sur le temps qu'un algorithme prend pour renvoyer un résultat ou sur la mémoire dont il a besoin. Dans le cadre de notre projet, nous nous attarderons plus particulièrement sur la quantité de calcul effectuée en fonction de la taille des entrées, ce qui est par ailleurs fortement liée à la notion de temps. De manière générale, plus un algorithme doit faire de calcul, plus il est lent. (Attention, toutes les opérations arithmétiques de base ne se valent pas)

De manière plus familière, on dira que la complexité d'un algorithme pourrait s'apparenter à son comportement lorsqu'il doit traiter des données plus ou moins grandes.
Chaque algorithme a une complexité, et on l'exprime par une fonction qui adopte un comportement similaire au nombre de calcul nécessaire en fonction de la taille des entrées.

=== Notation ===
La complexité réelle d'un algorithme peut être décrite par une fonction <math>f(n)</math> représentant le nombre d'opérations effectuées en fonction de la taille <math>n</math> des données d'entrée.

Cependant, afin de simplifier l'étude de cette croissance, on utilise généralement une borne asymptotique notée <math>\mathcal{O}(g(n))</math>, où <math>g(n)</math> est une fonction ayant le même ordre de grandeur que <math>f(n)</math> lorsque <math>n</math> devient grand.

On dit alors que :

<math>
f(n)\in\mathcal{O}(g(n))
</math>

si et seulement s'il existe une constante <math>C>0</math> et un entier <math>n_0</math> tels que :

<math>
\forall n\ge n_0,\ f(n)\le Cg(n)
</math>

Cette notation <math>\mathcal{O}(g(n))</math> permettra de comparer beaucoup plus facilement les algorithmes entre eux.

=== Master Theorem ===

Afin de déterminer la complexité de certains algorithmes récursifs, nous utiliserons le "Master Theorem".

Ce théorème permet d'obtenir directement l'ordre de grandeur de nombreuses relations de récurrence apparaissant dans l'analyse d'algorithmes de type « diviser pour régner », comme l'algorithme de Karatsuba ou celui de Strassen.

La démonstration complète de ce théorème dépasse le cadre de notre projet et nécessite des connaissances mathématiques plus avancées. Nous l'utiliserons donc principalement comme un outil nous permettant de déterminer efficacement la complexité asymptotique des algorithmes étudiés.

=== Graphiques ===

Les complexités étant des fonctions, nous pouvons les représenter par un graphique qui affichera le temps d'exécution (ou nombre d'opérations) en fonction de la taille des entrées.

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:30px; text-align:center;">
[[Fichier:complexite.webp|500px]]
<div><b>Graphiques des complexités</b></div>
</div>
<div style="max-width:800px;">
<p>Ce graphique ci-contre compare les complexités en fonction de la taille des d'entrées.</p>
<p>On comprend ainsi que certaines complexités ne sont pas raisonnable dans la cadre de la multiplication de grands entiers.</p>
<p>C'est pourquoi l'étude de ces algorithmes s'avère nécessaire.</p>
</div>
</div>

=== Exemple ===
L'algorithme naïf d'addition que nous avons tous appris à l'école a une complexité de <math>\mathcal{O}(n)</math>.
Soit n la taille des nombres en entrée, l'algorithme doit faire environ n addition pour arriver au résultat demandé.

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Addition.gif|220px]]
<div><b>Addition naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Comme le montre l'exemple ci-contre, 786 et 467 font 3 chiffres de long donc n sera de 3.</p>
<p>Il nous faudra 3 opérations pour additionner ces deux nombres.</p>
<p>C'est ainsi qu'avec une taille d'entrée n, l'algorithme de l'addition naïve va devoir faire n opérations.</p>
<p>Cette algorithme a donc une complexité <math>f(n) = n</math> qui n'a pas besoin d'être approximée.</p>
<p>Ainsi sa complexité finale sera <math>\mathcal{O}(n)</math>.</p>
</div>
</div>

= Problématique =

Le calcul du produit de deux entiers de manière naïve a une complexité de <math> \mathcal{O}(n^2)</math>, et celui de deux matrices une complexité de <math> \mathcal{O}(n^3)</math>. Afin de mieux comprendre ce qu'est la complexité algorithmique, nous devrons implémenter des algorithmes ayant le même objectif, mais étant plus efficaces. Ces algorithmes s'avèreront plus complexes mais devrait aboutir à un calcul plus rapide du produit demandé.

Nous séparerons notre wiki en deux grandes parties, la première concernera nos recherche sur [[#I - Produit d'entiers|la multiplication d'entiers]], la deuxième sur [[#II - Produit de matrices|la multiplication de matrices]].

= I - Produit d'entiers =

Notre départ commence avec l'algorithme de multiplication d'entier naïf.
En effet il s'agit de l'algorithme de multiplication le plus connu, et nous l'utiliserons comme référence pour le comparer aux futurs algorithmes plus efficaces.
Intéressons nous à sa complexité.

== 1) Nos implémentations des grands entiers ==

Qui dit produit de grands entiers dit implémentation de grands entiers.

Dans le cadre de nos recherches, nous allons devoir implémenter des algorithmes qui vont manipuler des grands entiers.

Nous avons donc choisi de créer deux représentations différentes de ceux-ci (car nous travaillons sur différents langages de programmation), nous permettant à la fois une implémentation simplifié, mais aussi de nous rapprocher d'une implémentation bas niveau.

=== A) En python ===
En python, l'utilisation des "bytes" m'a grandement servi à comprendre comment les entiers étaient manipulés à bas niveau. En effet, un des objectifs secondaires de nos recherches était de manipuler des entiers directement avec leur formes stockées sur l'ordinateur, et non pas avec des int python.
En effet l'utilisation des int python nous aurait permit de passer les étapes de retenues, de signes... D'autant plus que les bytes permettent de stocker un nombre en base 256, ce qui permet de visualiser plus facilement les grands entiers.

La forme finale de la représentation des grands entiers en python sera donc la suivante :

[ signe , bytes , bytes , (...) , bytes ]

Le signe est représenté par un entier, 1 si le nombre est positif, 0 sinon.
Cette configuration rendra plus simple la gestion des signes.

=== B) En C++ ===

En C++, pour avoir une représentation de grand entiers j'ai du définir ma propre structure pour m'affranchir de la limite de taille imposé par les entiers standards: (int32 ou int64). Pour cela, j'ai une structure qui possède l'équivalent d'un array de byte (ce qui nous permet d'être en base 256 au lieu de la base 10 habituelle), et pour traiter le signe j'utilise un booléen, ainsi en mémoire j'ai une structure de n*Octets + 1 octet en taille.

[ bytes , bytes , (...) , bytes ] [ signe ]

Le booléen prend 1 octet de place mais ne touche pas aux octets qui encode le grand entier.
Cette configuration rendra plus simple la gestion des signes dans le cadre des multiplication.

== 2) La multiplication naïve ==

=== A) Fonctionnement ===
Dans le cas de la multiplication d'entiers, nous allons prendre deux nombres qui n'ont pas nécessairement la même longueur. Soit les nombre a et b, de longueur respective <math>n</math> et <math> m </math>.
<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Multiplication.png|220px]]
<div><b>Multiplication naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Prenons deux nombres de longueur 3 et 2, et cherchons combien d'opérations l'algorithme de multiplication naïve va devoir faire pour nous renvoyer leur produit.</p>
<p>Dans un premier temps, on remarque que l'on va devoir multiplier chaque chiffre du nombre du haut par le chiffre des unités du bas, qui est 6. Cela va représenter <math>n</math> opérations. (6x5, 6x1 et 6x4)</p>
<p>Dans un deuxième temps nous constatons que nous allons devoir faire la même chose avec le chiffre des dizaines du nombre du bas. Cela nous ajoute de nouveau <math>n</math> opérations.</p>
<p>On arrive assez facilement à la conclusion que pour faire notre produit, il va nous falloir faire <math>n</math> fois <math>m</math> opérations.</p>
</div>
</div>

Ainsi, la complexité de la multiplication naïve est <math>\mathcal{O}(n^2)</math>.
Il est en de même avec la multiplication naïve récursive.

=== B) Graphique ===
Montrons maintenant sa courbe sur un graphique :

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Multiplicationnaive.png|500px]]
<div><b>Multiplication naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Les points noirs sont des repères pour que les autres courbes aient une forme cohérente.</p>
<p>Ils sont tous sur l'axe des abscisses.</p>
<p>La courbe rouge représente la complexité de la multiplication naïve.</p>
<p>On remarque que la courbe a un visuel très similaire à la fonction <math>f(x) = x^2</math> </p>
</div>
</div>

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Naif_recursif.png|500px]]
<div><b>Multiplication naïve récursive</b></div>
</div>
<div style="max-width:800px;">
<p>La courbe rouge représente la complexité de la multiplication naïve récursive.</p>
<p>Elle sera utilisé pour comparer les complexités entre algorithmes car, comme tous récursifs, elle a été codé avec les mêmes biais d'implémentation qu'eux.</p>
<p>Théoriquement les deux courbes ci-contre ont la même complexité, mais encore une fois, notre implémentation n'est pas parfaitement optimale et donc ne respecte pas de manière minutieuse le Master Theorem.</p>
</div>
</div>

== 3) La multiplication karastuba ==

=== A) Fonctionnement ===

L'algorithme de karatsuba est un algorithme récursif de type diviser pour régner.

L'idée générale de l'algorithme est de passer de 4 multiplication à 3. En effet ces opérations étant moins couteuses, il est préférable d'en ajouter si cela permet d'enlever des multiplications.

L'algorithme de multiplication naif récursif utilise la segmentation des facteurs en deux de manière successive.

Soit <math>x</math> et <math>y</math> deux facteurs, nous avons les égalités suivantes :

<div style="font-size: 20px;">
<math>x = a \times B^{n/2} + b</math>
<math>y = c \times B^{n/2} + d</math>
</div>

Avec <math>a</math> et <math>c</math> les premières moitiés des facteurs <math>x</math> et <math>y</math>,
et <math>b</math> et <math>d</math> les dernières moitiés de ces facteurs ainsi que <math>B</math> la base d'écriture du nombre (Nous sommes en base 256 avec les bytes).

Cette présentation des deux facteurs de notre multiplication n'est que la résultante d'un découpage.
Le [[#Master Theorem|Master Theorem]] nous montre que :

<div style="font-size: 20px;">
<math>T(n) = 4T(n/2) + O(n)</math>
</div>

Puisque nous avons après découpage 4 entiers de longueur <math>n/2</math>.

Ainsi, ce découpage ne permet pas de gagner du temps d'après le [[#Master Theorem|Master Theorem]].

Cependant, l'algorithme de Karatsuba réutilise ce principe en le modifiant, ce qui nous permet de baisser la complexité globale de la multiplication dans son entièreté.

Avec l'écriture ci-dessus des nombres <math>x</math> et <math>y</math>, on peut facilement en déduire l'égalité suivante :

<div style="font-size: 20px;">
<math>x \times y = (ac) \times B^n + (ad + bc) \times B^{n/2} + bd</math>
</div>

On remarque 4 multiplications longues à faire dans cette expression. Les multiplications dont <math>B</math> est l'un des facteurs sont très rapides puisqu'il s'agit de la base dans laquelle nous travaillons. De cela en résulte un décalage plutôt qu'un vrai calcul à faire.

Karatsuba développe une partie de cette expression pour pouvoir négocier une multiplication au prix d'additions et soustractions.

En effet, nous savons déjà que :

<div style="font-size: 20px;">
<math>(a + b)(c + d) = ac + ad + bc + bd</math>
</div>

En manipulant l'égalité nous obtenons :

<div style="font-size: 20px;">
<math>ad + bc = (a + b)(c + d) - ac - bd</math>
</div>

ac et bd ayant déjà été calculé précédemment, il nous reste uniquement la multiplication <math>(a + b)(c + d)</math>.

Nous venons ainsi de calculer <math>ad + bc</math> en seulement une multiplication. C'est la que repose le gain de temps de la méthode Karatsuba par rapport à la multiplication naïve.

En effet, l'algorithme n'effectuera alors plus que 3 multiplications :
<div style="font-size: 20px;">
<math>ac</math>
<math>bd</math>
<math>(a + b)(c + d)</math>
</div>

La relation de récurrence devient donc :
<div style="font-size: 20px;">
<math>T(n)=3T(n/2)+O(n)</math>
</div>

Et le Master Theorem nous dit que :
<div style="font-size: 20px;">
<math>T(n)\in O(n^{\log_2(3)})</math>
</div>

Or <math>\log_2(3)\approx 1.585</math>, donc la complexité de l'algorithme de Karatsuba est de <math> \mathcal{O}(n^{1.585})</math>. Ce qui est bien plus efficace que la multiplication classique, surtout lorsque les facteurs deviennent très grands.

=== B) Graphique ===
<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Karatsuba.png|500px]]
<div><b>Karatsuba</b></div>
</div>
<div style="max-width:800px;">
<p>Sur le graphique ci-contre nous avons utilisé la courbe de la multiplication naïve récursive (rouge) à titre de comparaison.</p>
<p>On remarque graphiquement que Karatsuba (jaune) prend moins de temps à chaque calcul de produit.</p>
<p>On en déduit donc expérimentalement que Karatsuba à une meilleure complexité que la multiplication naïve.</p>
<p>Ainsi nous vérifions donc ce que le Master Theorem prouve, c'est à dire que la complexité de karatsuba est de <math> \mathcal{O}(n^{1.585})</math> </p>
</div>
</div>

== 4) La multiplication toom-cook-3 ==

=== A) Fonctionnement ===

L'objectif est de diviser les grands entiers X et Y en trois blocs de taille égale k.
On les traite alors comme des polynômes de degré 2:

<math>P(z) = X_2 \cdot z^2 + X_1 \cdot z + X_0</math>
<math>Q(z) = Y_2 \cdot z^2 + Y_1 \cdot z + Y_0</math>

On choisit 5 points distincts pour évaluer nos polynômes.
Ce choix de 5 points est crucial car le produit de deux polynômes de degré 2 est un polynôme de degré 4, qui nécessite 5 points pour être défini.
Les points standards sont :

P(0) = X0
P(1) = X0 + X1 + X2
P(-1) = X0 - X1 + X2
P(2) = X0 + 2*X1 + 4*X2
P(inf) = X2

(On procède de manière similaire pour Q.)

Ensuite nous multiplions récursivement chaque points de P et de Q ensemble.
On effectue ainsi 5 multiplications de nombres plus petits au lieu des 9 multiplications requises par la méthode classique.

Après, nous effectuons une interpolation, cela permet de retrouver les 5 coefficients (w_0, w_1, w_2, w_3, w_4) du polynôme produit R(z) à partir des valeurs évaluées calculées précédemment.
On résout un système d'équations linéaires : <math> R(z) = w_4 z^4 + w_3 z^3 + w_2 z^2 + w_1 z + w_0 </math>
Finalement nous pouvons recomposer notre grand entier en positionnant les coefficients w_i aux bons rangs (en les décalant) et à gérer les retenues lors de l'addition finale:
<math>Résultat = w_4 B^{4k} + w_3 B^{3k} + w_2 B^{2k} + w_1 B^k + w_0</math>

=== B) Graphique ===

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Toomcook.png|500px]]
<div><b>Karatsuba</b></div>
</div>
<div style="max-width:800px;">
<p>on a reprit multi récursive (rouge)</p>
<p>on voit que Toom (vert) en dessous de karatsuba (jaune) en dessous de multi classique (rouge)</p>
<p>meilleur complexité</p>
</div>
</div>

== 5) La transformée de Fourier rapide ==

=== A) Fonctionnement ===

La transformation de Fourier rapide étant plus complexe que les autres algorithmes, nous allons essayer d'expliquer son fonctionnement malgré ne pas avoir réussi à l'implémenter.

Il faut comprendre que cet algorithme va considérer les facteurs comme des polynômes.

D'après le théorème de l'unisolvance, il n'existe qu'un seul polynôme de degré inférieur ou égal à <math> n </math> défini par <math>n + 1</math> points distincts. Cela implique non seulement que nous pouvons représenter chaque entier par un polynôme, mais également que si nous pouvons retrouver <math>n + m + 1</math> points (avec <math>n</math> et <math>m</math> la longueur des facteurs) du polynômes issue du produit entre deux facteurs, nous pourrons le retrouver.

Soit un entier quelconque, de forme :

<math>a_n a_{n-1} (...) a_1 a_0</math>

Avec <math>a_i</math>, un chiffre composant le nombre en base 10, qui vaut en réalité dans le nombre : <math>a_i \times 10^i</math>. On peut ainsi l'écrire sous la forme :

<math> P(x) = a_0 + a_1x + a_2x^2 + \dots + a_{n-1}x^{n-1} + a_nx^n </math>

Avec <math>x = 10</math> car nous sommes en base 10, nous obtenons :

<math>P(10) = a_0 + a_1 \times 10 + \dots + a_{n-1}10^{n-1} + a_n10^n </math>

Nous venons ainsi d'écrire notre nombre sous la forme d'un polynôme unique. Pour nous permettre d'évaluer en un nombre suffisant de points, nous allons devoir ajouter des 0 pour la récursion. Il nous faudra ajouter assez de 0 pour atteindre la prochaine puissance de 2 qui sera supérieure ou égale à <math>2n + 1</math>. L'ajout de 0 ne change pas le nombre car <math>0 \times x^n</math> n'ajoute pas de coefficient.

Cet algorithme est récursif et va segmenter en deux parties nos polynômes à chaque récursion. D'un coté les indice paires et d'un coté les impaires.

Ainsi prenons les nombres 1234 et 5678, ces nombres sont respectivement représentés par les polynômes <math> P(x) = 4 + 3x + 2x^2 + x^3 </math> et <math> P(x) = 8 + 7x + 6x^2 + 5^3 </math>. Ce sont des polynômes de degré 3, ainsi leur produit donnera lieu à un polynôme de degré 6. Il nous faudra donc au minimum 7 points d'évaluation pour retrouve ce produit. De ce fait, en les représentant de la manière suivante :

<math>[4, 3, 2, 1, 0, 0, 0, 0]</math>
<math>[8, 7, 6, 5, 0, 0, 0, 0]</math>

Nous aurons assez de récursions possible pour les évaluer en un nombre suffisant de points différents car nous auront 3 récursions à faire pour atteindre notre cas de base. A chaque récursion, nous allons diviser nos polynômes en deux parties ce qui nous fait 8 feuilles à la dernière récursion.

En effet à chaque étape de la récursion nous allons séparer nos polynômes en deux tel que :

<math> P(x)=P_{pair}x^2 + x \times P_{impair}x^2 </math>

Durant les récursions, nous segmentons les polynômes mais ne les évaluons pas. C'est à la remonté des récursions que nous allons réellement évaluer nos polynômes. Lorsque l'on atteint notre cas de base, c'est à dire des polynômes de degré 0, nous remarquons qu'ils sont constants, nous n'avons donc pas besoin de les évaluer. En effet, peut importe le point en lequel nous voudrons l'évaluer, le polynôme renverra la constante. Nous la renvoyons donc seule.
Ensuite commence la remontée des récursions. A l'étape 1 de notre remontée nous allons reformer le polynôme précédemment séparé pour obtenir un polynôme de degré 1. Puis, nous évaluons ce polynôme avec les racines seconde de l'unité. Nous faisons à nouveau remonté les évaluations et recombinons à nouveau le polynôme qui sera ainsi de degré 2.
Nous l'évaluons maintenant avec les racines 4eme de l'unité. A chaque évaluation, nous réutilisons les résultats précédents, cela nous est permit par les racines de l'unité qui ont une structure récursive exploitable.

Finalement, nous arrivons à la fin de notre FFT, avec une représentation fréquentielle de la forme :

<math> [P(W_0), P(W_1), (...), P(W_n-1), P(W_n)] </math>

Cette représentation fréquentielle n'est autre que les évaluations du polynôme P aux racines nièmes de l'unité. Nous avons donc maintenant au minimum <math>2n+1</math> évaluations des polynômes facteurs. Il nous faut maintenant trouver les évaluations du produit final, c'est à dire les évaluations concernant le polynôme qui sera issue de la multiplication. On pourra ainsi le retrouver.

Soit <math>C</math> un polynome tel que <math> C = A \times B </math>, alors on a :

<math> C(x) = A(x) \times B(x) </math>

Ainsi on en déduit que <math> C(W_n^k) = A(W_n^k) \times B(W_n^k) </math>

On comprend donc que <math>FFT(C) = FFT(A) \times FFT(B)</math>

Il faut préciser que l'on fait le produit de FFT(A) et FFT(B) terme à terme, soit évaluation par évaluation.

Une fois en possession de <math>FFT(C)</math>, qui n'est autre que l'évaluation de notre polynôme final en un nombre suffisant de points pour le retrouver, nous pouvons faire l'<math>IFFT(FFT(C))</math>, qui va nous permettre de retrouver les coefficients de notre polynôme en faisant l'exacte inverse de la FFT.

Une fois les coefficients retrouvés, il nous suffit de gérer les retenues, et nous retrouvons un entier de la forme : <math>a_0 a_1 (...) a_{n-1} a_n</math>

=== B) Graphique ===

Intéressons nous maintenant à la complexité de l'algorithme utilisant la transformée de Fourier rapide. On sait que l'algorithme passe par 5 étapes importantes :
<ul>
<li>passer deux nombre en polynomes</li>
<li>faire la fft</li>
<li>faire le produit terme a terme</li>
<li>faire l'ifft</li>
<li>retenue</li>
</ul>

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:30px; text-align:center;">
[[Fichier:FFT_image.webp|500px]]
<div><b>Graphiques des complexités</b></div>
</div>
<div style="max-width:800px;">
<p>Ce graphique ci-contre compare les complexités en fonction de la taille des d'entrées.</p>
<p>On comprend ainsi que certaines complexités ne sont pas raisonnable dans la cadre de la multiplication de grands entiers.</p>
<p>C'est pourquoi l'étude de ces algorithmes s'avère nécessaire.</p>
</div>
</div>

= II - Produit de matrices =

== 1.1) naïve ==

La multiplication naïve de matrice requiert d'avoir des tailles de lignes/colonne semblable, ensuite pour chaque membre de la matrice résultat, on doit multiplier les composantes ligne de la première matrice par les composantes colonne de la deuxième et le tout sommé.

On en déduit la formule suivante:
<math>C_{i,j} = \sum_{k=1}^{n} (A_{i,k} \times B_{k,j})</math>

Et visuellement:

[[Fichier:Matricenaive.jpeg]]

On a donc un algorithme d'ordre de complexité <math>\mathcal{O}(g(n))</math>

== 1.2) naïve récursive ==

Dans un premier temps on doit découper nos deux matrices en quatres sous matrices de plus petite taille.
<math>A = \begin{pmatrix} A_{11} & A_{12} \ A_{21} & A_{22} \end{pmatrix}</math>
<math>B = \begin{pmatrix} B_{11} & B_{12} \ B_{21} & B_{22} \end{pmatrix}</math>

Ensuite on vient calculer la matrice résultat.
<math>C_{11} = (A_{11} \times B_{11}) + (A_{12} \times B_{21})</math>
<math>C_{12} = (A_{11} \times B_{12}) + (A_{12} \times B_{22})</math>
<math>C_{21} = (A_{21} \times B_{11}) + (A_{22} \times B_{21})</math>
<math>C_{22} = (A_{21} \times B_{12}) + (A_{22} \times B_{22})</math>

Le côté récursif est utile que pour les matrices de tailles <= 32 (32 valeurs stockées dedans),
si on est au dessus de cette taille alors on divisera à nouveau nos matrices en quatres.
On aura 8 multiplications mais de plus petite taille au final.

== 2) strassen ==

=== A) Fonctionnement ===

Strassen consiste à définir 7 produits intermédiaires qui, par des jeux de sommes et de différences, permettent de reconstruire les quadrants de la matrice résultante. On passe ainsi d'une complexité de O(n^3) à environ O(n^2.81)

=== B) Graphique ===

On voit bien la différence de complexité sur la multiplication de grande matrice entre l'approche naïve et l'approche récursive qui est beaucoup plus rapide.

[[Fichier:Analyse matrices.png]]

= Conclusion =

( A FAIRE )

= Mentions =

Le premier gif est le résultat du travail de 'Walké', licence ci-contre : https://fr.wikipedia.org/wiki/Fichier:Addition.gif

= Sources =

Pour karatsuba : https://www.youtube.com/watch?v=PZ2gdWdKHAA

Pour mieux comprendre la FFT, nous avons utilisé plusieurs sources d'informations :
<ul>
<li> https://www.youtube.com/watch?v=h7apO7q16V0&list=WL&index=1&t=886s </li>
<li> https://fr.wikipedia.org/wiki/Interpolation_polynomiale </li>
</ul>

Algorithmes de multiplications d'entiers et de matrices

2026-05-11T12:01:58Z

Mangala : /* Sources */

= Introduction =

Depuis l'apparition des ordinateurs modernes, une quantité faramineuse de calcul a dû être effectuée. Les progressions technologiques nous poussent à envisager la puissance de calcul comme une ressource qu'il faut optimiser dans les moindres détails. C'est ainsi que l'optimisation des algorithmes de calcul est devenue cruciale, surtout lorsqu'il nous faut effectuer des opérations sur de très grands entiers par exemple.

= Objectif =

L'objectif majeur de ce projet est de comprendre de manière plus approfondie ce qu'est la '''complexité algorithmique'''.
Pour atteindre cet objectif, nous implémenterons plusieurs algorithmes de multiplication qui auront pour but de calculer le produit de grands entiers ou de matrices.

= Point important : complexité =

=== Définition ===
La complexité d'un algorithme est la quantité des ressources qu'il utilise en fonction de la taille des entrée qu'on lui demande de traiter. On peut par exemple se concentrer sur le temps qu'un algorithme prend pour renvoyer un résultat ou sur la mémoire dont il a besoin. Dans le cadre de notre projet, nous nous attarderons plus particulièrement sur la quantité de calcul effectuée en fonction de la taille des entrées, ce qui est par ailleurs fortement liée à la notion de temps. De manière générale, plus un algorithme doit faire de calcul, plus il est lent. (Attention, toutes les opérations arithmétiques de base ne se valent pas)

De manière plus familière, on dira que la complexité d'un algorithme pourrait s'apparenter à son comportement lorsqu'il doit traiter des données plus ou moins grandes.
Chaque algorithme a une complexité, et on l'exprime par une fonction qui adopte un comportement similaire au nombre de calcul nécessaire en fonction de la taille des entrées.

=== Notation ===
La complexité réelle d'un algorithme peut être décrite par une fonction <math>f(n)</math> représentant le nombre d'opérations effectuées en fonction de la taille <math>n</math> des données d'entrée.

Cependant, afin de simplifier l'étude de cette croissance, on utilise généralement une borne asymptotique notée <math>\mathcal{O}(g(n))</math>, où <math>g(n)</math> est une fonction ayant le même ordre de grandeur que <math>f(n)</math> lorsque <math>n</math> devient grand.

On dit alors que :

<math>
f(n)\in\mathcal{O}(g(n))
</math>

si et seulement s'il existe une constante <math>C>0</math> et un entier <math>n_0</math> tels que :

<math>
\forall n\ge n_0,\ f(n)\le Cg(n)
</math>

Cette notation <math>\mathcal{O}(g(n))</math> permettra de comparer beaucoup plus facilement les algorithmes entre eux.

=== Master Theorem ===

Afin de déterminer la complexité de certains algorithmes récursifs, nous utiliserons le "Master Theorem".

Ce théorème permet d'obtenir directement l'ordre de grandeur de nombreuses relations de récurrence apparaissant dans l'analyse d'algorithmes de type « diviser pour régner », comme l'algorithme de Karatsuba ou celui de Strassen.

La démonstration complète de ce théorème dépasse le cadre de notre projet et nécessite des connaissances mathématiques plus avancées. Nous l'utiliserons donc principalement comme un outil nous permettant de déterminer efficacement la complexité asymptotique des algorithmes étudiés.

=== Graphiques ===

Les complexités étant des fonctions, nous pouvons les représenter par un graphique qui affichera le temps d'exécution (ou nombre d'opérations) en fonction de la taille des entrées.

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:30px; text-align:center;">
[[Fichier:complexite.webp|500px]]
<div><b>Graphiques des complexités</b></div>
</div>
<div style="max-width:800px;">
<p>Ce graphique ci-contre compare les complexités en fonction de la taille des d'entrées.</p>
<p>On comprend ainsi que certaines complexités ne sont pas raisonnable dans la cadre de la multiplication de grands entiers.</p>
<p>C'est pourquoi l'étude de ces algorithmes s'avère nécessaire.</p>
</div>
</div>

=== Exemple ===
L'algorithme naïf d'addition que nous avons tous appris à l'école a une complexité de <math>\mathcal{O}(n)</math>.
Soit n la taille des nombres en entrée, l'algorithme doit faire environ n addition pour arriver au résultat demandé.

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Addition.gif|220px]]
<div><b>Addition naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Comme le montre l'exemple ci-contre, 786 et 467 font 3 chiffres de long donc n sera de 3.</p>
<p>Il nous faudra 3 opérations pour additionner ces deux nombres.</p>
<p>C'est ainsi qu'avec une taille d'entrée n, l'algorithme de l'addition naïve va devoir faire n opérations.</p>
<p>Cette algorithme a donc une complexité <math>f(n) = n</math> qui n'a pas besoin d'être approximée.</p>
<p>Ainsi sa complexité finale sera <math>\mathcal{O}(n)</math>.</p>
</div>
</div>

= Problématique =

Le calcul du produit de deux entiers de manière naïve a une complexité de <math> \mathcal{O}(n^2)</math>, et celui de deux matrices une complexité de <math> \mathcal{O}(n^3)</math>. Afin de mieux comprendre ce qu'est la complexité algorithmique, nous devrons implémenter des algorithmes ayant le même objectif, mais étant plus efficaces. Ces algorithmes s'avèreront plus complexes mais devrait aboutir à un calcul plus rapide du produit demandé.

Nous séparerons notre wiki en deux grandes parties, la première concernera nos recherche sur [[#I - Produit d'entiers|la multiplication d'entiers]], la deuxième sur [[#II - Produit de matrices|la multiplication de matrices]].

= I - Produit d'entiers =

Notre départ commence avec l'algorithme de multiplication d'entier naïf.
En effet il s'agit de l'algorithme de multiplication le plus connu, et nous l'utiliserons comme référence pour le comparer aux futurs algorithmes plus efficaces.
Intéressons nous à sa complexité.

== 1) Nos implémentations des grands entiers ==

Qui dit produit de grands entiers dit implémentation de grands entiers.

Dans le cadre de nos recherches, nous allons devoir implémenter des algorithmes qui vont manipuler des grands entiers.

Nous avons donc choisi de créer deux représentations différentes de ceux-ci (car nous travaillons sur différents langages de programmation), nous permettant à la fois une implémentation simplifié, mais aussi de nous rapprocher d'une implémentation bas niveau.

=== A) En python ===
En python, l'utilisation des "bytes" m'a grandement servi à comprendre comment les entiers étaient manipulés à bas niveau. En effet, un des objectifs secondaires de nos recherches était de manipuler des entiers directement avec leur formes stockées sur l'ordinateur, et non pas avec des int python.
En effet l'utilisation des int python nous aurait permit de passer les étapes de retenues, de signes... D'autant plus que les bytes permettent de stocker un nombre en base 256, ce qui permet de visualiser plus facilement les grands entiers.

La forme finale de la représentation des grands entiers en python sera donc la suivante :

[ signe , bytes , bytes , (...) , bytes ]

Le signe est représenté par un entier, 1 si le nombre est positif, 0 sinon.
Cette configuration rendra plus simple la gestion des signes.

=== B) En C++ ===

En C++, pour avoir une représentation de grand entiers j'ai du définir ma propre structure pour m'affranchir de la limite de taille imposé par les entiers standards: (int32 ou int64). Pour cela, j'ai une structure qui possède l'équivalent d'un array de byte (ce qui nous permet d'être en base 256 au lieu de la base 10 habituelle), et pour traiter le signe j'utilise un booléen, ainsi en mémoire j'ai une structure de n*Octets + 1 octet en taille.

[ bytes , bytes , (...) , bytes ] [ signe ]

Le booléen prend 1 octet de place mais ne touche pas aux octets qui encode le grand entier.
Cette configuration rendra plus simple la gestion des signes dans le cadre des multiplication.

== 2) La multiplication naïve ==

=== A) Fonctionnement ===
Dans le cas de la multiplication d'entiers, nous allons prendre deux nombres qui n'ont pas nécessairement la même longueur. Soit les nombre a et b, de longueur respective <math>n</math> et <math> m </math>.
<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Multiplication.png|220px]]
<div><b>Multiplication naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Prenons deux nombres de longueur 3 et 2, et cherchons combien d'opérations l'algorithme de multiplication naïve va devoir faire pour nous renvoyer leur produit.</p>
<p>Dans un premier temps, on remarque que l'on va devoir multiplier chaque chiffre du nombre du haut par le chiffre des unités du bas, qui est 6. Cela va représenter <math>n</math> opérations. (6x5, 6x1 et 6x4)</p>
<p>Dans un deuxième temps nous constatons que nous allons devoir faire la même chose avec le chiffre des dizaines du nombre du bas. Cela nous ajoute de nouveau <math>n</math> opérations.</p>
<p>On arrive assez facilement à la conclusion que pour faire notre produit, il va nous falloir faire <math>n</math> fois <math>m</math> opérations.</p>
</div>
</div>

Ainsi, la complexité de la multiplication naïve est <math>\mathcal{O}(n^2)</math>.
Il est en de même avec la multiplication naïve récursive.

=== B) Graphique ===
Montrons maintenant sa courbe sur un graphique :

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Multiplicationnaive.png|500px]]
<div><b>Multiplication naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Les points noirs sont des repères pour que les autres courbes aient une forme cohérente.</p>
<p>Ils sont tous sur l'axe des abscisses.</p>
<p>La courbe rouge représente la complexité de la multiplication naïve.</p>
<p>On remarque que la courbe a un visuel très similaire à la fonction <math>f(x) = x^2</math> </p>
</div>
</div>

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Naif_recursif.png|500px]]
<div><b>Multiplication naïve récursive</b></div>
</div>
<div style="max-width:800px;">
<p>La courbe rouge représente la complexité de la multiplication naïve récursive.</p>
<p>Elle sera utilisé pour comparer les complexités entre algorithmes car, comme tous récursifs, elle a été codé avec les mêmes biais d'implémentation qu'eux.</p>
<p>Théoriquement les deux courbes ci-contre ont la même complexité, mais encore une fois, notre implémentation n'est pas parfaitement optimale et donc ne respecte pas de manière minutieuse le Master Theorem.</p>
</div>
</div>

== 3) La multiplication karastuba ==

=== A) Fonctionnement ===

L'algorithme de karatsuba est un algorithme récursif de type diviser pour régner.

L'idée générale de l'algorithme est de passer de 4 multiplication à 3. En effet ces opérations étant moins couteuses, il est préférable d'en ajouter si cela permet d'enlever des multiplications.

L'algorithme de multiplication naif récursif utilise la segmentation des facteurs en deux de manière successive.

Soit <math>x</math> et <math>y</math> deux facteurs, nous avons les égalités suivantes :

<div style="font-size: 20px;">
<math>x = a \times B^{n/2} + b</math>
<math>y = c \times B^{n/2} + d</math>
</div>

Avec <math>a</math> et <math>c</math> les premières moitiés des facteurs <math>x</math> et <math>y</math>,
et <math>b</math> et <math>d</math> les dernières moitiés de ces facteurs ainsi que <math>B</math> la base d'écriture du nombre (Nous sommes en base 256 avec les bytes).

Cette présentation des deux facteurs de notre multiplication n'est que la résultante d'un découpage.
Le [[#Master Theorem|Master Theorem]] nous montre que :

<div style="font-size: 20px;">
<math>T(n) = 4T(n/2) + O(n)</math>
</div>

Puisque nous avons après découpage 4 entiers de longueur <math>n/2</math>.

Ainsi, ce découpage ne permet pas de gagner du temps d'après le [[#Master Theorem|Master Theorem]].

Cependant, l'algorithme de Karatsuba réutilise ce principe en le modifiant, ce qui nous permet de baisser la complexité globale de la multiplication dans son entièreté.

Avec l'écriture ci-dessus des nombres <math>x</math> et <math>y</math>, on peut facilement en déduire l'égalité suivante :

<div style="font-size: 20px;">
<math>x \times y = (ac) \times B^n + (ad + bc) \times B^{n/2} + bd</math>
</div>

On remarque 4 multiplications longues à faire dans cette expression. Les multiplications dont <math>B</math> est l'un des facteurs sont très rapides puisqu'il s'agit de la base dans laquelle nous travaillons. De cela en résulte un décalage plutôt qu'un vrai calcul à faire.

Karatsuba développe une partie de cette expression pour pouvoir négocier une multiplication au prix d'additions et soustractions.

En effet, nous savons déjà que :

<div style="font-size: 20px;">
<math>(a + b)(c + d) = ac + ad + bc + bd</math>
</div>

En manipulant l'égalité nous obtenons :

<div style="font-size: 20px;">
<math>ad + bc = (a + b)(c + d) - ac - bd</math>
</div>

ac et bd ayant déjà été calculé précédemment, il nous reste uniquement la multiplication <math>(a + b)(c + d)</math>.

Nous venons ainsi de calculer <math>ad + bc</math> en seulement une multiplication. C'est la que repose le gain de temps de la méthode Karatsuba par rapport à la multiplication naïve.

En effet, l'algorithme n'effectuera alors plus que 3 multiplications :
<div style="font-size: 20px;">
<math>ac</math>
<math>bd</math>
<math>(a + b)(c + d)</math>
</div>

La relation de récurrence devient donc :
<div style="font-size: 20px;">
<math>T(n)=3T(n/2)+O(n)</math>
</div>

Et le Master Theorem nous dit que :
<div style="font-size: 20px;">
<math>T(n)\in O(n^{\log_2(3)})</math>
</div>

Or <math>\log_2(3)\approx 1.585</math>, donc la complexité de l'algorithme de Karatsuba est de <math> \mathcal{O}(n^{1.585})</math>. Ce qui est bien plus efficace que la multiplication classique, surtout lorsque les facteurs deviennent très grands.

=== B) Graphique ===
<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Karatsuba.png|500px]]
<div><b>Karatsuba</b></div>
</div>
<div style="max-width:800px;">
<p>Sur le graphique ci-contre nous avons utilisé la courbe de la multiplication naïve récursive (rouge) à titre de comparaison.</p>
<p>On remarque graphiquement que Karatsuba (jaune) prend moins de temps à chaque calcul de produit.</p>
<p>On en déduit donc expérimentalement que Karatsuba à une meilleure complexité que la multiplication naïve.</p>
<p>Ainsi nous vérifions donc ce que le Master Theorem prouve, c'est à dire que la complexité de karatsuba est de <math> \mathcal{O}(n^{1.585})</math> </p>
</div>
</div>

== 4) La multiplication toom-cook-3 ==

=== A) Fonctionnement ===

L'objectif est de diviser les grands entiers X et Y en trois blocs de taille égale k.
On les traite alors comme des polynômes de degré 2:

<math>P(z) = X_2 \cdot z^2 + X_1 \cdot z + X_0</math>
<math>Q(z) = Y_2 \cdot z^2 + Y_1 \cdot z + Y_0</math>

On choisit 5 points distincts pour évaluer nos polynômes.
Ce choix de 5 points est crucial car le produit de deux polynômes de degré 2 est un polynôme de degré 4, qui nécessite 5 points pour être défini.
Les points standards sont :

P(0) = X0
P(1) = X0 + X1 + X2
P(-1) = X0 - X1 + X2
P(2) = X0 + 2*X1 + 4*X2
P(inf) = X2

(On procède de manière similaire pour Q.)

Ensuite nous multiplions récursivement chaque points de P et de Q ensemble.
On effectue ainsi 5 multiplications de nombres plus petits au lieu des 9 multiplications requises par la méthode classique.

Après, nous effectuons une interpolation, cela permet de retrouver les 5 coefficients (w_0, w_1, w_2, w_3, w_4) du polynôme produit R(z) à partir des valeurs évaluées calculées précédemment.
On résout un système d'équations linéaires : <math> R(z) = w_4 z^4 + w_3 z^3 + w_2 z^2 + w_1 z + w_0 </math>
Finalement nous pouvons recomposer notre grand entier en positionnant les coefficients w_i aux bons rangs (en les décalant) et à gérer les retenues lors de l'addition finale:
<math>Résultat = w_4 B^{4k} + w_3 B^{3k} + w_2 B^{2k} + w_1 B^k + w_0</math>

=== B) Graphique ===

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Toomcook.png|500px]]
<div><b>Karatsuba</b></div>
</div>
<div style="max-width:800px;">
<p>on a reprit multi récursive (rouge)</p>
<p>on voit que Toom (vert) en dessous de karatsuba (jaune) en dessous de multi classique (rouge)</p>
<p>meilleur complexité</p>
</div>
</div>

== 5) La transformée de Fourier rapide ==

=== A) Fonctionnement ===

La transformation de Fourier rapide étant plus complexe que les autres algorithmes, nous allons essayer d'expliquer son fonctionnement malgré ne pas avoir réussi à l'implémenter.

Il faut comprendre que cet algorithme va considérer les facteurs comme des polynômes.

D'après le théorème de l'unisolvance, il n'existe qu'un seul polynôme de degré inférieur ou égal à <math> n </math> défini par <math>n + 1</math> points distincts. Cela implique non seulement que nous pouvons représenter chaque entier par un polynôme, mais également que si nous pouvons retrouver <math>n + m + 1</math> points (avec <math>n</math> et <math>m</math> la longueur des facteurs) du polynômes issue du produit entre deux facteurs, nous pourrons le retrouver.

Soit un entier quelconque, de forme :

<math>a_n a_{n-1} (...) a_1 a_0</math>

Avec <math>a_i</math>, un chiffre composant le nombre en base 10, qui vaut en réalité dans le nombre : <math>a_i \times 10^i</math>. On peut ainsi l'écrire sous la forme :

<math> P(x) = a_0 + a_1x + a_2x^2 + \dots + a_{n-1}x^{n-1} + a_nx^n </math>

Avec <math>x = 10</math> car nous sommes en base 10, nous obtenons :

<math>P(10) = a_0 + a_1 \times 10 + \dots + a_{n-1}10^{n-1} + a_n10^n </math>

Nous venons ainsi d'écrire notre nombre sous la forme d'un polynôme unique. Pour nous permettre d'évaluer en un nombre suffisant de points, nous allons devoir ajouter des 0 pour la récursion. Il nous faudra ajouter assez de 0 pour atteindre la prochaine puissance de 2 qui sera supérieure ou égale à <math>2n + 1</math>. L'ajout de 0 ne change pas le nombre car <math>0 \times x^n</math> n'ajoute pas de coefficient.

Cet algorithme est récursif et va segmenter en deux parties nos polynômes à chaque récursion. D'un coté les indice paires et d'un coté les impaires.

Ainsi prenons les nombres 1234 et 5678, ces nombres sont respectivement représentés par les polynômes <math> P(x) = 4 + 3x + 2x^2 + x^3 </math> et <math> P(x) = 8 + 7x + 6x^2 + 5^3 </math>. Ce sont des polynômes de degré 3, ainsi leur produit donnera lieu à un polynôme de degré 6. Il nous faudra donc au minimum 7 points d'évaluation pour retrouve ce produit. De ce fait, en les représentant de la manière suivante :

<math>[4, 3, 2, 1, 0, 0, 0, 0]</math>
<math>[8, 7, 6, 5, 0, 0, 0, 0]</math>

Nous aurons assez de récursions possible pour les évaluer en un nombre suffisant de points différents car nous auront 3 récursions à faire pour atteindre notre cas de base. A chaque récursion, nous allons diviser nos polynômes en deux parties ce qui nous fait 8 feuilles à la dernière récursion.

En effet à chaque étape de la récursion nous allons séparer nos polynômes en deux tel que :

<math> P(x)=P_{pair}x^2 + x \times P_{impair}x^2 </math>

Durant les récursions, nous segmentons les polynômes mais ne les évaluons pas. C'est à la remonté des récursions que nous allons réellement évaluer nos polynômes. Lorsque l'on atteint notre cas de base, c'est à dire des polynômes de degré 0, nous remarquons qu'ils sont constants, nous n'avons donc pas besoin de les évaluer. En effet, peut importe le point en lequel nous voudrons l'évaluer, le polynôme renverra la constante. Nous la renvoyons donc seule.
Ensuite commence la remontée des récursions. A l'étape 1 de notre remontée nous allons reformer le polynôme précédemment séparé pour obtenir un polynôme de degré 1. Puis, nous évaluons ce polynôme avec les racines seconde de l'unité. Nous faisons à nouveau remonté les évaluations et recombinons à nouveau le polynôme qui sera ainsi de degré 2.
Nous l'évaluons maintenant avec les racines 4eme de l'unité. A chaque évaluation, nous réutilisons les résultats précédents, cela nous est permit par les racines de l'unité qui ont une structure récursive exploitable.

Finalement, nous arrivons à la fin de notre FFT, avec une représentation fréquentielle de la forme :

<math> [P(W_0), P(W_1), (...), P(W_n-1), P(W_n)] </math>

Cette représentation fréquentielle n'est autre que les évaluations du polynôme P aux racines nièmes de l'unité. Nous avons donc maintenant au minimum <math>2n+1</math> évaluations des polynômes facteurs. Il nous faut maintenant trouver les évaluations du produit final, c'est à dire les évaluations concernant le polynôme qui sera issue de la multiplication. On pourra ainsi le retrouver.

Soit <math>C</math> un polynome tel que <math> C = A \times B </math>, alors on a :

<math> C(x) = A(x) \times B(x) </math>

Ainsi on en déduit que <math> C(W_n^k) = A(W_n^k) \times B(W_n^k) </math>

On comprend donc que <math>FFT(C) = FFT(A) \times FFT(B)</math>

Il faut préciser que l'on fait le produit de FFT(A) et FFT(B) terme à terme, soit évaluation par évaluation.

Une fois en possession de <math>FFT(C)</math>, qui n'est autre que l'évaluation de notre polynôme final en un nombre suffisant de points pour le retrouver, nous pouvons faire l'<math>IFFT(FFT(C))</math>, qui va nous permettre de retrouver les coefficients de notre polynôme en faisant l'exacte inverse de la FFT.

Une fois les coefficients retrouvés, il nous suffit de gérer les retenues, et nous retrouvons un entier de la forme : <math>a_0 a_1 (...) a_{n-1} a_n</math>

=== B) Graphique ===

Intéressons nous maintenant à la complexité de l'algorithme utilisant la transformée de Fourier rapide. On sait que l'algorithme passe par 5 étapes importantes :

passer deux nombre en polynomes
faire la fft
faire le produit terme a terme
faire l'ifft
retenue

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:30px; text-align:center;">
[[Fichier:FFT_image.webp|500px]]
<div><b>Graphiques des complexités</b></div>
</div>
<div style="max-width:800px;">
<p>Ce graphique ci-contre compare les complexités en fonction de la taille des d'entrées.</p>
<p>On comprend ainsi que certaines complexités ne sont pas raisonnable dans la cadre de la multiplication de grands entiers.</p>
<p>C'est pourquoi l'étude de ces algorithmes s'avère nécessaire.</p>
</div>
</div>

= II - Produit de matrices =

== 1.1) naïve ==

La multiplication naïve de matrice requiert d'avoir des tailles de lignes/colonne semblable, ensuite pour chaque membre de la matrice résultat, on doit multiplier les composantes ligne de la première matrice par les composantes colonne de la deuxième et le tout sommé.

On en déduit la formule suivante:
<math>C_{i,j} = \sum_{k=1}^{n} (A_{i,k} \times B_{k,j})</math>

Et visuellement:

[[Fichier:Matricenaive.jpeg]]

On a donc un algorithme d'ordre de complexité <math>\mathcal{O}(g(n))</math>

== 1.2) naïve récursive ==

Dans un premier temps on doit découper nos deux matrices en quatres sous matrices de plus petite taille.
<math>A = \begin{pmatrix} A_{11} & A_{12} \ A_{21} & A_{22} \end{pmatrix}</math>
<math>B = \begin{pmatrix} B_{11} & B_{12} \ B_{21} & B_{22} \end{pmatrix}</math>

Ensuite on vient calculer la matrice résultat.
<math>C_{11} = (A_{11} \times B_{11}) + (A_{12} \times B_{21})</math>
<math>C_{12} = (A_{11} \times B_{12}) + (A_{12} \times B_{22})</math>
<math>C_{21} = (A_{21} \times B_{11}) + (A_{22} \times B_{21})</math>
<math>C_{22} = (A_{21} \times B_{12}) + (A_{22} \times B_{22})</math>

Le côté récursif est utile que pour les matrices de tailles <= 32 (32 valeurs stockées dedans),
si on est au dessus de cette taille alors on divisera à nouveau nos matrices en quatres.
On aura 8 multiplications mais de plus petite taille au final.

== 2) strassen ==

=== A) Fonctionnement ===

Strassen consiste à définir 7 produits intermédiaires qui, par des jeux de sommes et de différences, permettent de reconstruire les quadrants de la matrice résultante. On passe ainsi d'une complexité de O(n^3) à environ O(n^2.81)

=== B) Graphique ===

On voit bien la différence de complexité sur la multiplication de grande matrice entre l'approche naïve et l'approche récursive qui est beaucoup plus rapide.

[[Fichier:Analyse matrices.png]]

= Conclusion =

( A FAIRE )

= Mentions =

Le premier gif est le résultat du travail de 'Walké', licence ci-contre : https://fr.wikipedia.org/wiki/Fichier:Addition.gif

= Sources =

Pour karatsuba : https://www.youtube.com/watch?v=PZ2gdWdKHAA

Pour mieux comprendre la FFT, nous avons utilisé plusieurs sources d'informations :
<ul>
<li> https://www.youtube.com/watch?v=h7apO7q16V0&list=WL&index=1&t=886s </li>
<li> https://fr.wikipedia.org/wiki/Interpolation_polynomiale </li>
</ul>

Algorithmes de multiplications d'entiers et de matrices

2026-05-11T11:59:23Z

Mangala : /* B) Graphique */

= Introduction =

Depuis l'apparition des ordinateurs modernes, une quantité faramineuse de calcul a dû être effectuée. Les progressions technologiques nous poussent à envisager la puissance de calcul comme une ressource qu'il faut optimiser dans les moindres détails. C'est ainsi que l'optimisation des algorithmes de calcul est devenue cruciale, surtout lorsqu'il nous faut effectuer des opérations sur de très grands entiers par exemple.

= Objectif =

L'objectif majeur de ce projet est de comprendre de manière plus approfondie ce qu'est la '''complexité algorithmique'''.
Pour atteindre cet objectif, nous implémenterons plusieurs algorithmes de multiplication qui auront pour but de calculer le produit de grands entiers ou de matrices.

= Point important : complexité =

=== Définition ===
La complexité d'un algorithme est la quantité des ressources qu'il utilise en fonction de la taille des entrée qu'on lui demande de traiter. On peut par exemple se concentrer sur le temps qu'un algorithme prend pour renvoyer un résultat ou sur la mémoire dont il a besoin. Dans le cadre de notre projet, nous nous attarderons plus particulièrement sur la quantité de calcul effectuée en fonction de la taille des entrées, ce qui est par ailleurs fortement liée à la notion de temps. De manière générale, plus un algorithme doit faire de calcul, plus il est lent. (Attention, toutes les opérations arithmétiques de base ne se valent pas)

De manière plus familière, on dira que la complexité d'un algorithme pourrait s'apparenter à son comportement lorsqu'il doit traiter des données plus ou moins grandes.
Chaque algorithme a une complexité, et on l'exprime par une fonction qui adopte un comportement similaire au nombre de calcul nécessaire en fonction de la taille des entrées.

=== Notation ===
La complexité réelle d'un algorithme peut être décrite par une fonction <math>f(n)</math> représentant le nombre d'opérations effectuées en fonction de la taille <math>n</math> des données d'entrée.

Cependant, afin de simplifier l'étude de cette croissance, on utilise généralement une borne asymptotique notée <math>\mathcal{O}(g(n))</math>, où <math>g(n)</math> est une fonction ayant le même ordre de grandeur que <math>f(n)</math> lorsque <math>n</math> devient grand.

On dit alors que :

<math>
f(n)\in\mathcal{O}(g(n))
</math>

si et seulement s'il existe une constante <math>C>0</math> et un entier <math>n_0</math> tels que :

<math>
\forall n\ge n_0,\ f(n)\le Cg(n)
</math>

Cette notation <math>\mathcal{O}(g(n))</math> permettra de comparer beaucoup plus facilement les algorithmes entre eux.

=== Master Theorem ===

Afin de déterminer la complexité de certains algorithmes récursifs, nous utiliserons le "Master Theorem".

Ce théorème permet d'obtenir directement l'ordre de grandeur de nombreuses relations de récurrence apparaissant dans l'analyse d'algorithmes de type « diviser pour régner », comme l'algorithme de Karatsuba ou celui de Strassen.

La démonstration complète de ce théorème dépasse le cadre de notre projet et nécessite des connaissances mathématiques plus avancées. Nous l'utiliserons donc principalement comme un outil nous permettant de déterminer efficacement la complexité asymptotique des algorithmes étudiés.

=== Graphiques ===

Les complexités étant des fonctions, nous pouvons les représenter par un graphique qui affichera le temps d'exécution (ou nombre d'opérations) en fonction de la taille des entrées.

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:30px; text-align:center;">
[[Fichier:complexite.webp|500px]]
<div><b>Graphiques des complexités</b></div>
</div>
<div style="max-width:800px;">
<p>Ce graphique ci-contre compare les complexités en fonction de la taille des d'entrées.</p>
<p>On comprend ainsi que certaines complexités ne sont pas raisonnable dans la cadre de la multiplication de grands entiers.</p>
<p>C'est pourquoi l'étude de ces algorithmes s'avère nécessaire.</p>
</div>
</div>

=== Exemple ===
L'algorithme naïf d'addition que nous avons tous appris à l'école a une complexité de <math>\mathcal{O}(n)</math>.
Soit n la taille des nombres en entrée, l'algorithme doit faire environ n addition pour arriver au résultat demandé.

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Addition.gif|220px]]
<div><b>Addition naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Comme le montre l'exemple ci-contre, 786 et 467 font 3 chiffres de long donc n sera de 3.</p>
<p>Il nous faudra 3 opérations pour additionner ces deux nombres.</p>
<p>C'est ainsi qu'avec une taille d'entrée n, l'algorithme de l'addition naïve va devoir faire n opérations.</p>
<p>Cette algorithme a donc une complexité <math>f(n) = n</math> qui n'a pas besoin d'être approximée.</p>
<p>Ainsi sa complexité finale sera <math>\mathcal{O}(n)</math>.</p>
</div>
</div>

= Problématique =

Le calcul du produit de deux entiers de manière naïve a une complexité de <math> \mathcal{O}(n^2)</math>, et celui de deux matrices une complexité de <math> \mathcal{O}(n^3)</math>. Afin de mieux comprendre ce qu'est la complexité algorithmique, nous devrons implémenter des algorithmes ayant le même objectif, mais étant plus efficaces. Ces algorithmes s'avèreront plus complexes mais devrait aboutir à un calcul plus rapide du produit demandé.

Nous séparerons notre wiki en deux grandes parties, la première concernera nos recherche sur [[#I - Produit d'entiers|la multiplication d'entiers]], la deuxième sur [[#II - Produit de matrices|la multiplication de matrices]].

= I - Produit d'entiers =

Notre départ commence avec l'algorithme de multiplication d'entier naïf.
En effet il s'agit de l'algorithme de multiplication le plus connu, et nous l'utiliserons comme référence pour le comparer aux futurs algorithmes plus efficaces.
Intéressons nous à sa complexité.

== 1) Nos implémentations des grands entiers ==

Qui dit produit de grands entiers dit implémentation de grands entiers.

Dans le cadre de nos recherches, nous allons devoir implémenter des algorithmes qui vont manipuler des grands entiers.

Nous avons donc choisi de créer deux représentations différentes de ceux-ci (car nous travaillons sur différents langages de programmation), nous permettant à la fois une implémentation simplifié, mais aussi de nous rapprocher d'une implémentation bas niveau.

=== A) En python ===
En python, l'utilisation des "bytes" m'a grandement servi à comprendre comment les entiers étaient manipulés à bas niveau. En effet, un des objectifs secondaires de nos recherches était de manipuler des entiers directement avec leur formes stockées sur l'ordinateur, et non pas avec des int python.
En effet l'utilisation des int python nous aurait permit de passer les étapes de retenues, de signes... D'autant plus que les bytes permettent de stocker un nombre en base 256, ce qui permet de visualiser plus facilement les grands entiers.

La forme finale de la représentation des grands entiers en python sera donc la suivante :

[ signe , bytes , bytes , (...) , bytes ]

Le signe est représenté par un entier, 1 si le nombre est positif, 0 sinon.
Cette configuration rendra plus simple la gestion des signes.

=== B) En C++ ===

En C++, pour avoir une représentation de grand entiers j'ai du définir ma propre structure pour m'affranchir de la limite de taille imposé par les entiers standards: (int32 ou int64). Pour cela, j'ai une structure qui possède l'équivalent d'un array de byte (ce qui nous permet d'être en base 256 au lieu de la base 10 habituelle), et pour traiter le signe j'utilise un booléen, ainsi en mémoire j'ai une structure de n*Octets + 1 octet en taille.

[ bytes , bytes , (...) , bytes ] [ signe ]

Le booléen prend 1 octet de place mais ne touche pas aux octets qui encode le grand entier.
Cette configuration rendra plus simple la gestion des signes dans le cadre des multiplication.

== 2) La multiplication naïve ==

=== A) Fonctionnement ===
Dans le cas de la multiplication d'entiers, nous allons prendre deux nombres qui n'ont pas nécessairement la même longueur. Soit les nombre a et b, de longueur respective <math>n</math> et <math> m </math>.
<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Multiplication.png|220px]]
<div><b>Multiplication naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Prenons deux nombres de longueur 3 et 2, et cherchons combien d'opérations l'algorithme de multiplication naïve va devoir faire pour nous renvoyer leur produit.</p>
<p>Dans un premier temps, on remarque que l'on va devoir multiplier chaque chiffre du nombre du haut par le chiffre des unités du bas, qui est 6. Cela va représenter <math>n</math> opérations. (6x5, 6x1 et 6x4)</p>
<p>Dans un deuxième temps nous constatons que nous allons devoir faire la même chose avec le chiffre des dizaines du nombre du bas. Cela nous ajoute de nouveau <math>n</math> opérations.</p>
<p>On arrive assez facilement à la conclusion que pour faire notre produit, il va nous falloir faire <math>n</math> fois <math>m</math> opérations.</p>
</div>
</div>

Ainsi, la complexité de la multiplication naïve est <math>\mathcal{O}(n^2)</math>.
Il est en de même avec la multiplication naïve récursive.

=== B) Graphique ===
Montrons maintenant sa courbe sur un graphique :

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Multiplicationnaive.png|500px]]
<div><b>Multiplication naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Les points noirs sont des repères pour que les autres courbes aient une forme cohérente.</p>
<p>Ils sont tous sur l'axe des abscisses.</p>
<p>La courbe rouge représente la complexité de la multiplication naïve.</p>
<p>On remarque que la courbe a un visuel très similaire à la fonction <math>f(x) = x^2</math> </p>
</div>
</div>

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Naif_recursif.png|500px]]
<div><b>Multiplication naïve récursive</b></div>
</div>
<div style="max-width:800px;">
<p>La courbe rouge représente la complexité de la multiplication naïve récursive.</p>
<p>Elle sera utilisé pour comparer les complexités entre algorithmes car, comme tous récursifs, elle a été codé avec les mêmes biais d'implémentation qu'eux.</p>
<p>Théoriquement les deux courbes ci-contre ont la même complexité, mais encore une fois, notre implémentation n'est pas parfaitement optimale et donc ne respecte pas de manière minutieuse le Master Theorem.</p>
</div>
</div>

== 3) La multiplication karastuba ==

=== A) Fonctionnement ===

L'algorithme de karatsuba est un algorithme récursif de type diviser pour régner.

L'idée générale de l'algorithme est de passer de 4 multiplication à 3. En effet ces opérations étant moins couteuses, il est préférable d'en ajouter si cela permet d'enlever des multiplications.

L'algorithme de multiplication naif récursif utilise la segmentation des facteurs en deux de manière successive.

Soit <math>x</math> et <math>y</math> deux facteurs, nous avons les égalités suivantes :

<div style="font-size: 20px;">
<math>x = a \times B^{n/2} + b</math>
<math>y = c \times B^{n/2} + d</math>
</div>

Avec <math>a</math> et <math>c</math> les premières moitiés des facteurs <math>x</math> et <math>y</math>,
et <math>b</math> et <math>d</math> les dernières moitiés de ces facteurs ainsi que <math>B</math> la base d'écriture du nombre (Nous sommes en base 256 avec les bytes).

Cette présentation des deux facteurs de notre multiplication n'est que la résultante d'un découpage.
Le [[#Master Theorem|Master Theorem]] nous montre que :

<div style="font-size: 20px;">
<math>T(n) = 4T(n/2) + O(n)</math>
</div>

Puisque nous avons après découpage 4 entiers de longueur <math>n/2</math>.

Ainsi, ce découpage ne permet pas de gagner du temps d'après le [[#Master Theorem|Master Theorem]].

Cependant, l'algorithme de Karatsuba réutilise ce principe en le modifiant, ce qui nous permet de baisser la complexité globale de la multiplication dans son entièreté.

Avec l'écriture ci-dessus des nombres <math>x</math> et <math>y</math>, on peut facilement en déduire l'égalité suivante :

<div style="font-size: 20px;">
<math>x \times y = (ac) \times B^n + (ad + bc) \times B^{n/2} + bd</math>
</div>

On remarque 4 multiplications longues à faire dans cette expression. Les multiplications dont <math>B</math> est l'un des facteurs sont très rapides puisqu'il s'agit de la base dans laquelle nous travaillons. De cela en résulte un décalage plutôt qu'un vrai calcul à faire.

Karatsuba développe une partie de cette expression pour pouvoir négocier une multiplication au prix d'additions et soustractions.

En effet, nous savons déjà que :

<div style="font-size: 20px;">
<math>(a + b)(c + d) = ac + ad + bc + bd</math>
</div>

En manipulant l'égalité nous obtenons :

<div style="font-size: 20px;">
<math>ad + bc = (a + b)(c + d) - ac - bd</math>
</div>

ac et bd ayant déjà été calculé précédemment, il nous reste uniquement la multiplication <math>(a + b)(c + d)</math>.

Nous venons ainsi de calculer <math>ad + bc</math> en seulement une multiplication. C'est la que repose le gain de temps de la méthode Karatsuba par rapport à la multiplication naïve.

En effet, l'algorithme n'effectuera alors plus que 3 multiplications :
<div style="font-size: 20px;">
<math>ac</math>
<math>bd</math>
<math>(a + b)(c + d)</math>
</div>

La relation de récurrence devient donc :
<div style="font-size: 20px;">
<math>T(n)=3T(n/2)+O(n)</math>
</div>

Et le Master Theorem nous dit que :
<div style="font-size: 20px;">
<math>T(n)\in O(n^{\log_2(3)})</math>
</div>

Or <math>\log_2(3)\approx 1.585</math>, donc la complexité de l'algorithme de Karatsuba est de <math> \mathcal{O}(n^{1.585})</math>. Ce qui est bien plus efficace que la multiplication classique, surtout lorsque les facteurs deviennent très grands.

=== B) Graphique ===
<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Karatsuba.png|500px]]
<div><b>Karatsuba</b></div>
</div>
<div style="max-width:800px;">
<p>Sur le graphique ci-contre nous avons utilisé la courbe de la multiplication naïve récursive (rouge) à titre de comparaison.</p>
<p>On remarque graphiquement que Karatsuba (jaune) prend moins de temps à chaque calcul de produit.</p>
<p>On en déduit donc expérimentalement que Karatsuba à une meilleure complexité que la multiplication naïve.</p>
<p>Ainsi nous vérifions donc ce que le Master Theorem prouve, c'est à dire que la complexité de karatsuba est de <math> \mathcal{O}(n^{1.585})</math> </p>
</div>
</div>

== 4) La multiplication toom-cook-3 ==

=== A) Fonctionnement ===

L'objectif est de diviser les grands entiers X et Y en trois blocs de taille égale k.
On les traite alors comme des polynômes de degré 2:

<math>P(z) = X_2 \cdot z^2 + X_1 \cdot z + X_0</math>
<math>Q(z) = Y_2 \cdot z^2 + Y_1 \cdot z + Y_0</math>

On choisit 5 points distincts pour évaluer nos polynômes.
Ce choix de 5 points est crucial car le produit de deux polynômes de degré 2 est un polynôme de degré 4, qui nécessite 5 points pour être défini.
Les points standards sont :

P(0) = X0
P(1) = X0 + X1 + X2
P(-1) = X0 - X1 + X2
P(2) = X0 + 2*X1 + 4*X2
P(inf) = X2

(On procède de manière similaire pour Q.)

Ensuite nous multiplions récursivement chaque points de P et de Q ensemble.
On effectue ainsi 5 multiplications de nombres plus petits au lieu des 9 multiplications requises par la méthode classique.

Après, nous effectuons une interpolation, cela permet de retrouver les 5 coefficients (w_0, w_1, w_2, w_3, w_4) du polynôme produit R(z) à partir des valeurs évaluées calculées précédemment.
On résout un système d'équations linéaires : <math> R(z) = w_4 z^4 + w_3 z^3 + w_2 z^2 + w_1 z + w_0 </math>
Finalement nous pouvons recomposer notre grand entier en positionnant les coefficients w_i aux bons rangs (en les décalant) et à gérer les retenues lors de l'addition finale:
<math>Résultat = w_4 B^{4k} + w_3 B^{3k} + w_2 B^{2k} + w_1 B^k + w_0</math>

=== B) Graphique ===

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Toomcook.png|500px]]
<div><b>Karatsuba</b></div>
</div>
<div style="max-width:800px;">
<p>on a reprit multi récursive (rouge)</p>
<p>on voit que Toom (vert) en dessous de karatsuba (jaune) en dessous de multi classique (rouge)</p>
<p>meilleur complexité</p>
</div>
</div>

== 5) La transformée de Fourier rapide ==

=== A) Fonctionnement ===

La transformation de Fourier rapide étant plus complexe que les autres algorithmes, nous allons essayer d'expliquer son fonctionnement malgré ne pas avoir réussi à l'implémenter.

Il faut comprendre que cet algorithme va considérer les facteurs comme des polynômes.

D'après le théorème de l'unisolvance, il n'existe qu'un seul polynôme de degré inférieur ou égal à <math> n </math> défini par <math>n + 1</math> points distincts. Cela implique non seulement que nous pouvons représenter chaque entier par un polynôme, mais également que si nous pouvons retrouver <math>n + m + 1</math> points (avec <math>n</math> et <math>m</math> la longueur des facteurs) du polynômes issue du produit entre deux facteurs, nous pourrons le retrouver.

Soit un entier quelconque, de forme :

<math>a_n a_{n-1} (...) a_1 a_0</math>

Avec <math>a_i</math>, un chiffre composant le nombre en base 10, qui vaut en réalité dans le nombre : <math>a_i \times 10^i</math>. On peut ainsi l'écrire sous la forme :

<math> P(x) = a_0 + a_1x + a_2x^2 + \dots + a_{n-1}x^{n-1} + a_nx^n </math>

Avec <math>x = 10</math> car nous sommes en base 10, nous obtenons :

<math>P(10) = a_0 + a_1 \times 10 + \dots + a_{n-1}10^{n-1} + a_n10^n </math>

Nous venons ainsi d'écrire notre nombre sous la forme d'un polynôme unique. Pour nous permettre d'évaluer en un nombre suffisant de points, nous allons devoir ajouter des 0 pour la récursion. Il nous faudra ajouter assez de 0 pour atteindre la prochaine puissance de 2 qui sera supérieure ou égale à <math>2n + 1</math>. L'ajout de 0 ne change pas le nombre car <math>0 \times x^n</math> n'ajoute pas de coefficient.

Cet algorithme est récursif et va segmenter en deux parties nos polynômes à chaque récursion. D'un coté les indice paires et d'un coté les impaires.

Ainsi prenons les nombres 1234 et 5678, ces nombres sont respectivement représentés par les polynômes <math> P(x) = 4 + 3x + 2x^2 + x^3 </math> et <math> P(x) = 8 + 7x + 6x^2 + 5^3 </math>. Ce sont des polynômes de degré 3, ainsi leur produit donnera lieu à un polynôme de degré 6. Il nous faudra donc au minimum 7 points d'évaluation pour retrouve ce produit. De ce fait, en les représentant de la manière suivante :

<math>[4, 3, 2, 1, 0, 0, 0, 0]</math>
<math>[8, 7, 6, 5, 0, 0, 0, 0]</math>

Nous aurons assez de récursions possible pour les évaluer en un nombre suffisant de points différents car nous auront 3 récursions à faire pour atteindre notre cas de base. A chaque récursion, nous allons diviser nos polynômes en deux parties ce qui nous fait 8 feuilles à la dernière récursion.

En effet à chaque étape de la récursion nous allons séparer nos polynômes en deux tel que :

<math> P(x)=P_{pair}x^2 + x \times P_{impair}x^2 </math>

Durant les récursions, nous segmentons les polynômes mais ne les évaluons pas. C'est à la remonté des récursions que nous allons réellement évaluer nos polynômes. Lorsque l'on atteint notre cas de base, c'est à dire des polynômes de degré 0, nous remarquons qu'ils sont constants, nous n'avons donc pas besoin de les évaluer. En effet, peut importe le point en lequel nous voudrons l'évaluer, le polynôme renverra la constante. Nous la renvoyons donc seule.
Ensuite commence la remontée des récursions. A l'étape 1 de notre remontée nous allons reformer le polynôme précédemment séparé pour obtenir un polynôme de degré 1. Puis, nous évaluons ce polynôme avec les racines seconde de l'unité. Nous faisons à nouveau remonté les évaluations et recombinons à nouveau le polynôme qui sera ainsi de degré 2.
Nous l'évaluons maintenant avec les racines 4eme de l'unité. A chaque évaluation, nous réutilisons les résultats précédents, cela nous est permit par les racines de l'unité qui ont une structure récursive exploitable.

Finalement, nous arrivons à la fin de notre FFT, avec une représentation fréquentielle de la forme :

<math> [P(W_0), P(W_1), (...), P(W_n-1), P(W_n)] </math>

Cette représentation fréquentielle n'est autre que les évaluations du polynôme P aux racines nièmes de l'unité. Nous avons donc maintenant au minimum <math>2n+1</math> évaluations des polynômes facteurs. Il nous faut maintenant trouver les évaluations du produit final, c'est à dire les évaluations concernant le polynôme qui sera issue de la multiplication. On pourra ainsi le retrouver.

Soit <math>C</math> un polynome tel que <math> C = A \times B </math>, alors on a :

<math> C(x) = A(x) \times B(x) </math>

Ainsi on en déduit que <math> C(W_n^k) = A(W_n^k) \times B(W_n^k) </math>

On comprend donc que <math>FFT(C) = FFT(A) \times FFT(B)</math>

Il faut préciser que l'on fait le produit de FFT(A) et FFT(B) terme à terme, soit évaluation par évaluation.

Une fois en possession de <math>FFT(C)</math>, qui n'est autre que l'évaluation de notre polynôme final en un nombre suffisant de points pour le retrouver, nous pouvons faire l'<math>IFFT(FFT(C))</math>, qui va nous permettre de retrouver les coefficients de notre polynôme en faisant l'exacte inverse de la FFT.

Une fois les coefficients retrouvés, il nous suffit de gérer les retenues, et nous retrouvons un entier de la forme : <math>a_0 a_1 (...) a_{n-1} a_n</math>

=== B) Graphique ===

Intéressons nous maintenant à la complexité de l'algorithme utilisant la transformée de Fourier rapide. On sait que l'algorithme passe par 5 étapes importantes :

passer deux nombre en polynomes
faire la fft
faire le produit terme a terme
faire l'ifft
retenue

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:30px; text-align:center;">
[[Fichier:FFT_image.webp|500px]]
<div><b>Graphiques des complexités</b></div>
</div>
<div style="max-width:800px;">
<p>Ce graphique ci-contre compare les complexités en fonction de la taille des d'entrées.</p>
<p>On comprend ainsi que certaines complexités ne sont pas raisonnable dans la cadre de la multiplication de grands entiers.</p>
<p>C'est pourquoi l'étude de ces algorithmes s'avère nécessaire.</p>
</div>
</div>

= II - Produit de matrices =

== 1.1) naïve ==

La multiplication naïve de matrice requiert d'avoir des tailles de lignes/colonne semblable, ensuite pour chaque membre de la matrice résultat, on doit multiplier les composantes ligne de la première matrice par les composantes colonne de la deuxième et le tout sommé.

On en déduit la formule suivante:
<math>C_{i,j} = \sum_{k=1}^{n} (A_{i,k} \times B_{k,j})</math>

Et visuellement:

[[Fichier:Matricenaive.jpeg]]

On a donc un algorithme d'ordre de complexité <math>\mathcal{O}(g(n))</math>

== 1.2) naïve récursive ==

Dans un premier temps on doit découper nos deux matrices en quatres sous matrices de plus petite taille.
<math>A = \begin{pmatrix} A_{11} & A_{12} \ A_{21} & A_{22} \end{pmatrix}</math>
<math>B = \begin{pmatrix} B_{11} & B_{12} \ B_{21} & B_{22} \end{pmatrix}</math>

Ensuite on vient calculer la matrice résultat.
<math>C_{11} = (A_{11} \times B_{11}) + (A_{12} \times B_{21})</math>
<math>C_{12} = (A_{11} \times B_{12}) + (A_{12} \times B_{22})</math>
<math>C_{21} = (A_{21} \times B_{11}) + (A_{22} \times B_{21})</math>
<math>C_{22} = (A_{21} \times B_{12}) + (A_{22} \times B_{22})</math>

Le côté récursif est utile que pour les matrices de tailles <= 32 (32 valeurs stockées dedans),
si on est au dessus de cette taille alors on divisera à nouveau nos matrices en quatres.
On aura 8 multiplications mais de plus petite taille au final.

== 2) strassen ==

=== A) Fonctionnement ===

Strassen consiste à définir 7 produits intermédiaires qui, par des jeux de sommes et de différences, permettent de reconstruire les quadrants de la matrice résultante. On passe ainsi d'une complexité de O(n^3) à environ O(n^2.81)

=== B) Graphique ===

On voit bien la différence de complexité sur la multiplication de grande matrice entre l'approche naïve et l'approche récursive qui est beaucoup plus rapide.

[[Fichier:Analyse matrices.png]]

= Conclusion =

( A FAIRE )

= Mentions =

Le premier gif est le résultat du travail de 'Walké', licence ci-contre : https://fr.wikipedia.org/wiki/Fichier:Addition.gif

= Sources =

Pour karatsuba : https://www.youtube.com/watch?v=PZ2gdWdKHAA

Pour mieux comprendre la FFT, nous avons utilisé plusieurs sources d'informations :

https://www.youtube.com/watch?v=h7apO7q16V0&list=WL&index=1&t=886s

https://fr.wikipedia.org/wiki/Interpolation_polynomiale

Algorithmes de multiplications d'entiers et de matrices

2026-05-11T11:56:35Z

Mangala : /* B) Graphique */

= Introduction =

Depuis l'apparition des ordinateurs modernes, une quantité faramineuse de calcul a dû être effectuée. Les progressions technologiques nous poussent à envisager la puissance de calcul comme une ressource qu'il faut optimiser dans les moindres détails. C'est ainsi que l'optimisation des algorithmes de calcul est devenue cruciale, surtout lorsqu'il nous faut effectuer des opérations sur de très grands entiers par exemple.

= Objectif =

L'objectif majeur de ce projet est de comprendre de manière plus approfondie ce qu'est la '''complexité algorithmique'''.
Pour atteindre cet objectif, nous implémenterons plusieurs algorithmes de multiplication qui auront pour but de calculer le produit de grands entiers ou de matrices.

= Point important : complexité =

=== Définition ===
La complexité d'un algorithme est la quantité des ressources qu'il utilise en fonction de la taille des entrée qu'on lui demande de traiter. On peut par exemple se concentrer sur le temps qu'un algorithme prend pour renvoyer un résultat ou sur la mémoire dont il a besoin. Dans le cadre de notre projet, nous nous attarderons plus particulièrement sur la quantité de calcul effectuée en fonction de la taille des entrées, ce qui est par ailleurs fortement liée à la notion de temps. De manière générale, plus un algorithme doit faire de calcul, plus il est lent. (Attention, toutes les opérations arithmétiques de base ne se valent pas)

De manière plus familière, on dira que la complexité d'un algorithme pourrait s'apparenter à son comportement lorsqu'il doit traiter des données plus ou moins grandes.
Chaque algorithme a une complexité, et on l'exprime par une fonction qui adopte un comportement similaire au nombre de calcul nécessaire en fonction de la taille des entrées.

=== Notation ===
La complexité réelle d'un algorithme peut être décrite par une fonction <math>f(n)</math> représentant le nombre d'opérations effectuées en fonction de la taille <math>n</math> des données d'entrée.

Cependant, afin de simplifier l'étude de cette croissance, on utilise généralement une borne asymptotique notée <math>\mathcal{O}(g(n))</math>, où <math>g(n)</math> est une fonction ayant le même ordre de grandeur que <math>f(n)</math> lorsque <math>n</math> devient grand.

On dit alors que :

<math>
f(n)\in\mathcal{O}(g(n))
</math>

si et seulement s'il existe une constante <math>C>0</math> et un entier <math>n_0</math> tels que :

<math>
\forall n\ge n_0,\ f(n)\le Cg(n)
</math>

Cette notation <math>\mathcal{O}(g(n))</math> permettra de comparer beaucoup plus facilement les algorithmes entre eux.

=== Master Theorem ===

Afin de déterminer la complexité de certains algorithmes récursifs, nous utiliserons le "Master Theorem".

Ce théorème permet d'obtenir directement l'ordre de grandeur de nombreuses relations de récurrence apparaissant dans l'analyse d'algorithmes de type « diviser pour régner », comme l'algorithme de Karatsuba ou celui de Strassen.

La démonstration complète de ce théorème dépasse le cadre de notre projet et nécessite des connaissances mathématiques plus avancées. Nous l'utiliserons donc principalement comme un outil nous permettant de déterminer efficacement la complexité asymptotique des algorithmes étudiés.

=== Graphiques ===

Les complexités étant des fonctions, nous pouvons les représenter par un graphique qui affichera le temps d'exécution (ou nombre d'opérations) en fonction de la taille des entrées.

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:30px; text-align:center;">
[[Fichier:complexite.webp|500px]]
<div><b>Graphiques des complexités</b></div>
</div>
<div style="max-width:800px;">
<p>Ce graphique ci-contre compare les complexités en fonction de la taille des d'entrées.</p>
<p>On comprend ainsi que certaines complexités ne sont pas raisonnable dans la cadre de la multiplication de grands entiers.</p>
<p>C'est pourquoi l'étude de ces algorithmes s'avère nécessaire.</p>
</div>
</div>

=== Exemple ===
L'algorithme naïf d'addition que nous avons tous appris à l'école a une complexité de <math>\mathcal{O}(n)</math>.
Soit n la taille des nombres en entrée, l'algorithme doit faire environ n addition pour arriver au résultat demandé.

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Addition.gif|220px]]
<div><b>Addition naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Comme le montre l'exemple ci-contre, 786 et 467 font 3 chiffres de long donc n sera de 3.</p>
<p>Il nous faudra 3 opérations pour additionner ces deux nombres.</p>
<p>C'est ainsi qu'avec une taille d'entrée n, l'algorithme de l'addition naïve va devoir faire n opérations.</p>
<p>Cette algorithme a donc une complexité <math>f(n) = n</math> qui n'a pas besoin d'être approximée.</p>
<p>Ainsi sa complexité finale sera <math>\mathcal{O}(n)</math>.</p>
</div>
</div>

= Problématique =

Le calcul du produit de deux entiers de manière naïve a une complexité de <math> \mathcal{O}(n^2)</math>, et celui de deux matrices une complexité de <math> \mathcal{O}(n^3)</math>. Afin de mieux comprendre ce qu'est la complexité algorithmique, nous devrons implémenter des algorithmes ayant le même objectif, mais étant plus efficaces. Ces algorithmes s'avèreront plus complexes mais devrait aboutir à un calcul plus rapide du produit demandé.

Nous séparerons notre wiki en deux grandes parties, la première concernera nos recherche sur [[#I - Produit d'entiers|la multiplication d'entiers]], la deuxième sur [[#II - Produit de matrices|la multiplication de matrices]].

= I - Produit d'entiers =

Notre départ commence avec l'algorithme de multiplication d'entier naïf.
En effet il s'agit de l'algorithme de multiplication le plus connu, et nous l'utiliserons comme référence pour le comparer aux futurs algorithmes plus efficaces.
Intéressons nous à sa complexité.

== 1) Nos implémentations des grands entiers ==

Qui dit produit de grands entiers dit implémentation de grands entiers.

Dans le cadre de nos recherches, nous allons devoir implémenter des algorithmes qui vont manipuler des grands entiers.

Nous avons donc choisi de créer deux représentations différentes de ceux-ci (car nous travaillons sur différents langages de programmation), nous permettant à la fois une implémentation simplifié, mais aussi de nous rapprocher d'une implémentation bas niveau.

=== A) En python ===
En python, l'utilisation des "bytes" m'a grandement servi à comprendre comment les entiers étaient manipulés à bas niveau. En effet, un des objectifs secondaires de nos recherches était de manipuler des entiers directement avec leur formes stockées sur l'ordinateur, et non pas avec des int python.
En effet l'utilisation des int python nous aurait permit de passer les étapes de retenues, de signes... D'autant plus que les bytes permettent de stocker un nombre en base 256, ce qui permet de visualiser plus facilement les grands entiers.

La forme finale de la représentation des grands entiers en python sera donc la suivante :

[ signe , bytes , bytes , (...) , bytes ]

Le signe est représenté par un entier, 1 si le nombre est positif, 0 sinon.
Cette configuration rendra plus simple la gestion des signes.

=== B) En C++ ===

En C++, pour avoir une représentation de grand entiers j'ai du définir ma propre structure pour m'affranchir de la limite de taille imposé par les entiers standards: (int32 ou int64). Pour cela, j'ai une structure qui possède l'équivalent d'un array de byte (ce qui nous permet d'être en base 256 au lieu de la base 10 habituelle), et pour traiter le signe j'utilise un booléen, ainsi en mémoire j'ai une structure de n*Octets + 1 octet en taille.

[ bytes , bytes , (...) , bytes ] [ signe ]

Le booléen prend 1 octet de place mais ne touche pas aux octets qui encode le grand entier.
Cette configuration rendra plus simple la gestion des signes dans le cadre des multiplication.

== 2) La multiplication naïve ==

=== A) Fonctionnement ===
Dans le cas de la multiplication d'entiers, nous allons prendre deux nombres qui n'ont pas nécessairement la même longueur. Soit les nombre a et b, de longueur respective <math>n</math> et <math> m </math>.
<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Multiplication.png|220px]]
<div><b>Multiplication naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Prenons deux nombres de longueur 3 et 2, et cherchons combien d'opérations l'algorithme de multiplication naïve va devoir faire pour nous renvoyer leur produit.</p>
<p>Dans un premier temps, on remarque que l'on va devoir multiplier chaque chiffre du nombre du haut par le chiffre des unités du bas, qui est 6. Cela va représenter <math>n</math> opérations. (6x5, 6x1 et 6x4)</p>
<p>Dans un deuxième temps nous constatons que nous allons devoir faire la même chose avec le chiffre des dizaines du nombre du bas. Cela nous ajoute de nouveau <math>n</math> opérations.</p>
<p>On arrive assez facilement à la conclusion que pour faire notre produit, il va nous falloir faire <math>n</math> fois <math>m</math> opérations.</p>
</div>
</div>

Ainsi, la complexité de la multiplication naïve est <math>\mathcal{O}(n^2)</math>.
Il est en de même avec la multiplication naïve récursive.

=== B) Graphique ===
Montrons maintenant sa courbe sur un graphique :

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Multiplicationnaive.png|500px]]
<div><b>Multiplication naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Les points noirs sont des repères pour que les autres courbes aient une forme cohérente.</p>
<p>Ils sont tous sur l'axe des abscisses.</p>
<p>La courbe rouge représente la complexité de la multiplication naïve.</p>
<p>On remarque que la courbe a un visuel très similaire à la fonction <math>f(x) = x^2</math> </p>
</div>
</div>

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Naif_recursif.png|500px]]
<div><b>Multiplication naïve récursive</b></div>
</div>
<div style="max-width:800px;">
<p>La courbe rouge représente la complexité de la multiplication naïve récursive.</p>
<p>Elle sera utilisé pour comparer les complexités entre algorithmes car, comme tous récursifs, elle a été codé avec les mêmes biais d'implémentation qu'eux.</p>
<p>Théoriquement les deux courbes ci-contre ont la même complexité, mais encore une fois, notre implémentation n'est pas parfaitement optimale et donc ne respecte pas de manière minutieuse le Master Theorem.</p>
</div>
</div>

== 3) La multiplication karastuba ==

=== A) Fonctionnement ===

L'algorithme de karatsuba est un algorithme récursif de type diviser pour régner.

L'idée générale de l'algorithme est de passer de 4 multiplication à 3. En effet ces opérations étant moins couteuses, il est préférable d'en ajouter si cela permet d'enlever des multiplications.

L'algorithme de multiplication naif récursif utilise la segmentation des facteurs en deux de manière successive.

Soit <math>x</math> et <math>y</math> deux facteurs, nous avons les égalités suivantes :

<div style="font-size: 20px;">
<math>x = a \times B^{n/2} + b</math>
<math>y = c \times B^{n/2} + d</math>
</div>

Avec <math>a</math> et <math>c</math> les premières moitiés des facteurs <math>x</math> et <math>y</math>,
et <math>b</math> et <math>d</math> les dernières moitiés de ces facteurs ainsi que <math>B</math> la base d'écriture du nombre (Nous sommes en base 256 avec les bytes).

Cette présentation des deux facteurs de notre multiplication n'est que la résultante d'un découpage.
Le [[#Master Theorem|Master Theorem]] nous montre que :

<div style="font-size: 20px;">
<math>T(n) = 4T(n/2) + O(n)</math>
</div>

Puisque nous avons après découpage 4 entiers de longueur <math>n/2</math>.

Ainsi, ce découpage ne permet pas de gagner du temps d'après le [[#Master Theorem|Master Theorem]].

Cependant, l'algorithme de Karatsuba réutilise ce principe en le modifiant, ce qui nous permet de baisser la complexité globale de la multiplication dans son entièreté.

Avec l'écriture ci-dessus des nombres <math>x</math> et <math>y</math>, on peut facilement en déduire l'égalité suivante :

<div style="font-size: 20px;">
<math>x \times y = (ac) \times B^n + (ad + bc) \times B^{n/2} + bd</math>
</div>

On remarque 4 multiplications longues à faire dans cette expression. Les multiplications dont <math>B</math> est l'un des facteurs sont très rapides puisqu'il s'agit de la base dans laquelle nous travaillons. De cela en résulte un décalage plutôt qu'un vrai calcul à faire.

Karatsuba développe une partie de cette expression pour pouvoir négocier une multiplication au prix d'additions et soustractions.

En effet, nous savons déjà que :

<div style="font-size: 20px;">
<math>(a + b)(c + d) = ac + ad + bc + bd</math>
</div>

En manipulant l'égalité nous obtenons :

<div style="font-size: 20px;">
<math>ad + bc = (a + b)(c + d) - ac - bd</math>
</div>

ac et bd ayant déjà été calculé précédemment, il nous reste uniquement la multiplication <math>(a + b)(c + d)</math>.

Nous venons ainsi de calculer <math>ad + bc</math> en seulement une multiplication. C'est la que repose le gain de temps de la méthode Karatsuba par rapport à la multiplication naïve.

En effet, l'algorithme n'effectuera alors plus que 3 multiplications :
<div style="font-size: 20px;">
<math>ac</math>
<math>bd</math>
<math>(a + b)(c + d)</math>
</div>

La relation de récurrence devient donc :
<div style="font-size: 20px;">
<math>T(n)=3T(n/2)+O(n)</math>
</div>

Et le Master Theorem nous dit que :
<div style="font-size: 20px;">
<math>T(n)\in O(n^{\log_2(3)})</math>
</div>

Or <math>\log_2(3)\approx 1.585</math>, donc la complexité de l'algorithme de Karatsuba est de <math> \mathcal{O}(n^{1.585})</math>. Ce qui est bien plus efficace que la multiplication classique, surtout lorsque les facteurs deviennent très grands.

=== B) Graphique ===
<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Karatsuba.png|500px]]
<div><b>Karatsuba</b></div>
</div>
<div style="max-width:800px;">
<p>Sur le graphique ci-contre nous avons utilisé la courbe de la multiplication naïve récursive (rouge) à titre de comparaison.</p>
<p>On remarque graphiquement que Karatsuba (jaune) prend moins de temps à chaque calcul de produit.</p>
<p>On en déduit donc expérimentalement que Karatsuba à une meilleure complexité que la multiplication naïve.</p>
<p>Ainsi nous vérifions donc ce que le Master Theorem prouve, c'est à dire que la complexité de karatsuba est de <math> \mathcal{O}(n^{1.585})</math> </p>
</div>
</div>

== 4) La multiplication toom-cook-3 ==

=== A) Fonctionnement ===

L'objectif est de diviser les grands entiers X et Y en trois blocs de taille égale k.
On les traite alors comme des polynômes de degré 2:

<math>P(z) = X_2 \cdot z^2 + X_1 \cdot z + X_0</math>
<math>Q(z) = Y_2 \cdot z^2 + Y_1 \cdot z + Y_0</math>

On choisit 5 points distincts pour évaluer nos polynômes.
Ce choix de 5 points est crucial car le produit de deux polynômes de degré 2 est un polynôme de degré 4, qui nécessite 5 points pour être défini.
Les points standards sont :

P(0) = X0
P(1) = X0 + X1 + X2
P(-1) = X0 - X1 + X2
P(2) = X0 + 2*X1 + 4*X2
P(inf) = X2

(On procède de manière similaire pour Q.)

Ensuite nous multiplions récursivement chaque points de P et de Q ensemble.
On effectue ainsi 5 multiplications de nombres plus petits au lieu des 9 multiplications requises par la méthode classique.

Après, nous effectuons une interpolation, cela permet de retrouver les 5 coefficients (w_0, w_1, w_2, w_3, w_4) du polynôme produit R(z) à partir des valeurs évaluées calculées précédemment.
On résout un système d'équations linéaires : <math> R(z) = w_4 z^4 + w_3 z^3 + w_2 z^2 + w_1 z + w_0 </math>
Finalement nous pouvons recomposer notre grand entier en positionnant les coefficients w_i aux bons rangs (en les décalant) et à gérer les retenues lors de l'addition finale:
<math>Résultat = w_4 B^{4k} + w_3 B^{3k} + w_2 B^{2k} + w_1 B^k + w_0</math>

=== B) Graphique ===

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Toomcook.png|500px]]
<div><b>Karatsuba</b></div>
</div>
<div style="max-width:800px;">
<p>on a reprit multi récursive (rouge)</p>
<p>on voit que Toom (vert) en dessous de karatsuba (jaune) en dessous de multi classique (rouge)</p>
<p>meilleur complexité</p>
</div>
</div>

== 5) La transformée de Fourier rapide ==

=== A) Fonctionnement ===

La transformation de Fourier rapide étant plus complexe que les autres algorithmes, nous allons essayer d'expliquer son fonctionnement malgré ne pas avoir réussi à l'implémenter.

Il faut comprendre que cet algorithme va considérer les facteurs comme des polynômes.

D'après le théorème de l'unisolvance, il n'existe qu'un seul polynôme de degré inférieur ou égal à <math> n </math> défini par <math>n + 1</math> points distincts. Cela implique non seulement que nous pouvons représenter chaque entier par un polynôme, mais également que si nous pouvons retrouver <math>n + m + 1</math> points (avec <math>n</math> et <math>m</math> la longueur des facteurs) du polynômes issue du produit entre deux facteurs, nous pourrons le retrouver.

Soit un entier quelconque, de forme :

<math>a_n a_{n-1} (...) a_1 a_0</math>

Avec <math>a_i</math>, un chiffre composant le nombre en base 10, qui vaut en réalité dans le nombre : <math>a_i \times 10^i</math>. On peut ainsi l'écrire sous la forme :

<math> P(x) = a_0 + a_1x + a_2x^2 + \dots + a_{n-1}x^{n-1} + a_nx^n </math>

Avec <math>x = 10</math> car nous sommes en base 10, nous obtenons :

<math>P(10) = a_0 + a_1 \times 10 + \dots + a_{n-1}10^{n-1} + a_n10^n </math>

Nous venons ainsi d'écrire notre nombre sous la forme d'un polynôme unique. Pour nous permettre d'évaluer en un nombre suffisant de points, nous allons devoir ajouter des 0 pour la récursion. Il nous faudra ajouter assez de 0 pour atteindre la prochaine puissance de 2 qui sera supérieure ou égale à <math>2n + 1</math>. L'ajout de 0 ne change pas le nombre car <math>0 \times x^n</math> n'ajoute pas de coefficient.

Cet algorithme est récursif et va segmenter en deux parties nos polynômes à chaque récursion. D'un coté les indice paires et d'un coté les impaires.

Ainsi prenons les nombres 1234 et 5678, ces nombres sont respectivement représentés par les polynômes <math> P(x) = 4 + 3x + 2x^2 + x^3 </math> et <math> P(x) = 8 + 7x + 6x^2 + 5^3 </math>. Ce sont des polynômes de degré 3, ainsi leur produit donnera lieu à un polynôme de degré 6. Il nous faudra donc au minimum 7 points d'évaluation pour retrouve ce produit. De ce fait, en les représentant de la manière suivante :

<math>[4, 3, 2, 1, 0, 0, 0, 0]</math>
<math>[8, 7, 6, 5, 0, 0, 0, 0]</math>

Nous aurons assez de récursions possible pour les évaluer en un nombre suffisant de points différents car nous auront 3 récursions à faire pour atteindre notre cas de base. A chaque récursion, nous allons diviser nos polynômes en deux parties ce qui nous fait 8 feuilles à la dernière récursion.

En effet à chaque étape de la récursion nous allons séparer nos polynômes en deux tel que :

<math> P(x)=P_{pair}x^2 + x \times P_{impair}x^2 </math>

Durant les récursions, nous segmentons les polynômes mais ne les évaluons pas. C'est à la remonté des récursions que nous allons réellement évaluer nos polynômes. Lorsque l'on atteint notre cas de base, c'est à dire des polynômes de degré 0, nous remarquons qu'ils sont constants, nous n'avons donc pas besoin de les évaluer. En effet, peut importe le point en lequel nous voudrons l'évaluer, le polynôme renverra la constante. Nous la renvoyons donc seule.
Ensuite commence la remontée des récursions. A l'étape 1 de notre remontée nous allons reformer le polynôme précédemment séparé pour obtenir un polynôme de degré 1. Puis, nous évaluons ce polynôme avec les racines seconde de l'unité. Nous faisons à nouveau remonté les évaluations et recombinons à nouveau le polynôme qui sera ainsi de degré 2.
Nous l'évaluons maintenant avec les racines 4eme de l'unité. A chaque évaluation, nous réutilisons les résultats précédents, cela nous est permit par les racines de l'unité qui ont une structure récursive exploitable.

Finalement, nous arrivons à la fin de notre FFT, avec une représentation fréquentielle de la forme :

<math> [P(W_0), P(W_1), (...), P(W_n-1), P(W_n)] </math>

Cette représentation fréquentielle n'est autre que les évaluations du polynôme P aux racines nièmes de l'unité. Nous avons donc maintenant au minimum <math>2n+1</math> évaluations des polynômes facteurs. Il nous faut maintenant trouver les évaluations du produit final, c'est à dire les évaluations concernant le polynôme qui sera issue de la multiplication. On pourra ainsi le retrouver.

Soit <math>C</math> un polynome tel que <math> C = A \times B </math>, alors on a :

<math> C(x) = A(x) \times B(x) </math>

Ainsi on en déduit que <math> C(W_n^k) = A(W_n^k) \times B(W_n^k) </math>

On comprend donc que <math>FFT(C) = FFT(A) \times FFT(B)</math>

Il faut préciser que l'on fait le produit de FFT(A) et FFT(B) terme à terme, soit évaluation par évaluation.

Une fois en possession de <math>FFT(C)</math>, qui n'est autre que l'évaluation de notre polynôme final en un nombre suffisant de points pour le retrouver, nous pouvons faire l'<math>IFFT(FFT(C))</math>, qui va nous permettre de retrouver les coefficients de notre polynôme en faisant l'exacte inverse de la FFT.

Une fois les coefficients retrouvés, il nous suffit de gérer les retenues, et nous retrouvons un entier de la forme : <math>a_0 a_1 (...) a_{n-1} a_n</math>

=== B) Graphique ===

Les complexités étant des fonctions, nous pouvons les représenter par un graphique qui affichera le temps d'exécution (ou nombre d'opérations) en fonction de la taille des entrées.

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:30px; text-align:center;">
[[Fichier:FFT_image.webp|500px]]
<div><b>Graphiques des complexités</b></div>
</div>
<div style="max-width:800px;">
<p>Ce graphique ci-contre compare les complexités en fonction de la taille des d'entrées.</p>
<p>On comprend ainsi que certaines complexités ne sont pas raisonnable dans la cadre de la multiplication de grands entiers.</p>
<p>C'est pourquoi l'étude de ces algorithmes s'avère nécessaire.</p>
</div>
</div>

= II - Produit de matrices =

== 1.1) naïve ==

La multiplication naïve de matrice requiert d'avoir des tailles de lignes/colonne semblable, ensuite pour chaque membre de la matrice résultat, on doit multiplier les composantes ligne de la première matrice par les composantes colonne de la deuxième et le tout sommé.

On en déduit la formule suivante:
<math>C_{i,j} = \sum_{k=1}^{n} (A_{i,k} \times B_{k,j})</math>

Et visuellement:

[[Fichier:Matricenaive.jpeg]]

On a donc un algorithme d'ordre de complexité <math>\mathcal{O}(g(n))</math>

== 1.2) naïve récursive ==

Dans un premier temps on doit découper nos deux matrices en quatres sous matrices de plus petite taille.
<math>A = \begin{pmatrix} A_{11} & A_{12} \ A_{21} & A_{22} \end{pmatrix}</math>
<math>B = \begin{pmatrix} B_{11} & B_{12} \ B_{21} & B_{22} \end{pmatrix}</math>

Ensuite on vient calculer la matrice résultat.
<math>C_{11} = (A_{11} \times B_{11}) + (A_{12} \times B_{21})</math>
<math>C_{12} = (A_{11} \times B_{12}) + (A_{12} \times B_{22})</math>
<math>C_{21} = (A_{21} \times B_{11}) + (A_{22} \times B_{21})</math>
<math>C_{22} = (A_{21} \times B_{12}) + (A_{22} \times B_{22})</math>

Le côté récursif est utile que pour les matrices de tailles <= 32 (32 valeurs stockées dedans),
si on est au dessus de cette taille alors on divisera à nouveau nos matrices en quatres.
On aura 8 multiplications mais de plus petite taille au final.

== 2) strassen ==

=== A) Fonctionnement ===

Strassen consiste à définir 7 produits intermédiaires qui, par des jeux de sommes et de différences, permettent de reconstruire les quadrants de la matrice résultante. On passe ainsi d'une complexité de O(n^3) à environ O(n^2.81)

=== B) Graphique ===

On voit bien la différence de complexité sur la multiplication de grande matrice entre l'approche naïve et l'approche récursive qui est beaucoup plus rapide.

[[Fichier:Analyse matrices.png]]

= Conclusion =

( A FAIRE )

= Mentions =

Le premier gif est le résultat du travail de 'Walké', licence ci-contre : https://fr.wikipedia.org/wiki/Fichier:Addition.gif

= Sources =

Pour karatsuba : https://www.youtube.com/watch?v=PZ2gdWdKHAA

Pour mieux comprendre la FFT, nous avons utilisé plusieurs sources d'informations :

https://www.youtube.com/watch?v=h7apO7q16V0&list=WL&index=1&t=886s

https://fr.wikipedia.org/wiki/Interpolation_polynomiale

Algorithmes de multiplications d'entiers et de matrices

2026-05-11T11:56:02Z

Mangala : /* B) Graphique */

= Introduction =

Depuis l'apparition des ordinateurs modernes, une quantité faramineuse de calcul a dû être effectuée. Les progressions technologiques nous poussent à envisager la puissance de calcul comme une ressource qu'il faut optimiser dans les moindres détails. C'est ainsi que l'optimisation des algorithmes de calcul est devenue cruciale, surtout lorsqu'il nous faut effectuer des opérations sur de très grands entiers par exemple.

= Objectif =

L'objectif majeur de ce projet est de comprendre de manière plus approfondie ce qu'est la '''complexité algorithmique'''.
Pour atteindre cet objectif, nous implémenterons plusieurs algorithmes de multiplication qui auront pour but de calculer le produit de grands entiers ou de matrices.

= Point important : complexité =

=== Définition ===
La complexité d'un algorithme est la quantité des ressources qu'il utilise en fonction de la taille des entrée qu'on lui demande de traiter. On peut par exemple se concentrer sur le temps qu'un algorithme prend pour renvoyer un résultat ou sur la mémoire dont il a besoin. Dans le cadre de notre projet, nous nous attarderons plus particulièrement sur la quantité de calcul effectuée en fonction de la taille des entrées, ce qui est par ailleurs fortement liée à la notion de temps. De manière générale, plus un algorithme doit faire de calcul, plus il est lent. (Attention, toutes les opérations arithmétiques de base ne se valent pas)

De manière plus familière, on dira que la complexité d'un algorithme pourrait s'apparenter à son comportement lorsqu'il doit traiter des données plus ou moins grandes.
Chaque algorithme a une complexité, et on l'exprime par une fonction qui adopte un comportement similaire au nombre de calcul nécessaire en fonction de la taille des entrées.

=== Notation ===
La complexité réelle d'un algorithme peut être décrite par une fonction <math>f(n)</math> représentant le nombre d'opérations effectuées en fonction de la taille <math>n</math> des données d'entrée.

Cependant, afin de simplifier l'étude de cette croissance, on utilise généralement une borne asymptotique notée <math>\mathcal{O}(g(n))</math>, où <math>g(n)</math> est une fonction ayant le même ordre de grandeur que <math>f(n)</math> lorsque <math>n</math> devient grand.

On dit alors que :

<math>
f(n)\in\mathcal{O}(g(n))
</math>

si et seulement s'il existe une constante <math>C>0</math> et un entier <math>n_0</math> tels que :

<math>
\forall n\ge n_0,\ f(n)\le Cg(n)
</math>

Cette notation <math>\mathcal{O}(g(n))</math> permettra de comparer beaucoup plus facilement les algorithmes entre eux.

=== Master Theorem ===

Afin de déterminer la complexité de certains algorithmes récursifs, nous utiliserons le "Master Theorem".

Ce théorème permet d'obtenir directement l'ordre de grandeur de nombreuses relations de récurrence apparaissant dans l'analyse d'algorithmes de type « diviser pour régner », comme l'algorithme de Karatsuba ou celui de Strassen.

La démonstration complète de ce théorème dépasse le cadre de notre projet et nécessite des connaissances mathématiques plus avancées. Nous l'utiliserons donc principalement comme un outil nous permettant de déterminer efficacement la complexité asymptotique des algorithmes étudiés.

=== Graphiques ===

Les complexités étant des fonctions, nous pouvons les représenter par un graphique qui affichera le temps d'exécution (ou nombre d'opérations) en fonction de la taille des entrées.

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:30px; text-align:center;">
[[Fichier:complexite.webp|500px]]
<div><b>Graphiques des complexités</b></div>
</div>
<div style="max-width:800px;">
<p>Ce graphique ci-contre compare les complexités en fonction de la taille des d'entrées.</p>
<p>On comprend ainsi que certaines complexités ne sont pas raisonnable dans la cadre de la multiplication de grands entiers.</p>
<p>C'est pourquoi l'étude de ces algorithmes s'avère nécessaire.</p>
</div>
</div>

=== Exemple ===
L'algorithme naïf d'addition que nous avons tous appris à l'école a une complexité de <math>\mathcal{O}(n)</math>.
Soit n la taille des nombres en entrée, l'algorithme doit faire environ n addition pour arriver au résultat demandé.

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Addition.gif|220px]]
<div><b>Addition naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Comme le montre l'exemple ci-contre, 786 et 467 font 3 chiffres de long donc n sera de 3.</p>
<p>Il nous faudra 3 opérations pour additionner ces deux nombres.</p>
<p>C'est ainsi qu'avec une taille d'entrée n, l'algorithme de l'addition naïve va devoir faire n opérations.</p>
<p>Cette algorithme a donc une complexité <math>f(n) = n</math> qui n'a pas besoin d'être approximée.</p>
<p>Ainsi sa complexité finale sera <math>\mathcal{O}(n)</math>.</p>
</div>
</div>

= Problématique =

Le calcul du produit de deux entiers de manière naïve a une complexité de <math> \mathcal{O}(n^2)</math>, et celui de deux matrices une complexité de <math> \mathcal{O}(n^3)</math>. Afin de mieux comprendre ce qu'est la complexité algorithmique, nous devrons implémenter des algorithmes ayant le même objectif, mais étant plus efficaces. Ces algorithmes s'avèreront plus complexes mais devrait aboutir à un calcul plus rapide du produit demandé.

Nous séparerons notre wiki en deux grandes parties, la première concernera nos recherche sur [[#I - Produit d'entiers|la multiplication d'entiers]], la deuxième sur [[#II - Produit de matrices|la multiplication de matrices]].

= I - Produit d'entiers =

Notre départ commence avec l'algorithme de multiplication d'entier naïf.
En effet il s'agit de l'algorithme de multiplication le plus connu, et nous l'utiliserons comme référence pour le comparer aux futurs algorithmes plus efficaces.
Intéressons nous à sa complexité.

== 1) Nos implémentations des grands entiers ==

Qui dit produit de grands entiers dit implémentation de grands entiers.

Dans le cadre de nos recherches, nous allons devoir implémenter des algorithmes qui vont manipuler des grands entiers.

Nous avons donc choisi de créer deux représentations différentes de ceux-ci (car nous travaillons sur différents langages de programmation), nous permettant à la fois une implémentation simplifié, mais aussi de nous rapprocher d'une implémentation bas niveau.

=== A) En python ===
En python, l'utilisation des "bytes" m'a grandement servi à comprendre comment les entiers étaient manipulés à bas niveau. En effet, un des objectifs secondaires de nos recherches était de manipuler des entiers directement avec leur formes stockées sur l'ordinateur, et non pas avec des int python.
En effet l'utilisation des int python nous aurait permit de passer les étapes de retenues, de signes... D'autant plus que les bytes permettent de stocker un nombre en base 256, ce qui permet de visualiser plus facilement les grands entiers.

La forme finale de la représentation des grands entiers en python sera donc la suivante :

[ signe , bytes , bytes , (...) , bytes ]

Le signe est représenté par un entier, 1 si le nombre est positif, 0 sinon.
Cette configuration rendra plus simple la gestion des signes.

=== B) En C++ ===

En C++, pour avoir une représentation de grand entiers j'ai du définir ma propre structure pour m'affranchir de la limite de taille imposé par les entiers standards: (int32 ou int64). Pour cela, j'ai une structure qui possède l'équivalent d'un array de byte (ce qui nous permet d'être en base 256 au lieu de la base 10 habituelle), et pour traiter le signe j'utilise un booléen, ainsi en mémoire j'ai une structure de n*Octets + 1 octet en taille.

[ bytes , bytes , (...) , bytes ] [ signe ]

Le booléen prend 1 octet de place mais ne touche pas aux octets qui encode le grand entier.
Cette configuration rendra plus simple la gestion des signes dans le cadre des multiplication.

== 2) La multiplication naïve ==

=== A) Fonctionnement ===
Dans le cas de la multiplication d'entiers, nous allons prendre deux nombres qui n'ont pas nécessairement la même longueur. Soit les nombre a et b, de longueur respective <math>n</math> et <math> m </math>.
<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Multiplication.png|220px]]
<div><b>Multiplication naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Prenons deux nombres de longueur 3 et 2, et cherchons combien d'opérations l'algorithme de multiplication naïve va devoir faire pour nous renvoyer leur produit.</p>
<p>Dans un premier temps, on remarque que l'on va devoir multiplier chaque chiffre du nombre du haut par le chiffre des unités du bas, qui est 6. Cela va représenter <math>n</math> opérations. (6x5, 6x1 et 6x4)</p>
<p>Dans un deuxième temps nous constatons que nous allons devoir faire la même chose avec le chiffre des dizaines du nombre du bas. Cela nous ajoute de nouveau <math>n</math> opérations.</p>
<p>On arrive assez facilement à la conclusion que pour faire notre produit, il va nous falloir faire <math>n</math> fois <math>m</math> opérations.</p>
</div>
</div>

Ainsi, la complexité de la multiplication naïve est <math>\mathcal{O}(n^2)</math>.
Il est en de même avec la multiplication naïve récursive.

=== B) Graphique ===
Montrons maintenant sa courbe sur un graphique :

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Multiplicationnaive.png|500px]]
<div><b>Multiplication naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Les points noirs sont des repères pour que les autres courbes aient une forme cohérente.</p>
<p>Ils sont tous sur l'axe des abscisses.</p>
<p>La courbe rouge représente la complexité de la multiplication naïve.</p>
<p>On remarque que la courbe a un visuel très similaire à la fonction <math>f(x) = x^2</math> </p>
</div>
</div>

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Naif_recursif.png|500px]]
<div><b>Multiplication naïve récursive</b></div>
</div>
<div style="max-width:800px;">
<p>La courbe rouge représente la complexité de la multiplication naïve récursive.</p>
<p>Elle sera utilisé pour comparer les complexités entre algorithmes car, comme tous récursifs, elle a été codé avec les mêmes biais d'implémentation qu'eux.</p>
<p>Théoriquement les deux courbes ci-contre ont la même complexité, mais encore une fois, notre implémentation n'est pas parfaitement optimale et donc ne respecte pas de manière minutieuse le Master Theorem.</p>
</div>
</div>

== 3) La multiplication karastuba ==

=== A) Fonctionnement ===

L'algorithme de karatsuba est un algorithme récursif de type diviser pour régner.

L'idée générale de l'algorithme est de passer de 4 multiplication à 3. En effet ces opérations étant moins couteuses, il est préférable d'en ajouter si cela permet d'enlever des multiplications.

L'algorithme de multiplication naif récursif utilise la segmentation des facteurs en deux de manière successive.

Soit <math>x</math> et <math>y</math> deux facteurs, nous avons les égalités suivantes :

<div style="font-size: 20px;">
<math>x = a \times B^{n/2} + b</math>
<math>y = c \times B^{n/2} + d</math>
</div>

Avec <math>a</math> et <math>c</math> les premières moitiés des facteurs <math>x</math> et <math>y</math>,
et <math>b</math> et <math>d</math> les dernières moitiés de ces facteurs ainsi que <math>B</math> la base d'écriture du nombre (Nous sommes en base 256 avec les bytes).

Cette présentation des deux facteurs de notre multiplication n'est que la résultante d'un découpage.
Le [[#Master Theorem|Master Theorem]] nous montre que :

<div style="font-size: 20px;">
<math>T(n) = 4T(n/2) + O(n)</math>
</div>

Puisque nous avons après découpage 4 entiers de longueur <math>n/2</math>.

Ainsi, ce découpage ne permet pas de gagner du temps d'après le [[#Master Theorem|Master Theorem]].

Cependant, l'algorithme de Karatsuba réutilise ce principe en le modifiant, ce qui nous permet de baisser la complexité globale de la multiplication dans son entièreté.

Avec l'écriture ci-dessus des nombres <math>x</math> et <math>y</math>, on peut facilement en déduire l'égalité suivante :

<div style="font-size: 20px;">
<math>x \times y = (ac) \times B^n + (ad + bc) \times B^{n/2} + bd</math>
</div>

On remarque 4 multiplications longues à faire dans cette expression. Les multiplications dont <math>B</math> est l'un des facteurs sont très rapides puisqu'il s'agit de la base dans laquelle nous travaillons. De cela en résulte un décalage plutôt qu'un vrai calcul à faire.

Karatsuba développe une partie de cette expression pour pouvoir négocier une multiplication au prix d'additions et soustractions.

En effet, nous savons déjà que :

<div style="font-size: 20px;">
<math>(a + b)(c + d) = ac + ad + bc + bd</math>
</div>

En manipulant l'égalité nous obtenons :

<div style="font-size: 20px;">
<math>ad + bc = (a + b)(c + d) - ac - bd</math>
</div>

ac et bd ayant déjà été calculé précédemment, il nous reste uniquement la multiplication <math>(a + b)(c + d)</math>.

Nous venons ainsi de calculer <math>ad + bc</math> en seulement une multiplication. C'est la que repose le gain de temps de la méthode Karatsuba par rapport à la multiplication naïve.

En effet, l'algorithme n'effectuera alors plus que 3 multiplications :
<div style="font-size: 20px;">
<math>ac</math>
<math>bd</math>
<math>(a + b)(c + d)</math>
</div>

La relation de récurrence devient donc :
<div style="font-size: 20px;">
<math>T(n)=3T(n/2)+O(n)</math>
</div>

Et le Master Theorem nous dit que :
<div style="font-size: 20px;">
<math>T(n)\in O(n^{\log_2(3)})</math>
</div>

Or <math>\log_2(3)\approx 1.585</math>, donc la complexité de l'algorithme de Karatsuba est de <math> \mathcal{O}(n^{1.585})</math>. Ce qui est bien plus efficace que la multiplication classique, surtout lorsque les facteurs deviennent très grands.

=== B) Graphique ===
<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Karatsuba.png|500px]]
<div><b>Karatsuba</b></div>
</div>
<div style="max-width:800px;">
<p>Sur le graphique ci-contre nous avons utilisé la courbe de la multiplication naïve récursive (rouge) à titre de comparaison.</p>
<p>On remarque graphiquement que Karatsuba (jaune) prend moins de temps à chaque calcul de produit.</p>
<p>On en déduit donc expérimentalement que Karatsuba à une meilleure complexité que la multiplication naïve.</p>
<p>Ainsi nous vérifions donc ce que le Master Theorem prouve, c'est à dire que la complexité de karatsuba est de <math> \mathcal{O}(n^{1.585})</math> </p>
</div>
</div>

== 4) La multiplication toom-cook-3 ==

=== A) Fonctionnement ===

L'objectif est de diviser les grands entiers X et Y en trois blocs de taille égale k.
On les traite alors comme des polynômes de degré 2:

<math>P(z) = X_2 \cdot z^2 + X_1 \cdot z + X_0</math>
<math>Q(z) = Y_2 \cdot z^2 + Y_1 \cdot z + Y_0</math>

On choisit 5 points distincts pour évaluer nos polynômes.
Ce choix de 5 points est crucial car le produit de deux polynômes de degré 2 est un polynôme de degré 4, qui nécessite 5 points pour être défini.
Les points standards sont :

P(0) = X0
P(1) = X0 + X1 + X2
P(-1) = X0 - X1 + X2
P(2) = X0 + 2*X1 + 4*X2
P(inf) = X2

(On procède de manière similaire pour Q.)

Ensuite nous multiplions récursivement chaque points de P et de Q ensemble.
On effectue ainsi 5 multiplications de nombres plus petits au lieu des 9 multiplications requises par la méthode classique.

Après, nous effectuons une interpolation, cela permet de retrouver les 5 coefficients (w_0, w_1, w_2, w_3, w_4) du polynôme produit R(z) à partir des valeurs évaluées calculées précédemment.
On résout un système d'équations linéaires : <math> R(z) = w_4 z^4 + w_3 z^3 + w_2 z^2 + w_1 z + w_0 </math>
Finalement nous pouvons recomposer notre grand entier en positionnant les coefficients w_i aux bons rangs (en les décalant) et à gérer les retenues lors de l'addition finale:
<math>Résultat = w_4 B^{4k} + w_3 B^{3k} + w_2 B^{2k} + w_1 B^k + w_0</math>

=== B) Graphique ===

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Toomcook.png|500px]]
<div><b>Karatsuba</b></div>
</div>
<div style="max-width:800px;">
<p>on a reprit multi récursive (rouge)</p>
<p>on voit que Toom (vert) en dessous de karatsuba (jaune) en dessous de multi classique (rouge)</p>
<p>meilleur complexité</p>
</div>
</div>

== 5) La transformée de Fourier rapide ==

=== A) Fonctionnement ===

La transformation de Fourier rapide étant plus complexe que les autres algorithmes, nous allons essayer d'expliquer son fonctionnement malgré ne pas avoir réussi à l'implémenter.

Il faut comprendre que cet algorithme va considérer les facteurs comme des polynômes.

D'après le théorème de l'unisolvance, il n'existe qu'un seul polynôme de degré inférieur ou égal à <math> n </math> défini par <math>n + 1</math> points distincts. Cela implique non seulement que nous pouvons représenter chaque entier par un polynôme, mais également que si nous pouvons retrouver <math>n + m + 1</math> points (avec <math>n</math> et <math>m</math> la longueur des facteurs) du polynômes issue du produit entre deux facteurs, nous pourrons le retrouver.

Soit un entier quelconque, de forme :

<math>a_n a_{n-1} (...) a_1 a_0</math>

Avec <math>a_i</math>, un chiffre composant le nombre en base 10, qui vaut en réalité dans le nombre : <math>a_i \times 10^i</math>. On peut ainsi l'écrire sous la forme :

<math> P(x) = a_0 + a_1x + a_2x^2 + \dots + a_{n-1}x^{n-1} + a_nx^n </math>

Avec <math>x = 10</math> car nous sommes en base 10, nous obtenons :

<math>P(10) = a_0 + a_1 \times 10 + \dots + a_{n-1}10^{n-1} + a_n10^n </math>

Nous venons ainsi d'écrire notre nombre sous la forme d'un polynôme unique. Pour nous permettre d'évaluer en un nombre suffisant de points, nous allons devoir ajouter des 0 pour la récursion. Il nous faudra ajouter assez de 0 pour atteindre la prochaine puissance de 2 qui sera supérieure ou égale à <math>2n + 1</math>. L'ajout de 0 ne change pas le nombre car <math>0 \times x^n</math> n'ajoute pas de coefficient.

Cet algorithme est récursif et va segmenter en deux parties nos polynômes à chaque récursion. D'un coté les indice paires et d'un coté les impaires.

Ainsi prenons les nombres 1234 et 5678, ces nombres sont respectivement représentés par les polynômes <math> P(x) = 4 + 3x + 2x^2 + x^3 </math> et <math> P(x) = 8 + 7x + 6x^2 + 5^3 </math>. Ce sont des polynômes de degré 3, ainsi leur produit donnera lieu à un polynôme de degré 6. Il nous faudra donc au minimum 7 points d'évaluation pour retrouve ce produit. De ce fait, en les représentant de la manière suivante :

<math>[4, 3, 2, 1, 0, 0, 0, 0]</math>
<math>[8, 7, 6, 5, 0, 0, 0, 0]</math>

Nous aurons assez de récursions possible pour les évaluer en un nombre suffisant de points différents car nous auront 3 récursions à faire pour atteindre notre cas de base. A chaque récursion, nous allons diviser nos polynômes en deux parties ce qui nous fait 8 feuilles à la dernière récursion.

En effet à chaque étape de la récursion nous allons séparer nos polynômes en deux tel que :

<math> P(x)=P_{pair}x^2 + x \times P_{impair}x^2 </math>

Durant les récursions, nous segmentons les polynômes mais ne les évaluons pas. C'est à la remonté des récursions que nous allons réellement évaluer nos polynômes. Lorsque l'on atteint notre cas de base, c'est à dire des polynômes de degré 0, nous remarquons qu'ils sont constants, nous n'avons donc pas besoin de les évaluer. En effet, peut importe le point en lequel nous voudrons l'évaluer, le polynôme renverra la constante. Nous la renvoyons donc seule.
Ensuite commence la remontée des récursions. A l'étape 1 de notre remontée nous allons reformer le polynôme précédemment séparé pour obtenir un polynôme de degré 1. Puis, nous évaluons ce polynôme avec les racines seconde de l'unité. Nous faisons à nouveau remonté les évaluations et recombinons à nouveau le polynôme qui sera ainsi de degré 2.
Nous l'évaluons maintenant avec les racines 4eme de l'unité. A chaque évaluation, nous réutilisons les résultats précédents, cela nous est permit par les racines de l'unité qui ont une structure récursive exploitable.

Finalement, nous arrivons à la fin de notre FFT, avec une représentation fréquentielle de la forme :

<math> [P(W_0), P(W_1), (...), P(W_n-1), P(W_n)] </math>

Cette représentation fréquentielle n'est autre que les évaluations du polynôme P aux racines nièmes de l'unité. Nous avons donc maintenant au minimum <math>2n+1</math> évaluations des polynômes facteurs. Il nous faut maintenant trouver les évaluations du produit final, c'est à dire les évaluations concernant le polynôme qui sera issue de la multiplication. On pourra ainsi le retrouver.

Soit <math>C</math> un polynome tel que <math> C = A \times B </math>, alors on a :

<math> C(x) = A(x) \times B(x) </math>

Ainsi on en déduit que <math> C(W_n^k) = A(W_n^k) \times B(W_n^k) </math>

On comprend donc que <math>FFT(C) = FFT(A) \times FFT(B)</math>

Il faut préciser que l'on fait le produit de FFT(A) et FFT(B) terme à terme, soit évaluation par évaluation.

Une fois en possession de <math>FFT(C)</math>, qui n'est autre que l'évaluation de notre polynôme final en un nombre suffisant de points pour le retrouver, nous pouvons faire l'<math>IFFT(FFT(C))</math>, qui va nous permettre de retrouver les coefficients de notre polynôme en faisant l'exacte inverse de la FFT.

Une fois les coefficients retrouvés, il nous suffit de gérer les retenues, et nous retrouvons un entier de la forme : <math>a_0 a_1 (...) a_{n-1} a_n</math>

=== B) Graphique ===

( A FAIRE )
(on aura pas de courbe par contre)
FFT_image.webp

= II - Produit de matrices =

== 1.1) naïve ==

La multiplication naïve de matrice requiert d'avoir des tailles de lignes/colonne semblable, ensuite pour chaque membre de la matrice résultat, on doit multiplier les composantes ligne de la première matrice par les composantes colonne de la deuxième et le tout sommé.

On en déduit la formule suivante:
<math>C_{i,j} = \sum_{k=1}^{n} (A_{i,k} \times B_{k,j})</math>

Et visuellement:

[[Fichier:Matricenaive.jpeg]]

On a donc un algorithme d'ordre de complexité <math>\mathcal{O}(g(n))</math>

== 1.2) naïve récursive ==

Dans un premier temps on doit découper nos deux matrices en quatres sous matrices de plus petite taille.
<math>A = \begin{pmatrix} A_{11} & A_{12} \ A_{21} & A_{22} \end{pmatrix}</math>
<math>B = \begin{pmatrix} B_{11} & B_{12} \ B_{21} & B_{22} \end{pmatrix}</math>

Ensuite on vient calculer la matrice résultat.
<math>C_{11} = (A_{11} \times B_{11}) + (A_{12} \times B_{21})</math>
<math>C_{12} = (A_{11} \times B_{12}) + (A_{12} \times B_{22})</math>
<math>C_{21} = (A_{21} \times B_{11}) + (A_{22} \times B_{21})</math>
<math>C_{22} = (A_{21} \times B_{12}) + (A_{22} \times B_{22})</math>

Le côté récursif est utile que pour les matrices de tailles <= 32 (32 valeurs stockées dedans),
si on est au dessus de cette taille alors on divisera à nouveau nos matrices en quatres.
On aura 8 multiplications mais de plus petite taille au final.

== 2) strassen ==

=== A) Fonctionnement ===

Strassen consiste à définir 7 produits intermédiaires qui, par des jeux de sommes et de différences, permettent de reconstruire les quadrants de la matrice résultante. On passe ainsi d'une complexité de O(n^3) à environ O(n^2.81)

=== B) Graphique ===

On voit bien la différence de complexité sur la multiplication de grande matrice entre l'approche naïve et l'approche récursive qui est beaucoup plus rapide.

[[Fichier:Analyse matrices.png]]

= Conclusion =

( A FAIRE )

= Mentions =

Le premier gif est le résultat du travail de 'Walké', licence ci-contre : https://fr.wikipedia.org/wiki/Fichier:Addition.gif

= Sources =

Pour karatsuba : https://www.youtube.com/watch?v=PZ2gdWdKHAA

Pour mieux comprendre la FFT, nous avons utilisé plusieurs sources d'informations :

https://www.youtube.com/watch?v=h7apO7q16V0&list=WL&index=1&t=886s

https://fr.wikipedia.org/wiki/Interpolation_polynomiale

Fichier:FFT image.webp

2026-05-11T11:55:46Z

Mangala :

Algorithmes de multiplications d'entiers et de matrices

2026-05-11T11:51:17Z

Mangala : /* A) Fonctionnement */

= Introduction =

Depuis l'apparition des ordinateurs modernes, une quantité faramineuse de calcul a dû être effectuée. Les progressions technologiques nous poussent à envisager la puissance de calcul comme une ressource qu'il faut optimiser dans les moindres détails. C'est ainsi que l'optimisation des algorithmes de calcul est devenue cruciale, surtout lorsqu'il nous faut effectuer des opérations sur de très grands entiers par exemple.

= Objectif =

L'objectif majeur de ce projet est de comprendre de manière plus approfondie ce qu'est la '''complexité algorithmique'''.
Pour atteindre cet objectif, nous implémenterons plusieurs algorithmes de multiplication qui auront pour but de calculer le produit de grands entiers ou de matrices.

= Point important : complexité =

=== Définition ===
La complexité d'un algorithme est la quantité des ressources qu'il utilise en fonction de la taille des entrée qu'on lui demande de traiter. On peut par exemple se concentrer sur le temps qu'un algorithme prend pour renvoyer un résultat ou sur la mémoire dont il a besoin. Dans le cadre de notre projet, nous nous attarderons plus particulièrement sur la quantité de calcul effectuée en fonction de la taille des entrées, ce qui est par ailleurs fortement liée à la notion de temps. De manière générale, plus un algorithme doit faire de calcul, plus il est lent. (Attention, toutes les opérations arithmétiques de base ne se valent pas)

De manière plus familière, on dira que la complexité d'un algorithme pourrait s'apparenter à son comportement lorsqu'il doit traiter des données plus ou moins grandes.
Chaque algorithme a une complexité, et on l'exprime par une fonction qui adopte un comportement similaire au nombre de calcul nécessaire en fonction de la taille des entrées.

=== Notation ===
La complexité réelle d'un algorithme peut être décrite par une fonction <math>f(n)</math> représentant le nombre d'opérations effectuées en fonction de la taille <math>n</math> des données d'entrée.

Cependant, afin de simplifier l'étude de cette croissance, on utilise généralement une borne asymptotique notée <math>\mathcal{O}(g(n))</math>, où <math>g(n)</math> est une fonction ayant le même ordre de grandeur que <math>f(n)</math> lorsque <math>n</math> devient grand.

On dit alors que :

<math>
f(n)\in\mathcal{O}(g(n))
</math>

si et seulement s'il existe une constante <math>C>0</math> et un entier <math>n_0</math> tels que :

<math>
\forall n\ge n_0,\ f(n)\le Cg(n)
</math>

Cette notation <math>\mathcal{O}(g(n))</math> permettra de comparer beaucoup plus facilement les algorithmes entre eux.

=== Master Theorem ===

Afin de déterminer la complexité de certains algorithmes récursifs, nous utiliserons le "Master Theorem".

Ce théorème permet d'obtenir directement l'ordre de grandeur de nombreuses relations de récurrence apparaissant dans l'analyse d'algorithmes de type « diviser pour régner », comme l'algorithme de Karatsuba ou celui de Strassen.

La démonstration complète de ce théorème dépasse le cadre de notre projet et nécessite des connaissances mathématiques plus avancées. Nous l'utiliserons donc principalement comme un outil nous permettant de déterminer efficacement la complexité asymptotique des algorithmes étudiés.

=== Graphiques ===

Les complexités étant des fonctions, nous pouvons les représenter par un graphique qui affichera le temps d'exécution (ou nombre d'opérations) en fonction de la taille des entrées.

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:30px; text-align:center;">
[[Fichier:complexite.webp|500px]]
<div><b>Graphiques des complexités</b></div>
</div>
<div style="max-width:800px;">
<p>Ce graphique ci-contre compare les complexités en fonction de la taille des d'entrées.</p>
<p>On comprend ainsi que certaines complexités ne sont pas raisonnable dans la cadre de la multiplication de grands entiers.</p>
<p>C'est pourquoi l'étude de ces algorithmes s'avère nécessaire.</p>
</div>
</div>

=== Exemple ===
L'algorithme naïf d'addition que nous avons tous appris à l'école a une complexité de <math>\mathcal{O}(n)</math>.
Soit n la taille des nombres en entrée, l'algorithme doit faire environ n addition pour arriver au résultat demandé.

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Addition.gif|220px]]
<div><b>Addition naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Comme le montre l'exemple ci-contre, 786 et 467 font 3 chiffres de long donc n sera de 3.</p>
<p>Il nous faudra 3 opérations pour additionner ces deux nombres.</p>
<p>C'est ainsi qu'avec une taille d'entrée n, l'algorithme de l'addition naïve va devoir faire n opérations.</p>
<p>Cette algorithme a donc une complexité <math>f(n) = n</math> qui n'a pas besoin d'être approximée.</p>
<p>Ainsi sa complexité finale sera <math>\mathcal{O}(n)</math>.</p>
</div>
</div>

= Problématique =

Le calcul du produit de deux entiers de manière naïve a une complexité de <math> \mathcal{O}(n^2)</math>, et celui de deux matrices une complexité de <math> \mathcal{O}(n^3)</math>. Afin de mieux comprendre ce qu'est la complexité algorithmique, nous devrons implémenter des algorithmes ayant le même objectif, mais étant plus efficaces. Ces algorithmes s'avèreront plus complexes mais devrait aboutir à un calcul plus rapide du produit demandé.

Nous séparerons notre wiki en deux grandes parties, la première concernera nos recherche sur [[#I - Produit d'entiers|la multiplication d'entiers]], la deuxième sur [[#II - Produit de matrices|la multiplication de matrices]].

= I - Produit d'entiers =

Notre départ commence avec l'algorithme de multiplication d'entier naïf.
En effet il s'agit de l'algorithme de multiplication le plus connu, et nous l'utiliserons comme référence pour le comparer aux futurs algorithmes plus efficaces.
Intéressons nous à sa complexité.

== 1) Nos implémentations des grands entiers ==

Qui dit produit de grands entiers dit implémentation de grands entiers.

Dans le cadre de nos recherches, nous allons devoir implémenter des algorithmes qui vont manipuler des grands entiers.

Nous avons donc choisi de créer deux représentations différentes de ceux-ci (car nous travaillons sur différents langages de programmation), nous permettant à la fois une implémentation simplifié, mais aussi de nous rapprocher d'une implémentation bas niveau.

=== A) En python ===
En python, l'utilisation des "bytes" m'a grandement servi à comprendre comment les entiers étaient manipulés à bas niveau. En effet, un des objectifs secondaires de nos recherches était de manipuler des entiers directement avec leur formes stockées sur l'ordinateur, et non pas avec des int python.
En effet l'utilisation des int python nous aurait permit de passer les étapes de retenues, de signes... D'autant plus que les bytes permettent de stocker un nombre en base 256, ce qui permet de visualiser plus facilement les grands entiers.

La forme finale de la représentation des grands entiers en python sera donc la suivante :

[ signe , bytes , bytes , (...) , bytes ]

Le signe est représenté par un entier, 1 si le nombre est positif, 0 sinon.
Cette configuration rendra plus simple la gestion des signes.

=== B) En C++ ===

En C++, pour avoir une représentation de grand entiers j'ai du définir ma propre structure pour m'affranchir de la limite de taille imposé par les entiers standards: (int32 ou int64). Pour cela, j'ai une structure qui possède l'équivalent d'un array de byte (ce qui nous permet d'être en base 256 au lieu de la base 10 habituelle), et pour traiter le signe j'utilise un booléen, ainsi en mémoire j'ai une structure de n*Octets + 1 octet en taille.

[ bytes , bytes , (...) , bytes ] [ signe ]

Le booléen prend 1 octet de place mais ne touche pas aux octets qui encode le grand entier.
Cette configuration rendra plus simple la gestion des signes dans le cadre des multiplication.

== 2) La multiplication naïve ==

=== A) Fonctionnement ===
Dans le cas de la multiplication d'entiers, nous allons prendre deux nombres qui n'ont pas nécessairement la même longueur. Soit les nombre a et b, de longueur respective <math>n</math> et <math> m </math>.
<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Multiplication.png|220px]]
<div><b>Multiplication naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Prenons deux nombres de longueur 3 et 2, et cherchons combien d'opérations l'algorithme de multiplication naïve va devoir faire pour nous renvoyer leur produit.</p>
<p>Dans un premier temps, on remarque que l'on va devoir multiplier chaque chiffre du nombre du haut par le chiffre des unités du bas, qui est 6. Cela va représenter <math>n</math> opérations. (6x5, 6x1 et 6x4)</p>
<p>Dans un deuxième temps nous constatons que nous allons devoir faire la même chose avec le chiffre des dizaines du nombre du bas. Cela nous ajoute de nouveau <math>n</math> opérations.</p>
<p>On arrive assez facilement à la conclusion que pour faire notre produit, il va nous falloir faire <math>n</math> fois <math>m</math> opérations.</p>
</div>
</div>

Ainsi, la complexité de la multiplication naïve est <math>\mathcal{O}(n^2)</math>.
Il est en de même avec la multiplication naïve récursive.

=== B) Graphique ===
Montrons maintenant sa courbe sur un graphique :

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Multiplicationnaive.png|500px]]
<div><b>Multiplication naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Les points noirs sont des repères pour que les autres courbes aient une forme cohérente.</p>
<p>Ils sont tous sur l'axe des abscisses.</p>
<p>La courbe rouge représente la complexité de la multiplication naïve.</p>
<p>On remarque que la courbe a un visuel très similaire à la fonction <math>f(x) = x^2</math> </p>
</div>
</div>

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Naif_recursif.png|500px]]
<div><b>Multiplication naïve récursive</b></div>
</div>
<div style="max-width:800px;">
<p>La courbe rouge représente la complexité de la multiplication naïve récursive.</p>
<p>Elle sera utilisé pour comparer les complexités entre algorithmes car, comme tous récursifs, elle a été codé avec les mêmes biais d'implémentation qu'eux.</p>
<p>Théoriquement les deux courbes ci-contre ont la même complexité, mais encore une fois, notre implémentation n'est pas parfaitement optimale et donc ne respecte pas de manière minutieuse le Master Theorem.</p>
</div>
</div>

== 3) La multiplication karastuba ==

=== A) Fonctionnement ===

L'algorithme de karatsuba est un algorithme récursif de type diviser pour régner.

L'idée générale de l'algorithme est de passer de 4 multiplication à 3. En effet ces opérations étant moins couteuses, il est préférable d'en ajouter si cela permet d'enlever des multiplications.

L'algorithme de multiplication naif récursif utilise la segmentation des facteurs en deux de manière successive.

Soit <math>x</math> et <math>y</math> deux facteurs, nous avons les égalités suivantes :

<div style="font-size: 20px;">
<math>x = a \times B^{n/2} + b</math>
<math>y = c \times B^{n/2} + d</math>
</div>

Avec <math>a</math> et <math>c</math> les premières moitiés des facteurs <math>x</math> et <math>y</math>,
et <math>b</math> et <math>d</math> les dernières moitiés de ces facteurs ainsi que <math>B</math> la base d'écriture du nombre (Nous sommes en base 256 avec les bytes).

Cette présentation des deux facteurs de notre multiplication n'est que la résultante d'un découpage.
Le [[#Master Theorem|Master Theorem]] nous montre que :

<div style="font-size: 20px;">
<math>T(n) = 4T(n/2) + O(n)</math>
</div>

Puisque nous avons après découpage 4 entiers de longueur <math>n/2</math>.

Ainsi, ce découpage ne permet pas de gagner du temps d'après le [[#Master Theorem|Master Theorem]].

Cependant, l'algorithme de Karatsuba réutilise ce principe en le modifiant, ce qui nous permet de baisser la complexité globale de la multiplication dans son entièreté.

Avec l'écriture ci-dessus des nombres <math>x</math> et <math>y</math>, on peut facilement en déduire l'égalité suivante :

<div style="font-size: 20px;">
<math>x \times y = (ac) \times B^n + (ad + bc) \times B^{n/2} + bd</math>
</div>

On remarque 4 multiplications longues à faire dans cette expression. Les multiplications dont <math>B</math> est l'un des facteurs sont très rapides puisqu'il s'agit de la base dans laquelle nous travaillons. De cela en résulte un décalage plutôt qu'un vrai calcul à faire.

Karatsuba développe une partie de cette expression pour pouvoir négocier une multiplication au prix d'additions et soustractions.

En effet, nous savons déjà que :

<div style="font-size: 20px;">
<math>(a + b)(c + d) = ac + ad + bc + bd</math>
</div>

En manipulant l'égalité nous obtenons :

<div style="font-size: 20px;">
<math>ad + bc = (a + b)(c + d) - ac - bd</math>
</div>

ac et bd ayant déjà été calculé précédemment, il nous reste uniquement la multiplication <math>(a + b)(c + d)</math>.

Nous venons ainsi de calculer <math>ad + bc</math> en seulement une multiplication. C'est la que repose le gain de temps de la méthode Karatsuba par rapport à la multiplication naïve.

En effet, l'algorithme n'effectuera alors plus que 3 multiplications :
<div style="font-size: 20px;">
<math>ac</math>
<math>bd</math>
<math>(a + b)(c + d)</math>
</div>

La relation de récurrence devient donc :
<div style="font-size: 20px;">
<math>T(n)=3T(n/2)+O(n)</math>
</div>

Et le Master Theorem nous dit que :
<div style="font-size: 20px;">
<math>T(n)\in O(n^{\log_2(3)})</math>
</div>

Or <math>\log_2(3)\approx 1.585</math>, donc la complexité de l'algorithme de Karatsuba est de <math> \mathcal{O}(n^{1.585})</math>. Ce qui est bien plus efficace que la multiplication classique, surtout lorsque les facteurs deviennent très grands.

=== B) Graphique ===
<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Karatsuba.png|500px]]
<div><b>Karatsuba</b></div>
</div>
<div style="max-width:800px;">
<p>Sur le graphique ci-contre nous avons utilisé la courbe de la multiplication naïve récursive (rouge) à titre de comparaison.</p>
<p>On remarque graphiquement que Karatsuba (jaune) prend moins de temps à chaque calcul de produit.</p>
<p>On en déduit donc expérimentalement que Karatsuba à une meilleure complexité que la multiplication naïve.</p>
<p>Ainsi nous vérifions donc ce que le Master Theorem prouve, c'est à dire que la complexité de karatsuba est de <math> \mathcal{O}(n^{1.585})</math> </p>
</div>
</div>

== 4) La multiplication toom-cook-3 ==

=== A) Fonctionnement ===

L'objectif est de diviser les grands entiers X et Y en trois blocs de taille égale k.
On les traite alors comme des polynômes de degré 2:

<math>P(z) = X_2 \cdot z^2 + X_1 \cdot z + X_0</math>
<math>Q(z) = Y_2 \cdot z^2 + Y_1 \cdot z + Y_0</math>

On choisit 5 points distincts pour évaluer nos polynômes.
Ce choix de 5 points est crucial car le produit de deux polynômes de degré 2 est un polynôme de degré 4, qui nécessite 5 points pour être défini.
Les points standards sont :

P(0) = X0
P(1) = X0 + X1 + X2
P(-1) = X0 - X1 + X2
P(2) = X0 + 2*X1 + 4*X2
P(inf) = X2

(On procède de manière similaire pour Q.)

Ensuite nous multiplions récursivement chaque points de P et de Q ensemble.
On effectue ainsi 5 multiplications de nombres plus petits au lieu des 9 multiplications requises par la méthode classique.

Après, nous effectuons une interpolation, cela permet de retrouver les 5 coefficients (w_0, w_1, w_2, w_3, w_4) du polynôme produit R(z) à partir des valeurs évaluées calculées précédemment.
On résout un système d'équations linéaires : <math> R(z) = w_4 z^4 + w_3 z^3 + w_2 z^2 + w_1 z + w_0 </math>
Finalement nous pouvons recomposer notre grand entier en positionnant les coefficients w_i aux bons rangs (en les décalant) et à gérer les retenues lors de l'addition finale:
<math>Résultat = w_4 B^{4k} + w_3 B^{3k} + w_2 B^{2k} + w_1 B^k + w_0</math>

=== B) Graphique ===

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Toomcook.png|500px]]
<div><b>Karatsuba</b></div>
</div>
<div style="max-width:800px;">
<p>on a reprit multi récursive (rouge)</p>
<p>on voit que Toom (vert) en dessous de karatsuba (jaune) en dessous de multi classique (rouge)</p>
<p>meilleur complexité</p>
</div>
</div>

== 5) La transformée de Fourier rapide ==

=== A) Fonctionnement ===

La transformation de Fourier rapide étant plus complexe que les autres algorithmes, nous allons essayer d'expliquer son fonctionnement malgré ne pas avoir réussi à l'implémenter.

Il faut comprendre que cet algorithme va considérer les facteurs comme des polynômes.

D'après le théorème de l'unisolvance, il n'existe qu'un seul polynôme de degré inférieur ou égal à <math> n </math> défini par <math>n + 1</math> points distincts. Cela implique non seulement que nous pouvons représenter chaque entier par un polynôme, mais également que si nous pouvons retrouver <math>n + m + 1</math> points (avec <math>n</math> et <math>m</math> la longueur des facteurs) du polynômes issue du produit entre deux facteurs, nous pourrons le retrouver.

Soit un entier quelconque, de forme :

<math>a_n a_{n-1} (...) a_1 a_0</math>

Avec <math>a_i</math>, un chiffre composant le nombre en base 10, qui vaut en réalité dans le nombre : <math>a_i \times 10^i</math>. On peut ainsi l'écrire sous la forme :

<math> P(x) = a_0 + a_1x + a_2x^2 + \dots + a_{n-1}x^{n-1} + a_nx^n </math>

Avec <math>x = 10</math> car nous sommes en base 10, nous obtenons :

<math>P(10) = a_0 + a_1 \times 10 + \dots + a_{n-1}10^{n-1} + a_n10^n </math>

Nous venons ainsi d'écrire notre nombre sous la forme d'un polynôme unique. Pour nous permettre d'évaluer en un nombre suffisant de points, nous allons devoir ajouter des 0 pour la récursion. Il nous faudra ajouter assez de 0 pour atteindre la prochaine puissance de 2 qui sera supérieure ou égale à <math>2n + 1</math>. L'ajout de 0 ne change pas le nombre car <math>0 \times x^n</math> n'ajoute pas de coefficient.

Cet algorithme est récursif et va segmenter en deux parties nos polynômes à chaque récursion. D'un coté les indice paires et d'un coté les impaires.

Ainsi prenons les nombres 1234 et 5678, ces nombres sont respectivement représentés par les polynômes <math> P(x) = 4 + 3x + 2x^2 + x^3 </math> et <math> P(x) = 8 + 7x + 6x^2 + 5^3 </math>. Ce sont des polynômes de degré 3, ainsi leur produit donnera lieu à un polynôme de degré 6. Il nous faudra donc au minimum 7 points d'évaluation pour retrouve ce produit. De ce fait, en les représentant de la manière suivante :

<math>[4, 3, 2, 1, 0, 0, 0, 0]</math>
<math>[8, 7, 6, 5, 0, 0, 0, 0]</math>

Nous aurons assez de récursions possible pour les évaluer en un nombre suffisant de points différents car nous auront 3 récursions à faire pour atteindre notre cas de base. A chaque récursion, nous allons diviser nos polynômes en deux parties ce qui nous fait 8 feuilles à la dernière récursion.

En effet à chaque étape de la récursion nous allons séparer nos polynômes en deux tel que :

<math> P(x)=P_{pair}x^2 + x \times P_{impair}x^2 </math>

Durant les récursions, nous segmentons les polynômes mais ne les évaluons pas. C'est à la remonté des récursions que nous allons réellement évaluer nos polynômes. Lorsque l'on atteint notre cas de base, c'est à dire des polynômes de degré 0, nous remarquons qu'ils sont constants, nous n'avons donc pas besoin de les évaluer. En effet, peut importe le point en lequel nous voudrons l'évaluer, le polynôme renverra la constante. Nous la renvoyons donc seule.
Ensuite commence la remontée des récursions. A l'étape 1 de notre remontée nous allons reformer le polynôme précédemment séparé pour obtenir un polynôme de degré 1. Puis, nous évaluons ce polynôme avec les racines seconde de l'unité. Nous faisons à nouveau remonté les évaluations et recombinons à nouveau le polynôme qui sera ainsi de degré 2.
Nous l'évaluons maintenant avec les racines 4eme de l'unité. A chaque évaluation, nous réutilisons les résultats précédents, cela nous est permit par les racines de l'unité qui ont une structure récursive exploitable.

Finalement, nous arrivons à la fin de notre FFT, avec une représentation fréquentielle de la forme :

<math> [P(W_0), P(W_1), (...), P(W_n-1), P(W_n)] </math>

Cette représentation fréquentielle n'est autre que les évaluations du polynôme P aux racines nièmes de l'unité. Nous avons donc maintenant au minimum <math>2n+1</math> évaluations des polynômes facteurs. Il nous faut maintenant trouver les évaluations du produit final, c'est à dire les évaluations concernant le polynôme qui sera issue de la multiplication. On pourra ainsi le retrouver.

Soit <math>C</math> un polynome tel que <math> C = A \times B </math>, alors on a :

<math> C(x) = A(x) \times B(x) </math>

Ainsi on en déduit que <math> C(W_n^k) = A(W_n^k) \times B(W_n^k) </math>

On comprend donc que <math>FFT(C) = FFT(A) \times FFT(B)</math>

Il faut préciser que l'on fait le produit de FFT(A) et FFT(B) terme à terme, soit évaluation par évaluation.

Une fois en possession de <math>FFT(C)</math>, qui n'est autre que l'évaluation de notre polynôme final en un nombre suffisant de points pour le retrouver, nous pouvons faire l'<math>IFFT(FFT(C))</math>, qui va nous permettre de retrouver les coefficients de notre polynôme en faisant l'exacte inverse de la FFT.

Une fois les coefficients retrouvés, il nous suffit de gérer les retenues, et nous retrouvons un entier de la forme : <math>a_0 a_1 (...) a_{n-1} a_n</math>

=== B) Graphique ===

( A FAIRE )
(on aura pas de courbe par contre)

= II - Produit de matrices =

== 1.1) naïve ==

La multiplication naïve de matrice requiert d'avoir des tailles de lignes/colonne semblable, ensuite pour chaque membre de la matrice résultat, on doit multiplier les composantes ligne de la première matrice par les composantes colonne de la deuxième et le tout sommé.

On en déduit la formule suivante:
<math>C_{i,j} = \sum_{k=1}^{n} (A_{i,k} \times B_{k,j})</math>

Et visuellement:

[[Fichier:Matricenaive.jpeg]]

On a donc un algorithme d'ordre de complexité <math>\mathcal{O}(g(n))</math>

== 1.2) naïve récursive ==

Dans un premier temps on doit découper nos deux matrices en quatres sous matrices de plus petite taille.
<math>A = \begin{pmatrix} A_{11} & A_{12} \ A_{21} & A_{22} \end{pmatrix}</math>
<math>B = \begin{pmatrix} B_{11} & B_{12} \ B_{21} & B_{22} \end{pmatrix}</math>

Ensuite on vient calculer la matrice résultat.
<math>C_{11} = (A_{11} \times B_{11}) + (A_{12} \times B_{21})</math>
<math>C_{12} = (A_{11} \times B_{12}) + (A_{12} \times B_{22})</math>
<math>C_{21} = (A_{21} \times B_{11}) + (A_{22} \times B_{21})</math>
<math>C_{22} = (A_{21} \times B_{12}) + (A_{22} \times B_{22})</math>

Le côté récursif est utile que pour les matrices de tailles <= 32 (32 valeurs stockées dedans),
si on est au dessus de cette taille alors on divisera à nouveau nos matrices en quatres.
On aura 8 multiplications mais de plus petite taille au final.

== 2) strassen ==

=== A) Fonctionnement ===

Strassen consiste à définir 7 produits intermédiaires qui, par des jeux de sommes et de différences, permettent de reconstruire les quadrants de la matrice résultante. On passe ainsi d'une complexité de O(n^3) à environ O(n^2.81)

=== B) Graphique ===

On voit bien la différence de complexité sur la multiplication de grande matrice entre l'approche naïve et l'approche récursive qui est beaucoup plus rapide.

[[Fichier:Analyse matrices.png]]

= Conclusion =

( A FAIRE )

= Mentions =

Le premier gif est le résultat du travail de 'Walké', licence ci-contre : https://fr.wikipedia.org/wiki/Fichier:Addition.gif

= Sources =

Pour karatsuba : https://www.youtube.com/watch?v=PZ2gdWdKHAA

Pour mieux comprendre la FFT, nous avons utilisé plusieurs sources d'informations :

https://www.youtube.com/watch?v=h7apO7q16V0&list=WL&index=1&t=886s

https://fr.wikipedia.org/wiki/Interpolation_polynomiale

Algorithmes de multiplications d'entiers et de matrices

2026-05-11T11:45:44Z

Mangala : /* A) Fonctionnement */

= Introduction =

Depuis l'apparition des ordinateurs modernes, une quantité faramineuse de calcul a dû être effectuée. Les progressions technologiques nous poussent à envisager la puissance de calcul comme une ressource qu'il faut optimiser dans les moindres détails. C'est ainsi que l'optimisation des algorithmes de calcul est devenue cruciale, surtout lorsqu'il nous faut effectuer des opérations sur de très grands entiers par exemple.

= Objectif =

L'objectif majeur de ce projet est de comprendre de manière plus approfondie ce qu'est la '''complexité algorithmique'''.
Pour atteindre cet objectif, nous implémenterons plusieurs algorithmes de multiplication qui auront pour but de calculer le produit de grands entiers ou de matrices.

= Point important : complexité =

=== Définition ===
La complexité d'un algorithme est la quantité des ressources qu'il utilise en fonction de la taille des entrée qu'on lui demande de traiter. On peut par exemple se concentrer sur le temps qu'un algorithme prend pour renvoyer un résultat ou sur la mémoire dont il a besoin. Dans le cadre de notre projet, nous nous attarderons plus particulièrement sur la quantité de calcul effectuée en fonction de la taille des entrées, ce qui est par ailleurs fortement liée à la notion de temps. De manière générale, plus un algorithme doit faire de calcul, plus il est lent. (Attention, toutes les opérations arithmétiques de base ne se valent pas)

De manière plus familière, on dira que la complexité d'un algorithme pourrait s'apparenter à son comportement lorsqu'il doit traiter des données plus ou moins grandes.
Chaque algorithme a une complexité, et on l'exprime par une fonction qui adopte un comportement similaire au nombre de calcul nécessaire en fonction de la taille des entrées.

=== Notation ===
La complexité réelle d'un algorithme peut être décrite par une fonction <math>f(n)</math> représentant le nombre d'opérations effectuées en fonction de la taille <math>n</math> des données d'entrée.

Cependant, afin de simplifier l'étude de cette croissance, on utilise généralement une borne asymptotique notée <math>\mathcal{O}(g(n))</math>, où <math>g(n)</math> est une fonction ayant le même ordre de grandeur que <math>f(n)</math> lorsque <math>n</math> devient grand.

On dit alors que :

<math>
f(n)\in\mathcal{O}(g(n))
</math>

si et seulement s'il existe une constante <math>C>0</math> et un entier <math>n_0</math> tels que :

<math>
\forall n\ge n_0,\ f(n)\le Cg(n)
</math>

Cette notation <math>\mathcal{O}(g(n))</math> permettra de comparer beaucoup plus facilement les algorithmes entre eux.

=== Master Theorem ===

Afin de déterminer la complexité de certains algorithmes récursifs, nous utiliserons le "Master Theorem".

Ce théorème permet d'obtenir directement l'ordre de grandeur de nombreuses relations de récurrence apparaissant dans l'analyse d'algorithmes de type « diviser pour régner », comme l'algorithme de Karatsuba ou celui de Strassen.

La démonstration complète de ce théorème dépasse le cadre de notre projet et nécessite des connaissances mathématiques plus avancées. Nous l'utiliserons donc principalement comme un outil nous permettant de déterminer efficacement la complexité asymptotique des algorithmes étudiés.

=== Graphiques ===

Les complexités étant des fonctions, nous pouvons les représenter par un graphique qui affichera le temps d'exécution (ou nombre d'opérations) en fonction de la taille des entrées.

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:30px; text-align:center;">
[[Fichier:complexite.webp|500px]]
<div><b>Graphiques des complexités</b></div>
</div>
<div style="max-width:800px;">
<p>Ce graphique ci-contre compare les complexités en fonction de la taille des d'entrées.</p>
<p>On comprend ainsi que certaines complexités ne sont pas raisonnable dans la cadre de la multiplication de grands entiers.</p>
<p>C'est pourquoi l'étude de ces algorithmes s'avère nécessaire.</p>
</div>
</div>

=== Exemple ===
L'algorithme naïf d'addition que nous avons tous appris à l'école a une complexité de <math>\mathcal{O}(n)</math>.
Soit n la taille des nombres en entrée, l'algorithme doit faire environ n addition pour arriver au résultat demandé.

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Addition.gif|220px]]
<div><b>Addition naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Comme le montre l'exemple ci-contre, 786 et 467 font 3 chiffres de long donc n sera de 3.</p>
<p>Il nous faudra 3 opérations pour additionner ces deux nombres.</p>
<p>C'est ainsi qu'avec une taille d'entrée n, l'algorithme de l'addition naïve va devoir faire n opérations.</p>
<p>Cette algorithme a donc une complexité <math>f(n) = n</math> qui n'a pas besoin d'être approximée.</p>
<p>Ainsi sa complexité finale sera <math>\mathcal{O}(n)</math>.</p>
</div>
</div>

= Problématique =

Le calcul du produit de deux entiers de manière naïve a une complexité de <math> \mathcal{O}(n^2)</math>, et celui de deux matrices une complexité de <math> \mathcal{O}(n^3)</math>. Afin de mieux comprendre ce qu'est la complexité algorithmique, nous devrons implémenter des algorithmes ayant le même objectif, mais étant plus efficaces. Ces algorithmes s'avèreront plus complexes mais devrait aboutir à un calcul plus rapide du produit demandé.

Nous séparerons notre wiki en deux grandes parties, la première concernera nos recherche sur [[#I - Produit d'entiers|la multiplication d'entiers]], la deuxième sur [[#II - Produit de matrices|la multiplication de matrices]].

= I - Produit d'entiers =

Notre départ commence avec l'algorithme de multiplication d'entier naïf.
En effet il s'agit de l'algorithme de multiplication le plus connu, et nous l'utiliserons comme référence pour le comparer aux futurs algorithmes plus efficaces.
Intéressons nous à sa complexité.

== 1) Nos implémentations des grands entiers ==

Qui dit produit de grands entiers dit implémentation de grands entiers.

Dans le cadre de nos recherches, nous allons devoir implémenter des algorithmes qui vont manipuler des grands entiers.

Nous avons donc choisi de créer deux représentations différentes de ceux-ci (car nous travaillons sur différents langages de programmation), nous permettant à la fois une implémentation simplifié, mais aussi de nous rapprocher d'une implémentation bas niveau.

=== A) En python ===
En python, l'utilisation des "bytes" m'a grandement servi à comprendre comment les entiers étaient manipulés à bas niveau. En effet, un des objectifs secondaires de nos recherches était de manipuler des entiers directement avec leur formes stockées sur l'ordinateur, et non pas avec des int python.
En effet l'utilisation des int python nous aurait permit de passer les étapes de retenues, de signes... D'autant plus que les bytes permettent de stocker un nombre en base 256, ce qui permet de visualiser plus facilement les grands entiers.

La forme finale de la représentation des grands entiers en python sera donc la suivante :

[ signe , bytes , bytes , (...) , bytes ]

Le signe est représenté par un entier, 1 si le nombre est positif, 0 sinon.
Cette configuration rendra plus simple la gestion des signes.

=== B) En C++ ===

En C++, pour avoir une représentation de grand entiers j'ai du définir ma propre structure pour m'affranchir de la limite de taille imposé par les entiers standards: (int32 ou int64). Pour cela, j'ai une structure qui possède l'équivalent d'un array de byte (ce qui nous permet d'être en base 256 au lieu de la base 10 habituelle), et pour traiter le signe j'utilise un booléen, ainsi en mémoire j'ai une structure de n*Octets + 1 octet en taille.

[ bytes , bytes , (...) , bytes ] [ signe ]

Le booléen prend 1 octet de place mais ne touche pas aux octets qui encode le grand entier.
Cette configuration rendra plus simple la gestion des signes dans le cadre des multiplication.

== 2) La multiplication naïve ==

=== A) Fonctionnement ===
Dans le cas de la multiplication d'entiers, nous allons prendre deux nombres qui n'ont pas nécessairement la même longueur. Soit les nombre a et b, de longueur respective <math>n</math> et <math> m </math>.
<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Multiplication.png|220px]]
<div><b>Multiplication naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Prenons deux nombres de longueur 3 et 2, et cherchons combien d'opérations l'algorithme de multiplication naïve va devoir faire pour nous renvoyer leur produit.</p>
<p>Dans un premier temps, on remarque que l'on va devoir multiplier chaque chiffre du nombre du haut par le chiffre des unités du bas, qui est 6. Cela va représenter <math>n</math> opérations. (6x5, 6x1 et 6x4)</p>
<p>Dans un deuxième temps nous constatons que nous allons devoir faire la même chose avec le chiffre des dizaines du nombre du bas. Cela nous ajoute de nouveau <math>n</math> opérations.</p>
<p>On arrive assez facilement à la conclusion que pour faire notre produit, il va nous falloir faire <math>n</math> fois <math>m</math> opérations.</p>
</div>
</div>

Ainsi, la complexité de la multiplication naïve est <math>\mathcal{O}(n^2)</math>.
Il est en de même avec la multiplication naïve récursive.

=== B) Graphique ===
Montrons maintenant sa courbe sur un graphique :

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Multiplicationnaive.png|500px]]
<div><b>Multiplication naïve</b></div>
</div>
<div style="max-width:800px;">
<p>Les points noirs sont des repères pour que les autres courbes aient une forme cohérente.</p>
<p>Ils sont tous sur l'axe des abscisses.</p>
<p>La courbe rouge représente la complexité de la multiplication naïve.</p>
<p>On remarque que la courbe a un visuel très similaire à la fonction <math>f(x) = x^2</math> </p>
</div>
</div>

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Naif_recursif.png|500px]]
<div><b>Multiplication naïve récursive</b></div>
</div>
<div style="max-width:800px;">
<p>La courbe rouge représente la complexité de la multiplication naïve récursive.</p>
<p>Elle sera utilisé pour comparer les complexités entre algorithmes car, comme tous récursifs, elle a été codé avec les mêmes biais d'implémentation qu'eux.</p>
<p>Théoriquement les deux courbes ci-contre ont la même complexité, mais encore une fois, notre implémentation n'est pas parfaitement optimale et donc ne respecte pas de manière minutieuse le Master Theorem.</p>
</div>
</div>

== 3) La multiplication karastuba ==

=== A) Fonctionnement ===

L'algorithme de karatsuba est un algorithme récursif de type diviser pour régner.

L'idée générale de l'algorithme est de passer de 4 multiplication à 3. En effet ces opérations étant moins couteuses, il est préférable d'en ajouter si cela permet d'enlever des multiplications.

L'algorithme de multiplication naif récursif utilise la segmentation des facteurs en deux de manière successive.

Soit <math>x</math> et <math>y</math> deux facteurs, nous avons les égalités suivantes :

<div style="font-size: 20px;">
<math>x = a \times B^{n/2} + b</math>
<math>y = c \times B^{n/2} + d</math>
</div>

Avec <math>a</math> et <math>c</math> les premières moitiés des facteurs <math>x</math> et <math>y</math>,
et <math>b</math> et <math>d</math> les dernières moitiés de ces facteurs ainsi que <math>B</math> la base d'écriture du nombre (Nous sommes en base 256 avec les bytes).

Cette présentation des deux facteurs de notre multiplication n'est que la résultante d'un découpage.
Le [[#Master Theorem|Master Theorem]] nous montre que :

<div style="font-size: 20px;">
<math>T(n) = 4T(n/2) + O(n)</math>
</div>

Puisque nous avons après découpage 4 entiers de longueur <math>n/2</math>.

Ainsi, ce découpage ne permet pas de gagner du temps d'après le [[#Master Theorem|Master Theorem]].

Cependant, l'algorithme de Karatsuba réutilise ce principe en le modifiant, ce qui nous permet de baisser la complexité globale de la multiplication dans son entièreté.

Avec l'écriture ci-dessus des nombres <math>x</math> et <math>y</math>, on peut facilement en déduire l'égalité suivante :

<div style="font-size: 20px;">
<math>x \times y = (ac) \times B^n + (ad + bc) \times B^{n/2} + bd</math>
</div>

On remarque 4 multiplications longues à faire dans cette expression. Les multiplications dont <math>B</math> est l'un des facteurs sont très rapides puisqu'il s'agit de la base dans laquelle nous travaillons. De cela en résulte un décalage plutôt qu'un vrai calcul à faire.

Karatsuba développe une partie de cette expression pour pouvoir négocier une multiplication au prix d'additions et soustractions.

En effet, nous savons déjà que :

<div style="font-size: 20px;">
<math>(a + b)(c + d) = ac + ad + bc + bd</math>
</div>

En manipulant l'égalité nous obtenons :

<div style="font-size: 20px;">
<math>ad + bc = (a + b)(c + d) - ac - bd</math>
</div>

ac et bd ayant déjà été calculé précédemment, il nous reste uniquement la multiplication <math>(a + b)(c + d)</math>.

Nous venons ainsi de calculer <math>ad + bc</math> en seulement une multiplication. C'est la que repose le gain de temps de la méthode Karatsuba par rapport à la multiplication naïve.

En effet, l'algorithme n'effectuera alors plus que 3 multiplications :
<div style="font-size: 20px;">
<math>ac</math>
<math>bd</math>
<math>(a + b)(c + d)</math>
</div>

La relation de récurrence devient donc :
<div style="font-size: 20px;">
<math>T(n)=3T(n/2)+O(n)</math>
</div>

Et le Master Theorem nous dit que :
<div style="font-size: 20px;">
<math>T(n)\in O(n^{\log_2(3)})</math>
</div>

Or <math>\log_2(3)\approx 1.585</math>, donc la complexité de l'algorithme de Karatsuba est de <math> \mathcal{O}(n^{1.585})</math>. Ce qui est bien plus efficace que la multiplication classique, surtout lorsque les facteurs deviennent très grands.

=== B) Graphique ===
<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Karatsuba.png|500px]]
<div><b>Karatsuba</b></div>
</div>
<div style="max-width:800px;">
<p>Sur le graphique ci-contre nous avons utilisé la courbe de la multiplication naïve récursive (rouge) à titre de comparaison.</p>
<p>On remarque graphiquement que Karatsuba (jaune) prend moins de temps à chaque calcul de produit.</p>
<p>On en déduit donc expérimentalement que Karatsuba à une meilleure complexité que la multiplication naïve.</p>
<p>Ainsi nous vérifions donc ce que le Master Theorem prouve, c'est à dire que la complexité de karatsuba est de <math> \mathcal{O}(n^{1.585})</math> </p>
</div>
</div>

== 4) La multiplication toom-cook-3 ==

=== A) Fonctionnement ===

L'objectif est de diviser les grands entiers X et Y en trois blocs de taille égale k.
On les traite alors comme des polynômes de degré 2:

<math>P(z) = X_2 \cdot z^2 + X_1 \cdot z + X_0</math>
<math>Q(z) = Y_2 \cdot z^2 + Y_1 \cdot z + Y_0</math>

On choisit 5 points distincts pour évaluer nos polynômes.
Ce choix de 5 points est crucial car le produit de deux polynômes de degré 2 est un polynôme de degré 4, qui nécessite 5 points pour être défini.
Les points standards sont :

P(0) = X0
P(1) = X0 + X1 + X2
P(-1) = X0 - X1 + X2
P(2) = X0 + 2*X1 + 4*X2
P(inf) = X2

(On procède de manière similaire pour Q.)

Ensuite nous multiplions récursivement chaque points de P et de Q ensemble.
On effectue ainsi 5 multiplications de nombres plus petits au lieu des 9 multiplications requises par la méthode classique.

Après, nous effectuons une interpolation, cela permet de retrouver les 5 coefficients (w_0, w_1, w_2, w_3, w_4) du polynôme produit R(z) à partir des valeurs évaluées calculées précédemment.
On résout un système d'équations linéaires : <math> R(z) = w_4 z^4 + w_3 z^3 + w_2 z^2 + w_1 z + w_0 </math>
Finalement nous pouvons recomposer notre grand entier en positionnant les coefficients w_i aux bons rangs (en les décalant) et à gérer les retenues lors de l'addition finale:
<math>Résultat = w_4 B^{4k} + w_3 B^{3k} + w_2 B^{2k} + w_1 B^k + w_0</math>

=== B) Graphique ===

<div style="display:flex; flex-direction: row; align-items: center; justify-content: center">
<div style="display:inline-block; margin:20px; text-align:center;">
[[Fichier:Toomcook.png|500px]]
<div><b>Karatsuba</b></div>
</div>
<div style="max-width:800px;">
<p>on a reprit multi récursive (rouge)</p>
<p>on voit que Toom (vert) en dessous de karatsuba (jaune) en dessous de multi classique (rouge)</p>
<p>meilleur complexité</p>
</div>
</div>

== 5) La transformée de Fourier rapide ==

=== A) Fonctionnement ===

La transformation de Fourier rapide étant plus complexe que les autres algorithmes, nous allons essayer d'expliquer son fonctionnement malgré ne pas avoir réussi à l'implémenter.

Il faut comprendre que cet algorithme va considérer les facteurs comme des polynômes.

D'après le théorème de l'unisolvance, il n'existe qu'un seul polynôme de degré inférieur ou égal à <math> n </math> défini par <math>n + 1</math> points distincts. Cela implique non seulement que nous pouvons représenter chaque entier par un polynôme, mais également que si nous pouvons retrouver <math>n + m + 1</math> points (avec <math>n</math> et <math>m</math> la longueur des facteurs) du polynômes issue du produit entre deux facteurs, nous pourrons le retrouver.

Soit un entier quelconque, de forme :

<math>a_n a_{n-1} (...) a_1 a_0</math>

Avec <math>a_i</math>, un chiffre composant le nombre en base 10, qui vaut en réalité dans le nombre : <math>a_i \times 10^i</math>. On peut ainsi l'écrire sous la forme :

<math> P(x) = a_0 + a_1x + a_2x^2 + \dots + a_{n-1}x^{n-1} + a_nx^n </math>

Avec <math>x = 10</math> car nous sommes en base 10, nous obtenons :

<math>P(10) = a_0 + a_1 \times 10 + \dots + a_{n-1}10^{n-1} + a_n10^n </math>

Nous venons ainsi d'écrire notre nombre sous la forme d'un polynôme unique. Pour nous permettre d'évaluer en un nombre suffisant de points, nous allons devoir ajouter des 0 pour la récursion. Il nous faudra ajouter assez de 0 pour atteindre la prochaine puissance de 2 qui sera supérieure ou égale à <math>2n + 1</math>. L'ajout de 0 ne change pas le nombre car <math>0 \times x^n</math> n'ajoute pas de coefficient.

Cet algorithme est récursif et va segmenter en deux parties nos polynômes à chaque récursion. D'un coté les indice paires et d'un coté les impaires.

Ainsi prenons les nombres 1234 et 5678, ces nombres sont respectivement représentés par les polynômes <math> P(x) = 4 + 3x + 2x^2 + x^3 </math> et <math> P(x) = 8 + 7x + 6x^2 + 5^3 </math>. Ce sont des polynômes de degré 3, ainsi leur produit donnera lieu à un polynôme de degré 6. Il nous faudra donc au minimum 7 points d'évaluation pour retrouve ce produit. De ce fait, en les représentant de la manière suivante :

<math>[4, 3, 2, 1, 0, 0, 0, 0]</math>
<math>[8, 7, 6, 5, 0, 0, 0, 0]</math>

Nous aurons assez de récursions possible pour les évaluer en un nombre suffisant de points différents car nous auront 3 récursions à faire pour atteindre notre cas de base. A chaque récursion, nous allons diviser nos polynômes en deux parties ce qui nous fait 8 feuilles à la dernière récursion.

En effet à chaque étape de la récursion nous allons séparer nos polynômes en deux tel que :

<math> P(x)=P_{pair}(x^2) + x \times P_{impair}(x^2) </math>

Durant les récursions, nous segmentons les polynômes mais ne les évaluons pas. C'est à la remonté des récursions que nous allons réellement évaluer nos polynômes. Lorsque l'on atteint notre cas de base, c'est à dire des polynômes de degré 0, nous remarquons qu'ils sont constants, nous n'avons donc pas besoin de les évaluer. En effet, peut importe le point en lequel nous voudrons l'évaluer, le polynôme renverra la constante. Nous la renvoyons donc seule.
Ensuite commence la remontée des récursions. A l'étape 1 de notre remontée nous allons reformer le polynôme précédemment séparé pour obtenir un polynôme de degré 1. Puis, nous évaluons ce polynôme avec les racines seconde de l'unité. Nous faisons à nouveau remonté les évaluations et recombinons à nouveau le polynôme qui sera ainsi de degré 2.
Nous l'évaluons maintenant avec les racines 4eme de l'unité. A chaque évaluation, nous réutilisons les résultats précédents, cela nous est permit par les racines de l'unité qui ont une structure récursive exploitable.

Finalement, nous arrivons à la fin de notre FFT, avec une représentation fréquentielle de la forme :

<math> [P(W_0), P(W_1), (...), P(W_n-1), P(W_n)] </math>

Cette représentation fréquentielle n'est autre que les évaluations du polynôme P aux racines nièmes de l'unité. Nous avons donc maintenant au minimum <math>2n+1</math> évaluations des polynômes facteurs. Il nous faut maintenant trouver les évaluations du produit final, c'est à dire les évaluations concernant le polynôme qui sera issue de la multiplication. On pourra ainsi le retrouver.

Soit <math>C</math> un polynome tel que <math> C = A \times B </math>, alors on a :

<math> C(x) = A(x) \times B(x) </math>

Ainsi on en déduit que <math> C(W_n^k) = A(W_n^k) \times B(W_n^k) </math>

On comprend donc que <math>FFT(C) = FFT(A) \times FFT(B)</math>

Il faut préciser que l'on fait le produit de FFT(A) et FFT(B) terme à terme, soit évaluation par évaluation.

Une fois en possession de <math>FFT(C)</math>, qui n'est autre que l'évaluation de notre polynôme final en un nombre suffisant de points pour le retrouver, nous pouvons faire l'<math>IFFT(FFT(C))</math>, qui va nous permettre de retrouver les coefficients de notre polynôme en faisant l'exacte inverse de la FFT.

Une fois les coefficients retrouvés, il nous suffit de gérer les retenues, et nous retrouvons un entier de la forme : <math>a_0 a_1 (...) a_{n-1} a_n</math>

=== B) Graphique ===

( A FAIRE )
(on aura pas de courbe par contre)

= II - Produit de matrices =

== 1.1) naïve ==

La multiplication naïve de matrice requiert d'avoir des tailles de lignes/colonne semblable, ensuite pour chaque membre de la matrice résultat, on doit multiplier les composantes ligne de la première matrice par les composantes colonne de la deuxième et le tout sommé.

On en déduit la formule suivante:
<math>C_{i,j} = \sum_{k=1}^{n} (A_{i,k} \times B_{k,j})</math>

Et visuellement:

[[Fichier:Matricenaive.jpeg]]

On a donc un algorithme d'ordre de complexité <math>\mathcal{O}(g(n))</math>

== 1.2) naïve récursive ==

Dans un premier temps on doit découper nos deux matrices en quatres sous matrices de plus petite taille.
<math>A = \begin{pmatrix} A_{11} & A_{12} \ A_{21} & A_{22} \end{pmatrix}</math>
<math>B = \begin{pmatrix} B_{11} & B_{12} \ B_{21} & B_{22} \end{pmatrix}</math>

Ensuite on vient calculer la matrice résultat.
<math>C_{11} = (A_{11} \times B_{11}) + (A_{12} \times B_{21})</math>
<math>C_{12} = (A_{11} \times B_{12}) + (A_{12} \times B_{22})</math>
<math>C_{21} = (A_{21} \times B_{11}) + (A_{22} \times B_{21})</math>
<math>C_{22} = (A_{21} \times B_{12}) + (A_{22} \times B_{22})</math>

Le côté récursif est utile que pour les matrices de tailles <= 32 (32 valeurs stockées dedans),
si on est au dessus de cette taille alors on divisera à nouveau nos matrices en quatres.
On aura 8 multiplications mais de plus petite taille au final.

== 2) strassen ==

=== A) Fonctionnement ===

Strassen consiste à définir 7 produits intermédiaires qui, par des jeux de sommes et de différences, permettent de reconstruire les quadrants de la matrice résultante. On passe ainsi d'une complexité de O(n^3) à environ O(n^2.81)

=== B) Graphique ===

On voit bien la différence de complexité sur la multiplication de grande matrice entre l'approche naïve et l'approche récursive qui est beaucoup plus rapide.

[[Fichier:Analyse matrices.png]]

= Conclusion =

( A FAIRE )

= Mentions =

Le premier gif est le résultat du travail de 'Walké', licence ci-contre : https://fr.wikipedia.org/wiki/Fichier:Addition.gif

= Sources =

Pour karatsuba : https://www.youtube.com/watch?v=PZ2gdWdKHAA

Pour mieux comprendre la FFT, nous avons utilisé plusieurs sources d'informations :

https://www.youtube.com/watch?v=h7apO7q16V0&list=WL&index=1&t=886s

https://fr.wikipedia.org/wiki/Interpolation_polynomiale