On généralise la méthode de Newton aux vecteurs. Mais on commence progressivement pour ceux qui ne sont pas habitués à utiliser des vecteurs. On commence par vectorialiser l'image de la fonction avec 3 dimension. La fonction appliqué à un réel `x` retourne un vecteur à 3 composantes. La variable d'état est maintenant un vecteur et se note `vec f` et elle comprend trois composantes qui sont des fonctions et qui sont des variables d'état notées `f_1,f_2,f_3` déterminées par la variable d'état `x`.
`vec f = ((f_1),(f_2),(f_3))`
`vec f"←"(x)`
`f_1"←"(x)`
`f_2"←"(x)`
`f_3"←"(x)`
Et donc nous avons par définition :
`vecf"="vec(f)(x)`
`f_1"="f_1(x)`
`f_2"="f_2(x)`
`f_3"="f_3(x)`
On suppose que la variable `vec f` est dérivable par rapport à `x`, une dérivée totale puisqu'elle ne dépend que de `x` et qui s'applique à chaque composante. Comme il n'y a qu'un seul paramètre, l'opérateur gradien est l'opérateur scalaire de dérivation exacte selon `x` :
`grad = d/(dx)`
La dérivé de `vecf` se note :
`vec(f’)=d/(dx)vec f = (dvecf)/(dx) = (((df_1)/(dx)), ((df_2)/(dx)), ((df_3)/(dx)) )=((f_1’ ),(f_2’ ),(f_3’ ))`
La dérivée de `vecf` selon `x` constitue une nouvelle variable d'état bien définie notée `vecf’` et est liée à `x`
`vec(f’)"←"(x)`
`vec(f) = ((f_1),(f_2),(f_3))` `vec(f’) = ((f_1’),(f_2’),(f_3’))`
Le développement de Taylor s'écrit ainsi :
`vec (f)(x"+"v) = vec (f) + vec(f’)v + vec(O)(v^2)`
C'est à dire en explicitant chaque vecteur, cela correspond à trois équations :
`f_1(x"+"v) = f_1 + f_1’ v + O(v^2)`
`f_2(x"+"v) = f_2 + f_2’ v + O(v^2)`
`f_3(x"+"v) = f_3 + f_3’ v + O(v^2)`
On pose une valeur `x` initiale et on cherche la variation `v` telle que `x"+"v` soit égale à une racine de `vecf`, c'est à dire telle que `vec(f)(x"+"v) "=" vec 0`. Le calcul se fait à `vec(O)(v^2)` prés.
`vec (f)(x"+"v) = 0`
`vec(f) + vec(f’)v = 0`
`vec(f’)v = - vec(f)`
`((f_1’),(f_2’),(f_3’)) v = -((f_1),(f_2),(f_3))`
Généralement, il n'y a pas de solution, les deux vecteurs `vecf` et `vec(f’)` ne sont pas colinéaires. Quelque soit `v` il y aura des écarts `e_1,e_2,e_3` pour chaque composante.
`vec(f) + vec(f’)v = vec e`
`((f_1),(f_2),(f_3))+((f_1’),(f_2’),(f_3’)) v = ((e_1),(e_2),(e_3))`
On fait une approximation par les moindres carrés, qui s'avèrera constituer une opération vectorielle simple. On choisie `v` tel que la somme des carrés des écarts noté `vartheta`, soit minimum. `vartheta` s'appelle le carré de l'erreur.
`vartheta = sum_(i=1)^3 e_i^2 = sum_(i=1)^3 (f_i+f_i'v)^2`
Ainsi le but change, il n'est plus de rechercher une racine `v`, mais de rechecher une valeur `v` tel que le carré de l'erreur `vec(f)(v)"·"vec(f)(v)` soit minimum.
Calculons la dérivée de `vartheta` selon `v`, sachant que `v` est posé comme étant indépendant de `x`, de `vec f` et de `vec(f')` :
`(del vartheta)/(del v) = sum_i del/(del v) (f_i+ f_i'v)^2`
`(del vartheta)/(del v) = sum_i 2(f_i+f_i'v) del/(del v)(f_i+f_i'v) `
`(del vartheta)/(del v) = 2sum_i (f_i+f_i'v)f_i'`
`(del vartheta)/(2del v) = sum_i (f_i f_i' + f_i'f_i'v)`
`(del vartheta)/(2del v) = sum_i f_i f_i' + vsum_i f_i'f_i'`
Notez que ni `x` ni `vec f` ni `vec f'` ne dépendent de `v`. Et donc pour que le carré de l'erreur, `vartheta`, soit minimum, il est nécessaire que sa dérivée partielle selon `v` soit nulle :
`(del vartheta)/(del v)= 0`
`sum_(i=1)^3 f_i f_i' + vsum_(i=1)^3 f_i'f_i'= 0`
`v= - (sum f_i f_i')/(sumf_i' f_i')`
De telles sommes se mettent sous forment d'un produit scalaire ou matriciel :
`sum f_i f_i' = f_1f’_1+f_2f’_2+f_3f’_3 = vecf"·"vecf’ = (f_1,f_2,f_3)((f’_1),(f’_2),(f’_3)) = vec(f)^t vec(f’)`
`sumf_i' f_i' = f’_1f’_1+f’_2f’_2+f’_3f’_3 = vec(f’)"·"vec(f’) = (f’_1,f’_2,f’_3)((f’_1),(f’_2),(f’_3)) = vec(f’)^t vec(f’)`
On obtient la formule vectorielle de Newton pour une fonction de `RR"→"RR^n` :
`v = - (vec(f)^t vec(f’))/(vec(f’)^t vec (f’))`
Récapitulons :
`vec (f)(x"+"v) =vec(f) + vec(f’)v = 0`
`vec(f’)v = - vec(f)`
`vec(f’)^tvec(f’)v = - vec(f’)^tvec(f)`
`v = - (vec(f’)^tvec(f’))^ -1 vec(f’)^tvec(f)`
Puis le résultat précédent peut s'écrire en utilisant le produit scalaire et en s'affranchissant des conventions du calcul matriciel :
`vec (f)(x"+"v) =vec(f) + vec(f’)v = 0`
`vec(f’)v = - vec(f)`
`vec(f’)"·"vec(f’)v = - vec(f’)"·"vec(f)`
`vec(f’)^2v = - vec(f’)"·"vec(f)`
`v = - (vec(f’)"·"vec(f))/(vec(f’)^2)`
Et en donnant la définition de la dérivée `f’=dvecf"/"dx`, le résultat s'écrit :
`v = - ((dvecf)/(dx)"·"vec(f))/(((dvecf)/(dx))^2)`
Les dérivées sont calculées empiriquement à partir d'un `epsilon_i` spécifique pour chaque composante `f_i` comme suit :
`f’_1 = (df_1)/(dx) ~~ (vec(f)(x"+"epsilon_1)-vec(f))/epsilon_1`
`f’_2 = (df_2)/(dx) ~~ (vec(f)(x"+"epsilon_2)-vec(f))/epsilon_1`
`f’_1 = (df_3)/(dx) ~~ (vec(f)(x"+"epsilon_3)-vec(f))/epsilon_1`
Le vecteurs d'échelle dans lequelle évolue `vec(f)(x)` d'une itération à une autre doit être le même que celui `vec epsilon` qui est utilisé pour calculer la dérivée de `vecf`. On remarque de façon empirique que le choix le plus simple est un bon choix :
`vec epsilon = vec(f) + vec(f’)v`
Néanmoins les composantes de la fonction `f` n'ont pas forcement la même échelle. Au départ on concoit que l'image de `f` est un espace euclidien muni de la distance canonique qui est la somme des carrés des composantes, mais il est possible de perfectionner la méthode, d'élargire son spectre d'application. Et la première amélioration consiste à considérer les échelles différentes pour chaque composante, un facteur d'échelle que l'on note `vec epsilon`. Ainsi pour chaque composante d'indice `i` il y a une échelle `epsilon_i`. Ces échelles se regroupe en un vecteur `vec epsilon`. On commence par transformer la fonction `f` afin que sont image soit d'échelle `1` pour chaque composante.
`M=((epsilon_1^-1,0,...,0), (0,epsilon_2^-1,...,0),(...,...,...,...),(0,0,...,epsilon_n^-1))`
`vec g = Mvec f`
La formule vectorielle de Newton se réécrit ainsi :
`v = - ((dvec(g))/(dx)"·"vec(g))/(((dvec(g))/(dx))^2)`
`v = - (M(dvecf)/(dx)"·"Mvec(f))/((M(dvecf)/(dx))^2)`
On définit le produit parallèle noté `"*"` de priorité syntaxique plus forte que le produit "·", telle que par exemple :
`((a),(b))"*"((x),(y)) = ((ax),(by))`
Ainsi nous avons :
`v = - (vec epsilon"*"(dvecf)/(dx)"·"vec epsilon"*"vec(f))/((vec epsilon"*"(dvecf)/(dx))^2)`
L'erreur
`vec epsilon := - (vec epsilon"*"(dvecf)/(dx)"*"vec epsilon"*"vec(f))/((vec epsilon"*"(dvecf)/(dx))^2)`
En signant l'échelle, on rend l'image strictement positive et on peut ajouter une deuxième généralisation qu'est l'échelle logarithmique de puissance `vec µ`. Ainsi pour chaque composante d'indice `i` il y a une échelle logarithmique de puissance `µ_i`. Ces puissances d'échelle se regroupe en un vecteur `vec µ`. On commence par transformer la fonction `f` afin que sont image soit de puissance d'échelle `1` pour chaque composante.
`g_1 = log_(µ_1)(f_1)`
`(dg_1)/dx = d log_(µ_1)(f_1) = (df_1)/(dx)1/(f ln(µ_1))`
---- 26 juillet 2021 ----
Étant donné une fonction `f` de `RR^3` vers `RR`. Nous voulons trouver de façon approchée une racine `vec x`, c'est à dire telle que `f(vec x)=0`. Le vecteur `vec x` comprend trois composantes :
On pose une valeur `vec x` initiale et on cherche une variation `vec v` telle que `vec x"+"vec v` soit égale à une racine de `f`, c'est à dire telle que `f(vec x"+"vec v) "=" vec 0`. Le calcul se fait à `O(vec v^2)` prés.
`f(vec x"+"vec v) = f + f’ vec v = 0`
`f’ vec v = - f`
`[(delf)/(del x_1), (delf)/(del x_2), (delf)/(del x_3)] [(v_1),(v_2),(v_3)] = -f`
`(delf)/(del x_1) v_1 + (delf)/(del x_2) v_2 + (delf)/(del x_3) v_3 = -f`
Notez que `f` est un scalaire, que `f’` est une matrice ligne, et que `vec(v)` est une matrice colonne.
`f’ =grad^t f = [(delf)/(del x_1), (delf)/(del x_2), (delf)/(del x_3)]`
`f’^"t"=grad f = [((delf)/(del x_1)), ((delf)/(del x_2)), ((delf)/(del x_3))]`
Il y a 3 inconnus `v_1,v_2,v_3` et une seule équation. Il y a donc une plétore de solutions. Laquelle choisire ?. L'idée consiste à procéder comme précédement, en multipliant à gauche chaque membre de l'équation par la transposée de la dérivée. Le produit d'un vecteur ligne par un vecteur colonne de même taille produit un scalaire :
`f’^t f’ = [((delf)/(del x_1)), ((delf)/(del x_2)), ((delf)/(del x_3))] [(delf)/(del x_1), (delf)/(del x_2), (delf)/(delx_3)] = ( (((delf)/(del x_1))^2, (delf)/(delx_1)(delf)/(delx_2), (delf)/(del x_1)(delf)/(delx_3)), ((delf)/(del x_1)(delf)/(delx_2), ((delf)/(delx_2))^2, (delf)/(del x_2)(delf)/(delx_3)), ((delf)/(delx_1)(delf)/(delx_3), (delf)/(delx_2)(delf)/(delx_3), ((delf)/(del x_3))^2))`
Et il ne serait pas étonnant que cette matrice soit non-inversible pour le seul cas où :
`(del f)/(del x_1) = (del f)/(del x_2) = (del f)/(del x_3) = 0`
On choisie la solution que l'on obtient en multipliant à gauche chaque membre de l'équation par la transposé de la dérivée :
`f(vec x"+"vec v) = 0`
`f + f’ vec v = 0`
`f’ vec v = - f`
`f’^t f’ vec v = - f’^t f`
`gradf grad^tf vec v = - grad f f`
`gradf"×"grad f vec v = - fgrad f`
` vec v = - f [gradf"×"grad f]^-1 gradf`
Notez que `(gradf"×"gradf)^-1` désigne la matrice inverse de `gradf"×"gradf`. Notez que le produit avec comme premier argument `grad` est prioritaire. Puis ce raisonnement peut s'écrire en s'affranchissant des conventions du calcul matriciel :
`f(vec x"+"vec v) = 0`
`f + gradf"·"vec v = 0`
`gradf"·"vec v = -f`
`gradfgradf"·"vec v = - gradf f`
`vec v = - f [gradfgradf]^-1"·"gradf`
Notez que `(gradfgradf)^-1` désigne le vecteur de vecteurs inverse de `gradfgradf`. Notez que le produit s'évalue de gauche à droite et est prioritaire au produit scalaire généralisé `"·"`. Récapitulons, nous avons à `O(vec v^2)` prés :
`f(vec x"+"vec v) = f + f’ vec v = 0`
`f’ vec v = - f`
`f’^t [f’ vec v]= - f’^t f`
`[f’^t f’] vec v= - f’^t f`
`( (((delf)/(del x_1))^2, (delf)/(delx_1)(delf)/(delx_2), (delf)/(del x_1)(delf)/(delx_3)), ((delf)/(del x_1)(delf)/(delx_2), ((delf)/(delx_2))^2, (delf)/(del x_2)(delf)/(delx_3)), ((delf)/(delx_1)(def)/(delx_3), (delf)/(delx_2)(delf)/(delx_3), ((delf)/(del x_3))^2)) [(v_1),(v_2),(v_3)] = - [((delf)/(del x_1)), ((delf)/(del x_2)), ((delf)/(del x_3))] f`
`(grad f)^ square vec v = -f [vec grad f] `
On ne calcul pas l'inverse de la matrice, mas on la diagonalise. On calcule `vecv` en résolvant cette équation linéaire à l'aide de l'algorithme par pivot.
On considère une fonction vectorielle `vec f` de `RR^3"→"RR^2`.
`vec f"←"(vec x)`
`vec f = ((f_1),(f_2))`
`f_1"←"(vec x)`
`f_2"←"(vec x)`
`vec x = ((x_1),(x_2),(x_3))`
La dérivée de `f` est une matrice notée `f’` qui est déterminée par `x`
`f’"←"(x)`
Elle peut se décomposer en un vecteur ligne de vecteurs colonnes :
`f’ = ( (del vec f)/(del x_1), (del vec f)/(del x_2),(del vec f)/(del x_3)) = ( ((delf_1)/(delx_1),(delf_1)/(delx_2),(delf_1)/(delx_3)),((delf_2)/(delx_1),(delf_2)/(delx_2),(delf_2)/(delx_3)))`
Et elle peut se décomposer en un vecteur colonne de vecteurs lignes :
`f’ = ((f_1’),(f_2’)) = ( (grad^t f_1),(grad^t f_2) ) = ( ((delf_1)/(delx_1),(delf_1)/(delx_2),(delf_1)/(delx_3)),((delf_2)/(delx_1),(delf_2)/(delx_2),(delf_2)/(delx_3)))`
`f’=(grad vec f^t)^t = (grad"×"vec f)^t= (((del/(delx_1)),(del/(delx_2)),(del/(delx_3)))(f_1,f_2))^t`
Le développement de Taylor donne l'approximation suivante à `O(vec v^2)` près :
`vec(f)(vec x"+" vec v) = vecf + f’ vec v`
On cherche la variation `vec v` telle que :
`vec(f)(vec x"+" vec v ) =0`
`vecf + f’ vec v=0`
`f’ vec v = - vecf`
On multiplie à gauche chaque membre de l'équation par la transposé de la dérivée :
`f’^t f’ vec v = - f’^t vecf`
`vec v = - (f’^t f’)^-1 f’^t vecf`
On ne calcul pas l'inverse de la matrice, juste on la diagonalise.
`f’^t f’ vec v = - f’^t vecf`
`( ((delf_1)/(delx_1),(delf_2)/(delx_1)),((delf_1)/(delx_2),(delf_2)/(delx_2)),((delf_1)/(delx_3),(delf_2)/(delx_3)) ) ( ((delf_1)/(delx_1),(delf_1)/(delx_2),(delf_1)/(delx_3)), ((delf_2)/(delx_1),(delf_2)/(delx_2),(delf_2)/(delx_3)) ) [(v_1),(v_2),(v_3)] = ( ((delf_1)/(delx_1),(delf_2)/(delx_1)),((delf_1)/(delx_2),(delf_2)/(delx_2)),((delf_1)/(delx_3),(delf_2)/(delx_3)) ) [(f_1),(f_2)]`
`f’^t f’ ` est une matrice carré. On résoud l'équation linéaire en `vecv` par l'algorithme du pivot.
---- 26 juillet 2021 ----