« Découvrir Scilab/Calcul numérique » : différence entre les versions

Contenu supprimé Contenu ajouté
export vers Résolutiond 'équations
export de Dé&rivation et Intégration
Ligne 1 :
<noinclude>{{NavTitre|book={{BASEPAGENAME}}|prev=Calculs élémentaires|next=RésolutionCalcul d'équationsdifférentiel et intégral}}</noinclude>
{{Scilab}}
 
Ligne 918 :
 
L'algorithme par défaut de <code>leastsq()</code> est l'algorithme de pseudo-Newton. On peut aussi utiliser l'[[w:Méthode du gradient conjugué|algorithme du gradient conjugué]] en ajoutant <code>"gc"</code> aux paramètres, ou bien algorithme foncitonnant avec les fonctions non-différentiables avec <code>"nd"</code>. On peut enfin utiliser la commande <code>lsqrsolve()</code>, qui utilise l'algorithme de Levenberg-Marquardt.
 
== Dérivation ==
 
La dérivation peut s'aborder de différentes manières selon les données disponibles.
 
=== Pour une fonction définie ===
 
S'il s'agit d'un polynôme ou d'une fraction rationnelle, la commande <code>derivat()</code> effectue la dérivée formelle, par exemple
<source lang="scilab">
-->q = (1 + %s^2)/(1+%s)
q =
2
1 + s
-----
1 + s
-->derivat(q)
ans =
2
- 1 + 2s + s
----------
2
1 + 2s + s
</source>
 
Si l'on dispose d'une fonction extérieure (définie par <code>function() … endfunction</code> ou bien par <code>deff()</code>), alors on peut utiliser la fonction <code>numderivative()</code><ref>les fonctions <code>derivative()</code> et <code>numdiff()</code> sont déclarées obsolètes et ont été supprimées à partir de la version 6</ref> pour obtenir l'approximation de la matrice jacobienne et hessienne :
<source lang="scilab">
-->deff("y = f(x)", "y = x.^2")
 
-->numderivative(f, 2) // f'(x) = 2*x ; J = f'(2) = 4
ans =
4.
 
-->[J, H] = numderivative(f, 2) // f''(x) = 2 ; H = f''(2) = 2
H =
2.
J =
4.
 
-->x=(1:3)';
 
-->numderivative(f, x)
ans =
2. 0. 0.
0. 4. 0.
0. 0. 6.
 
-->[J, H] = numderivative(f, x)
H =
2. 0. 0. 0. 0. 0. 0. 0. 0.
0. 0. 0. 0. 2. 0. 0. 0. 0.
0. 0. 0. 0. 0. 0. 0. 0. 2.
J =
2. 0. 0.
0. 4. 0.
0. 0. 6.
</source>
 
=== Pour une liste de valeurs ===
 
Si l'on dispose d'une liste de valeurs, typiquement un vecteur ''x'' et un vecteur ''y'' de même dimension, il faut alors distinguer plusieurs cas.
 
==== Valeurs peu bruitées ====
 
Si l'on suppose que le bruit est faible, donc que les valeurs sont « exactes », et que de plus la dérivée seconde est faible, alors on peut se contenter de déterminer les pentes entre les points, c'est-à-dire de calculer le taux de variation, faire une interpolation linéaire. Par exemple :
<source lang="scilab">
x = [0 2 5 20 40 60 80];
y = [0.0956820 0.0480457 0.0277857 0.0036214 0.0002543 0.0002543 0.0001265];
 
yprime = diff(y)./diff(x);
 
subplot(2, 1, 1)
plot(x, y)
 
subplot(2, 1, 2)
plot(x(1:$-1), yprime)
</source>
Si la dérivée seconde n'est pas négligeable, on peut alors utiliser une interpolation par un polynôme de degré trois (''spline'' cubique) :
<source lang="scilab">
yprime1 = splin(x, y);
 
subplot(2, 1, 2)
plot(x, yprime1, "r")
</source>
 
==== Valeurs bruitées : régression et lissage ====
 
Les méthodes ci-dessus sont très sensibles au bruit. Si les valeurs sont bruitées, alors il faut lisser la courbe d'une manière ou d'une autre.
 
Si l'on dispose d'un modèle analytique pour les données, on peut déterminer les paramètre de ce modèle par régression, voir la [[#Régression|section ci-dessus]]. Sinon, l'utilisation d'une ''spline'' par la commande <code>lsq_splin()</code> présentée [[#Lissage|ci-dessus]] permet également d'obtenir la dérivée : il suffit d'évaluer la ''spline'' avec la syntaxe suivante :
<source lang="scilab">
[yi, yprime2] = interp(x, xs, ys, d); // valeurs de la spline aux abscisses x
// et valeurs de la dérivée
</source>
 
[[Fichier:Savitzky-golay pic gaussien bruite.svg|vignette|Détermination des dérivée et dérivée seconde par l'algorithme de Savitzky-Golay.]]
 
L'algorithme de Savitzky-Golay présenté [[#Lissage|ci-dessus]] permet également d'obtenir la dérivée : comme on détermine localement un polynôme, on a les dérivées successives de ce polynôme.
 
== Intégration ==
 
=== Intégrale numérique ===
 
Scilab peut calculer <font id="integration1">l'intégrale numérique</span> d'une fonction entre deux bornes :
<source lang="scilab" id="integrate1">
integrate("expression", "x", x0, x1)
</source>
calcule l’intégrale de la fonction décrite par ''expression'' ; ''expression'' est une chaîne de caractères interprétable par Scilab, comme par exemple <code>"sin(x)"</code>. Le paramètre ''x'' est la variable d’intégration, et les bornes sont ''x0'' et ''x1''.
 
Par exemple :
 
<source lang="scilab">
// fonction carré
function [y] = f(x)
y = x.^2
endfunction
 
// intégrale entre 0 et 4
Y = integrate("f(x)", "x", 0, 4)
 
// vérification
Y1 = 4^3/3
</source>
On peut aussi utiliser la fonction <code>intg(a, b, f)</code> où ''a'' et ''b'' sont les bornes d'intégration. Avec l'exemple précédent :
<source lang="scilab">
-->Y = intg(0, 4, f)
Y =
21.333333
</source>
 
Il peut également effectuer une intégration numérique à partir d'une suite de points (''x''(''i''), ''y''(''i'')), par la méthode des trapèzes, avec la commande <code>inttrap()</code> :
<source lang="scilab">
x = linspace(0, 4, 50);
y = f(x);
inttrap(x, y)
</source>
 
=== Produit de convolution ===
 
Considérons deux suite de valeurs (vecteurs ligne) (''h<sub>i</sub>'')<sub>1 ≤ ''i'' ≤ ''m''</sub> et (''x<sub>i</sub>'')<sub>1 ≤ ''i'' ≤ ''n''</sub>, avec ''m'' &lt; ''n''. Le produit de convolution discret est défini par :
: <math>y_j = \sum_{i = 1}^m h_j \times x_{k + 1 - j}</math>
Il est obtenu par la commande <code>conv(h, x)</code> ou bien la commande <code>convol(h, x)</code>. Par exemple, pour convoluer une fonction sinus avec une fonction porte de largeur 5 points :
 
<source lang="scilab">
t = linspace(0, %pi, 50);
x = sin(t);
h = 1/5*ones(1, 5);
y = conv(h, x);
plot(x)
plot(y, "r")
</source>
 
Les commandes <code>conv</code> et <code>convol</code> n'utilisent pas le même algorithme. La fonction <code>convol</code> utilise la transformée de Fourier rapide, et est mieux adaptée lorsqu'il y a beaucoup de valeurs.
 
== Le problème de la précision et de l'exactitude ==