--- /dev/null
+\documentclass[10pt,a4paper,french]{article}
+\usepackage[francais]{babel}
+\usepackage[utf8]{inputenc}
+\usepackage{a4}
+\usepackage{amsmath}
+\usepackage{amsfonts}
+\usepackage{amssymb}
+\usepackage{framed}
+\usepackage{dsfont}
+\usepackage[amsmath,thmmarks,thref,framed]{ntheorem}
+\usepackage[dvips]{graphics}
+\usepackage{epsfig}
+\usepackage{calc}
+\usepackage{tabls}
+\usepackage{slashbox}
+\usepackage{times}
+\usepackage{multicol}
+\usepackage{tabularx}
+\usepackage{textcomp}
+
+\usepackage{pst-all}
+
+\usepackage[a4paper]{geometry}
+
+
+\date{}
+\geometry{hmargin=1cm, tmargin=1cm,bmargin=1.5cm}
+\begin{document}
+\title{UE MESI, Master IMR 2ème année.\\
+ Novembre 2012 (durée 1h). J.-F. Couchot,}
+
+\maketitle
+\vspace{-5em}
+\begin{tabular}{ll}
+Nom:& ........................................\\
+Prénom:& ........................................\\
+\end{tabular}
+
+
+On s'intéresse à résoudre une équation de la forme $f(x)=0$ par la
+méthode de Müller. Dans cette méthode, on considère que l'on
+a le triplet de points $(x_{n-2},x_{n-1},x_{n})$. Pour calculer
+$x_{n+1}$, on fait comme suit:
+\begin{enumerate}
+\item \label{itm:1} on approche $f(x)$ par un polynôme $P(x)$ aux points
+ $(x_{n-2},x_{n-1},x_{n})$,
+\item\label{itm:2} on résout l'équation $P(x)=0$. La racine la plus proche de $x_n$ est $x_{n+1}$;
+\item on recommence avec le triplet $(x_{n-1},x_{n},x_{n+1})$\ldots
+\end{enumerate}
+
+
+
+
+
+
+Vos réponses seront données directement ci-dessous.
+
+\begin{enumerate}
+
+\item En utilisant une base de Lagrange, montrer que le polynôme $P(x)$
+ obtenu à l'étape 1. de la première itération est défini par
+$$
+P(x) = \dfrac{(x-x_{n-1})(x-x_{n-2})f(x_n)}{(x_n-x_{n-1})(x_n-x_{n-2})} +
+\dfrac{(x-x_{n})(x-x_{n-2})f(x_{n-1})}{(x_{n-1}-x_{n})(x_{n-1}-x_{n-2})} +
+\dfrac{(x-x_{n})(x-x_{n-1})f(x_{n-2})}{(x_{n-2}-x_{n})(x_{n-2}-x_{n-1})}
+$$
+
+\vspace{4cm}
+
+\item Montrer que le polynôme de la question précédente est de degré 2.
+ Est-ce cohérent avec le fait qu'on veuille approximer $f$ en trois points?
+\vspace{4cm}
+
+\item Montrer que le polynôme de la première question peut s'écrire
+ sous la forme $P(x) = a_n x^2 + b_n x + c $ où
+\begin{eqnarray*}
+a_n & = & \dfrac{f(x_n)}{(x_n-x_{n-1})(x_n-x_{n-2})} +
+\dfrac{f(x_{n-1})}{(x_{n-1}-x_{n})(x_{n-1}-x_{n-2})} +
+\dfrac{f(x_{n-2})}{(x_{n-2}-x_{n})(x_{n-2}-x_{n-1})} \\
+b_n & = &-\dfrac{f(x_n)(x_{n-1}+x_{n-2})}{(x_n-x_{n-1})(x_n-x_{n-2})} -
+\dfrac{f(x_{n-1})(x_{n}+x_{n-2})}{(x_{n-1}-x_{n})(x_{n-1}-x_{n-2})} -
+\dfrac{f(x_{n-2})(x_{n}+x_{n-1})}{(x_{n-2}-x_{n})(x_{n-2}-x_{n-1})} \\
+c_n & = & \dfrac{f(x_n)x_{n-1}x_{n-2}}{(x_n-x_{n-1})(x_n-x_{n-2})} +
+\dfrac{f(x_{n-1})x_{n}x_{n-2}}{(x_{n-1}-x_{n})(x_{n-1}-x_{n-2})} +
+\dfrac{f(x_{n-2})x_{n}x_{n-1}}{(x_{n-2}-x_{n})(x_{n-2}-x_{n-1})}
+\end{eqnarray*}
+\vspace{8cm}
+
+
+\item Exprimer les deux racines $x'_{n}$ et $x''_{n}$ du polynôme précédent
+en fonctions de $a_n$, $b_n$ et $c_n$ lorsqu'on itère dans les réels.
+\vspace{3cm}
+
+\item Comment est alors défini $x_{n+1}$?
+\vspace{3cm}
+
+\item On pourrait montrer que l'ordre de la convergence est 1,84. Comparer cette vitesse de convergence avec celle de Newton et celle de Lagrange.
+\vspace{3cm}
+
+
+\item Donner le code Python de la fonction
+ $\verb+[n,X] = iteration_muller(x+_{\verb+0+},\verb+x+_{\verb+1+},\verb+x+_{\verb+2+}\verb+,m,epsilon,f)+$ où
+\begin{itemize}
+\item $\verb+x+_{\verb+0+}$, $\verb+x+_{\verb+1+}$ et $\verb+x+_{\verb+2+}$ sont les trois premières valeurs des itérés, \verb+m+
+ est le nombre maximal
+ d'itérations, \texttt{epsilon} est la précision souhaitée
+ et \verb+f+ la fonction à itérer;
+\item \verb+n+ est le nombre d'itérations réalisées pour que
+\verb+f(+$\verb+x+_{\verb+n+}$\verb+)+=0 ou que
+$|\verb+x+_{\verb+n+}- \verb+x+_{\verb+n-1+}| \leq \verb+epsilon+$, \verb+n+ étant inférieur à \verb+m+ et \verb+X+ est
+ le vecteur contenant les
+ valeurs $\verb+x+_{\verb+0+},\ldots,\verb+x+_{\verb+n+}$.
+\end{itemize}
+\end{enumerate}
+
+
+\end{document}
\ No newline at end of file
--- /dev/null
+% demo_affiche_courbe : ce script permet d'afficher des courbes\r
+% correspondant à des approximations d'équations différentielles.\r
+%\r
+% paramètres d'entrée : \r
+% * nombre de courbes ;\r
+% * la borne supérieure de l'intervalle d'étude T ; \r
+% * pour chacune de ces courbes, X un vecteur contenant les valeurs, déja calculées,\r
+% aux instants 0,h,2h,...,Nh=T.\r
+%\r
+\r
+%nombre de points pour l'affichage défini par ngra \r
+ngra=1000;\r
+\r
+T=input('entrez la borne supérieur de l''intervalle : ');\r
+nc=input('entrez le nombre de courbes d''erreurs à tracer : ');\r
+YY=cell(nc,1);\r
+xx=cell(nc,1);\r
+yy=cell(nc,1);\r
+for k=1:nc\r
+ YY{k}=input(['entrez le vecteur des valeurs de la courbe numero ',num2str(k),': ']);\r
+end\r
+for k=1:nc\r
+ N=length(YY{k})-1; \r
+ if (N<ngra)\r
+ h=T/N;\r
+ xx{k}=0:h:T; \r
+ yy{k}=YY{k};\r
+ else\r
+ h=T/N;\r
+ p=fix(N/ngra);\r
+ auxiy=YY{k};\r
+ yy{k}=[auxiy(1:p:N+1) auxiy(N+1)];\r
+ x=0:h:T;\r
+ xx{k}=[x(1:p:N+1) T];\r
+ end\r
+end\r
+chlegend='legend(';\r
+for k=1:nc-1\r
+ chlegend=[chlegend,'''courbe ',num2str(k),''',']; \r
+end\r
+chlegend=[chlegend,'''courbe ',num2str(nc),''',0)']; \r
+clf;\r
+hold on;\r
+for k=1:nc\r
+ plot(xx{k,1},yy{k,1},couleur7(k));\r
+end\r
+eval(chlegend);\r
+title('valeurs approchées');\r
+hold off;\r
+\r
+\r
+\r
+\r
--- /dev/null
+function Y=resout_euler_explicite(N,T,y0,fcn)\r
+% \r
+%\r
+%\r
+% resoud_euler_explicite : résolution d'une équation différentielle par la méthode d'Euler explicite.\r
+%\r
+% *********************************************************\r
+%\r
+% Y=resout_euler_explicite(N,T,y0,fcn) calcule les valeurs aux instants 0,h,2h,...,Nh=T par la méthode\r
+% d'Euler explicite pour l'équation différentielle y't)=f(t,y(t)) sur [0,T] et y(0)=y0.\r
+% \r
+% * variables d'entrées :\r
+% N : nombre de valeurs calculées ; \r
+% T : borne supérieure de l'intervalle ;\r
+% y0 : valeur de y à t=0 ;\r
+% fcn : chaine de caractères (de type 'f(t,y)') représentant la fonction f.\r
+%\r
+% * variables de sortie :\r
+% Y : valeurs calculée aux instants 0,h,2h,...,Nh=T.\r
+%\r
+% \r
+% \r
+% ************ Fonctions auxiliaires utilisées ************\r
+%\r
+% aucune\r
+%\r
+% *********************************************************\r
+%\r
+\r
+\r
+\r
+% Contrôles d'entrée\r
+\r
+% nombre d'arguments\r
+if nargin~=4\r
+ error('nombre d''arguments de la fonction incorrect');\r
+end\r
+ \r
+% Corps d'algorithme\r
+h=T/N;\r
+Y=zeros(1,N+1);\r
+Y(1)=y0;\r
+auxiY=y0;\r
+for i=1:N\r
+ t=h*(i-1);\r
+ y=auxiY;\r
+ auxiY=auxiY+h*eval(fcn);\r
+ Y(i+1)=auxiY;\r
+end\r
+\r
+\r
+\r
+\r
--- /dev/null
+function Y=resout_euler_implicite(N,T,y0,fcn,nmax,epsilon)\r
+% \r
+%\r
+%\r
+% resoud_euler_implicite : résolution d'une équation différentielle par la méthode d'Euler implicite.\r
+%\r
+% *********************************************************\r
+%\r
+% X=resout_euler_implicite(N,T,y0,fcn,nmax,epsilon) calcule les valeurs aux instants 0,h,2h,...,Nh=T par la méthode\r
+% d'Euler implicite pour l'équation différentielle y't)=f(t,y(t)) sur [0,T] et y(0)=y0.\r
+% A chaque itération, l'équation y_{n+1}=y_n+hf(t_{n+1},y_{n+1}) est résolue par la méthode de Newton\r
+% où la valeur initiale est choisie égale à y_n.\r
+% \r
+% La dérivée partielle df/dy est calculée en symbolique.\r
+%\r
+% * variables d'entrées :\r
+% N : nombre de valeurs calculées ; \r
+% T : borne supérieure de l'intervalle ;\r
+% y0 : valeur de y à t=0 ;\r
+% fcn : chaine de caractères (de type 'f(t,y)') représentant la fonction f\r
+% epsilon : précision souhaitée (pour la méthode de Newton)\r
+% nmax : nombre maximal d'itérations (pour la méthode de Newton)\r
+%\r
+% * variables de sortie :\r
+% Y : valeurs calculée aux instants 0,h,2h,...,Nh=T.\r
+%\r
+% \r
+% \r
+% ************ Fonctions auxiliaires utilisées ************\r
+%\r
+% aucune\r
+%\r
+% *********************************************************\r
+%\r
+\r
+% Contrôles d'entrée\r
+\r
+% nombre d'arguments\r
+if nargin~=6\r
+ error('nombre d''arguments de la fonction incorrect');\r
+end\r
+ \r
+% Corps d'algorithme\r
+h=T/N;\r
+Y=zeros(1,N+1);\r
+Y(1)=y0;\r
+auxiY=y0;\r
+syms t y;\r
+g=eval(fcn);\r
+fcnpsymb=diff(g,y);\r
+fcnp=char(fcnpsymb);\r
+yapp=y0;\r
+for i=1:N\r
+ t=h*i;\r
+ y=yapp;\r
+ fx=-h*eval(fcn);\r
+ fxp=1-h*eval(fcnp);\r
+ test=((fx)~=0);\r
+ n=0;\r
+ v=yapp;\r
+ while(test)\r
+ oldv=v;\r
+ v=v-fx/fxp;\r
+ y=v;\r
+ fx=v-yapp-h*eval(fcn);\r
+ fxp=1-h*eval(fcnp);\r
+ n=n+1;\r
+ test=~((fx==0)|(n>=nmax)|(abs(v-oldv)<=epsilon));\r
+ end \r
+ yapp=v;\r
+ if (n>=nmax)\r
+ error('attention, n>nmax pour la méthode de Newton : arrêt du programme');\r
+ end\r
+ Y(i+1)=yapp;\r
+end\r
+\r
+\r
+\r
+\r
--- /dev/null
+function Y=resout_runge_kutta2(N,T,y0,fcn)\r
+% \r
+%\r
+%\r
+% resout_runge_kutta2 : résolution d'une équation différentielle par la méthode de Runge Kutta 2 (explicite).\r
+%\r
+% *********************************************************\r
+%\r
+% Y=resout_runge_kutta2(N,T,y0,fcn) calcule les valeurs aux instants 0,h,2h,...,Nh=T par la méthode\r
+% de Runge Kutta d'ordre 2 (explicite) pour l'équation différentielle y't)=f(t,y(t)) sur [0,T] et y(0)=y0.\r
+% \r
+% * variables d'entrées :\r
+% N : nombre de valeurs calculées ; \r
+% T : borne supérieure de l'intervalle ;\r
+% y0 : valeur de y à t=0 ;\r
+% fcn : chaine de caractères (de type 'f(t,y)') représentant la fonction f.\r
+%\r
+% * variables de sortie :\r
+% Y : valeurs calculée aux instants 0,h,2h,...,Nh=T.\r
+%\r
+% \r
+% \r
+% ************ Fonctions auxiliaires utilisées ************\r
+%\r
+% aucune\r
+%\r
+% *********************************************************\r
+%\r
+\r
+\r
+\r
+% Contrôles d'entrée\r
+\r
+% nombre d'arguments\r
+if nargin~=4\r
+ error('nombre d''arguments de la fonction incorrect');\r
+end\r
+ \r
+% Corps d'algorithme\r
+h=T/N;\r
+Y=zeros(1,N+1);\r
+Y(1)=y0;\r
+auxiY=y0;\r
+for i=1:N\r
+ t=h*(i-1);\r
+ y=auxiY;\r
+ k1=h*eval(fcn);\r
+ t=t+h;\r
+ y=auxiY+k1;\r
+ k2=h*eval(fcn);\r
+ auxiY=auxiY+(k1+k2)/2;\r
+ Y(i+1)=auxiY;\r
+end\r
+\r
+\r
+\r
+\r
--- /dev/null
+function Y=resout_runge_kutta4(N,T,y0,fcn)\r
+% \r
+%\r
+%\r
+% resout_runge_kutta4 : résolution d'une équation différentielle par la méthode de Runge Kutta 4 (explicite).\r
+%\r
+% *********************************************************\r
+%\r
+% Y=resout_runge_kutta4(N,T,y0,fcn) calcule les valeurs aux instants 0,h,2h,...,Nh=T par la méthode\r
+% de Runge Kutta d'ordre 4 (explicite) pour l'équation différentielle y't)=f(t,y(t)) sur [0,T] et y(0)=y0.\r
+% \r
+% * variables d'entrées :\r
+% N : nombre de valeurs calculées ; \r
+% T : borne supérieure de l'intervalle ;\r
+% y0 : valeur de y à t=0 ;\r
+% fcn : chaine de caractères (de type 'f(t,y)') représentant la fonction f.\r
+%\r
+% * variables de sortie :\r
+% Y : valeurs calculée aux instants 0,h,2h,...,Nh=T.\r
+%\r
+% \r
+% \r
+% ************ Fonctions auxiliaires utilisées ************\r
+%\r
+% aucune\r
+%\r
+% *********************************************************\r
+%\r
+\r
+\r
+\r
+% Contrôles d'entrée\r
+\r
+% nombre d'arguments\r
+if nargin~=4\r
+ error('nombre d''arguments de la fonction incorrect');\r
+end\r
+ \r
+% Corps d'algorithme\r
+h=T/N;\r
+Y=zeros(1,N+1);\r
+Y(1)=y0;\r
+auxiY=y0;\r
+for i=1:N\r
+ t=h*(i-1);\r
+ y=auxiY;\r
+ k1=h*eval(fcn);\r
+ t=t+h/2;\r
+ y=auxiY+k1/2;\r
+ k2=h*eval(fcn);\r
+ y=auxiY+k2/2;\r
+ k3=h*eval(fcn);\r
+ t=h*i;\r
+ y=auxiY+k3;\r
+ k4=h*eval(fcn);\r
+ auxiY=auxiY+(k1+2*k2+2*k3+k4)/6;\r
+ Y(i+1)=auxiY;\r
+end\r
+\r
+\r
+\r
+\r
--- /dev/null
+function Y=resout_theta_methode(theta,N,T,y0,fcn,nmax,epsilon)\r
+% \r
+%\r
+%\r
+% resout_theta_methode : résolution d'une équation différentielle par la theta-méthode.\r
+%\r
+% *********************************************************\r
+%\r
+% Y=resout_theta_methode(theta,N,T,y0,fcn,nmax,epsilon) calcule les valeurs aux instants 0,h,2h,...,Nh=T par \r
+% la theta-méthode\r
+% pour l'équation différentielle y't)=f(t,y(t)) sur [0,T] et y(0)=y0.\r
+% A chaque itération, l'équation y_{n+1}=y_n+theta hf(t_{n+1},y_{n+1})+(1-theta)hf(t_{n},y_{n})\r
+% est résolue par la méthode de Newton\r
+% où la valeur initiale est choisie égale à y_n.\r
+% \r
+% La dérivée partielle df/dy est calculée en symbolique.\r
+%\r
+% * variables d'entrées :\r
+% theta est un réel dans [0,1] ;\r
+% N : nombre de valeurs calculées ; \r
+% T : borne supérieure de l'intervalle ;\r
+% y0 : valeur de y à t=0 ;\r
+% fcn : chaine de caractères (de type 'f(t,y)') représentant la fonction f\r
+% epsilon : précision souhaitée (pour la méthode de Newton)\r
+% nmax : nombre maximal d'itérations (pour la méthode de Newton)\r
+%\r
+% * variables de sortie :\r
+% Y : valeurs calculée aux instants 0,h,2h,...,Nh=T.\r
+%\r
+% \r
+% \r
+% ************ Fonctions auxiliaires utilisées ************\r
+%\r
+% aucune\r
+%\r
+% *********************************************************\r
+%\r
+\r
+% Contrôles d'entrée\r
+\r
+% nombre d'arguments\r
+if nargin~=7\r
+ error('nombre d''arguments de la fonction incorrect');\r
+end\r
+ \r
+% Corps d'algorithme\r
+h=T/N;\r
+Y=zeros(1,N+1);\r
+Y(1)=y0;\r
+auxiY=y0;\r
+syms t y;\r
+g=eval(fcn);\r
+fcnpsymb=diff(g,y);\r
+fcnp=char(fcnpsymb);\r
+yapp=y0;\r
+for i=1:N\r
+ y=yapp;\r
+ t=h*(i-1);\r
+ auxidud=h*(1-theta)*eval(fcn);\r
+ t=h*i;\r
+ fx=-h*theta*eval(fcn)-auxidud;\r
+ fxp=1-h*theta*eval(fcnp);\r
+ test=((fx)~=0);\r
+ n=0;\r
+ v=yapp;\r
+ while(test)\r
+ oldv=v;\r
+ v=v-fx/fxp;\r
+ y=v;\r
+ t=h*i;\r
+ fx=v-yapp-h*theta*eval(fcn)-auxidud;\r
+ fxp=1-h*theta*eval(fcnp);\r
+ n=n+1;\r
+ test=~((fx==0)|(n>=nmax)|(abs(v-oldv)<=epsilon));\r
+ end \r
+ yapp=v;\r
+ if (n>=nmax)\r
+ error('attention, n>nmax pour la méthode de Newton : arrêt du programme');\r
+ end\r
+ Y(i+1)=yapp;\r
+end\r
--- /dev/null
+% demo_log_erreur_schema : ce script permet de déterminer \r
+% l'ordre du schéma de façon graphique\r
+% et numérique des cinq méthodes suivantes : \r
+% * Euler explicite ;\r
+% * Euler implicite ;\r
+% * Runge Kutta explicite d'ordre 2\r
+% * theta_méthode\r
+% * Runge Kutta explicite d'ordre 4\r
+%\r
+% paramètres d'entrée : \r
+% nmin et nmax : deux entiers entre lesquels varie n ;\r
+% T : borne supérieure de l'intervalle ;\r
+% y0 : valeur de y à t=0 ;\r
+% theta est un réel dans [0,1] ;\r
+% epsilon : précision souhaitée (pour la méthode de Newton, pour les méthodes implicites)\r
+% nmax : nombre maximal d'itérations (pour la méthode de Newton, pour les méthodes implicites)\r
+% fcn : chaine de caractères (de type 'f(t,y)') représentant la fonction f\r
+\r
+pmin=input('entrez l''exposant pmin tel que le plus petit entier de calcul soit 10^pmin : ');\r
+pmax=input('entrez l''exposant pmax tel que le plus grand entier de calcul soit 10^pmax : ');\r
+nc=input('entrez le nombre de calcul : ');\r
+T=input('entrez la borne supérieur de l''intervalle : ');\r
+y0=input('entrez la condition initiale : ');\r
+theta=input('entrez le paramètre theta : ');\r
+epsilon=input('entrez epsilon (pour la méthode de Newton, pour les méthodes implicites) : ');\r
+nmax=input('entrez le nombre maximum d''itérations (pour la méthode de Newton, pour les méthodes implicites) : ');\r
+fcn=input('entrez fcn (sous la forme ''f(t,y)'') : ');\r
+\r
+syms t y;\r
+g=eval(fcn);\r
+fcnpsymb=diff(g,y);\r
+fcnp=char(fcnpsymb);\r
+x=[];\r
+y1=[];\r
+y2=[];\r
+y3=[];\r
+y4=[];\r
+y5=[];\r
+for N=logspace(pmin,pmax,nc)\r
+ NN=fix(N);\r
+ x=[x log10(NN)];\r
+ Ya1=resout_euler_explicite(NN,T,y0,fcn);\r
+ Yb1=resout_euler_explicite(2*NN,T,y0,fcn);\r
+ Ya2=resout_euler_implicite_bis(NN,T,y0,fcn,fcnp,nmax,epsilon);\r
+ Yb2=resout_euler_implicite_bis(2*NN,T,y0,fcn,fcnp,nmax,epsilon);\r
+ Ya3=resout_runge_kutta2(NN,T,y0,fcn); \r
+ Yb3=resout_runge_kutta2(2*NN,T,y0,fcn); \r
+ Ya4=resout_theta_methode_bis(theta,NN,T,y0,fcn,fcnp,nmax,epsilon);\r
+ Yb4=resout_theta_methode_bis(theta,2*NN,T,y0,fcn,fcnp,nmax,epsilon);\r
+ Ya5=resout_runge_kutta4(NN,T,y0,fcn); \r
+ Yb5=resout_runge_kutta4(2*NN,T,y0,fcn); \r
+ auxi1=-log10(max(abs(Ya1-Yb1(1:2:end)))); \r
+ auxi2=-log10(max(abs(Ya2-Yb2(1:2:end)))); \r
+ auxi3=-log10(max(abs(Ya3-Yb3(1:2:end)))); \r
+ auxi4=-log10(max(abs(Ya4-Yb4(1:2:end)))); \r
+ auxi5=-log10(max(abs(Ya5-Yb5(1:2:end)))); \r
+ y1=[y1 auxi1]; \r
+ y2=[y2 auxi2]; \r
+ y3=[y3 auxi3]; \r
+ y4=[y4 auxi4]; \r
+ y5=[y5 auxi5]; \r
+ disp(' ');\r
+ disp(['calcul pour N=',int2str(NN),' terminé']);\r
+end\r
+[a1,b,r1]=regression_lineaire(x,y1);\r
+[a2,b,r2]=regression_lineaire(x,y2);\r
+[a3,b,r3]=regression_lineaire(x,y3);\r
+[a4,b,r4]=regression_lineaire(x,y4);\r
+[a5,b,r5]=regression_lineaire(x,y5);\r
+clf;\r
+hold on;\r
+plot(x,y1,x,y2,x,y3,x,y4,x,y5);\r
+legend('Euler explicite','Euler implicite','runge Kutta 2','theta-méthode','runge Kutta 4',0);\r
+title('détermination des ordres des schémas');\r
+hold off;\r
+disp(' ');\r
+disp('pour avoir une estimation des ordres, tapez sur une touche');\r
+pause;\r
+disp(' ');\r
+disp('Euler explicite');\r
+disp(['ordre=',num2str(a1)]);\r
+disp(['correlation=',num2str(r1)]);\r
+disp(' ');\r
+disp('Euler implicite');\r
+disp(['ordre=',num2str(a2)]);\r
+disp(['correlation=',num2str(r2)]);\r
+disp(' ');\r
+disp('runge Kutta 2');\r
+disp(['ordre=',num2str(a3)]);\r
+disp(['correlation=',num2str(r3)]);\r
+disp(' ');\r
+disp('theta-méthode');\r
+disp(['ordre=',num2str(a4)]);\r
+disp(['correlation=',num2str(r4)]);\r
+disp(' ');\r
+disp('runge Kutta 4');\r
+disp(['ordre=',num2str(a5)]);\r
+disp(['correlation=',num2str(r5)]);\r
+\r
+\r
--- /dev/null
+function Y=resout_euler_implicite_bis(N,T,y0,fcn,fcnp,nmax,epsilon)\r
+% \r
+%\r
+%\r
+% resoud_euler_implicite_bis : résolution d'une équation différentielle par la méthode d'Euler implicite.\r
+%\r
+% *********************************************************\r
+%\r
+% X=resout_euler_implicite_bis(N,T,y0,fcn,fcnp,nmax,epsilon) calcule les valeurs aux instants 0,h,2h,...,Nh=T \r
+% par la méthode d'Euler implicite pour l'équation différentielle y't)=f(t,y(t)) sur [0,T] et y(0)=y0.\r
+% A chaque itération, l'équation y_{n+1}=y_n+hf(t_{n+1},y_{n+1}) est résolue par la méthode de Newton\r
+% où la valeur initiale est choisie égale à y_n.\r
+% \r
+% La dérivée partielle df/dy est entrée comme paramètre.\r
+%\r
+% * variables d'entrées :\r
+% N : nombre de valeurs calculées ; \r
+% T : borne supérieure de l'intervalle ;\r
+% y0 : valeur de y à t=0 ;\r
+% fcn : chaine de caractères (de type 'f(t,y)') représentant la fonction \r
+% fcnp : chaine de caractères (de type 'f(t,y)') représentant la fonction df/dy\r
+% epsilon : précision souhaitée (pour la méthode de Newton)\r
+% nmax : nombre maximal d'itérations (pour la méthode de Newton)\r
+%\r
+% * variables de sortie :\r
+% Y : valeurs calculée aux instants 0,h,2h,...,Nh=T.\r
+%\r
+% \r
+% \r
+% ************ Fonctions auxiliaires utilisées ************\r
+%\r
+% aucune\r
+%\r
+% *********************************************************\r
+%\r
+\r
+% Contrôles d'entrée\r
+\r
+% nombre d'arguments\r
+if nargin~=7\r
+ error('nombre d''arguments de la fonction incorrect');\r
+end\r
+ \r
+% Corps d'algorithme\r
+h=T/N;\r
+Y=zeros(1,N+1);\r
+Y(1)=y0;\r
+auxiY=y0;\r
+yapp=y0;\r
+for i=1:N\r
+ t=h*i;\r
+ y=yapp;\r
+ fx=-h*eval(fcn);\r
+ fxp=1-h*eval(fcnp);\r
+ test=((fx)~=0);\r
+ n=0;\r
+ v=yapp;\r
+ while(test)\r
+ oldv=v;\r
+ v=v-fx/fxp;\r
+ y=v;\r
+ fx=v-yapp-h*eval(fcn);\r
+ fxp=1-h*eval(fcnp);\r
+ n=n+1;\r
+ test=~((fx==0)|(n>=nmax)|(abs(v-oldv)<=epsilon));\r
+ end \r
+ yapp=v;\r
+ if (n>=nmax)\r
+ error('attention, n>nmax pour la méthode de Newton : arrêt du programme');\r
+ end\r
+ Y(i+1)=yapp;\r
+end\r
+\r
+\r
+\r
+\r
--- /dev/null
+function Y=resout_theta_methode_bis(theta,N,T,y0,fcn,fcnp,nmax,epsilon)\r
+% \r
+%\r
+%\r
+% resout_theta_methode_bis : résolution d'une équation différentielle par la theta-méthode.\r
+%\r
+% *********************************************************\r
+%\r
+% Y=resout_theta_methode_bis(theta,N,T,y0,fcn,nmax,epsilon) calcule les valeurs aux instants 0,h,2h,...,Nh=T par \r
+% la theta-méthode\r
+% pour l'équation différentielle y't)=f(t,y(t)) sur [0,T] et y(0)=y0.\r
+% A chaque itération, l'équation y_{n+1}=y_n+theta hf(t_{n+1},y_{n+1})+(1-theta)hf(t_{n},y_{n})\r
+% est résolue par la méthode de Newton\r
+% où la valeur initiale est choisie égale à y_n.\r
+% \r
+% La dérivée partielle df/dy est entrée comme paramètre.\r
+%\r
+% * variables d'entrées :\r
+% theta est un réel dans [0,1] ;\r
+% N : nombre de valeurs calculées ; \r
+% T : borne supérieure de l'intervalle ;\r
+% y0 : valeur de y à t=0 ;\r
+% fcn : chaine de caractères (de type 'f(t,y)') représentant la fonction f\r
+% fcnp : chaine de caractères (de type 'f(t,y)') représentant la fonction df/dy\r
+% epsilon : précision souhaitée (pour la méthode de Newton)\r
+% nmax : nombre maximal d'itérations (pour la méthode de Newton)\r
+%\r
+% * variables de sortie :\r
+% Y : valeurs calculée aux instants 0,h,2h,...,Nh=T.\r
+%\r
+% \r
+% \r
+% ************ Fonctions auxiliaires utilisées ************\r
+%\r
+% aucune\r
+%\r
+% *********************************************************\r
+%\r
+\r
+% Contrôles d'entrée\r
+\r
+% nombre d'arguments\r
+if nargin~=8\r
+ error('nombre d''arguments de la fonction incorrect');\r
+end\r
+ \r
+% Corps d'algorithme\r
+h=T/N;\r
+Y=zeros(1,N+1);\r
+Y(1)=y0;\r
+auxiY=y0;\r
+yapp=y0;\r
+for i=1:N\r
+ y=yapp;\r
+ t=h*(i-1);\r
+ auxidud=h*(1-theta)*eval(fcn);\r
+ t=h*i;\r
+ fx=-h*theta*eval(fcn)-auxidud;\r
+ fxp=1-h*theta*eval(fcnp);\r
+ test=((fx)~=0);\r
+ n=0;\r
+ v=yapp;\r
+ while(test)\r
+ oldv=v;\r
+ v=v-fx/fxp;\r
+ y=v;\r
+ t=h*i;\r
+ fx=v-yapp-h*theta*eval(fcn)-auxidud;\r
+ fxp=1-h*theta*eval(fcnp);\r
+ n=n+1;\r
+ test=~((fx==0)|(n>=nmax)|(abs(v-oldv)<=epsilon));\r
+ end \r
+ yapp=v;\r
+ if (n>=nmax)\r
+ error('attention, n>nmax pour la méthode de Newton : arrêt du programme');\r
+ end\r
+ Y(i+1)=yapp;\r
+end\r
--- /dev/null
+function dly=calcul_developpement_limite(t,y,h,p);\r
+\r
+%\r
+% calcul_developpement_limite : calcul symbolique du développement limité ...\r
+%\r
+% *********************************************************\r
+%\r
+% dly=calcul_developpement_limite(t,y,h,p) est le développement limité\r
+% formel de y, solution de y'(t)=f(t,y(t)) autour de y() à l'ordre p.\r
+% variables d'entrées : \r
+% * entier naturel p \r
+% * symbolique t , y et h \r
+% variables de sortie : dly=alcul_developpement_limite(t,y,h,p)\r
+%\r
+% \r
+% \r
+% ************ Fonctions auxiliaires utilisées ************\r
+%\r
+% aucune\r
+%\r
+% *********************************************************\r
+%\r
+\r
+syms yb tb hb;\r
+auxifacto=sym(1);\r
+factoriel=[];\r
+for j=1:p\r
+ auxifacto=auxifacto*j;\r
+ factoriel=[factoriel 1/auxifacto];\r
+end\r
+puissanceh=hb.^(1:p);\r
+F=calcul_fonction_fp(tb,yb,p-1);\r
+if (p==0)\r
+ dly=yb; \r
+else\r
+ dly=yb+sum(factoriel.*puissanceh.*F);\r
+end\r
+dly=subs(dly,{'tb','yb','hb'},{char(t),char(y),char(h)});\r
--- /dev/null
+function F=calcul_fonction_fp(t,y,p);\r
+\r
+%\r
+% calcul_fonction_fp : définition symbolique des fonctions f_0,...,f_p\r
+%\r
+% *********************************************************\r
+%\r
+% F=calcul_fonction_fp(t,y,p)\r
+% calcule les fonctions f_0, f_1, ..., f_p définies par récurrence par\r
+% f_0(t,y)=f(t,y)\r
+% pour k dans {0,...,p-1},\r
+% f_{k+1}=diff(f_k,t)(t,y)+diff(f_k,y)(t,y)*f(t,y). \r
+% Chaque foncton f_k est stockée dans F(k+1) pour k dans {0,...,p-1}.\r
+% * variables d'entrée : \r
+% * entier naturel p \r
+% * symbolique t , y et h \r
+% * variables de sortie : F=[f_0 f_1 ... f_p]\r
+%\r
+% \r
+% \r
+% ************ Fonctions auxiliaires utilisées ************\r
+%\r
+% aucune\r
+%\r
+% *********************************************************\r
+%\r
+\r
+\r
+if (p>=0) \r
+ syms yb tb;\r
+ fcn=sym('f(tb,yb)');\r
+ fauxi=fcn;\r
+ F=zeros(1,p+1);\r
+ F=sym(F);\r
+ F(1)=fcn;\r
+ for k=0:p-1\r
+ fauxi=simplify(diff(fauxi,tb)+diff(fauxi,yb)*fcn);\r
+ F(k+2)=fauxi;\r
+ end\r
+ for k=1:p+1\r
+ F(k)=subs(F(k),{'tb','yb'},{char(t),char(y)});; \r
+ end\r
+else\r
+ F=sym([]);\r
+end\r
+\r
+\r
+\r
+\r
+\r
--- /dev/null
+% ce script determine_ordre calcule les erreurs de consistance pour les \r
+% schémas numériques d'Euler explicite, Runge Kutta 2 et 4. \r
+\r
+disp('calcul en cours ....');\r
+syms t y h;\r
+dly=calcul_developpement_limite(t,y,h,6);\r
+phiee=phi_euler_explicite_symbolique(t,y,h);\r
+phirk2=phi_runge_kutta2_symbolique(t,y,h);\r
+phirk4=phi_runge_kutta4_symbolique(t,y,h);\r
+ynpuee=y+h*phiee;\r
+ynpurk2=y+h*phirk2;\r
+ynpurk4=y+h*phirk4;\r
+see=simplify(taylor(dly,h,3)-taylor(ynpuee,h,3));\r
+srk2=simplify(taylor(dly,h,4)-taylor(ynpurk2,h,4));\r
+srk4=simplify(taylor(dly,h,6)-taylor(ynpurk4,h,6));\r
+disp('développement limité à l''ordre 5 : ');\r
+pretty(expand(taylor(dly,h,6)));\r
+disp('appuyez sur une touche pour continuer.');\r
+pause;\r
+disp('erreur de consistance pour Euler explicite (à l''ordre 2) : ');\r
+pretty(see);\r
+disp('appuyez sur une touche pour continuer.');\r
+pause;\r
+disp('erreur de consistance pour RK2 (à l''ordre 3) : ');\r
+pretty(srk2);\r
+disp('appuyez sur une touche pour continuer.');\r
+pause;\r
+disp('erreur de consistance pour RK4 (à l''ordre 5) : ');\r
+pretty(srk4);\r
+disp('appuyez sur une touche pour continuer.');\r
+pause;\r
+\r
+\r
+\r
--- /dev/null
+function phi=phi_euler_explicite_symbolique(t,y,h);\r
+\r
+%\r
+% phi_euler_explicite_symbolique : définition symbolique du schéma d'Euler (Phi)\r
+%\r
+% *********************************************************\r
+%\r
+% phi=phi_euler_explicite_symbolique(t,y,h)\r
+% calcule la fonction (en symbolique) : (t,y)-> Phi(t,y) telle\r
+% le schéma d'Euler explicite s'écrive sous la forme :\r
+% y_{i+1}=y_{i}+h Phi(t_i,y_i,h)\r
+% variables d'entrée : t , y et h (symbolique))\r
+%% variables de sortie : res=Phi(t,y,h)\r
+%\r
+% \r
+% \r
+% ************ Fonctions auxiliaires utilisées ************\r
+%\r
+% aucune\r
+%\r
+% *********************************************************\r
+%\r
+\r
+syms yb tb hb;\r
+fcn=sym('f(tb,yb)');\r
+phi=subs(fcn,{'tb','yb'},{char(t),char(y)});\r
+\r
+\r
+\r
--- /dev/null
+function phi=phi_runge_kutta2_symbolique(t,y,h);\r
+\r
+%\r
+% phi_runge_kutta2_symbolique : définition symbolique de Runge Kutta 2 (Phi)\r
+%\r
+% *********************************************************\r
+%\r
+% phi=phi_runge_kutta2_symbolique(t,y,h)\r
+% calcule la fonction (en symbolique) : (t,y)-> Phi(t,y) telle\r
+% le schéma de Runge Kutta 2 s'écrive sous la forme :\r
+% y_{i+1}=y_{i}+h Phi(t_i,y_i,h)\r
+% variables d'entrée : t , y et h (symbolique))\r
+%% variables de sortie : res=Phi(t,y,h)\r
+%\r
+% \r
+% \r
+% ************ Fonctions auxiliaires utilisées ************\r
+%\r
+% aucune\r
+%\r
+% *********************************************************\r
+%\r
+\r
+syms yb tb hb;\r
+fcn=sym('f(tb,yb)');\r
+k1tilde=fcn;\r
+fcnb=subs(fcn,{'tb','yb'},{tb+hb,yb+hb*k1tilde});\r
+k2tilde=fcnb;\r
+phi=(k1tilde+k2tilde)/sym(2);\r
+phi=subs(phi,{'tb','yb','hb'},{char(t),char(y),char(h)});\r
+\r
+\r
+\r
+\r
+\r
+\r
+\r
--- /dev/null
+function phi=phi_runge_kutta4_symbolique(t,y,h);\r
+\r
+%\r
+% phi_runge_kutta4_symbolique : définition symbolique de Runge Kutta 4 (Phi)\r
+%\r
+% *********************************************************\r
+%\r
+% phi=phi_runge_kutta4_symbolique(t,y,h)\r
+% calcule la fonction (en symbolique) : (t,y)-> Phi(t,y) telle\r
+% le schéma de Runge Kutta 4 s'écrive sous la forme :\r
+% y_{i+1}=y_{i}+h Phi(t_i,y_i,h)\r
+% variables d'entrée : t , y et h (symbolique))\r
+%% variables de sortie : res=Phi(t,y,h)\r
+%\r
+% \r
+% \r
+% ************ Fonctions auxiliaires utilisées ************\r
+%\r
+% aucune\r
+%\r
+% *********************************************************\r
+%\r
+\r
+syms yb tb hb;\r
+fcn=sym('f(tb,yb)');\r
+k1tilde=fcn;\r
+fcnb=subs(fcn,{'tb','yb'},{tb+1/2*hb,yb+1/2*hb*k1tilde});\r
+k2tilde=fcnb;\r
+fcnb=subs(fcn,{'tb','yb'},{tb+1/2*hb,yb+1/2*hb*k2tilde});\r
+k3tilde=fcnb;\r
+fcnb=subs(fcn,{'tb','yb'},{tb+hb,yb+hb*k3tilde});\r
+k4tilde=fcnb;\r
+phi=1/6*(k1tilde+2*k2tilde+2*k3tilde+k4tilde);\r
+phi=subs(phi,{'tb','yb','hb'},{char(t),char(y),char(h)});\r
--- /dev/null
+% ce script demo_trace_systeme_mecanique calcule les \r
+% solutions du système à deux degrés de liberté régi par le système : \r
+% x1''(t)+(k1+k2)x1-k2x2+c1x'1+d1(x'1)^3=f1\r
+% x2''(t)-k2x1+(k2+k3)x2+c2x'2+d2(x'2)^3=f2\r
+% déterminée par les schémas d'Euler implicite et de Runge Kutta 4.\r
+%\r
+%\r
+% * les paramètres d'entrée sont : \r
+% k : le vecteur contenant k1, k2 et k3,\r
+% c : le vecteur contenant c1 et c2,\r
+% d : le vecteur contenant d1, d2,\r
+% y0 : le vecteur contenant les conditions initiales (x1(0), x1'(0), x2(0), x2'(0))\r
+% fcn1 : chaine de caractères (de type 'f1(t)') représentant la fonction f1, \r
+% fcn2 : chaine de caractères (de type 'f2(t)') représentant la fonction f2, \r
+% N : un entier non nul,\r
+% T : la borne supérieur de l'intervalle d'étude.\r
+%\r
+% * le script affiche les approximation de x1, x1', x2 et x2' sur [0,T].\r
+\r
+clear all;\r
+%nombre de points pour l'affichage défini par ngra \r
+ngra=1000;\r
+\r
+% entree des paramètres\r
+k=input('entrez le vecteur [k1,k2,k3] : ');\r
+c=input('entrez le vecteur [c1,c2]: ');\r
+d=input('entrez le vecteur [d1,d2]: ');\r
+y0=input('entrez le vecteur des conditions initiales [x1(0),x1''(0),x2(0),x2''(0)]: ');\r
+fcn1=input('entrez la fonction f1 sous la forme ''f1(t)'': ');\r
+fcn2=input('entrez la fonction f2 sous la forme ''f2(t)'': ');\r
+N=input('entrez le nombre de points de discretisation : ');\r
+T=input('entrez T : ');\r
+\r
+\r
+% définition de la fonction F telle que le système soit équivalent à Y'(t)=F(t,Y(t)) dans R^4.\r
+% F est defini en fonction de t et de y, vecteur à 4 composantes.\r
+A=-[0 -1 0 0;\r
+ k(1)+k(2) c(1) -k(2) 0;\r
+ 0 0 0 -1;\r
+ -k(2) 0 k(2)+k(3) c(2)];\r
+H='-[0;d(1)*(y(2))^3;0;d(2)*(y(4))^3]';\r
+G=['[0; ',fcn1,';','0;',fcn2,']'];\r
+fcn=[H,'+',G,'+A*y'];\r
+h=T/N;\r
+\r
+% calcul de la solution par Euler explicite.\r
+Yeuler=zeros(4,N+1);\r
+Yeuler(:,1)=y0';\r
+auxiY=y0';\r
+for i=1:N\r
+ t=h*(i-1);\r
+ y=auxiY;\r
+ auxiY=auxiY+h*eval(fcn);\r
+ Yeuler(:,i+1)=auxiY;\r
+end\r
+\r
+% calcul de la solution par Runge Kutta.\r
+Yrungekutta=zeros(4,N+1);\r
+Yrungekutta(:,1)=y0';\r
+auxiY=y0';\r
+for i=1:N\r
+ t=h*(i-1);\r
+ y=auxiY;\r
+ k1=h*eval(fcn);\r
+ t=t+h/2;\r
+ y=auxiY+k1/2;\r
+ k2=h*eval(fcn);\r
+ y=auxiY+k2/2;\r
+ k3=h*eval(fcn);\r
+ t=h*i;\r
+ y=auxiY+k3;\r
+ k4=h*eval(fcn);\r
+ auxiY=auxiY+(k1+2*k2+2*k3+k4)/6;\r
+ Yrungekutta(:,i+1)=auxiY;\r
+end\r
+\r
+\r
+% préparation des vecteurs de tracé.\r
+if (N<ngra)\r
+ x=0:h:T;\r
+ yeuler=Yeuler;\r
+ yrungekutta=Yrungekutta;\r
+else\r
+ p=fix(N/ngra);\r
+ yeuler=[Yeuler(:,1:p:N+1) Yeuler(:,N+1)];\r
+ yrungekutta=[Yrungekutta(:,1:p:N+1) Yrungekutta(:,N+1)];\r
+ x=0:h:T;\r
+ x=[x(1:p:N+1) T];\r
+end\r
+\r
+% tracé\r
+clf;\r
+subplot(2,1,1); \r
+plot(x,yeuler(1,:),x,yeuler(3,:),x,yrungekutta(1,:),x,yrungekutta(3,:),[0 T],[0 0],'k');\r
+legend('x1 par Euler','x2 par Euler','x1 par RK4','x2 par RK4',0);\r
+subplot(2,1,2); \r
+plot(x,yeuler(2,:),x,yeuler(4,:),x,yrungekutta(2,:),x,yrungekutta(4,:),[0 T],[0 0],'k');\r
+legend('x1'' par Euler','x2'' par Euler','x1'' par RK4','x2'' par RK4',0);\r
+\r
+\r
+\r
+\r
+\r
+\r
+\r
+\r
--- /dev/null
+% demo_trace_log_erreur_iteration : ce script affiche les erreurs en \r
+% courbes logarithmique et permet de déterminer l'ordre du schéma \r
+% de façon graphique et numérique.\r
+\r
+% paramètres d'entrée : \r
+% * limite présumée\r
+% * nombre de courbe\r
+% * pour chacune d'elles, X un vecteur contenant les itérés, déja calculé,\r
+% * x_0,x_1,x_2,...,x_{n_p}\r
+\r
+% les termes correspondant à une erreur nulle sont enlevés.\r
+\r
+% saisie des données\r
+l=input('entrez la limite commune présumée : ');\r
+nc=input('entrez le nombre de courbes d''erreurs à tracer : ');\r
+M=cell(nc,1);\r
+nuage=cell(nc,2);\r
+pente=zeros(1,nc);\r
+corel=zeros(1,nc);\r
+for k=1:nc\r
+ M{k}=input(['entrez le vecteur des itérés de la courbe numero ',num2str(k),': ']);\r
+end\r
+% détermination des nuages de points\r
+% et calcul des pentes et des correlations\r
+for k=1:nc\r
+ auxi=abs(M{k}-l);\r
+ ind=find(auxi~=0);\r
+ auxi=auxi(ind);\r
+ auxi=log10(auxi);\r
+ x=auxi(1:end-1);\r
+ y=auxi(2:end);\r
+ nuage{k,1}=x;\r
+ nuage{k,2}=y;\r
+ [pente(k),b,corel(k)]=regression_lineaire(x,y);\r
+end\r
+% tracé du graphique\r
+chlegend='legend(';\r
+for k=1:nc-1\r
+ chlegend=[chlegend,'''courbe ',num2str(k),''',']; \r
+end\r
+chlegend=[chlegend,'''courbe ',num2str(nc),''',0)']; \r
+clf;\r
+hold on;\r
+for k=1:nc\r
+ plot(nuage{k,1}, nuage{k,2},couleur7(k));\r
+end\r
+eval(chlegend);\r
+title('détermination graphique de l''ordre');\r
+hold off;\r
+% éventuel affichage des pentes et des correlations\r
+disp(' ');\r
+disp('pour avoir une estimation des ordres, tapez sur une touche');\r
+pause;\r
+for k=1:nc\r
+ eval(['disp(''courbe',num2str(k),''')']);\r
+ disp('ordre = ');\r
+ disp(pente(k));\r
+ disp('correlation = ');\r
+ disp(corel(k));\r
+end\r
+\r
+\r
+\r
+\r
+\r
+\r
+\r
+\r
+\r
+\r
--- /dev/null
+function [n,X]=iteration_corde(a,b,x0,nmax,epsilon,fcn)\r
+\r
+\r
+% iteration_corde : calcul d'une racine d'une fonction par la méthode de la corde\r
+%\r
+% *********************************************************\r
+%\r
+% [n,X]=iteration_corde(a,b,x0,nmax,epsilon,fcn) renvoie\r
+% les itérés de la méthode de la corde\r
+%\r
+% variables d'entrées : \r
+% * a,b : borne de l'intervalle (avec f(a)f(b)<=0) \r
+% * nmax : nombre maximal d'itérations\r
+% * x0 : terme initial\r
+% * epsilon : précision souhaitée\r
+% * fcn est une chaîne de caractère représentant la fonction \r
+% (de type inline, builtin ou par fichier M-file);\r
+%\r
+% variables de sortie :\r
+% * n est l'indice correspondant à x_n avec f(x_n)=0 ou |x_n-x_{n-1}|<epsilon \r
+% ou n>=nmax\r
+% * X est une vecteur qui contient les valeurs de x_0 à x_n\r
+%\r
+% \r
+% \r
+% ************ Fonctions auxiliaires utilisées ************\r
+%\r
+% aucune\r
+%\r
+% *********************************************************\r
+%\r
+\r
+\r
+\r
+\r
+\r
+\r
+% Contrôles d'entrée\r
+if (a>=b)\r
+ error('il faut a<b');\r
+end\r
+qs=exist(fcn);\r
+if (qs~=2) & (qs~=5) & (qs~=1)\r
+ error('fcn doit être le nom d''une fonction (built-in, M-file ou inline)');\r
+end\r
+\r
+% corps d'algorithme\r
+n=0;\r
+delta=(b-a)/(feval(fcn,b)-feval(fcn,a));\r
+test=(feval(fcn,x0)~=0);\r
+x=x0;\r
+X=x0;\r
+while(test)\r
+ xm1=x;\r
+ x=x-delta*feval(fcn,x);\r
+ X=[X x];\r
+ n=n+1;\r
+ test=~((feval(fcn,x)==0)|(n>=nmax)|(abs(x-xm1)<=epsilon));\r
+end\r
+if (n>=nmax)\r
+ disp('attention, n>nmax');\r
+end\r
+\r
+\r
--- /dev/null
+function [n,X]=iteration_dichotomie(a,b,nmax,epsilon,fcn)\r
+\r
+\r
+% iteration_dichotomie : calcul d'une racine d'une fonction par dichotomie\r
+%\r
+% *********************************************************\r
+%\r
+% [n,X]=iteration_dichotomie(a,b,nmax,epsilon,fcn) renvoie\r
+% les itérés de la méthode de dichotomie\r
+%\r
+% variables d'entrées : \r
+% * a,b : borne de l'intervalle (avec f(a)f(b)<=0) \r
+% * nmax : nombre maximal d'itérations\r
+% * epsilon : précision souhaitée\r
+% * fcn est une chaîne de caractère représentant la fonction \r
+% (de type inline, builtin ou par fichier M-file);\r
+%\r
+% variables de sortie :\r
+% * n est l'indice tel que (1/2^n)(b-a)<epsilon\r
+% * X est une vecteur qui contient les valeurs de x_0 à x_n\r
+%\r
+% \r
+% \r
+% ************ Fonctions auxiliaires utilisées ************\r
+%\r
+% aucune\r
+%\r
+% *********************************************************\r
+%\r
+\r
+\r
+\r
+% Contrôles d'entrée\r
+if (a>=b)\r
+ error('il faut a<b');\r
+end\r
+qs=exist(fcn);\r
+if (qs~=2) & (qs~=5) & (qs~=1)\r
+ error('fcn doit être le nom d''une fonction (built-in, M-file ou inline)');\r
+end\r
+if (feval(fcn,a)*feval(fcn,b)>0)\r
+ error('il faut f(a)f(b)<=0');\r
+end\r
+\r
+% corps d'algorithme\r
+X=(a+b)/2;\r
+n=fix(-log(epsilon/(b-a))/log(2))+1;\r
+if (n>nmax)\r
+ error('il faut n plus petit que nmax');\r
+end\r
+for k=1:n\r
+ x=(a+b)/2;\r
+ X=[X x];\r
+ auxif=feval(fcn,a)*feval(fcn,x);\r
+ if (auxif<=0) \r
+ b=x;\r
+ else\r
+ a=x;\r
+ end \r
+end\r
--- /dev/null
+function [n,X]=iteration_newton(x0,nmax,epsilon,fcn)\r
+\r
+\r
+% iteration_newton : calcul d'une racine la méthode de Newton\r
+%\r
+% *********************************************************\r
+%\r
+% [n,X]=iteration_newton(x0,nmax,epsilon,fcn) renvoie\r
+% les itérés de la méthode de Newton\r
+% (la dérivée f' est calculée symboliquement)\r
+%\r
+% variables d'entrées : \r
+% * nmax : nombre maximal d'itérations\r
+% * x0 : le premier terme\r
+% * epsilon : précision souhaitée\r
+% * fcn est une chaîne de caractère représentant la fonction \r
+% (de type inline, builtin ou par fichier M-file);\r
+%\r
+% variables de sortie :\r
+% * n est l'indice correspondant à x_n avec f(x_n)=0 ou |x_n-x_{n-1}|<epsilon \r
+% ou n>=nmax\r
+% * X est une vecteur qui contient les valeurs de x_0 à x_n\r
+%\r
+% \r
+% \r
+% ************ Fonctions auxiliaires utilisées ************\r
+%\r
+% aucune\r
+%\r
+% *********************************************************\r
+%\r
+\r
+\r
+\r
+% Contrôles d'entrée\r
+qs=exist(fcn);\r
+if (qs~=2) & (qs~=5) & (qs~=1)\r
+ error('fcn doit être le nom d''une fonction (built-in, M-file ou inline)');\r
+end\r
+\r
+% corps d'algorithme\r
+syms vx\r
+g=feval(fcn,vx);\r
+fcnpsymb=diff(g,vx);\r
+n=0;\r
+test=(feval(fcn,x0)~=0);\r
+x=x0;\r
+fx=feval(fcn,x);\r
+fxp=subs(fcnpsymb,vx,x);\r
+if ~(isnumeric(fxp));\r
+ fxp=eval(fxp);\r
+end\r
+X=x0;\r
+while(test)\r
+ xnp1=x-fx/fxp;\r
+ n=n+1;\r
+ fxnp1=feval(fcn,xnp1);\r
+ test=~((fxnp1==0)|(n>=nmax)|(abs(x-xnp1)<=epsilon));\r
+ x=xnp1;\r
+ fx=feval(fcn,x);\r
+ fxp=subs(fcnpsymb,vx,x);\r
+ if ~(isnumeric(fxp));\r
+ fxp=eval(fxp);\r
+ end\r
+ X=[X x];\r
+end \r
+if (n>=nmax)\r
+ disp('attention, n>nmax');\r
+end\r
+\r
+\r
--- /dev/null
+function [n,X]=iteration_regula_falsi(xm1,x0,nmax,epsilon,fcn)\r
+\r
+\r
+% iteration_regula_falsi : calcul d'une racine par regula falsi\r
+%\r
+% *********************************************************\r
+%\r
+% [n,X]=iteration_regula_falsi(x0,xm1,nmax,epsilon,fcn) renvoie\r
+% les itérés de la méthode de la la fausse position\r
+%\r
+% variables d'entrées : \r
+% * nmax : nombre maximal d'itérations\r
+% * xm1 et x0 : les deux premiers termes (x_{-1} et x_0)\r
+% * epsilon : précision souhaitée\r
+% * fcn est une chaîne de caractère représentant la fonction \r
+% (de type inline, builtin ou par fichier M-file);\r
+%\r
+% variables de sortie :\r
+% * n est l'indice correspondant à x_n avec f(x_n)=0 ou |x_n-x_{n-1}|<epsilon \r
+% ou n>=nmax\r
+% * X est une vecteur qui contient les valeurs de x_0 à x_n\r
+%\r
+% \r
+% \r
+% ************ Fonctions auxiliaires utilisées ************\r
+%\r
+% aucune\r
+%\r
+% *********************************************************\r
+%\r
+\r
+\r
+\r
+% Contrôles d'entrée\r
+qs=exist(fcn);\r
+if (feval(fcn,x0)*feval(fcn,xm1)>0)\r
+ error('il faut f(x0)f(x_(-1))<0');\r
+end\r
+if (qs~=2) & (qs~=5) & (qs~=1)\r
+ error('fcn doit être le nom d''une fonction (built-in, M-file ou inline)');\r
+end\r
+\r
+% corps d'algorithme\r
+p=-1;\r
+n=0;\r
+test=(feval(fcn,x0)~=0);\r
+x=x0;\r
+xp=xm1;\r
+fxp=feval(fcn,xm1);\r
+fx=feval(fcn,x);\r
+xmm1=xm1;\r
+X=x0;\r
+while(test)\r
+ xnp1=x-((x-xp)/(fx-fxp))*fx;\r
+ fxnp1=feval(fcn,xnp1);\r
+ test=~((fxnp1==0)|(n>=nmax)|(abs(x-xmm1)<=epsilon));\r
+ xmm1=x;\r
+ x=xnp1;\r
+ fx=feval(fcn,x);\r
+ X=[X x];\r
+ if (test)\r
+ if (feval(fcn,xmm1)*fx<0) \r
+ p=n;\r
+ xp=xmm1;\r
+ fxp=feval(fcn,xp);\r
+ end\r
+ end\r
+ n=n+1;\r
+end \r
+if (n>=nmax)\r
+ disp('attention, n>nmax');\r
+end\r
+\r
+\r
--- /dev/null
+function [n,X]=iteration_secante(xm1,x0,nmax,epsilon,fcn)\r
+\r
+\r
+% iteration_secante : calcul d'une racine la méthode de la sécante\r
+%\r
+% *********************************************************\r
+%\r
+% [n,X]=iteration_secante(x0,xm1,nmax,epsilon,fcn) renvoie\r
+% les itérés de la méthode de la sécante\r
+%\r
+% variables d'entrées : \r
+% * nmax : nombre maximal d'itérations\r
+% * xm1 et x0 : les deux premiers termes (x_{-1} et x_0)\r
+% * epsilon : précision souhaitée\r
+% * fcn est une chaîne de caractère représentant la fonction \r
+% (de type inline, builtin ou par fichier M-file);\r
+%\r
+% variables de sortie :\r
+% * n est l'indice correspondant à x_n avec f(x_n)=0 ou |x_n-x_{n-1}|<epsilon \r
+% ou n>=nmax\r
+% * X est une vecteur qui contient les valeurs de x_0 à x_n\r
+%\r
+% \r
+% \r
+% ************ Fonctions auxiliaires utilisées ************\r
+%\r
+% aucune\r
+%\r
+% *********************************************************\r
+%\r
+\r
+\r
+\r
+\r
+% Contrôles d'entrée\r
+qs=exist(fcn);\r
+if (qs~=2) & (qs~=5) & (qs~=1)\r
+ error('fcn doit être le nom d''une fonction (built-in, M-file ou inline)');\r
+end\r
+\r
+% corps d'algorithme\r
+n=0;\r
+test=(feval(fcn,x0)~=0);\r
+x=x0;\r
+xmm1=xm1;\r
+fxmm1=feval(fcn,xm1);\r
+fx=feval(fcn,x);\r
+X=x0;\r
+while(test)\r
+ xnp1=x-((x-xmm1)/(fx-fxmm1))*fx;\r
+ n=n+1;\r
+ fxnp1=feval(fcn,xnp1);\r
+ test=~((fxnp1==0)|(n>=nmax)|(abs(x-xmm1)<=epsilon));\r
+ xmm1=x;\r
+ fxmm1=fx;\r
+ x=xnp1;\r
+ fx=feval(fcn,x);\r
+ X=[X x];\r
+end \r
+if (n>=nmax)\r
+ disp('attention, n>nmax');\r
+end\r
+\r
+\r
--- /dev/null
+function [ordre,corel]=log_erreur_iteration(l,X)\r
+\r
+\r
+% log_erreur_iteration : détermination d'un ordre de convergence (équation non linéaire)\r
+%\r
+% *********************************************************\r
+%\r
+% [ordre,corel]=log_erreur_iteration(l,X) renvoie\r
+% l'ordre et la correlation à partir d'itérés déjà calculé par une méthode numérique de \r
+% résolution de l'équation (scalaire) f(x)=0.\r
+%\r
+% variables d'entrées : \r
+% * X : le vecteur des différentes valeurs de la suite x_n\r
+% (déjà calculé par une méthode type dichotomie, Newton ....)\r
+% * l : la limite présumée (souvent choisie égale à la dernière valeur de X)\r
+%\r
+% variables de sortie :\r
+% * ordre est l'ordre mesuré (par droite de moindres carrés, à partir du nuage log-log)\r
+% * corel : correlation mesurée \r
+%\r
+% \r
+% \r
+% ************ Fonctions auxiliaires utilisées ************\r
+%\r
+% regression_lineaire\r
+%\r
+% *********************************************************\r
+%\r
+\r
+% corps d'algorithme\r
+auxi=abs(X-l);\r
+ind=find(auxi~=0);\r
+auxi=auxi(ind);\r
+auxi=log10(auxi);\r
+x=auxi(1:end-1);\r
+y=auxi(2:end);\r
+[ordre,b,corel]=regression_lineaire(x,y);\r
+\r
+\r
--- /dev/null
+% demo_trace_iteration_point_fixe : tracé des différents itérés d'une méthode de point fixe.\r
+%\r
+% à entrer : * la fonction g (telle que x_{n+1}=g(x_n)),\r
+% * la valeur initiale (numérique ou symbolique)\r
+% * p l'indice de la dernière valeur calculée. \r
+% affiche le colimaçon : \r
+% * avec les valeurs successives avec animation par movie\r
+% * ou en statique\r
+\r
+clear g x0 X F k p;\r
+disp('entrée de la fonction g');\r
+g=saisiefonction;\r
+x0=input('entrez la première valeur : ');\r
+p=input('entrez le nombre de valeurs : ');\r
+ch=input('voulez vous le colimaçon en statique (entrez s) ou en animation (entrez a) : ','s');\r
+if isnumeric(x0)\r
+ X=zeros(1,p+1);\r
+ ch0=' (numérique)';\r
+ vx0=num2str(x0);\r
+else\r
+ X=sym(zeros(1,p+1));\r
+ ch0=' (symbolique)';\r
+ vx0=char(x0);\r
+end\r
+auxi=x0;\r
+X(1)=x0;\r
+for k=1:p\r
+ auxi=feval(g,auxi);\r
+ X(k+1)=auxi;\r
+end\r
+p=length(X)-1;\r
+if ~isnumeric(x0)\r
+ X=double(vpa(X));\r
+end\r
+xmin=min(X);\r
+xmax=max(X);\r
+if (xmin==xmax)\r
+ error('attention, suite constante : arrêt du programme');\r
+end\r
+clf;\r
+x2=xmax+0.1*(xmax-xmin);\r
+x1=xmin-0.1*(xmax-xmin);\r
+xgraph=x1:(x2-x1)/200:x2;\r
+abscisse=zeros(1,2*p+1);\r
+ordonnee=zeros(1,2*p+1);\r
+abscisse(1:2:2*p+1)=X;\r
+abscisse(2:2:2*p)=X(1:end-1);\r
+ordonnee(1)=xmin;\r
+ordonnee(2:2:2*p)=X(2:end);\r
+ordonnee(3:2:2*p+1)=X(2:end);\r
+hold on;\r
+axis([x1 x2 x1 x2]);\r
+plot(xgraph,feval(g,xgraph),'r');\r
+plot([x1 x2],[x1 x2],'g');\r
+if (strcmp(ch,'s'))\r
+ c=exist(g);\r
+ if (c==2) | (c==5) \r
+ titre=[g,'(x)'];\r
+ else\r
+ titre=formula(g);\r
+ end\r
+ \r
+ title([int2str(p),' itérés de la fonction ',titre, ' pour x0=',vx0,ch0]);\r
+ plot(abscisse,ordonnee,'b');\r
+ legend('y=g(x)','y=x','itérés',0);\r
+else\r
+ for k=0:p-1\r
+ plot(abscisse(1:2*k+3),ordonnee(1:2*k+3));\r
+ plot(X(k+1),X(k+2),'o b');\r
+ F(k+1)=getframe;\r
+ end\r
+ movie(F,1,6);\r
+end\r
+hold off;\r
--- /dev/null
+function [n,X]=iteration_point_fixe(x0,nmax,epsilon,fcn)\r
+\r
+\r
+% iteration_point_fixe : calcul des itérés de la méthode de point fixe\r
+%\r
+% *********************************************************\r
+%\r
+% [n,X]=iteration_point_fixe(x0,nmax,epsilon,fcn) renvoie\r
+% les itérés de la méthode de point fixe\r
+%\r
+% variables d'entrées : \r
+% * nmax : nombre maximal d'itérations\r
+% * x0 : terme initial\r
+% * epsilon : précision souhaitée\r
+% * fcn est une chaîne de caractère représentant la fonction \r
+% (de type inline, builtin ou par fichier M-file);\r
+%\r
+% variables de sortie :\r
+% * n est l'indice correspondant à x_n avec f(x_n)=0 ou |x_n-x_{n-1}|<epsilon \r
+% ou n>=nmax\r
+% * X est une vecteur qui contient les valeurs de x_0 à x_n\r
+%\r
+% ************ Fonctions auxiliaires utilisées ************\r
+%\r
+% aucune\r
+%\r
+% *********************************************************%\r
+\r
+\r
+\r
+\r
+\r
+\r
+% Contrôles d'entrée\r
+qs=exist(fcn);\r
+if (qs~=2) & (qs~=5) & (qs~=1)\r
+ error('fcn doit être le nom d''une fonction (built-in, M-file ou inline)');\r
+end\r
+\r
+% corps d'algorithme\r
+n=0;\r
+test=(feval(fcn,x0)-x0~=0);\r
+x=x0;\r
+X=x0;\r
+xm1=x0;\r
+while(test)\r
+ x=feval(fcn,x);\r
+ X=[X x];\r
+ n=n+1;\r
+ test=~((feval(fcn,x)-x0==0)|(n>=nmax)|(abs(x-xm1)<=epsilon));\r
+ xm1=x; \r
+end\r
+if (n>=nmax)\r
+ disp('attention, n>nmax');\r
+end\r
+\r
+\r
--- /dev/null
+% etude_fonction_particulier : petit script pour étudier la fonction\r
+% f(x)=2/sqrt(3)*cos(x)+3-2sqrt(3)\r
+\r
+g=inline('2/sqrt(3)*cos(x)+3-2*sqrt(3)');\r
+gp=inline('-2/sqrt(3)*sin(x)');\r
+x=0:0.01:pi/3;\r
+plot(x,g(x)-x,x,gp(x));\r
+legend('courbe de g(x)-x','courbe de g''(x)');\r
+\r
--- /dev/null
+function [er,X]=sqrtm_iteration_newton(A,X0,epsilon)\r
+\r
+% \r
+% sqrtm_iteration_newton : calcul d'une racine carrée de matrice par la méthode de Newton.\r
+%\r
+%\r
+% *********************************************************\r
+%\r
+% [er,X]=sqrtm_iteration_newton(A,X0,espilon)\r
+% calcule les différents itérés de\r
+% la méthode de Newton pour la recherche d'une racine de matrice.\r
+% A chaque itération, elle affiche et stocke le résultat X_k ainsi que l'erreur\r
+% er(k)=|||X_k^2-A|||.\r
+% \r
+% variables d'entrées :\r
+% * A :matrice dont on veut une racine.\r
+% * X0 : matrice initiale\r
+% * epsilon : paramètre de précision\r
+% variables de sortie :\r
+% * er: suite des erreurs, définies par er(k)=norm(X_k^2-A).\r
+% * X : suite des itérés (matriciels) calculés.\r
+% \r
+% ATTENTION : nombre maximum d'itération défini par nmax\r
+% \r
+% ************ Fonctions auxiliaires utilisées ************\r
+%\r
+% aucune\r
+%\r
+% *********************************************************\r
+%\r
+\r
+% nombre maximum d'itération défini par nmax\r
+nmax=100;\r
+\r
+% Contrôles d'entrée\r
+[n,p]=size(A);\r
+if (n~=p) \r
+ error('attention, A n''est pas carrée : arrêt du programme');\r
+end\r
+if (norm(A*X0-X0*A,inf)~=0)\r
+ disp('attention, la matrice initiale et A ne commutent pas !!');\r
+end\r
+\r
+ \r
+\r
+% Corps d'algorithme\r
+er=[];\r
+x=X0;\r
+X=x;\r
+k=0;\r
+test=(norm(X0^2-A,inf)~=0);\r
+while(test)\r
+ y=(x+A/x)/2;\r
+ disp(['itération numéro ',int2str(k)]);\r
+ y2=y^2;\r
+ erloc=norm(y2-A);\r
+ er=[er erloc];\r
+ X=[X y];\r
+ test=~((norm(y2-A,inf)==0)|(k>=nmax)|(norm(x-y,inf)<=epsilon));\r
+ disp('itéré : ');\r
+ disp(y);\r
+ disp(['erreur : ',num2str(erloc)]);\r
+ disp('appuyez sur une touche pour continuer');\r
+ pause;\r
+ k=k+1;\r
+ x=y;\r
+end\r
+if (n>=nmax)\r
+ disp('attention, n>nmax');\r
+end\r
--- /dev/null
+function [n,X]=iteration_ordre3_gen(x0,nmax,epsilon,fcn)\r
+\r
+\r
+% iteration_ordre3_gen : calcul d'une racine la méthode d'ordre 3 générale\r
+%\r
+% *********************************************************\r
+%\r
+% [n,X]=iteration_ordre3_gen(x0,nmax,epsilon,fcn) renvoie\r
+% l'approximation de la racine d'une fonction par la méthode d'ordre trois\r
+% générale (les dérivées f' et f'' sont calculées symboliquement)\r
+%\r
+% variables d'entrées : \r
+% * nmax : nombre maximal d'itérations\r
+% * x0 : le premier terme\r
+% * epsilon : précision souhaitée\r
+% * fcn est une chaîne de caractère représentant la fonction \r
+% (de type inline, builtin ou par fichier M-file);\r
+%\r
+% variables de sortie :\r
+% * X est une vecteur qui contient les valeurs x_0, x_1, ...,x_n\r
+% * n est l'indice correspondant à x_n avec f(x_n)=0 ou |x_n-x_{n-1}|<epsilon \r
+% ou n>=nmax\r
+% \r
+% \r
+% ************ Fonctions auxiliaires utilisées ************\r
+%\r
+% aucune\r
+%\r
+% *********************************************************\r
+%\r
+\r
+\r
+% Contrôles d'entrée\r
+qs=exist(fcn);\r
+if (qs~=2) & (qs~=5) & (qs~=1)\r
+ error('fcn doit être le nom d''une fonction (built-in, M-file ou inline)');\r
+end\r
+\r
+% corps d'algorithme\r
+syms vx\r
+g=feval(fcn,vx);\r
+fcnpsymb=diff(g,vx);\r
+fcnppsymb=diff(fcnpsymb,vx);\r
+n=0;\r
+test=(feval(fcn,x0)~=0);\r
+x=x0;\r
+X=x;\r
+fx=feval(fcn,x);\r
+fxp=subs(fcnpsymb,vx,x);\r
+if ~(isnumeric(fxp));\r
+ xpp=eval(fxp);\r
+end\r
+fxpp=subs(fcnppsymb,vx,x);\r
+if ~(isnumeric(fxpp));\r
+ xpp=eval(fxpp);\r
+end\r
+while(test)\r
+ A=fxpp/2;\r
+ B=fxp;\r
+ C=fx;\r
+ if (C==0)\r
+ d=0; \r
+ else \r
+ r=sqrt(B^2-4*A*C);\r
+ Bp=B+r;\r
+ Bm=B-r;\r
+ Bpn=abs(Bp);\r
+ Bmn=abs(Bm);\r
+ if (Bpn<Bmn)\r
+ d=-2*C/Bm; \r
+ else\r
+ d=-2*C/Bp; \r
+ end\r
+ end\r
+ xnp1=x+d;\r
+ fxnp1=feval(fcn,xnp1);\r
+ test=~((fxnp1==0)|(n>=nmax)|(abs(x-xnp1)<=epsilon));\r
+ x=xnp1;\r
+ fx=feval(fcn,x);\r
+ fxp=subs(fcnpsymb,vx,x);\r
+ if ~(isnumeric(fxp));\r
+ xpp=eval(fxp);\r
+ end\r
+ fxpp=subs(fcnppsymb,vx,x);\r
+ if ~(isnumeric(fxpp));\r
+ xpp=eval(fxpp);\r
+ end\r
+ n=n+1;\r
+ X=[X x];\r
+end \r
+if (n>=nmax)\r
+ disp('attention, n>nmax');\r
+end\r
--- /dev/null
+function [n,X]=iteration_ordre3_gen_symb(x0,nmax,epsilon,fcn)\r
+\r
+\r
+% iteration_ordre3_gen_symb : calcul d'une racine la méthode d'ordre 3 générale (symbolyque)\r
+%\r
+% *********************************************************\r
+%\r
+% [n,X]=iteration_ordre3_gen_symb(x0,nmax,epsilon,fcn) renvoie\r
+% l'approximation de la racine d'une fonction par la méthode d'ordre trois\r
+% générale (les dérivées f' et f'' sont calculées symboliquement)\r
+% calcul en symbolique (x0 et fcn peuvent l'être)\r
+%\r
+% variables d'entrées : \r
+% * nmax : nombre maximal d'itérations\r
+% * x0 : le premier terme (éventuellement symbolique)\r
+% * epsilon : précision souhaitée\r
+% * fcn est une chaîne de caractère représentant la fonction (éventuellement symbolique) \r
+% (de type inline, builtin ou par fichier M-file); \r
+%\r
+% variables de sortie :\r
+% * X est une vecteur qui contient les valeurs x_0, x_1, ...,x_n\r
+% * n est l'indice correspondant à x_n avec f(x_n)=0 ou |x_n-x_{n-1}|<epsilon \r
+% ou n>=nmax\r
+% \r
+% \r
+% ************ Fonctions auxiliaires utilisées ************\r
+%\r
+% aucune\r
+%\r
+% *********************************************************\r
+%\r
+\r
+\r
+% Contrôles d'entrée\r
+qs=exist(fcn);\r
+if (qs~=2) & (qs~=5) & (qs~=1)\r
+ error('fcn doit être le nom d''une fonction (built-in, M-file ou inline)');\r
+end\r
+\r
+% corps d'algorithme\r
+syms vx\r
+g=feval(fcn,vx);\r
+fcnpsymb=diff(g,vx);\r
+fcnppsymb=diff(fcnpsymb,vx);\r
+n=0;\r
+test=(feval(fcn,x0)~=0);\r
+x=x0;\r
+X=x;\r
+fx=feval(fcn,x);\r
+fxp=subs(fcnpsymb,vx,x);\r
+if ~(isnumeric(fxp));\r
+ xpp=eval(fxp);\r
+end\r
+fxpp=subs(fcnppsymb,vx,x);\r
+if ~(isnumeric(fxpp));\r
+ xpp=eval(fxpp);\r
+end\r
+while(test)\r
+ A=fxpp/2;\r
+ B=fxp;\r
+ C=fx;\r
+ if (C==0)\r
+ d=0; \r
+ else \r
+ r=sqrt(B^2-4*A*C);\r
+ Bp=B+r;\r
+ Bm=B-r;\r
+ Bpn=abs(Bp);\r
+ Bmn=abs(Bm);\r
+ if (isnumeric(Bpn))\r
+ if (Bpn<Bmn)\r
+ d=-2*C/Bm; \r
+ else\r
+ d=-2*C/Bp; \r
+ end\r
+ else\r
+ if (double(Bpn)<double(Bmn))\r
+ d=-2*C/Bm; \r
+ else\r
+ d=-2*C/Bp; \r
+ end\r
+ end\r
+ end\r
+ xnp1=x+d;\r
+ fxnp1=feval(fcn,xnp1);\r
+ test=~((fxnp1==0)|(n>=nmax)|(abs(double(x-xnp1))<=epsilon));\r
+ x=xnp1;\r
+ fx=feval(fcn,x);\r
+ fxp=subs(fcnpsymb,vx,x);\r
+ if ~(isnumeric(fxp));\r
+ xpp=eval(fxp);\r
+ end\r
+ fxpp=subs(fcnppsymb,vx,x);\r
+ if ~(isnumeric(fxpp));\r
+ xpp=eval(fxpp);\r
+ end\r
+ n=n+1;\r
+ X=[X x];\r
+end \r
+if (n>=nmax)\r
+ disp('attention, n>nmax');\r
+end\r
--- /dev/null
+function [ait,deb_acc]=aitken(x0,exp_g,eps_seuil,n_max,nul_seuil)\r
+% produit les accélérés d'Aitken d'une suite du point fixe et l'indice de début d'accélération.\r
+% La convergence de la suite initiale est supposée connue,\r
+% ainsi que celle des accélérés.\r
+%\r
+% variables d'entrée\r
+% x0 est la valeur initiale,\r
+% exp_g le nom de la fonction d'itération passé sous la forme 'g(x)'\r
+% eps_seuil désigne comme annoncé dans l'ouvrage le seuil de variation\r
+% relative des itérés qui déclenche le processus d'accélération.\r
+% n_max est la taille maximale du vecteur attendu en sortie;\r
+% on se limite à des valeurs d'itérés distinctes au sens de nul_seuil.\r
+% nul_seuil est un réel positif en-dessous duquel un réel est considéré\r
+% nul;\r
+% plus précisément pour un vecteur d'itérés on ne prend plus en compte\r
+% les valeurs distantes de la valeur finale de moins de nul_seuil.\r
+%\r
+% variables de sortie\r
+% ait désigne le vecteur constitué des premiers itérés ordinaires de x0\r
+% par la fonction g,\r
+% suivis dès que possible au sens des paramètres passés,\r
+% par les accélérés d'Aitken,\r
+% avec arret dès que les suivants sont identiques au dernier terme\r
+% au sens de nul_seuil choisi.\r
+% deb_acc est l'indice au sens matlab du premier accéléré produit.\r
+\r
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\r
+% Fonctions appelées *\r
+% \r
+% \r
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\r
+\r
+\r
+% spécifications\r
+format long e;\r
+\r
+\r
+% tests d'entrée\r
+if nargin~=5\r
+ error('Nombre des arguments incorrect');\r
+end\r
+if n_max<2\r
+ error('taille n_max insuffisante pour accélérer');\r
+end\r
+% Il convient sans doute de tester d'autres paramètres, leur type etc...\r
+% selon la dangerosité des utilisateurs!\r
+\r
+\r
+% Algorithme proprement dit\r
+\r
+% Génération des itérés simples par la fonction g;\r
+% on peut remplacer par une écriture matricielle ce bloc. Il sera moins\r
+% lisible.\r
+x=x0;val(1)=x;\r
+for i=1:n_max-1\r
+ x=eval(exp_g);\r
+ val(i+1)=x;\r
+end\r
+\r
+\r
+% Mise à l'abri de misères!\r
+% On évite des valeurs identiques à partir d'un certain rang.\r
+ind=find(abs(diff(val))>nul_seuil);val=val(ind);\r
+n_max=size(val,2);\r
+\r
+% recherche des ratios de variation relative des éléments de val;\r
+% voir cours.\r
+\r
+% Ici q(n) représentera ce qui dans le cours est q d'indice n\r
+% contrairement à l'ordinaire matlab.\r
+q=diff(val(1:n_max-1))./diff(val(2:n_max));\r
+\r
+% variation des qn\r
+rel=diff(q)./q(2:n_max-2);\r
+ind=find(abs(rel)<eps_seuil);\r
+sprintf('Début de l''accélération x d''indice:%3.0f ',ind(1));\r
+deb_acc=ind(1)+1;\r
+\r
+% détermination du vecteur ait\r
+if ind(1)<=n_max-2\r
+ % calcul des accélérés sous aitken\r
+ ait=zeros(1,n_max-1);\r
+ ait(1:ind(1))=val(1:ind(1));\r
+ \r
+ % version matricielle\r
+ ait(ind(1)+1:n_max-1)=val(ind(1)+2:n_max)+diff(val(ind(1)+1:n_max))./(q(ind(1):n_max-2)-1);\r
+end\r
+\r
+\r
+% on suprime les valeurs présentes dans ait égales au sens de nul_seuil\r
+% à la dernière calculée considérée comme la limite.\r
+ind=find(abs(ait-ait(size(ait,2)))>=nul_seuil);\r
+ait=ait(ind);\r
+\r
+\r
+% affichage des résultats à la demande de l'utilisateur\r
+% Ce bloc peut etre remplacé par le passage d'un champ complémentaire\r
+% dans la fonction aitken, par exemple dem_affichage,\r
+% qui serait un booléen égal à 1\r
+% ssi l'utlisateur veut afficher les résultats.\r
+% Ainsi l'utilisateur par une copie de la fenetre de commande\r
+% après exécution récupère et imprime l'appel de fonction\r
+% avec les paramètres passés, suivi des résultats obtenus.\r
+\r
+\r
+ch=input('Voulez-vous afficher les résultats? (Si oui, taper 1)','s');\r
+if str2num(ch)==1\r
+ % à modifier selon l'impression souhaitée\r
+ nb_lig=3;\r
+ \r
+ s=[];\r
+ for i=1:size(ait,2)\r
+ s=[s sprintf('ait%2.0f = %12.10f ',i,ait(i))];\r
+ % pourrait etre remplacé par un calibrage en fonction\r
+ % de nul_seuil du type cal=-log10(2*nul_seuil)\r
+ % à passer après transformation chaine à la place de 12.10f.\r
+ if rem(i,nb_lig)==0|(i==size(ait,2))\r
+ disp(s);sprintf('\n');\r
+ s=[];\r
+ end\r
+ end\r
+end\r
+\r
+% fin de fonction aitken\r
--- /dev/null
+function entrelacs_conv_anim(f1,f2)\r
+% Propose une visualisation animée de la convergence d'une suite.\r
+%\r
+% variables d'entrée\r
+% f1 désigne un vecteur de n1 valeurs d'une suite convergente\r
+% dont la dernière est considérée comme la limite.\r
+% L'écart à la limite sera représenté par des rayons polaires\r
+% répartis sur un cercle proportionnellement aux gains de variation relative,\r
+% rapportés à la somme de ceux-ci, tous considérés en valeur absolue.\r
+% Le rayon est l'écart de chaque valeur à la "limite".\r
+% Idem en f2.\r
+\r
+\r
+% Tests d'entrée\r
+if nargin~=2\r
+ error('Nombre des arguments incorrect');\r
+end\r
+\r
+% ménage!\r
+clf;\r
+\r
+% Calibrage des données: ces constantes modifiables par l'utilisateur\r
+% pourraient aussi etre passées comme champs complémentaires.\r
+% nul_seuil: un nombre inférieur en valeur absolue à nul_seuil est considéré nul.\r
+% rap_seuil: pourcentage de la fenetre en dessous duquel on dilate l'image.\r
+% u: unité de pause en secondes; règle la vitesse de production des images.\r
+\r
+\r
+nul_seuil=0.5E-11;\r
+rap_seuil=0.1;\r
+u=1;\r
+\r
+% détermination des rayons vecteurs, angles\r
+% et initialisations diverses relatives à f1\r
+r1=abs(f1-f1(size(f1,2)));ind1=find(r1>nul_seuil);\r
+r1=r1(ind1);\r
+nb_pas1=size(r1,2);\r
+att1=zeros(1,nb_pas1);alph1=zeros(1,nb_pas1);\r
+var_rel1=abs(diff(r1))./abs(r1(2:nb_pas1));\r
+att1(2:nb_pas1)=1./var_rel1*u;\r
+alph1(2:nb_pas1)=2*pi/sum(var_rel1)*cumsum(var_rel1);\r
+\r
+% détermination des rayons vecteurs, angles\r
+% et initialisations diverses relatives à f2\r
+r2=abs(f2-f2(size(f2,2)));ind2=find(r2>nul_seuil);\r
+r2=r2(ind2);\r
+nb_pas2=size(r2,2);\r
+att2=zeros(1,nb_pas2);alph2=zeros(1,nb_pas2);\r
+var_rel2=abs(diff(r2))./abs(r2(2:nb_pas2));\r
+att2(2:nb_pas2)=1./var_rel2*u;\r
+alph2(2:nb_pas2)=2*pi/sum(var_rel2)*cumsum(var_rel2);\r
+\r
+% création de la table globale\r
+% qui sera ordonnée temporellement ultérieurement.\r
+date1=cumsum(att1);num1=ones(1,nb_pas1);\r
+X1=r1.*cos(alph1);Y1=r1.*sin(alph1);\r
+date2=cumsum(att2);num2=3*ones(1,nb_pas2);\r
+X2=r2.*cos(alph2);Y2=r2.*sin(alph2);\r
+\r
+date=[date1 date2];num=[num1 num2];\r
+X=[X1 X2];Y=[Y1 Y2];r=[r1 r2];\r
+[tdate,ind]=sort(date);\r
+tnum=num(ind); tr=r(ind);\r
+tX=X(ind);tY=Y(ind);tatt=[0 diff(tdate)];\r
+\r
+\r
+% création des valeurs qui s'enroulent autour de\r
+% la limite avec ajustement d'échelle automatique\r
+% initialisations\r
+coef=1.1*min(r1(1),r2(1));\r
+lim1=[-coef coef -coef coef];\r
+c=rap_seuil*coef;\r
+x=[-c,-c,c,c,-c];y=[-c,c,c,-c,-c];\r
+tot=nb_pas1+nb_pas2;compt1=0;compt2=0;\r
+encor1=1;encor2=1;\r
+\r
+n=1;\r
+\r
+ \r
+% préparation des fenetres\r
+figure;\r
+subplot(2,2,1);title('Conv de suite 1');hold on;\r
+subplot(2,2,2);title('Var rel cum pour suite 1');hold on;\r
+subplot(2,2,3);title('Conv de suite 2');hold on;\r
+subplot(2,2,4);title('Var rel cum pour suite 2');hold on;\r
+\r
+max1=max(nb_pas1,nb_pas2);\r
+max2=max(sum(var_rel1),sum(var_rel2));\r
+lim2=1.1*[2 max1 0 max2];\r
+\r
+subplot(2,2,2);\r
+axis(lim2);plot((2:nb_pas1),cumsum(var_rel1),'k.-');\r
+hold on;\r
+subplot(2,2,4);\r
+axis(lim2);plot((2:nb_pas2),cumsum(var_rel2),'k.-');\r
+hold on;\r
+\r
+while n<=tot\r
+ if (1/coef*tr(n)>rap_seuil)\r
+ % suivi des points traites\r
+ ch=num2str(1+(tnum(n)-1)/2);\r
+ ch_x=['compt' ch];ch_y=['var_rel' ch];\r
+ eval([ch_x '=' ch_x '+1;']);tx=eval(ch_x);\r
+ ty=eval(['sum(' ch_y '(1:tx-1))']);\r
+ \r
+ % tracés dans les fenetres\r
+ subplot(2,2,tnum(n));axis(lim1);\r
+ line([0,tX(n)],[0,tY(n)]);hold on;\r
+ subplot(2,2,tnum(n)+1);axis(lim2);\r
+ plot([tx],[ty],'cs');\r
+ hold on;\r
+ \r
+ % prise d'une pause (bien méritée!)\r
+ pause(tatt(n));\r
+ \r
+ % mise à jour de n\r
+ n=n+1;\r
+ j=find(tnum(n:tot)==1);\r
+ if (j==[])&(encor1)\r
+ encor1=0;\r
+ subplot(2,2,1);axis(lim1);\r
+ plot([0],[0],'rp-');\r
+ legend('Limite ''atteinte''',0);\r
+ hold on;\r
+ end\r
+ j=find(tnum(n:tot)==3);\r
+ if (j==[])&(encor2);\r
+ encor2=0;\r
+ subplot(2,2,3);axis(lim1);\r
+ plot([0],[0],'rp-');\r
+ legend('Limite ''atteinte''',0);\r
+ hold on;\r
+ end\r
+ \r
+ else\r
+ % annonce d'agrandissement\r
+ c=rap_seuil*coef;\r
+ x=[-c,-c,c,c,-c];y=[-c,c,c,-c,-c];\r
+ if encor1\r
+ subplot(2,2,1);axis(lim1);\r
+ plot(x,y,'r.--');\r
+ hold on;pause(u/4);\r
+ end\r
+ if encor2\r
+ subplot(2,2,3);axis(lim1);\r
+ plot(x,y,'r.--');\r
+ hold on;pause(u/4);\r
+ end\r
+ \r
+ % changement d'échelle\r
+ k=1.1/coef*tr(n);\r
+ lim1=k*lim1;coef=k*coef;\r
+ end\r
+end\r
+\r
+% fin de fonction
\ No newline at end of file
--- /dev/null
+function val=point_fixe(x0,nom_g,n_max)\r
+% produit un vecteur d'itérés d'une valeur initiale par une fonction g\r
+%\r
+% variable d'entrée\r
+% x0 est la valeur initiale choisie;\r
+% nom_g l'expression de la fonction donnée\r
+% sous la forme d'une chaine 'g(x)';\r
+% n_max est un entier naturel donnant la longueur du vecteur des itérés.\r
+%\r
+% variables de sortie\r
+% val est le vecteur des itérés de x0 par g de longueur n_max.\r
+\r
+% On pourra tester cette fonction en tapant en fenetre de commande\r
+% point_fixe(2,'(60*x-36-6*x^2)^(1/4)',20).\r
+\r
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\r
+% Fonctions appelées *\r
+% \r
+% \r
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\r
+\r
+% spécifications\r
+format long e;\r
+\r
+\r
+x=x0;val(1)=x;\r
+for i=1:n_max-1\r
+ x=eval(nom_g);\r
+ val(i+1)=x;val;\r
+end\r
+\r
+ch=input('Voulez-vous afficher les résultats? (Si oui, taper 1)','s');\r
+if str2num(ch)==1\r
+ % à modifier selon l'impression souhaitée\r
+ nb_lig=3;\r
+ \r
+ s=[];\r
+ for i=1:size(val,2)\r
+ s=[s sprintf('ptf%2.0f = %12.10f ',i,val(i))];\r
+ % pourrait etre remplacé par un calibrage en fonction\r
+ % de nul_seuil du type cal=-log10(2*nul_seuil)\r
+ % à passer après transformation chaine à la place de 12.10f.\r
+ if (rem(i,nb_lig)==0)|(i==size(val,2))\r
+ disp(s);sprintf('\n');\r
+ s=[];\r
+ end\r
+ end\r
+end\r
+\r
+% fin de point_fixe\r
+ \r
--- /dev/null
+function [stef,deb_acc]=steffensen(x0,exp_g,eps_seuil,n_max,nul_seuil)\r
+% Produit accélérés de Steffensen d'une suite du point fixe et indice de\r
+% début d'accélération.\r
+% La convergence de la suite initiale est supposée connue,\r
+% ainsi que celle des accélérés.\r
+% Ce fichier bénéficie de la connaissance préalable de la fonction ait.\r
+%\r
+% variables d'entrée\r
+% x0 est la valeur initiale,\r
+% exp_g le nom de la fonction d'itération passé sous la forme 'g(x)'\r
+% eps_seuil désigne comme annoncé dans l'ouvrage le seuil de variation\r
+% relative des itérés,\r
+% qui déclenche le processus d'accélération.\r
+% n_max est la taille maximale du vecteur attendu en sortie;\r
+% on se limite à des valeurs d'itérés distinctes au sens de nul_seuil.\r
+% nul_seuil est un réel positif en-dessous duquel\r
+% un réel est considéré nul.\r
+%\r
+% variables de sortie\r
+% stef désigne le vecteur constitué des premiers itérés ordinaires de x0\r
+% par la fonction g,\r
+% suivis dès que possible au sens des paramètres passés,\r
+% par les accélérés de Steffensen,\r
+% avec arret dès que les suivants sont identiques au sens de nul_seuil\r
+% choisi.\r
+% deb_acc est l'indice au sens matlab du premier accéléré produit.\r
+\r
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\r
+% Fonctions appelées *\r
+% \r
+% \r
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\r
+\r
+\r
+% spécifications\r
+format long e;\r
+\r
+\r
+% Tests d'entrée\r
+if nargin~=5\r
+ error('Nombre des arguments incorrect');\r
+end\r
+if n_max<2\r
+ error('taille n_max insuffisante pour accélérer');\r
+end\r
+% Il convient sans doute de tester d'autres paramètres, leur type etc...\r
+% selon la dangerosité des utilisateurs!\r
+% Test complémentaire sur donnée\r
+if n_max<2\r
+ error('taille n_max insuffisante pour accélérer');\r
+end\r
+\r
+% Algorithme proprement dit\r
+\r
+% Initialisation des vecteurs stef et util\r
+\r
+stef=zeros(1,n_max);stef(1)=x0;\r
+% util vecteur de longueur 4, contient initialement les itérés lents\r
+% ordinaires.\r
+x=x0;util(1)=x;\r
+for i=1:3\r
+ x=eval(exp_g);\r
+ util(i+1)=x;\r
+end\r
+\r
+% Initialisations\r
+% numéro du premier candidat à l'accélération\r
+% au sens des indices matlab\r
+compt=2;deb_acc=2;\r
+\r
+% Initialisations avant l'entrée en boucle\r
+% en pratique toujours parcourue une fois...\r
+\r
+q_util=diff(util(1:3))./diff(util(2:4));\r
+rel=diff(q_util)/q_util(2);\r
+% définition du booléen d'autorisation d'accélération: voir cours.\r
+b_acc=(abs(rel)<eps_seuil);\r
+\r
+% Puis on recherche les ratios relatifs à util,\r
+% vecteur des seules valeurs utiles à l'accélération.\r
+% Attention ici q_util(n) représente q_util d'indice n contrairement\r
+% à l'ordinaire matlab.\r
+\r
+% Attente d'accélération (comme en Aitken)\r
+while (b_acc==0)&(compt<=n_max)\r
+ \r
+ % construction de stef avant accélération\r
+ stef(compt)=util(2);\r
+ \r
+ % mise à jour de util\r
+ x=util(4);\r
+ util(1:3)=util(2:4);\r
+ util(4)=eval(exp_g);\r
+ \r
+ % test pour accélération\r
+ q_util=diff(util(1:3))./diff(util(2:4));\r
+ rel=diff(q_util)/q_util(2);\r
+ b_acc=(abs(rel)<eps_seuil);\r
+ \r
+ % mise à jour de compt et deb_acc\r
+ compt=compt+1;deb_acc=deb_acc+1;\r
+end\r
+\r
+\r
+% Après une zone tampon, l'accélération systématique:\r
+% on va changer de cheval!\r
+% Le vecteur acc contiendra trois accélérés successifs;\r
+% on calcule le premier sous ce bloc if.\r
+\r
+% initialisations\r
+acc=zeros(1,3);acc(1:2)=util(1:2);\r
+\r
+% zone tampon\r
+if compt<=n_max\r
+ % premier style de calcul:utilisation de eval\r
+ g_acc=[exp_g,'+(' exp_g '-acc(2))/((acc(2)-acc(1))/(' exp_g '-acc(2))-1)'];\r
+ x=acc(2);val=eval(g_acc);\r
+ stef(compt)=val;acc(3)=val;\r
+ % préparation de la suite: glissement des accélérés\r
+ % et mise à jour de compt\r
+ acc(1:2)=acc(2:3);\r
+ x=acc(2);acc(3)=eval(exp_g);\r
+ compt=compt+1;\r
+end\r
+\r
+% Calcul des accélérés avec ré-entrance\r
+while (compt<=n_max)&(abs(diff(acc(1:2)))>nul_seuil)\r
+ \r
+ % calcul de l'accéléré suivant\r
+ % ici par formule du delta2 d'Aitken!\r
+ val=acc(3)-(diff(acc(2:3))^2)/diff(diff(acc));\r
+ stef(compt)=val;acc(3)=val;\r
+ \r
+ % Il convient de noter que les accélérés obtenus pourraient etre\r
+ % améliorés en considérant les deux accélérés obtenus à partir de \r
+ % trois itérés successifs; ceci éviterait le phénomène qui apparait\r
+ % sous la fonction entrelacs... appliquée aux steffensen.\r
+ \r
+ % préparation du tour suivant\r
+ acc(1:2)=acc(2:3);\r
+ x=acc(2);acc(3)=eval(exp_g);\r
+ compt=compt+1;\r
+end\r
+\r
+% suppression des valeurs rendues inutiles après l'arret du calcul\r
+stef;ind=find(stef~=0);stef=stef(ind);\r
+\r
+\r
+% affichage des résultats à la demande de l'utilisateur\r
+% Ce bloc peut etre remplacé par le passage d'un champ complémentaire\r
+%dans la fonction steffensen par exemple dem_affichage,\r
+% qui serait un booléen égal à 1\r
+% ssi l'utilisateur veut afficher les résultats.\r
+% Ainsi l'utilisateur par une copie de la fenetre de commande\r
+% après exécution récupère\r
+% et imprime l'appel de fonction avec les paramètres passés\r
+% suivi des résultats obtenus.\r
+\r
+ch=input('Voulez-vous afficher les résultats? (Si oui, taper 1)','s');\r
+if str2num(ch)==1\r
+ % à modifier selon l'impression souhaitée\r
+ nb_lig=3;\r
+ \r
+ s=[];\r
+ for i=1:size(stef,2)\r
+ s=[s sprintf('stef%2.0f = %12.10f ',i,stef(i))];\r
+ % pourrait etre remplacé par un calibrage en fonction\r
+ % de nul_seuil du type cal=-log10(2*nul_seuil)\r
+ % à passer après transformation chaine à la place de 12.10f.\r
+ if rem(i,nb_lig)==0|(i==size(stef,2))\r
+ disp(s);sprintf('\n');\r
+ s=[];\r
+ end\r
+ end\r
+end\r
+ \r
+% fin de fonction steffensen\r
+\r
--- /dev/null
+function visu1_conv_anim(f1)\r
+% Propose une visualisation animée de la convergence d'une suite.\r
+%\r
+% variables d'entrée\r
+% f1 désigne un vecteur de n1 valeurs d'une suite convergente\r
+% dont la dernière est considérée comme la limite.\r
+% L'écart à la limite sera représenté par des rayons polaires\r
+% répartis sur un cercle proportionnellement aux gains de variation relative,\r
+% rapportés à la somme de ceux-ci, tous considérés en valeur absolue.\r
+% Le rayon est l'écart de chaque valeur à la "limite".\r
+\r
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\r
+% Fonctions appelées *\r
+% \r
+% \r
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\r
+\r
+% Tests d'entrée\r
+if nargin~=1\r
+ error('Nombre des arguments incorrect');\r
+end\r
+\r
+% ménage!\r
+clf;\r
+\r
+% Calibrage des données: ces constantes modifiables par l'utilisateur\r
+% pourraient aussi etre passées comme champs complémentaires.\r
+\r
+% nul_seuil: un nombre inférieur en valeur absolue à nul_seuil est considéré nul.\r
+% rap_seuil: pourcentage de la fenetre en dessous duquel on dilate l'image.\r
+% u unité de temps en seconde, pour l'expression d'une pause\r
+% déterminant la vitesse de défilement des images.\r
+nul_seuil=0.5E-11;\r
+rap_seuil=0.1;\r
+u=2;\r
+\r
+\r
+% détermination des rayons vecteurs, angles\r
+% et initialisations diverses relatives à f1\r
+\r
+r1=abs(f1-f1(size(f1,2)));ind1=find(r1>nul_seuil);\r
+r1=r1(ind1);\r
+nb_pas1=size(r1,2);\r
+att1=zeros(1,nb_pas1);alph1=zeros(1,nb_pas1);\r
+var_rel=abs(diff(r1))./abs(r1(2:nb_pas1));\r
+att1(2:nb_pas1)=1./var_rel*u;\r
+alph1(2:nb_pas1)=2*pi/sum(var_rel)*cumsum(var_rel);\r
+coef=1.1*r1(1);\r
+lim=[-coef coef -coef coef];\r
+\r
+\r
+% création des valeurs qui s'enroulent autour de\r
+% la limite avec ajustement d'échelle automatique\r
+\r
+n=1;\r
+\r
+% préparation de la fenetre\r
+title('Visualisation de convergence');\r
+c=rap_seuil*coef;\r
+X=[-c,-c,c,c,-c];Y=[-c,c,c,-c,-c];\r
+\r
+while n<=nb_pas1\r
+ if (1/coef*r1(n)>rap_seuil)\r
+ \r
+ x1=r1(n)*cos(alph1(n));\r
+ y1=r1(n)*sin(alph1(n));\r
+ % tracé\r
+ axis(lim);\r
+ line([0,x1],[0,y1]);hold on;\r
+ % prise d'une pause (bien méritée!)\r
+ pause(att1(n));\r
+ % mise à jour de n\r
+ n=n+1;\r
+ else\r
+ % annonce d'agrandissement\r
+ c=rap_seuil*coef;\r
+ X=[-c,-c,c,c,-c];Y=[-c,c,c,-c,-c];\r
+ axis(lim);\r
+ plot(X,Y,'r.--');\r
+ hold on;pause(u/4)\r
+ % changement d'échelle\r
+ k=1.1/coef*r1(n);\r
+ lim=k*lim;coef=k*coef;\r
+ end\r
+end \r
+\r
+% indication de fin de convergence\r
+axis(lim);\r
+plot([0],[0],'rp-');legend('Limite ''atteinte''',0);\r
+hold off;\r
+\r
+% fin de fonction\r
+\r
+\r
+\r
+ \r
+ \r
+ \r
+ \r
+ \r
+ \r
+\r
+\r
+ \r
+\r
+\r
+\r
+\r
+\r
+\r
+\r
+\r
+\r
+\r
+\r
--- /dev/null
+function visu2_conv_anim(f1,f2)\r
+% Propose une visualisation animée de la convergence comparée de deux suites.\r
+%\r
+% variables d'entrée\r
+% f1 désigne un vecteur de n1 valeurs qui seront représentées en polaire\r
+% par pas angulaire de 2*pi/n1;\r
+% le rayon est l'écart de chaque valeur à la dernière, considérée comme limite.\r
+% Idem en f2.\r
+\r
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\r
+% Fonctions appelées *\r
+% \r
+% \r
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\r
+\r
+\r
+% Tests d'entrée\r
+if nargin~=2\r
+ error('Nombre des arguments incorrect');\r
+end\r
+\r
+% ménage!\r
+clf;\r
+\r
+% Calibrage des données: ces constantes modifiables par l'utilisateur\r
+% pourraient aussi etre passées comme champs complémentaires.\r
+% nul_seuil: un nombre inférieur en valeur absolue à nul_seuil est considéré nul.\r
+% rap_seuil: pourcentage de la fenetre en dessous duquel on dilate l'image.\r
+% u: unité de pause en secondes; règle la vitesse de production des images.\r
+\r
+\r
+nul_seuil=0.5E-11;\r
+rap_seuil=0.1;\r
+u=1;\r
+\r
+% détermination des rayons vecteurs\r
+r1=abs(f1-f1(size(f1,2)));ind1=find(r1>nul_seuil);\r
+r1=r1(ind1);\r
+r2=abs(f2-f2(size(f2,2)));ind2=find(r2>nul_seuil);\r
+r2=r2(ind2);\r
+\r
+% calibrage des axes et choix du pas angulaire\r
+alph1=2*pi/size(r1,2);\r
+alph2=2*pi/size(r2,2);\r
+coef=1.1*min(r1(1),r2(1));\r
+lim=[-coef coef -coef coef];\r
+\r
+% création des valeurs qui s'enroulent autour de\r
+% la limite avec ajustement d'échelle automatique\r
+\r
+tailles=[size(r1,2),size(r2,2)];\r
+nb_pas1=min(tailles);nb_pas2=max(tailles);\r
+n=1;\r
+\r
+% préparation des fenetres\r
+subplot(2,1,1);title('Convergence de suite 1');\r
+subplot(2,1,2);title('Convergence de suite 2');\r
+% on peut faire plus rusé pour le titre!\r
+c=rap_seuil*coef;\r
+X=[-c,-c,c,c,-c];Y=[-c,c,c,-c,-c];\r
+\r
+while n<=nb_pas1\r
+ if (1/coef*min(r1(n),r2(n))>rap_seuil)\r
+ \r
+ x1=r1(n)*cos((n-1)*alph1);\r
+ y1=r1(n)*sin((n-1)*alph1);\r
+ x2=r2(n)*cos((n-1)*alph2);\r
+ y2=r2(n)*sin((n-1)*alph2);\r
+ \r
+ % tracé dans les deux fenetres\r
+ subplot(2,1,1);axis(lim);\r
+ line([0,x1],[0,y1]);hold on;\r
+ subplot(2,1,2);axis(lim);\r
+ line([0,x2],[0,y2]);hold on;\r
+ \r
+ % prise d'une pause (bien méritée!)\r
+ pause(2*u);\r
+ \r
+ % mise à jour de n\r
+ n=n+1;\r
+ else\r
+ % annonce d'agrandissement\r
+ c=rap_seuil*coef;\r
+ X=[-c,-c,c,c,-c];Y=[-c,c,c,-c,-c];\r
+ subplot(2,1,1);axis(lim);\r
+ plot(X,Y,'r.--');\r
+ hold on;pause(2)\r
+ subplot(2,1,2);axis(lim);\r
+ plot(X,Y,'r.--');\r
+ hold on;pause(2);\r
+ % changement d'échelle\r
+ k=1.1/coef*min(r1(n),r2(n));\r
+ lim=k*lim;coef=k*coef;\r
+ end\r
+end \r
+% Variante : il est possible d'utiliser\r
+% la fonction movie et de créer une animation\r
+\r
+% indication de fin de convergence\r
+\r
+if nb_pas1~=nb_pas2\r
+ ind=find(tailles==nb_pas2);\r
+ r3=eval(['r' num2str(ind)]);\r
+ alph3=eval(['alph' num2str(ind)]);\r
+ num=3-ind;\r
+ subplot(2,1,num);axis(lim);\r
+ plot([0],[0],'rp-');legend('Limite ''atteinte''',0);\r
+ hold on;\r
+ % préparation de fin de tracé\r
+ num=3-num;\r
+else\r
+ subplot(2,1,1);axis(lim);\r
+ plot([0],[0],'rp-');legend('Limite ''atteinte''',0);\r
+ hold on;subplot(2,1,2);axis(lim);\r
+ plot([0],[0],'bp-');legend('Limite ''atteinte''',0);\r
+ hold on;\r
+end\r
+\r
+% tracé de la courbe restante éventuelle\r
+\r
+while n<=nb_pas2\r
+ if (1/coef*r3(n)>rap_seuil)\r
+ \r
+ x3=r3(n)*cos((n-1)*alph3);\r
+ y3=r3(n)*sin((n-1)*alph3);\r
+ \r
+ % tracé dans la fenetre convenable\r
+ subplot(2,1,num);axis(lim);\r
+ line([0,x3],[0,y3]);hold on;\r
+ \r
+ % prise d'une pause (bien méritée!)\r
+ pause(2);\r
+ \r
+ % mise à jour de n\r
+ n=n+1;\r
+ else\r
+ % annonce d'agrandissement\r
+ c=rap_seuil*coef;\r
+ X=[-c,-c,c,c,-c];Y=[-c,c,c,-c,-c];\r
+ subplot(2,1,num);axis(lim);\r
+ plot(X,Y,'r.--');\r
+ hold on;pause(2);\r
+ % changement d'échelle\r
+ k=1.1/coef*r3(n);\r
+ lim=k*lim;coef=k*coef;\r
+ end\r
+end\r
+\r
+% limite atteinte\r
+subplot(2,1,num);axis(lim);\r
+plot([0],[0],'bp-');legend('Limite ''atteinte''',0);\r
+hold off;\r
+\r
+% fin de fonction
\ No newline at end of file
--- /dev/null
+function affiche_racines(ens_rac,exp_pol3,f_seuil)\r
+% affiche les racines sous différentes formes possibles\r
+%\r
+% variables d'entrée\r
+% ens_rac est le vecteur des racines de l'équation traitée;\r
+% exp_pol3 est la chaine associée à pol3;\r
+% f_seuil désigne le module de pol3(x) pour lequel il est assimilé à zéro.\r
+%\r
+% variables de sortie\r
+% on peut extraire les objets fabriqués.\r
+\r
+% tests à écrire; pas de fonctions sous-jacente...\r
+\r
+% au fait\r
+% sortie des résultats sous forme symbolique\r
+disp('Sortie des résultats sous forme symbolique proposée par matlab');\r
+symb=sym(ens_rac,'r');disp('ens_rac = ');disp (symb);\r
+\r
+\r
+% tentative d'arrondi des racines au sens de f_seuil\r
+% pourrait s'écrire matriciellement ou etre une routine annexe déclenchée\r
+% par le passage d'un champ complémentaire.\r
+\r
+for k=1:size(ens_rac,2)\r
+ x=round(ens_rac(k));val=eval(exp_pol3);\r
+ if abs(val)<f_seuil\r
+ ens_rac(k)=round(ens_rac(k));\r
+ end \r
+end\r
+disp('Sortie des résultats arrondis au sens de f_seuil');\r
+disp(num2str(ens_rac));\r
+disp('Sortie des résultats bruts');\r
+ens_rac\r
--- /dev/null
+function [ens_rac,nb_iter]=muller(init,pol3,arret)\r
+% Produit une racine d'équation (E) f(x)=0 par méthode de Muller.\r
+% Le calcul se termine par un forçage à une écriture symbolique de rac,\r
+% qui est affichée en plus de la numérique!\r
+% Ceci peut etre aisément modifié!\r
+%\r
+% variables d'entrée\r
+% init est un vecteur de trois valeurs initiales distinctes\r
+% pour la méthode de Muller classique. On peut généraliser!\r
+% pol3 définit le polynome de degré trois, passé comme un vecteur\r
+% de réels conformément à l'ordinaire matlab.\r
+% arret est un vecteur de trois réels [f_seuil,nul_seuil,n_max]\r
+% dont la signification est la suivante:\r
+% si |f(x)|<f_seuil on considère f(x) nul;\r
+% si |x|<nul_seuil on considère x nul;\r
+% n_max est un entier naturel qui désigne le nombre maximal\r
+% d'itérations autorisées.\r
+%\r
+% variables de sortie\r
+% ens_rac désigne l'ensemble des valeurs approchées des racines réelles\r
+% ou complexes de l'équation pol3(x)=0.\r
+% Elles sont obtenues à partir d'init par algorithme de Muller classique.\r
+% nb_iter est un vecteur qui grade trace du nombre d'itérations\r
+% nécessaires au calcul de chaque racine, sachant qu'une racine complexe\r
+% et sa conjuguée sont produites en un seul calcul.\r
+%\r
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\r
+% Fonctions connexes appelées\r
+%\r
+% muller_elem, affiche_racines (si libérée du commentaire)\r
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\r
+% spécification\r
+format long e;\r
+\r
+% Tests d'entrée\r
+\r
+if nargin~=3\r
+ error('Nombre des arguments incorrect, ou écriture inattendue');\r
+end\r
+% Les tests de controle suivants peuvent etre plus ou moins développés,\r
+% selon la dangerosité pressentie de l'utilisateur... ordinaire!\r
+if (size(init,1)~=1)|(size(init,2)~=3)|((sum(diff(init)==0)>0))\r
+ error('Champ init mal écrit. Voir controle');\r
+end\r
+if (size(arret,1)~=1)|(size(arret,2)~=3)\r
+ error('Champ arret mal écrit. Voir controle');\r
+end\r
+if (size(pol3,1)~=1)|(isstr(pol3))\r
+ error('Champ pol3 mal écrit. pol3 est un vecteur de réels ici');\r
+end\r
+% compléments éventuels\r
+\r
+\r
+% Algorithme proprement dit\r
+\r
+\r
+% initialisations et préparation des données\r
+ens_rac=[];nb_iter=[];\r
+\r
+while pol3(1)==0\r
+ pol3(1)=[];\r
+end\r
+% si on a passé sciemment le vecteur nul,\r
+% on peut s'interroger sur la nullité de l'utilisateur!\r
+deg=size(pol3,2)-1;\r
+\r
+% création de la chaine d'appel de muller_elem associée à pol3 ou autre!\r
+vect=pol3;\r
+exp_f=vect2str(vect);\r
+\r
+\r
+while deg>1\r
+ \r
+ % adjonction des nouvelles racines issues de Muller élémentaire\r
+ [rac,iter]=muller_elem(init,exp_f,arret);\r
+ ens_rac=[ens_rac rac];nb_iter=[nb_iter iter];\r
+ \r
+ % deflation\r
+ taille=size(rac,2);\r
+ switch taille\r
+ case 1\r
+ div=[1 -rac];deg=deg-1;\r
+ case 2\r
+ div=[1 -sum(rac) prod(rac)];deg=deg-2;\r
+ end\r
+ \r
+ % préparation de l'itération suivante\r
+ vect=deconv(vect,div);\r
+ exp_f=vect2str(vect);\r
+end\r
+\r
+% fin de déflation éventuelle\r
+if deg==1 \r
+ rac=-vect(2)/vect(1);\r
+ iter=0;\r
+ ens_rac=[ens_rac rac];nb_iter=[nb_iter iter];\r
+end\r
+\r
+% affichage éventuel des résultats\r
+% à libérer du commentaire éventuellement\r
+% affiche_racines(ens_rac,vect2str(pol3),arret(1));\r
+% fin de fonction
\ No newline at end of file
--- /dev/null
+function [rac,nb_iter]=muller_elem(init,exp_f,arret)\r
+% Produit une racine d'équation (E) f(x)=0 par méthode de Muller.\r
+% Le calcul se termine par un forçage à une écriture symbolique de rac,\r
+% qui est affichée en plus de la numérique!\r
+% Ceci peut etre aisément modifié!\r
+%\r
+% variables d'entrée\r
+% init est un vecteur de trois valeurs initiales distinctes\r
+% pour la méthode de Muller classique. On peut généraliser!\r
+% exp_f est l'expression de la fonction f sous la forme 'f(x)';\r
+% arret est un vecteur de trois réels [f_seuil,nul_seuil,n_max]\r
+% dont la signification est la suivante:\r
+% si |f(x)|<f_seuil on considère f(x) nul;\r
+% si |x|<nul_seuil on considère x nul;\r
+% n_max est un entier naturel qui désigne le nombre maximal\r
+% d'itérations autorisées.\r
+%\r
+% variables de sortie\r
+% rac est une valeur approchée de la racine obtenue à partir d'init\r
+% par algorithme de Muller classique; elle peut etre réelle ou complexe.\r
+% nb_iter désigne le nombre d'itérations exécutée pour sortir rac.\r
+%\r
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\r
+% Fonctions connexes appelées\r
+%\r
+%\r
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\r
+% spécification\r
+format long e;\r
+\r
+% Tests d'entrée\r
+\r
+if nargin~=3\r
+ error('Nombre des arguments incorrect, ou écriture inattendue');\r
+end\r
+% Les tests de controle suivants peuvent etre plus ou moins développés,\r
+% selon la dangerosité pressentie de l'utilisateur... ordinaire!\r
+if (size(init,1)~=1)|(size(init,2)~=3)|((sum(diff(init)==0)>0))\r
+ error('Champ init mal écrit. Voir controle');\r
+end\r
+if (size(arret,1)~=1)|(size(arret,2)~=3)\r
+ error('Champ arret mal écrit. Voir controle');\r
+end\r
+% compléments éventuels\r
+\r
+\r
+% Algorithme proprement dit\r
+\r
+% Etape 1:initialisations\r
+X=init;Y=zeros(1,3);\r
+\r
+% La suite serait avantageusement remplacée par une écriture vectorielle\r
+% mais l'utilisateur calculera faux sans le voir..; Il faudrait écrire\r
+% 'x.^2+1' au lieu de 'x^2+1'\r
+for k=1:3\r
+ x=X(k);Y(k)=eval(exp_f);\r
+end\r
+\r
+d=diff(X);dif_div=diff(Y)./d;\r
+nb_iter=0;\r
+bool_arret=0;\r
+\r
+% Etape 2\r
+while bool_arret==0\r
+ nb_iter=nb_iter+1;\r
+ % détermination du polynome d'interpolation de f sur le support x\r
+ % et résolution de l'équation approchée\r
+ An=diff(dif_div)/sum(d);\r
+ Bn=dif_div(2)+An*d(2);\r
+ x=X(3);Cn=eval(exp_f);\r
+ if abs(Cn)<arret(1)\r
+ bool_arret=1;\r
+ else\r
+ % détermination du bon epsilon fournissant le dénominateur optimal\r
+ den=Bn+sqrt(Bn^2-4*An*Cn).*[1 -1];[val,ind]=max(abs(den));\r
+ den_opt=den(ind);\r
+ ajout=-2*Cn/den_opt;\r
+ \r
+ % préparation de la boucle suivante\r
+ \r
+ X(1:2)=X(2:3);X(3)=X(2)+ajout;\r
+ Y(1:2)=Y(2:3);\r
+ x=X(3);Y(3)=eval(exp_f);\r
+ d=diff(X);dif_div=diff(Y)./d;\r
+ %mise à jour de bool_arret\r
+ bool_arret=...\r
+ (nb_iter>arret(3))|(abs(ajout)<arret(2))|(abs(Y(3))<arret(1));\r
+ \r
+ end\r
+end\r
+\r
+% toilettage de la racine:\r
+% on la force réelle si elle l'est presque (au sens de nul_seuil)\r
+% si elle est complexe, on renvoie aussi sa conjuguée dont on sait\r
+% qu'elle est aussi solution par théorie des corps si l'expression\r
+% de f est à coefficient réels.\r
+\r
+if abs(real(X(3)))<arret(2)\r
+ X(3)=imag(X(3))*i;\r
+end\r
+if abs(imag(X(3)))<arret(2)\r
+ rac=real(X(3));\r
+else\r
+ rac=[X(3) conj(X(3))];\r
+end\r
+\r
+% sortie des résultats sous forme symbolique\r
+% Libérer du commentaire, si souhaité, les deux lignes suivantes.\r
+% Voir aussi la fonction affiche_racines.\r
+\r
+disp('Sortie des résultats sous forme symbolique proposée par matlab');\r
+symb=sym(rac,'r');disp('rac = ');disp (symb);\r
+\r
+% fin de fonction
\ No newline at end of file
--- /dev/null
+function [exp_f]=vect2str(vect)\r
+% transforme un vecteur d'écriture de plynome en chaine\r
+% de forme conventionnelle.\r
+%\r
+% variables d'entrée\r
+% vecteur de définition du polynome considéré\r
+%\r
+% variable de sortie\r
+% chaine d'écriture anx^n+...+a0 du polynome considéré\r
+%\r
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\r
+% Fonctions connexes appelées\r
+%\r
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\r
+\r
+% controles inexistants ici car opérés en amont\r
+\r
+deg=size(vect,2)-1;\r
+\r
+% création de la chaine d'appel de muller_elem associée à vect\r
+s='';\r
+if vect(deg+1)>=0\r
+ s='+';\r
+end\r
+exp_f=[s num2str(vect(deg+1))];\r
+for k=1:deg\r
+ s='';\r
+ if vect(deg+1-k)>=0\r
+ s='+';\r
+ end\r
+ exp_f=[s num2str(vect(deg+1-k)) '*x^' num2str(k) exp_f];\r
+end\r
+\r
+% fin de fonction\r
--- /dev/null
+function z=fonct1(omega,t)\r
+% calcule pour des vecteurs convenables z=F(omega,t) dans le tp4I.\r
+% variables d'entrée\r
+% omega et t sont définis dans l'énoncé du tp et dans trace_surface\r
+%\r
+% variables de sortie\r
+% z est la valeur définie dans l'énoncé du tp4I.\r
+\r
+z=2*(t.*omega-pi).*sin(omega.*t)+cos(omega.*t);\r
--- /dev/null
+function [chaine]=test_oscillation(x0)\r
+% calcule les itérés de Newton de la valeur t issue de l'étude de la\r
+% question 1 du tp4I.\r
+%\r
+% variable d'entrée\r
+% x0 représente la solution de l'équation F(1,t)=0 qui devrait fournir\r
+% une suite d'itérés de Newton oscillante.\r
+%\r
+% variable de sortie\r
+% annonce ce qui s'est passé effectivement lors du calcul\r
+%\r
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\r
+% Fonctions connexes appelées\r
+%\r
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\r
+% tests à compléter éventuellement\r
+if nargin~=1\r
+ error('Nombre des arguments incorrect');\r
+end\r
+clf;format long e;\r
+\r
+% définitions de constantes modifiables par l'utilisateur\r
+\r
+nul_seuil=1E-10;\r
+iter_max=30;\r
+\r
+\r
+% test complémentaire. On peut passer val_omega comme champ pour détourner\r
+% cette fonction de sa seule application au cas omega=1.\r
+val_omega=1; % valeur non nulle, attention!\r
+if (x0<=0)|(x0>=2*pi/val_omega)\r
+ error('Le champ x0 est incorrect. Voir test complémentaire');\r
+end\r
+ \r
+\r
+% initialisations\r
+v=zeros(1,iter_max+1);\r
+nb_iter=1;\r
+v(1)=x0;v(2)=v(1)+cos(v(1))/sin(v(1));x1=v(2);\r
+normal=1;\r
+\r
+% boucle générale\r
+while nb_iter<iter_max\r
+ nb_iter=nb_iter+1;\r
+ v(nb_iter+1)=v(nb_iter)+cos(v(nb_iter))/sin(v(nb_iter));\r
+ \r
+ if normal==1\r
+ switch mod(nb_iter,2)\r
+ case 0\r
+ normal=(abs(v(nb_iter+1)-x0)<nul_seuil);\r
+ case 1\r
+ normal=(abs(v(nb_iter+1)-x1)<nul_seuil);\r
+ end\r
+ if normal==0\r
+ rupture=nb_iter;\r
+ end\r
+ end\r
+end\r
+\r
+% annonce de la situation\r
+if normal\r
+ chaine='Tout s''est passé comme prévu';\r
+else\r
+ chaine=...\r
+ ['Le phénomène d''oscillation s''est produit jusqu''au terme ' ...\r
+ num2str(rupture)];\r
+end\r
+\r
+% tracé des itérés\r
+plot(v);\r
+xlabel('numéro matlab des itérés');ylabel('Valeurs prises');\r
+title('Evolution des termes de la suite de Newton du tp4I');\r
+legend(['au sens d''un écart de : ' num2str(nul_seuil)],0); \r
+\r
+% fin de fonction\r
+\r
+\r
+
\ No newline at end of file
--- /dev/null
+function trace_surface(nb_pas,omega_deb,omega_fin,t_deb,t_fin)\r
+% représente la surface d'équation z=F(omega,t) du tp4I.\r
+%\r
+% variables d'entrée\r
+% nb_pas est un entier désignant la taille commune des vecteurs omega et t\r
+% omega_deb, omega_fin désignent respectivement\r
+% les valeurs initiale et finale prises par le paramètre omega.\r
+% idem en t_deb et t_fin pour t\r
+%\r
+% variables de sortie\r
+% une image qu'il sera possible de capter ou d'imprimer.\r
+%\r
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\r
+% Fonctions connexes appelées\r
+%\r
+% fonct1\r
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\r
+\r
+% Tests éventuels\r
+if nargin~=5\r
+ error('Nombres des arguments incorrects');\r
+end\r
+\r
+% tests complémentaires éventuels sur les autres arguments\r
+% en fonction des utilisateurs...\r
+nb_pas=floor(nb_pas);\r
+if nb_pas==0\r
+ error('Le champ nb_pas est mal passé. Voir partie controle');\r
+end\r
+\r
+pas_t=(t_fin-t_deb)/nb_pas;pas_om=(omega_fin-omega_deb)/nb_pas;\r
+t=t_deb:pas_t:t_fin;\r
+omega=omega_deb:pas_om:omega_fin;\r
+[T,OMEGA]=meshgrid(t,omega);\r
+Z=fonct1(OMEGA,T);\r
+\r
+% tracés \r
+figure(1);\r
+% on peut choisir taille et position sur l'écran via son handle\r
+% et set(1,'position',champs de position). Voir figure...\r
+mesh(OMEGA,T,Z);\r
+grid;\r
+title('Surface z=F(omega,t)');\r
+xlabel('omega');ylabel('t');zlabel('z');\r
+\r
+ch=input('Voulez-vous des tracés complémentaires? (si oui taper 1)','s');\r
+if ch=='1'\r
+ % on peut positionner la fenetre en fonction de celle des commandes\r
+ pos=get(1,'position');\r
+ figure(2);\r
+ set(2,'position',pos-30);\r
+ \r
+ subplot(2,1,1);\r
+ contour(T,OMEGA,Z,[0 0]);\r
+ title('Niveau zéro de z=F(omega,t)');\r
+ xlabel('t');ylabel('omega');\r
+ \r
+ subplot(2,1,2);\r
+ % à modifier par l'utilisateur ou à saisir ou à passer comme champ!\r
+ val_omega=1;\r
+ \r
+ omega=val_omega*ones(size(t));\r
+ plot(t,fonct1(omega,t));\r
+ xlabel('t');ylabel(['y=F(' num2str(val_omega) ',t)']);\r
+ legend(['Courbe y=F(omega,t) pour omega=' num2str(val_omega)],0);\r
+end\r
+\r
+\r
+\r
--- /dev/null
+function continuer\r
+% réalise les opérations nécessaires au prolongement de visualisation\r
+% des solutions relatives à la convergence de l'équation de Ferrari\r
+global att3 CONT\r
+\r
+att3=0;\r
+\r
+% fin de fonction !
\ No newline at end of file
--- /dev/null
+function creat_fen2_dem\r
+% création d'une fenetre pour interroger l'utilisateur!\r
+\r
+% On ne controle rien...Plusieurs choix ont été faits pour l'aspect démo...\r
+\r
+% pour la portabilité graphique\r
+global f2_pos\r
+\r
+% autres globales\r
+global h_f2 BR BP\r
+global rep att2 choix\r
+\r
+\r
+\r
+close all;\r
+% création d'une fenetre à boutons\r
+\r
+h_f2=figure...\r
+ ('Name','Hypothèses à étudier',...% titre fenetre\r
+ 'Position',f2_pos,'NumberTitle','off','Resize','off',...\r
+ 'Menubar','none');\r
+\r
+% calcul de données pour la géométrie de la fenetre; couleurs.\r
+marg_h=floor(f2_pos(3)/8);\r
+seg=floor(f2_pos(4)/6);\r
+haut=floor(3*seg/9); %3 seg réservés aux boutons\r
+larg=floor((f2_pos(3)-2*marg_h)/8);\r
+couleurs=[1 1 0.5;0.7 0.7 1;1 0.2 0.2];\r
+\r
+\r
+% création du titre en texte fixe\r
+h_t=uicontrol(h_f2,...\r
+'style','text',...\r
+'position',[marg_h 4*seg 6*marg_h seg],...\r
+'string','Cliquez pour déterminer les intervalles [a,b] vérifiant :',...\r
+'backgroundcolor',[1 1 1],'fontsize',[14]);\r
+\r
+% création des boutons radios relatifs à chaque hypothèse disponible\r
+BR=zeros(1,6);\r
+\r
+% ensemble des hypothèses\r
+BR1_pos=[marg_h+3/2*larg seg+7*haut 5*larg haut];\r
+BR(1)=uicontrol(h_f2,...\r
+ 'style','radio',...\r
+ 'backgroundcolor',couleurs(1,:),...\r
+ 'position',BR1_pos,'string','l''ensemble des hypothèses.',...\r
+ 'value',0,...\r
+ 'callback','det_choix(1);');\r
+\r
+% hypothèse 2\r
+BR2_pos=[marg_h seg+5*haut 3*larg haut];\r
+BR(2)=uicontrol(h_f2,...\r
+ 'style','radio',...\r
+ 'backgroundcolor',couleurs(2,:),...\r
+ 'position',BR2_pos,'string','l''hypothèse 2.','value',0,...\r
+ 'callback','det_choix(2);');\r
+\r
+% hypothèse 3\r
+BR3_pos=[marg_h+5*larg seg+5*haut 3*larg haut];\r
+BR(3)=uicontrol(h_f2,...\r
+ 'style','radio',...\r
+ 'backgroundcolor',couleurs(2,:),...\r
+ 'position',BR3_pos,'string','l''hypothèse 3.', 'value',0,...\r
+ 'callback','det_choix(3);');\r
+\r
+% hypothèse 4\r
+BR4_pos=[marg_h seg+3*haut 3*larg haut];\r
+BR(4)=uicontrol(h_f2,...\r
+ 'style','radio',...\r
+ 'backgroundcolor',couleurs(2,:),...\r
+ 'position',BR4_pos,'string','l''hypothèse 4.','value',0,...\r
+ 'callback','det_choix(4);');\r
+ \r
+% hypothèse 5\r
+BR5_pos=[marg_h+5*larg seg+3*haut 3*larg haut];\r
+BR(5)=uicontrol(h_f2,...\r
+ 'style','radio',...\r
+ 'backgroundcolor',couleurs(2,:),...\r
+ 'position',BR5_pos,'string','l''hypothèse 5.','value',0,...\r
+ 'callback','det_choix(5);');\r
+\r
+% demande de la visualisation de l'intersection\r
+BR6_pos=[marg_h+1/2*larg seg+haut 7*larg haut];\r
+BR(6)=uicontrol(h_f2,...\r
+ 'style','radio',...\r
+ 'backgroundcolor',couleurs(1,:),...\r
+ 'position',BR6_pos,...\r
+ 'string','Pour visualiser l''intersection des contraintes.',...\r
+ 'value',0,'callback','det_choix(6);');\r
+\r
+\r
+% on pourrait définir un frame pour encadrer!\r
+\r
+% bouton poussoir d'arret\r
+\r
+BP_pos=[marg_h+2*larg haut 4*larg haut];\r
+BP=uicontrol(h_f2,...\r
+ 'style','push',...\r
+ 'backgroundcolor',couleurs(3,:),...\r
+ 'position',BP_pos,'string','FIN',...\r
+ 'callback','det_choix(0);');\r
+\r
+% fin de fonction\r
--- /dev/null
+function creat_fen3_dem\r
+% création d'une fenetre de demande de continuation d'un processus.\r
+\r
+% On ne controle rien!\r
+\r
+% pour la portabilité graphique\r
+global f2_pos f3_pos\r
+\r
+global h_f3 CONT\r
+global att3\r
+\r
+\r
+% création d'une fenetre à boutons\r
+\r
+h_f3=figure...\r
+ ('Name','Poursuivre',...% titre fenetre\r
+ 'Position',f3_pos,'NumberTitle','off','Resize','off',...\r
+ 'Menubar','none');\r
+ set(h_f3,'resize','on');\r
+\r
+% éléments de géométrie pour le dessin du poussoir\r
+seg=floor(f3_pos(4)/5);\r
+larg=floor(f3_pos(3)/7);\r
+CONT_pos=[2*larg,2*seg,3*larg,seg];\r
+\r
+\r
+ % création du bouton poussoir de continuation\r
+\r
+CONT_pos=[50 30 260 40];\r
+CONT=uicontrol(h_f3,...\r
+ 'style','push',...\r
+ 'backgroundcolor',[0.5 1 0.5],...\r
+ 'position',CONT_pos,'string','CONTINUER',...\r
+ 'callback','continuer');\r
+\r
+% fin de fonction\r
--- /dev/null
+function demo_tp4I\r
+% demo de vérification d'hypothèses du théorème de conditions\r
+% suffisantes de convergence de méthode de Newton\r
+% pour une fonction polynome.\r
+% Peut etre transformée en fonction évidemment.\r
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\r
+% Fonctions connexes appelées\r
+%\r
+% continuer,creat_fen2_dem,creat_fen3_dem,det_choix,etude_hypotheses,\r
+% (lect_courb),sortie,traitement_dem,vect2str_mat\r
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\r
+\r
+% tests éventuels(non rédigés!)\r
+\r
+\r
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\r
+% initialisations\r
+clear all;close all;\r
+\r
+% variables globales modifiables avec prudence!\r
+\r
+% A modifier pour la portabilité graphique.\r
+% Ecrit initialement sur un 17 pouces.\r
+% pour modifier les positions des fenetres 1,2 ou 3 vous les mettez\r
+% en place sur votre écran et pour chacune vous récupérer son handle h.\r
+% en tapant get(h,'position') vous récupérez le vecteur position que vous\r
+% remplacez dans l'écriture ci-dessous.\r
+global f1_pos; f1_pos=[383 35 630 648];\r
+global f2_pos; f2_pos=[10 35 360 285];\r
+global f3_pos; f3_pos=[10 35 360 100];\r
+\r
+global unite_att\r
+global A B\r
+\r
+% autres variables modifiables par l'utilisateur\r
+% unité d'attente de la réaction de l'utilisateur\r
+% maxi 20 unités pour fenetre 2\r
+% maxi 240 unités pour fenetre 3\r
+unite_att=0.5;\r
+\r
+% on peut modifier bornes et pas\r
+pas_a=0.01;a=1:pas_a:4;\r
+pas_b=.1;b=3:pas_b:10;\r
+[A,B]=meshgrid(a,b);\r
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\r
+\r
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\r
+% on n'y touche pas sauf après étude approfondie!\r
+\r
+% Pour l'équation de Ferrari\r
+pol=[1 0 6 -60 36];\r
+% Ceci est modifiable mais le reste devra suivre dans etude_hypothèses!\r
+\r
+global ens_H H2 H3 H4 H5;\r
+global h_f2 BR BP;\r
+global rep att2 att3 choix coul leg\r
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\r
+\r
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\r
+% première partie\r
+\r
+% recherche des intervalles convenables pour chaque hypothèse\r
+% et pour l'ensemble des hypothèses du théorème.\r
+[ens_H,H2,H3,H4,H5]=etude_hypotheses(A,B);\r
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\r
+\r
+\r
+\r
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\r
+% deuxième partie: proposition de visualisation des hypothèses\r
+\r
+disp('Voulez-vous visualiser les [a,b]');\r
+disp('qui vérifient les hypothèses ?');\r
+ch=input('(si oui,taper 1) ','s');\r
+if ch=='1'\r
+ rep=1;\r
+ % préparation de visualisation\r
+ \r
+ % choix des couleurs pour la représentation des intervalles [a,b]\r
+ % sur lesquels les diverses hypothèses sont valides.\r
+ coul=cell(1,5);\r
+ coul{1}='k.';coul{2}='m.';coul{3}='b.';coul{4}='g.';coul{5}='r.';\r
+\r
+ % création de la cellule des titres d'images à venir\r
+ leg=cell(1,6);\r
+ leg{1}=['En blanc,les intervalles [a,b] sur lesquels'...\r
+ ' le théorème est applicable.'];\r
+ for k=2:5\r
+ leg{k}=['En blanc, les intervalles [a,b], sur lesquels '...\r
+ 'l''hypothèse ' num2str(k) ' est valide.'];\r
+ end\r
+ leg{6}=['En blanc, les intervalles [a,b] valides'...\r
+ ' lors du rajout des hypothèses 2 à 5.'];\r
+\r
+else\r
+ rep=0;\r
+end\r
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\r
+\r
+\r
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\r
+% entrée en boucle sur rep\r
+\r
+while rep==1\r
+ \r
+ % on réinitialise rep et choix;on ne rentre en boucle que si rep\r
+ % est modifié et passe donc à 1.\r
+ rep=0;choix=0;\r
+ \r
+ % ouverture de fenetre de choix 2\r
+ creat_fen2_dem;\r
+ \r
+ % attente jusqu'a 20 unités de temps: unite_att\r
+ compt=0;att2=1;\r
+ \r
+ while (att2==1)&(compt<19)\r
+ pause(unite_att);\r
+ compt=compt+1;\r
+ end\r
+ \r
+ % traitement relatif au choix obtenu (entre 0 et 5)\r
+ traitement_dem(choix);\r
+ \r
+ % regrets!\r
+ if compt>=19\r
+ \r
+ % L'utilisateur n'a rien choisi!\r
+ disp('Trop tard. On sort !');\r
+ end\r
+ \r
+end\r
+\r
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\r
+\r
+sortie;\r
+\r
+% fin de demo!
\ No newline at end of file
--- /dev/null
+function choix=det_choix(num)\r
+% trouve le choix de l'utilisateur pour passer ce champ à traitement_dem\r
+%\r
+% variable d'entrée\r
+% num est un entier qui désigne le numéro du bouton radio\r
+% de creat_fen2_dem ou 0 si on sort du poussoir du meme fichier.\r
+% on ne controle rien!\r
+global h_f2 BR\r
+global choix rep att2\r
+\r
+\r
+att2=0;\r
+switch num\r
+case 0,\r
+ return;\r
+otherwise\r
+ if (get(BR(num),'value')==1)\r
+ rep=1;choix=num;\r
+ end\r
+end\r
+\r
+% fin de fonction\r
--- /dev/null
+function [ens_H,H2,H3,H4,H5]=etude_hypotheses(A,B)\r
+% etudie la validité de l'hypothese num du théorème pour A et B\r
+%\r
+% variables d'entrée\r
+% A et B désignent respectivement les origine et extrémité de l'intervalle\r
+% [a,b] sur lequel on étudie la convergence.\r
+% H2,H3,H4,H5,ens_H sont les matrices booléennes des indices\r
+% de la matrice des couples (a,b) qui vérifient les hypothèses\r
+% (de numéro indiqué pour les premières,\r
+% de conjonction des précédentes pour ens_H)\r
+% du théorème de condition suffisante de convergence\r
+% de la suite de Newton sur [a,b].\r
+\r
+% tests sommaires\r
+if nargin~=2\r
+ error('Nombre des arguments incorrect');\r
+end\r
+\r
+% Donnée interne de pol: attention cette donnée agit fortement\r
+% sur l'écriture des contraintes; on évitera de passer pol comme champ.\r
+pol=[1 0 6 -60 36];\r
+\r
+% étude hypothèse 1\r
+% inutile: pol est polynome donc C2 sur tout intervalle de R.\r
+\r
+% étude hypothèse 2\r
+x=A;f_A=eval(vect2str_mat(pol));\r
+x=B;f_B=eval(vect2str_mat(pol));\r
+H2=((A<B)&(f_A.*f_B<0));\r
+\r
+% étude hypothèse 3\r
+% La dérivée de pol est croissante; il suffit d'imposer pol'(a)>0 ici;\r
+% pour l'étude de la racine proche de 2, ce serait pol'(a)<0.\r
+d1_pol=polyder(pol);\r
+x=A;d1_f_A=eval(vect2str_mat(d1_pol));\r
+x=B;d1_f_B=eval(vect2str_mat(d1_pol));\r
+H3=((A<B)&(d1_f_A>0));\r
+\r
+% étude hypothèse 4\r
+% La dérivée seconde est certainement positive.\r
+% d2_pol=polyder(d1_pol);\r
+H4=(A<B);\r
+\r
+\r
+% étude hypothèse 5\r
+H5=((A<B)&(abs(f_A./d1_f_A)<(B-A))&(abs(f_B./d1_f_B)<(B-A)));\r
+\r
+ens_H=H2&H3&H4&H5;\r
+\r
+% fin de fonction
\ No newline at end of file
--- /dev/null
+function sortie\r
+% permet de quitter proprement la zone\r
+\r
+global rep\r
+\r
+% nettoie les variables accumulées\r
+global f3_pos f2_pos f1_pos\r
+global h_f3 h_f2 CONT BR BP \r
+global rep A B ens_H H2 H3 H4 H5;\r
+\r
+clear f1_pos f2_pos f3_pos;\r
+clear A B ens_H H2 H3 H4 H5;\r
+\r
+disp('A plus tard');\r
+\r
+% fin de fonction\r
+\r
--- /dev/null
+function traitement_dem(choix)\r
+% visualise les solutions en [a,b] vérifiant diverses hypothèses\r
+% du théorème de condition suffisante de convergence en Newton.\r
+%\r
+% variables d'entrée\r
+% choix est un entier désignant le numéro des hypothèses à visualiser.\r
+%\r
+% variables de sortie\r
+% aucune: on peut capter l'image produite.\r
+%\r
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\r
+% Fonctions connexes appelées\r
+%\r
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\r
+\r
+% pour la portabilité graphique\r
+global f1_pos f2_pos f3_pos\r
+\r
+% autres globales\r
+global A B ens_H H2 H3 H4 H5\r
+global h_f2 h_f3 CONT att3\r
+global unite_att rep coul leg\r
+\r
+% effacement de fenetre de demande 2\r
+close(h_f2);\r
+\r
+% préparation des tracés:affectation des variables nécessaires\r
+\r
+switch choix\r
+case 0,\r
+ return\r
+case 1,\r
+ Z=ens_H;\r
+case 6,\r
+ % on ne fait rien pour l'instant;\r
+otherwise,\r
+ eval(['Z=H' num2str(choix) ';']);\r
+ \r
+end\r
+\r
+\r
+% tracé proprement dit dans la fenetre appropriée\r
+\r
+switch choix\r
+ \r
+case 6,\r
+ % préparation de la fenetre 1\r
+ h_f1=figure('Position',f1_pos);\r
+ for k=2:5\r
+ eval(['K=logical(1-H' num2str(k) ');']);\r
+ h_p=plot(A(K),B(K),coul{k});\r
+ lim=[min(min(A)) max(max(A)) min(min(B)) max(max(B))];\r
+ xlabel('Valeurs de a');ylabel('Valeurs de b');\r
+ title(leg{6});\r
+ h_leg=legend(['ajout de l''hypothèse ' num2str(k)],0); \r
+ \r
+ % travail de détail sur la légende!\r
+ enf=get(h_leg(1),'Children');\r
+ set(enf(1),'Color',get(h_p,'color'),'Marker','*');\r
+ delete(enf(2));\r
+ pause(2); \r
+ delete(h_leg);\r
+ hold on;\r
+ end\r
+ \r
+otherwise,\r
+ % préparation de la fenetre 1\r
+ h_f1=figure('Position',f1_pos);\r
+ plot(A(logical(1-Z)),B(logical(1-Z)),coul{choix});\r
+ lim=[min(min(A)) max(max(A)) min(min(B)) max(max(B))];\r
+ xlabel('Valeurs de a');ylabel('Valeurs de b');\r
+ title(leg{choix});\r
+ \r
+ % traitement un peu spécial pour l'ensemble des hypothèses.\r
+ if choix==1 \r
+ % On sort une solution optimale au sens d'un critère à définir.\r
+ \r
+ % On peut optimiser au sens de la taille de |b-a|.\r
+ % Ceci se discute! On peut chercher surtout à avoir un a minimal;\r
+ % dans d'autres cas on cherchera un b maximal.\r
+ \r
+ % critère 1\r
+ %[temp,ind]=max(abs(B(H)-A(H)));\r
+ % à prolonger mais de peu de sens ici.\r
+ \r
+ % critère 2\r
+ % on minimise a et on cherche pour cette valeur le b maximal\r
+ % possible, ou l'inverse dans d'autres cas.\r
+ % sortie des a et b solutions.\r
+ hold on;\r
+ tempA=A(Z);\r
+ tempB=B(Z);\r
+ if (sum(size(tempA))>0) % donc idem en B!\r
+ a_opt=min(tempA);\r
+ ind_a=(tempA==a_opt);\r
+ b_opt=max(tempB(ind_a));\r
+ plot(a_opt,b_opt,'r*');\r
+ h_leg=legend(['Solution optimale: a= ' ...\r
+ num2str(a_opt) '; b= ' num2str(b_opt)],0);\r
+ % détails\r
+ enf=get(h_leg(1),'Children');\r
+ set(enf(1),'Color','r','Marker','*');\r
+ delete(enf(2));\r
+\r
+ end\r
+ end\r
+ \r
+end\r
+\r
+% complément dans le cas de l'ensemble des hypothèses\r
+\r
+\r
+\r
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\r
+% possibilité de lecture de coordonnées: supprimer le commentaire.\r
+% on clique gauche pour lire;\r
+% on sort en cliquant droit!\r
+\r
+%lect_courb(1);\r
+\r
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\r
+\r
+% ouverture de fenetre de choix 3\r
+creat_fen3_dem;\r
+\r
+% attente jusqu'a 120 unités de temps: unite_att\r
+compt=0;att3=1;\r
+\r
+while (att3==1)&(compt<120)\r
+ pause(unite_att);\r
+ compt=compt+1;\r
+end\r
+\r
+% fermeture de fenetre 3, non visibilité et nettoyage de fenetre 1\r
+close(h_f3);close(h_f1);\r
+\r
+\r
+% gestion de réponse ou de son absence\r
+if compt>=120\r
+ rep=0;\r
+ disp('Trop tard. Assez attendu.');\r
+ disp('Vous pouvez modifier le temps sous traitement_dem ligne 123');\r
+end\r
+\r
+\r
+% fin de fonction\r
+\r
--- /dev/null
+function [exp_f]=vect2str_mat(vect)\r
+% transforme un vecteur d'écriture de polynome en chaine à évaluer\r
+% sous forme matricielle.\r
+%\r
+% variables d'entrée\r
+% vecteur de définition du polynome considéré\r
+%\r
+% variable de sortie\r
+% chaine d'écriture anx^n+...+a0 du polynome considéré\r
+%\r
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\r
+% Fonctions connexes appelées\r
+%\r
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\r
+\r
+% controles inexistants ici car opérés en amont\r
+\r
+deg=size(vect,2)-1;\r
+\r
+% création de la chaine d'appel de muller_elem associée à vect\r
+s='';\r
+if vect(deg+1)>=0\r
+ s='+';\r
+end\r
+exp_f=[s num2str(vect(deg+1))];\r
+for k=1:deg\r
+ s='';\r
+ if vect(deg+1-k)>=0\r
+ s='+';\r
+ end\r
+ exp_f=[s num2str(vect(deg+1-k)) '.*(x.^' num2str(k) ')' exp_f];\r
+end\r
+\r
+% fin de fonction\r
--- /dev/null
+function [a,b,c,d]=calcul_coeff_ordre4(A)\r
+\r
+% calcul_coeff_ordre4 : mis au point en symbolique d'une méthode d'ordre 4.\r
+%\r
+% [a,b,c,d]=calcul_coeff_ordre4(A) calcule les coefficents a,b,c,d tels que \r
+% la fonction g(x)=a*x+b/x+c/x^3+d/x^5 définisse une suite du point fixe\r
+% avec un ordre de convergence égal à 4 autour de l=sqrt(A);\r
+%\r
+% paramètres d'entrées : A\r
+% paramètres de sorties : a,b,c,d\r
+%\r
+% \r
+% \r
+% ************ Fonctions auxiliaires utilisées ************\r
+%\r
+% aucune\r
+%\r
+% *********************************************************\r
+%\r
+\r
+\r
+% tests préliminaire\r
+if isnumeric(A)\r
+ if (A<=0) \r
+ error('attention, l''argument doit être strictement positif');\r
+ end\r
+end\r
+% corps d'algorithme\r
+syms x a b c d;\r
+g=a*x+b/x+c/x^3+d/x^5;\r
+gp=diff(g,x);\r
+gp2=diff(g,x,2);\r
+gp3=diff(g,x,3);\r
+B=solve(g-x,gp,gp2,gp3,a,b,c,d);\r
+a=sym(subs(B.a,x,sqrt(sym(A))));\r
+b=sym(subs(B.b,x,sqrt(sym(A))));\r
+c=sym(subs(B.c,x,sqrt(sym(A))));\r
+d=sym(subs(B.d,x,sqrt(sym(A))));\r
+\r
+\r
+\r
+\r
--- /dev/null
+function [a,b,c]=calcul_coeff_racine3(A)\r
+\r
+% calcul_coeff_racine3 : mis au point en symbolique d'une méthode d'ordre 3 convergeant vers l^(1/3).\r
+%\r
+% [a,b,c]=calcul_coeff_racine3(A) calcule les coefficents a,b,c tels que \r
+% la fonction g(x)=a*x+b/x^2+c/x^5 définisse une suite du point fixe\r
+% avec un ordre de convergence égal à 3 autour de l=(A)^(1/3);\r
+%\r
+% paramètres d'entrées : A\r
+% paramètres de sorties : a,b,c\r
+% \r
+%\r
+% \r
+% ************ Fonctions auxiliaires utilisées ************\r
+%\r
+% aucune\r
+%\r
+% *********************************************************\r
+%\r
+\r
+\r
+% tests préliminaire\r
+if isnumeric(A)\r
+ if (A<=0) \r
+ error('attention, l''argument doit être strictement positif');\r
+ end\r
+end\r
+% corps d'algorithme\r
+syms x a b c;\r
+g=a*x+b/x^2+c/x^5;\r
+gp=diff(g,x);\r
+gp2=diff(g,x,2);\r
+B=solve(g-x,gp,gp2,a,b,c);\r
+a=sym(subs(B.a,x,(sym(A))^(1/3)));\r
+b=sym(subs(B.b,x,(sym(A))^(1/3)));\r
+c=sym(subs(B.c,x,(sym(A))^(1/3)));\r
--- /dev/null
+function [er,X]=sqrtm_iteration_ordre3(A,X0,epsilon)\r
+\r
+% \r
+% sqrtm_iteration_ordre3 : calcul d'une racine carrée de matrice par la méthode de Newton.\r
+%\r
+%\r
+% *********************************************************\r
+%\r
+% [er,X]=sqrtm_iteration_ordre3(A,X0,epsilon)\r
+% calcule les différents itérés de\r
+% la méthode d'ordre 3 pour la recherche d'une racine de matrice.\r
+% A chaque itération, elle affiche et stocke le résultat X_k ainsi que l'erreur\r
+% er(k)=|||X_k^2-A|||.\r
+% \r
+% variables d'entrées :\r
+% * A :matrice dont on veut une racine.\r
+% * X0 : matrice initiale\r
+% * epsilon : paramètre de précision\r
+% variables de sortie :\r
+% * er: suite des erreurs, définies par er(k)=norm(X_k^2-A).\r
+% * X : suite des itérés (matriciels) calculés.\r
+% \r
+% ATTENTION : nombre maximum d'itération défini par nmax\r
+% \r
+% ************ Fonctions auxiliaires utilisées ************\r
+%\r
+% aucune\r
+%\r
+% *********************************************************\r
+%\r
+\r
+% nombre maximum d'itération défini par nmax\r
+nmax=100;\r
+\r
+% Contrôles d'entrée\r
+[n,p]=size(A);\r
+if (n~=p) \r
+ error('attention, A n''est pas carrée : arrêt du programme');\r
+end\r
+sqrtmA=sqrtm(A);\r
+if (norm(sqrtmA*X0-X0*sqrtmA,inf)~=0)\r
+ disp('attention, la matrice initiale et la racine de A ne commutent pas !!');\r
+end\r
+\r
+\r
+% Corps d'algorithme\r
+er=[];\r
+X=X0;\r
+x=X0;\r
+k=0;\r
+A2=A^2;\r
+test=(norm(x^2-A,inf)~=0);\r
+while(test)\r
+ z=inv(x);\r
+ y=(3/8)*x+(3/4)*A*z-(1/8)*A2*(z^3);\r
+ disp(['itération numéro ',int2str(k)]);\r
+ y2=y^2;\r
+ erloc=norm(y2-A);\r
+ er=[er erloc];\r
+ X=[X y];\r
+ test=~((norm(y2-A,inf)==0)|(k>=nmax)|(norm(x-y,inf)<=epsilon));\r
+ disp('itéré : ');\r
+ disp(y);\r
+ disp(['erreur : ',num2str(erloc)]);\r
+ disp('appuyez sur une touche pour continuer');\r
+ pause;\r
+ k=k+1;\r
+ x=y;\r
+end\r
+if (n>=nmax)\r
+ disp('attention, n>nmax');\r
+end\r
--- /dev/null
+function res=pic(x)\r
+\r
+% pic(x) est la fonction égale à \r
+% 2*x sur [0,1/2] ;\r
+% 2*(1-x) sur [1/2,1].\r
+\r
+res=2*x.*(double(x)<=1/2)+2*(1-x).*(double(x)>1/2);\r
+if ~(isnumeric(x))\r
+ res=simplify(res);\r
+end
\ No newline at end of file
--- /dev/null
+function res=sommeA(p,n)\r
+\r
+% sommeA : calcul de somme (version A).\r
+%\r
+% *********************************************************\r
+%\r
+% res=sommeA(p,n)\r
+% \r
+% calcul de la somme \sum_{i=1}^n 1/(i^p) en utilisant une boucle \r
+% et en sommant dans l'ordre des indices croissants.\r
+%\r
+% variables d'entrées :\r
+% * p,n : deux entiers \r
+%\r
+% variables de sortie\r
+% * res: résultats de la somme\r
+% \r
+% \r
+% ************ Fonctions auxiliaires utilisées ************\r
+%\r
+% aucune\r
+%\r
+% *********************************************************\r
+\r
+\r
+\r
+% Contrôles d'entrée\r
+% nombre d'arguments\r
+if nargin~=2\r
+ error('nombre d''arguments de la fonction incorrect');\r
+end\r
+% autres tests éventuels \r
+ \r
+\r
+% Corps d'algorithme\r
+s=1;\r
+for i=2:n\r
+ s=s+1/(i^p);\r
+end\r
+res=s;\r
--- /dev/null
+function res=sommeB(p,n)\r
+\r
+% sommeB : calcul de somme (version B).\r
+%\r
+% *********************************************************\r
+%\r
+% res=sommeB(p,n)\r
+% \r
+% calcul de la somme \sum_{i=1}^n 1/(i^p) en utilisant un calcul \r
+% matriciel et en sommant dans l'ordre des indices croissants.\r
+%\r
+% variables d'entrées :\r
+% * p,n : deux entiers \r
+%\r
+% variables de sortie\r
+% * res: résultats de la somme\r
+% \r
+% \r
+% ************ Fonctions auxiliaires utilisées ************\r
+%\r
+% aucune\r
+%\r
+% *********************************************************\r
+\r
+\r
+\r
+% Contrôles d'entrée\r
+% nombre d'arguments\r
+if nargin~=2\r
+ error('nombre d''arguments de la fonction incorrect');\r
+end\r
+% autres tests éventuels \r
+ \r
+\r
+% Corps d'algorithme\r
+res=sum(1./((1:n).^p));\r
--- /dev/null
+function res=sommeC(p,n)\r
+\r
+% sommeC : calcul de somme (version C).\r
+%\r
+% *********************************************************\r
+%\r
+% res=sommeC(p,n)\r
+% \r
+% calcul de la somme \sum_{i=1}^n 1/(i^p) en utilisant un calcul \r
+% matriciel et en sommant dans l'ordre des indices décroissants.\r
+%\r
+% variables d'entrées :\r
+% * p,n : deux entiers \r
+%\r
+% variables de sortie\r
+% * res: résultats de la somme\r
+% \r
+% \r
+% ************ Fonctions auxiliaires utilisées ************\r
+%\r
+% aucune\r
+%\r
+% *********************************************************\r
+\r
+\r
+\r
+% Contrôles d'entrée\r
+% nombre d'arguments\r
+if nargin~=2\r
+ error('nombre d''arguments de la fonction incorrect');\r
+end\r
+% autres tests éventuels \r
+ \r
+\r
+% Corps d'algorithme\r
+res=sum(1./((n:-1:1).^p));\r
--- /dev/null
+function affiche_erreur_derivee(hm,hM,R)\r
+% \r
+%\r
+% affiche_erreur_derivee : affichage de l'erreur (logarithmique) pour calcul numérique de dérivée.\r
+%\r
+% *********************************************************\r
+%\r
+% affiche_erreur_derivee(hm,hM,R) :\r
+% affiche le nuage de point (log10(h_i),log10(epsilon(h_i)))\r
+% où pour tout entier i appartenant à (0,...,R), \r
+% h_i=h=hm.^((R-i)/R).*hM.^(i/R);\r
+% epsilon(h_i) est l'erreur commise en remplaçant la dérivée\r
+% de la fonction exponentielle en 1 par (exp(1+h_i)-exp(t-h_i))/(2h_i)\r
+%\r
+%\r
+% variables d'entrées :\r
+% * hm et hM sont deux pas strictement positifs (hm<hM);\r
+% * R est le nombre de calcul fait.\r
+%\r
+% variables de sortie : \r
+% * le graphe décrit ci-dessus\r
+% \r
+% \r
+% ************ Fonctions auxiliaires utilisées ************\r
+%\r
+% aucune\r
+%\r
+% *********************************************************\r
+\r
+\r
+\r
+% Contrôles d'entrée\r
+\r
+% nombre d'arguments\r
+if nargin~=3\r
+ error('nombre d''arguments de la fonction incorrect');\r
+end\r
+% autres tests éventuels \r
+ \r
+\r
+% Corps d'algorithme\r
+i=0:R;\r
+h=hm.^((R-i)/R).*hM.^(i/R);\r
+epsilon=abs((exp(1+h)-exp(1-h))./(2*h)-exp(1));\r
+J=find(epsilon==0);\r
+epsilon(J)=1e-20;\r
+X=log10(h);\r
+Y=log10(epsilon);\r
+plot(X,Y);\r
+\r
+\r
+\r
--- /dev/null
+function res=vandermonde1(X)\r
+% \r
+%\r
+% vandermonde1 : matrice de vandermonde (par boucle).\r
+%\r
+% *********************************************************\r
+%\r
+% res=vandermonde1(X)\r
+% calcule la matrice de Vandermonde définie par : \r
+% pour tout i,j entier dans {1,p} res(i,j)= (x_j)^(i-1)\r
+% calcul par boucle.\r
+% avec \r
+% variables d'entrées : \r
+% * X : vecteur à p composantes\r
+%\r
+% variables de sortie : \r
+% * matrice de Vandermonde.\r
+%\r
+% \r
+% \r
+% ************ Fonctions auxiliaires utilisées ************\r
+%\r
+% aucune\r
+%\r
+% *********************************************************\r
+%\r
+%\r
+\r
+\r
+\r
+% Contrôles d'entrée\r
+\r
+% nombre d'arguments\r
+if nargin~=1\r
+ error('nombre d''arguments de la fonction incorrect');\r
+end\r
+% autres tests éventuels \r
+ \r
+\r
+% Corps d'algorithme\r
+n=length(X)-1;\r
+for i=1:n+1\r
+ for j=1:n+1\r
+ res(i,j)=(X(j))^(i-1);\r
+ end\r
+end\r
--- /dev/null
+function res=vandermonde2(X)\r
+% \r
+%\r
+% vandermonde2 : matrice de vandermonde (sans boucle).\r
+%\r
+% *********************************************************\r
+%\r
+% res=vandermonde2(X)\r
+% calcule la matrice de Vandermonde définie par : \r
+% pour tout i,j entier dans {1,p} res(i,j)= (x_j)^(i-1)\r
+% calcul sans boucle.\r
+% avec \r
+% variables d'entrées : \r
+% * X : vecteur à p composantes\r
+%\r
+% variables de sortie : \r
+% * matrice de Vandermonde.\r
+%\r
+% \r
+% \r
+% ************ Fonctions auxiliaires utilisées ************\r
+%\r
+% aucune\r
+%\r
+% *********************************************************\r
+%\r
+%\r
+\r
+\r
+\r
+% Contrôles d'entrée\r
+\r
+% nombre d'arguments\r
+if nargin~=1\r
+ error('nombre d''arguments de la fonction incorrect');\r
+end\r
+% autres tests éventuels \r
+ \r
+\r
+% Corps d'algorithme\r
+n=length(X)-1;\r
+res=(ones(n+1,1)*X).^((0:n)'*ones(1,n+1));\r
--- /dev/null
+function compar_perf(ch1,ch2,deb,fin)\r
+% compare les tracés des fonctions ch1 et ch2 entre deb et fin\r
+% variables d'entrée\r
+% ch1,ch2 chaines désignant des noms de fonctions\r
+% deb et fin désignent des entiers naturels extrémités\r
+% d'un vecteur d'entiers de pas 1 (deb<=fin).\r
+% variables de sortie\r
+% aucune.\r
+% La fonction réalise un tracé qu'on peut exporter. \r
+% \r
+% ************ Fonctions connexes utilisées ***************\r
+% fonct1,fonct2 \r
+% *********************************************************\r
+\r
+% Contrôles d'entrée\r
+\r
+% nombre d'arguments\r
+\r
+% autres tests éventuels \r
+ \r
+% Corps d'algorithme\r
+\r
+n=deb:fin;\r
+im1=feval(ch1,n);\r
+im2=feval(ch2,n);\r
+\r
+% sortie des résultats\r
+\r
+plot(n,im1,'r',n,im2,'g');\r
+\r
+\r
+% fin de fonction()\r
+\r
--- /dev/null
+% Cadre pour démo élémentaire\r
+% L'utilisateur peut définir d'autres fonctions polynomes\r
+% ou non que les seules fonct1 et fonct2.\r
+% Il pourra aussi par utilisation de la fonction roots\r
+% déterminer les valeurs réelles qui font basculer\r
+% les positions respectives de ch1(n) et ch2(n),\r
+% en extrayant du vecteur des racines, celles\r
+% qui ne sont pas dans C-R.\r
+\r
+% ************ Fonctions connexes utilisées ***************\r
+% fonct1, fonct2, compar_perf\r
+% *********************************************************\r
+\r
+% Contrôles d'entrée\r
+\r
+% nombre d'arguments\r
+\r
+% autres tests éventuels \r
+ \r
+% Corps d'algorithme\r
+\r
+ch1='fonct1';ch2='fonct2';\r
+compar_perf(ch1,ch2,0,150);\r
+\r
+% sortie des résultats\r
+\r
+\r
+\r
+% fin de script
\ No newline at end of file
--- /dev/null
+function y1=fonct1(n)\r
+% calcule les images de n par la fonction fonct1.\r
+% variables d'entrée\r
+% n vecteur de nombres pensés entiers ici.\r
+% variables de sortie\r
+% y1 vecteur image de n par fonct1\r
+% \r
+% \r
+% ************ Fonctions connexes utilisées ***************\r
+% \r
+% *********************************************************\r
+\r
+% Contrôles d'entrée\r
+\r
+% nombre d'arguments\r
+\r
+% autres tests éventuels \r
+ \r
+% Corps d'algorithme\r
+\r
+% sortie des résultats\r
+\r
+y1=(0.0008).*(n.^3)+(0.1).*(n.^2);\r
+\r
+% fin de fonction()\r
--- /dev/null
+function y2=fonct2(n)\r
+% calcule les images de n par la fonction fonct2.\r
+% variables d'entrée\r
+% n vecteur de nombres pensés entiers ici.\r
+% variables de sortie\r
+% y2 vecteur image de n par fonct1\r
+% \r
+% \r
+% ************ Fonctions connexes utilisées ***************\r
+% \r
+% *********************************************************\r
+\r
+% Contrôles d'entrée\r
+\r
+% nombre d'arguments\r
+\r
+% autres tests éventuels \r
+ \r
+% Corps d'algorithme\r
+\r
+% sortie des résultats\r
+\r
+y2=(0.17).*(n.^2)+(0.05).*n;\r
+\r
+% fin de fonction()\r
--- /dev/null
+function lect_absc(eps)\r
+% lit les abscisses des points d'une courbe\r
+%\r
+% variables d'entrée et fonctionnement\r
+%\r
+% Tant que l'utilisateur clique gauche\r
+% le système affiche un entier qui représente\r
+% la partie entière de cette abscisse si eps=-1,\r
+% la partie entière de cette abscisse si eps=1;\r
+% on sort en cliquant droit.\r
+%\r
+% variables de sortie\r
+% affichage de l'abscisse du point cliqué,\r
+% en respectant l'arrondi décrit ci-dessus.\r
+% \r
+% \r
+% ************ Fonctions connexes utilisées ***************\r
+% \r
+% *********************************************************\r
+\r
+% Contrôles d'entrée\r
+% nombre d'arguments\r
+if nargin~=1\r
+ error('passage d''arguments incorrect');\r
+end;\r
+% autres tests éventuels \r
+if eps^2~=1\r
+ error('Champ eps incorrect');\r
+end\r
+\r
+\r
+ \r
+% Corps d'algorithme\r
+\r
+% traitement proprement dit\r
+bout=1;\r
+while bout==1\r
+ [x,y,bout]=ginput(1);\r
+ % on peut sortir x et y.\r
+ text(x,y,['n=' num2str(floor(x+1+(eps-1)/2))]);\r
+end\r
+\r
+\r
+% sortie des résultats\r
+\r
+\r
+\r
+% fin de fonction()\r
+\r
+\r
+\r
--- /dev/null
+function trace1(deb,fin)\r
+% trace les courbes de T1 et T2 pour deb<=x<= fin\r
+% \r
+% variables d'entrée\r
+% deb et fin de significations triviales,\r
+% pensées valeurs entières...\r
+% \r
+% variables de sortie\r
+% aucune. On trace et peut exporter.\r
+% \r
+% \r
+% ************ Fonctions connexes utilisées ***************\r
+% \r
+% *********************************************************\r
+\r
+% Contrôles d'entrée\r
+\r
+% nombre d'arguments\r
+\r
+% autres tests éventuels \r
+ \r
+% Corps d'algorithme\r
+\r
+n=deb:fin;\r
+y1=(0.001).*(n.^3);\r
+y2=(0.19).*(n.^2);\r
+\r
+% sortie des résultats\r
+\r
+plot(n,y1,'r',n,y2,'g');\r
+\r
+% fin de fonction()\r
--- /dev/null
+function trace2(deb,fin)\r
+% trace les courbes de T1 et T2 pour deb<=x<= fin\r
+% \r
+% variables d'entrée\r
+% deb et fin de significations triviales,\r
+% pensées valeurs entières...\r
+% \r
+% variables de sortie\r
+% aucune. On trace et peut exporter.\r
+% \r
+% \r
+% ************ Fonctions connexes utilisées ***************\r
+% \r
+% *********************************************************\r
+\r
+% Contrôles d'entrée\r
+\r
+% nombre d'arguments\r
+\r
+% autres tests éventuels \r
+ \r
+% Corps d'algorithme\r
+\r
+n=deb:fin;\r
+y1=(0.0008).*(n.^3)+(0.1).*(n.^2);\r
+y2=(0.17).*(n.^2)+(0.05).*n;\r
+\r
+% sortie des résultats\r
+\r
+plot(n,y1,'r',n,y2,'g');\r
+\r
+% fin de fonction()\r
--- /dev/null
+function res=couleur7(k)\r
+\r
+\r
+% couleur7 : renvoie une couleur (modulo 7).\r
+%\r
+% *********************************************************\r
+%\r
+% res=couleur(k) est une chaîne de caractère telle que \r
+% si k (mod 7)=1, couleur7='b';\r
+% si k (mod 7)=2, couleur7='g';\r
+% si k (mod 7)=3, couleur7='r';\r
+% si k (mod 7)=4, couleur7='c';\r
+% si k (mod 7)=5, couleur7='m';\r
+% si k (mod 7)=6, couleur7='y';\r
+% si k (mod 7)=0, couleur7='k';\r
+% \r
+% variables d'entrées : k entier\r
+%\r
+% variables de sortie : res chaîne de caractère.\r
+% \r
+% \r
+% ************ Fonctions auxiliaires utilisées ************\r
+%\r
+% aucune\r
+%\r
+% *********************************************************\r
+%\r
+\r
+% Contrôles d'entrée\r
+% nombre d'arguments\r
+if nargin~=1\r
+ error('nombre d''arguments de la fonction incorrect');\r
+end\r
+\r
+% corps d'algorithme\r
+switch mod(k,7)\r
+ case 1\r
+ res='b';\r
+ case 2\r
+ res='g';\r
+ case 3\r
+ res='r';\r
+ case 4\r
+ res='c';\r
+ case 5\r
+ res='m';\r
+ case 6\r
+ res='y';\r
+ case 0\r
+ res='k';\r
+end\r
+\r
--- /dev/null
+function [a,b,r]=regression_lineaire(x,y)\r
+\r
+% regression_lineaire : calcul de droite de moindres carrées.\r
+%\r
+% x et y sont deux vecteurs de même taille.\r
+% [a,b,r]=regression_lineaire(x,y) renvoie a : le pente de la droite,\r
+% b : l'ordonnée à l'origine,\r
+% r : la correlation\r
+%\r
+% \r
+% \r
+% ************ Fonctions auxiliaires utilisées ************\r
+%\r
+% aucune\r
+%\r
+% *********************************************************\r
+%\r
+\r
+n=length(x);\r
+sumx=sum(x);\r
+sumy=sum(y);\r
+r=corrcoef(x,y);\r
+r=r(1,2);\r
+[p,s]=polyfit(x,y,1);\r
+a=p(1);\r
+b=p(2);\r
+\r
+\r
+\r
--- /dev/null
+function res=saisiefonction\r
+\r
+% saisiefonction : saisie au clavier d'une fonction.\r
+%\r
+% *********************************************************\r
+%\r
+% cette fonction saisit au clavier le nom d'une fonction f :\r
+% - si cette fonction est une fonction built-in ou définie par un fichier .m\r
+% il faut rentrer au clavier le nom de cette fonction sans apostrophes.\r
+% - sinon, il faut entrer sans appostrophe la chaine qui definit cette fonction\r
+% en fonction de x et sans point (vectorize les rajoute) (exemple : 1/(1+x^2))\r
+%\r
+% dans le premier cas, res est la chaine égale au nom de la fonction\r
+% dans le second cas, res est la fonction déclarée par inline\r
+%\r
+% dans le deux cas, on calcule l'image de X par res en utilisant y=feval(res,x)\r
+% ou on fait un graphique avec fplot(res,...)\r
+%\r
+% ATTENTION : fonction avec argument à entrer au clavier.\r
+\r
+disp(' ');\r
+disp(' ');\r
+disp('Entrez le nom de la fonction sans apostrophes : ');\r
+disp(' ');\r
+disp(' ');\r
+disp('- Soit directement le nom de cette fonction, si elle built-in');\r
+disp(' exemple : cos');\r
+disp('- Soit directement le nom du fichier *.m ou elle est stockée');\r
+disp(' exemple : dudu');\r
+disp('- Soit la chaîne de caratère en fonction de x sinon (sans apostrophe et sans point).');\r
+disp(' exemple : 1/(1+x^2)');\r
+ch=input('fonction : ','s');\r
+c=exist(ch);\r
+\r
+if (c==2) | (c==5) \r
+ res=ch;\r
+else\r
+ res=eval(['vectorize(inline(','''',ch,'''','))']);\r
+end
\ No newline at end of file
--- /dev/null
+% exemple de calcul formel avec tracé.\r
+\r
+syms a b x;\r
+f=(a-x)*(x-b);\r
+fp=diff(f,x);\r
+d=solve(fp);\r
+pretty(simplify(subs(f,x,d)));\r
+\r
+disp('pour voir le graphe, appuyez sur une touche');\r
+pause;\r
+X=-1:2/500:1;\r
+Y=subs(subs(f,{a,b},{-1,1}),x,X);\r
+plot(X,Y);
\ No newline at end of file
--- /dev/null
+% exemple de calcul formel avec tracé.\r
+\r
+syms h x;\r
+f=(h-x)*x*(x+h);\r
+fp=diff(f,x);\r
+d=solve(expand(fp));\r
+q=simplify(subs(f,'x',d));\r
+r=eval(vpa(q));\r
+pretty(eval(vpa(q)));\r
+\r
+disp('pour voir le graphe, appuyez sur une touche');\r
+pause;\r
+X=-1:2/500:1;\r
+Y=subs(subs(f,h,1),x,X);\r
+plot(X,Y);
\ No newline at end of file
--- /dev/null
+% crée le vecteur x,\r
+% y11 =f(x),\r
+% y12 =f'x),\r
+% y21 la dérivées approchées,\r
+% y22, l'erreur.\r
+n=1000;\r
+x=linspace(-10,10,n);\r
+\r
+y11=-x.*sin(x);\r
+y12=-x.*cos(x)-sin(x);\r
+y21=diff(y11)./(x(2)-x(1));\r
+y22=(y21-y12(1:n-1));\r
+\r
+% tracé du graphique en haut à gauche\r
+\r
+subplot(2,2,1); plot(x,y11);\r
+title('la fonction');\r
+\r
+% tracé du graphique en haut à droite\r
+\r
+subplot(2,2,2); plot(x,y12);\r
+title('la dérivée');\r
+\r
+% tracé du graphique en bas à gauche\r
+\r
+subplot(2,2,3); plot(x(1:n-1),y21);\r
+title('la dérivée approchée');\r
+\r
+% tracé du graphique en bas à droite\r
+\r
+subplot(2,2,4); plot(x(1:n-1),y22);\r
+title('l''erreur');\r
+\r
+\r
--- /dev/null
+function res=escalier(x)\r
+\r
+% escalier : fonction escalier (définie ici par 4 valeurs).\r
+%\r
+% *********************************************************\r
+%\r
+% res=escalier(x)\r
+% \r
+%\r
+% variables d'entrées \r
+% * x: réel ou tableau\r
+%\r
+% variables de sortie : res=f(x) (ou tableau des images) avec, si x réel \r
+% * f(x)=0 si x<0;\r
+% =1 si 0<=x<=2;\r
+% =2 si 2<x<18;\r
+% =3 si 18<=x.\r
+%\r
+%\r
+% ************ Fonctions auxiliaires utilisées ************\r
+%\r
+% aucune\r
+%\r
+% *********************************************************\r
+\r
+\r
+\r
+% Contrôles d'entrée\r
+% nombre d'arguments\r
+if nargin~=1\r
+ error('nombre d''arguments de la fonction incorrect');\r
+end\r
+ \r
+% Corps d'algorithme\r
+res=((0<=x)&(x<=2))+((2<x)&(x<18))*2+(x>=18)*3;\r
+\r
+\r
+\r
+\r
--- /dev/null
+function x=somme1(n,m)\r
+% déterminer ce que fait cette fonction à deux variables d'entrée.\r
+\r
+for i= 1:n\r
+ xtemp=0;\r
+ for j = 1:m\r
+ xtemp=xtemp+log(i)*exp(-j^2);\r
+ end\r
+ x(i)=xtemp;\r
+end\r
--- /dev/null
+function res=int_fcn(c,N,A,B,fcn,varargin)\r
+\r
+\r
+% int_fcn : calcul approché d'intégrale par méthode classique\r
+%\r
+% *********************************************************\r
+%\r
+% res=int_fcn(c,N,A,B,fcn,varargin) renvoie la valeur approchée de l'intégrale\r
+% d'une fonction sur un intevalle par la méthodes des rectangles, des milieux,\r
+% des trapèzes ou de simpson.\r
+%\r
+% variables d'entrées : \r
+% * c définit la méthode : \r
+% c=1 : méthode des rectangles,\r
+% c=2 : méthode des trapèzes,\r
+% c=3 : méthode des milieux,\r
+% c=4 : méthode de Simpson;\r
+% * N est le nombre de sous intervalles utilisés (correspondant à h=(B-A)/N)\r
+% * [A,B] est l'intervalle d'intégration\r
+% * fcn est une chaîne de caractère représentant la fonction \r
+% (de type inline, builtin ou par fichier M-file);\r
+% * varargin sont les arguments optionnels de la fonction.\r
+% attention, intégration par rapport à la première variable de f.\r
+%\r
+% variables de sortie\r
+% * res est la valeur approchée de l'intégrale calculée.\r
+% \r
+% \r
+% ************ Fonctions auxiliaires utilisées ************\r
+%\r
+% aucune\r
+%\r
+% *********************************************************\r
+%\r
+\r
+\r
+\r
+% Contrôles d'entrée\r
+% nombre d'arguments\r
+if (A>=B)\r
+ error('il faut A<B');\r
+end\r
+if (fix(N)~=N) | (N <1)\r
+ error('n doit être un entier naturel non nul');\r
+end\r
+if ~((c==1) | (c==2) | (c==3) | (c==4))\r
+ error('c doit être un entier égal à 1, 2, 3 ou 4');\r
+end\r
+qs=exist(fcn);\r
+if (qs~=2) & (qs~=5) & (qs~=1)\r
+ error('fcn doit être le nom d''une fonction (built-in, M-file ou inline)');\r
+end\r
+\r
+\r
+h=(B-A)/N;\r
+switch(c)\r
+% calcul par la méthode des rectangles\r
+ case(1)\r
+ res=h*sum(feval(fcn,A:h:B-h,varargin{:}));\r
+% calcul par la méthode des trapèzes (sans trapz)\r
+ case(2)\r
+ res=(h/2)*(feval(fcn,A,varargin{:})+feval(fcn,B,varargin{:})+...\r
+ 2*sum(feval(fcn,A+h:h:B-h,varargin{:}))); \r
+% calcul par la méthode du point milieu\r
+ case(3)\r
+ res=h*sum(feval(fcn,A+h/2:h:B-h/2,varargin{:}));\r
+% calcul par la méthode de Simpson\r
+ case(4)\r
+ res=(h/6)*(feval(fcn,A,varargin{:})+feval(fcn,B,varargin{:})+...\r
+ 2*sum(feval(fcn,A+h:h:B-h,varargin{:}))+...\r
+ 4*sum(feval(fcn,A+h/2:h:B-h/2,varargin{:})));\r
+end
\ No newline at end of file
--- /dev/null
+function P=calcul_poly_gauss(c,n)\r
+\r
+% calcul_poly_gauss : calcul des polynômes othogonaux de Gauss\r
+%\r
+% *********************************************************\r
+%\r
+% P=calcul_poly_gauss(c,n) renvoie les polynômes de Gauss P_0,P_1,...,P_n\r
+% pour les quatre méthodes génériques (Legendre, Tchebytchev, Hermite \r
+% et Laguerre.\r
+%\r
+% variables d'entrées : \r
+% * n : entier naturel.\r
+% * c définit la méthode : \r
+% c=1 : Gauss-Legendre,\r
+% c=2 : Gauss-Tchebytchev,\r
+% c=3 : Gauss-Hermite,\r
+% c=4 : Gauss-Laguerre.\r
+% variables de sortie\r
+% * P : tableau de taille (n+1)*(n+1) tel que \r
+% pour tout i dans {1,...,n+1}, P(i,1:i) contient\r
+% le polynôme P_{i-1} (coefficient dominant en tête)\r
+% \r
+% \r
+% ************ Fonctions auxiliaires utilisées ************\r
+%\r
+% aucune\r
+%\r
+% *********************************************************\r
+%\r
+\r
+\r
+\r
+\r
+% Contrôles d'entrée\r
+% nombre d'arguments\r
+if nargin~=2\r
+ error('nombre d''arguments de la fonction incorrect');\r
+end\r
+% autres tests éventuels \r
+if (fix(n)~=n) | (n<0)\r
+ error('l''entier n doit être un entier naturel');\r
+end\r
+if ~((c==1) | (c==2) | (c==3) | (c==4))\r
+ error('c doit être un entier égal à 1, 2, 3 ou 4');\r
+end\r
+\r
+\r
+% Corps d'algorithme.\r
+P=zeros(n+1,n+1);\r
+if (c~=2)\r
+ P(1,1)=1;\r
+ Lb=[];\r
+ La=[1];\r
+ for k=0:n-1\r
+ switch(c)\r
+ case 1\r
+ auxi0=1/(k+1);\r
+ auxi1=(2*k+1)*auxi0;\r
+ auxi2=-k*auxi0;\r
+ Lc=[auxi1*La 0]+[0 0 auxi2*Lb];\r
+ case 3\r
+ Lc=[2*La 0]-[0 0 2*k*Lb];\r
+ case 4\r
+ auxi0=1/(k+1);\r
+ auxi1=(2*k+1)*auxi0;\r
+ auxi2=-k*auxi0;\r
+ Lc=[-auxi0*La 0]+[0 auxi1*La]+[0 0 auxi2*Lb]; \r
+ end\r
+ Lb=La;\r
+ La=Lc;\r
+ P(k+2,1:k+2)=Lc; \r
+ end\r
+else\r
+ P(1,1)=1;\r
+ if (n>=1)\r
+ P(2,1:2)=[1 0];\r
+ Lb=1;\r
+ La=[1 0];\r
+ for k=1:n-1 \r
+ Lc=[2*La 0]-[0 0 Lb];\r
+ Lb=La;\r
+ La=Lc;\r
+ P(k+2,1:k+2)=Lc; \r
+ end\r
+ end\r
+end\r
--- /dev/null
+% script demo_trace_poly_gauss : tracé des polynômes de gauss P_0, P_1,...,P_n \r
+%\r
+%\r
+% pour l'une des quatre familes : \r
+% Gauss-Legendre,\r
+% Gauss-Tchebytchev,\r
+% Gauss-Hermite,\r
+% Gauss-Laguerre.\r
+%\r
+%\r
+%\r
+% ************ Fonctions auxiliaires utilisées ************\r
+% \r
+% calcul_poly_gauss \r
+%\r
+% *********************************************************\r
+\r
+\r
+n=input('entrez l''entier naturel n : ');\r
+N=input('entrez le nombre de points pour le graphique : ');\r
+disp('choix de la famille : ');\r
+disp('c=1 : Gauss-Legendre');\r
+disp('c=2 : Gauss-Tchebytchev');\r
+disp('c=3 : Gauss-Hermite');\r
+disp('c=4 : Gauss-Laguerre');\r
+c=input('entrez c : ');\r
+if (c==3) | (c==4) \r
+ A=input('entrez la borne supérieure de l''intervalle d''etude : ');\r
+else\r
+ A=1;\r
+end\r
+choix=input('voulez vous voir les légendes ? entrez o ou n : ','s');\r
+if (c==4)\r
+ h=A/(N);\r
+ x=0:h:A;\r
+else\r
+ h=2*A/(N);\r
+ x=-A:h:A; \r
+end\r
+P=calcul_poly_gauss(c,n);\r
+clf;\r
+hold on;\r
+if strcmp(choix,'o')\r
+ touslesnoms=[];\r
+ toutesleslegendes=[];\r
+ Q=5;\r
+ Qtestt=0;\r
+ for k=0:n\r
+ nom =num2str(k);\r
+ long=length(nom);\r
+ Qtestt=Qtestt+1;\r
+ touslesnoms=[touslesnoms,' ',nom];\r
+ legende=[nom,blanks(Q-long+1)];\r
+ toutesleslegendes=[toutesleslegendes;legende];\r
+ end\r
+end\r
+for k=0:n\r
+ cou=couleur7(k);\r
+ plot(x,polyval(P(k+1,1:k+1),x),cou); \r
+end\r
+if strcmp(choix,'o')\r
+ legend(strvcat(toutesleslegendes),0);\r
+end \r
+hold off;\r
--- /dev/null
+function Iapp=int_gauss(n,points,poids,rcn)\r
+\r
+% int_gauss : calcul de l'intégrale par méthode de Gauss à n+1 points\r
+%\r
+% *********************************************************\r
+%\r
+% Iapp=int_gauss(n,points,poids,fcn) : valeur approchée de l'intégrale\r
+% de la fonction rcn=r=f/w (w poids poids) sur l'intervalle sous la forme conventionnelle (a,b) avec \r
+% l'une des quatre méthodes à n+1 points: \r
+% Legendre, Tchebytchev, Hermite ou Laguerre, éventuellement en formel \r
+%\r
+%\r
+% variables d'entrées : \r
+% * n : entier naturel.\r
+% * points : tableau de taille (q+1)*(q+1) (avec n<=q) tel que \r
+% pour tout l dans {0,...,q}, points(l+1,1:l+1) contient\r
+% les l+1 points x_i de la formule (à l+1 points)\r
+% * poids : tableau de taille (n+1)*(n+1) tel que \r
+% pour tout l dans {0,...,n}, poids(l+1,1:l+1) contient\r
+% les l+1 poids D_i de la formule (à l+1 points)\r
+% * rcn est une chaîne de caractère représentant la fonction r=f/w\r
+% (de type inline, builtin ou par fichier M-file);\r
+% variables de sortie\r
+% * Iapp : valeur approchée de l'intégrale de f sur un intervalle conventionnel.\r
+% \r
+% \r
+% \r
+% ************ Fonctions auxiliaires utilisées ************\r
+%\r
+% aucune\r
+%\r
+% *********************************************************\r
+\r
+\r
+% Contrôles d'entrée\r
+% nombre d'arguments\r
+if nargin~=4\r
+ error('nombre d''arguments de la fonction incorrect');\r
+end\r
+% autres tests éventuels \r
+if (fix(n)~=n) | (n<0)\r
+ error('l''entier n doit être un entier naturel');\r
+end\r
+[q1,q2]=size(points);\r
+[q3,q4]=size(poids);\r
+if (q1~=q2)\r
+ error('attention, le troisième argument doit être une matrice carrée');\r
+end\r
+if (q3~=q4)\r
+ error('attention, le quatrième argument doit être une matrice carrée');\r
+end\r
+if (q1~=q3)\r
+ error('attention, le troisième et le quatrième argument doivent avoir la même taille');\r
+end\r
+if (n>q1-1) \r
+ error('attention, n est trop grand');\r
+end\r
+\r
+% Corps d'algorithme.\r
+Iapp=sum(feval(rcn,(points(n+1,1:n+1))).*poids(n+1,1:n+1));\r
--- /dev/null
+function Iapp=int_gauss_legendre(n,a,b,points,poids,fcn)\r
+\r
+% int_gauss_legendre : calcul de l'intégrale par méthode de Gauss-Legendre à n+1 points\r
+%\r
+% *********************************************************\r
+%\r
+% Iapp=int_gauss_legendre(n,a,b,points,poids,fcn) : valeur approchée de l'intégrale\r
+% de la fonction fcn sur l'intervalle [a,b] avec la méthode de Gauss-Legendre\r
+% à n+1 points.\r
+% \r
+% variables d'entrées : \r
+% * n : entier naturel.\r
+% * a,b : bornes de l'intervalle\r
+% * points : tableau de taille (q+1)*(q+1) (avec n<=q) tel que \r
+% pour tout l dans {0,...,q}, points(l+1,1:l+1) contient\r
+% les l+1 points x_i de la formule (à l+1 points)\r
+% * poids : tableau de taille (n+1)*(n+1) tel que \r
+% pour tout l dans {0,...,n}, poids(l+1,1:l+1) contient\r
+% les l+1 poids D_i de la formule (à l+1 points)\r
+% * fcn est une chaîne de caractère représentant la fonction \r
+% (de type inline, builtin ou par fichier M-file);\r
+% variables de sortie\r
+% * Iapp : valeur approchée de l'intégrale\r
+% \r
+% \r
+% ************ Fonctions auxiliaires utilisées ************\r
+%\r
+% aucune\r
+%\r
+% *********************************************************\r
+%\r
+%\r
+\r
+% Contrôles d'entrée\r
+% nombre d'arguments\r
+if nargin~=6\r
+ error('nombre d''arguments de la fonction incorrect');\r
+end\r
+% autres tests éventuels \r
+if (fix(n)~=n) | (n<0)\r
+ error('l''entier n doit être un entier naturel');\r
+end\r
+if (a>=b)\r
+ error('attention, a doit être plus petit que b');\r
+end\r
+[q1,q2]=size(points);\r
+[q3,q4]=size(poids);\r
+if (q1~=q2)\r
+ error('attention, le troisième argument doit être une matrice carrée');\r
+end\r
+if (q3~=q4)\r
+ error('attention, le quatrième argument doit être une matrice carrée');\r
+end\r
+if (q1~=q3)\r
+ error('attention, le troisième et le quatrième argument doivent avoir la même taille');\r
+end\r
+if (n>q1-1) \r
+ error('attention, n est trop grand');\r
+end\r
+\r
+% Corps d'algorithme.\r
+auxi=(b-a)/2;\r
+Iapp=auxi*sum(feval(fcn,auxi*(points(n+1,1:n+1)+1)+a).*poids(n+1,1:n+1));\r
--- /dev/null
+function [points,poids]=points_poids_gauss(c,n)\r
+\r
+\r
+% points_poids_gauss : calcul des poids et des points de Gauss\r
+% \r
+% *********************************************************\r
+%\r
+% [points,poids]=points_poids_gauss(c,n) renvoie les points D_i et les points x_i\r
+% des formules d'intégration à l+1 points pour 0<=l<=n, pour \r
+% l'une des quatre méthodes : Legendre, Tchebytchev, Hermite ou Laguerre.\r
+%\r
+% variables d'entrées : \r
+% * n : entier naturel.\r
+% * c définit la méthode : \r
+% c=1 : méthode de Gauss-Legendre,\r
+% c=2 : méthode de Gauss-Tchebychev,\r
+% c=3 : méthode de Gauss-Hermite,\r
+% c=4 : méthode de Gauss-Laguerre;\r
+%\r
+% variables de sortie\r
+% * points : tableau de taille (n+1)*(n+1) tel que \r
+% pour tout l dans {0,...,n}, points(l+1,1:l+1) contient\r
+% les l+1 points x_i de la formule (à l+1 points)\r
+% * poids : tableau de taille (n+1)*(n+1) tel que \r
+% pour tout l dans {0,...,n}, poids(l+1,1:l+1) contient\r
+% les l+1 poids D_i de la formule (à l+1 points)\r
+%\r
+%\r
+% ************ Fonctions auxiliaires utilisées ************\r
+%\r
+% calcul_poly_gauss\r
+%\r
+% *********************************************************\r
+\r
+\r
+% Contrôles d'entrée\r
+% nombre d'arguments\r
+if nargin~=2\r
+ error('nombre d''arguments de la fonction incorrect');\r
+end\r
+% autres tests éventuels \r
+if (fix(n)~=n) | (n<0)\r
+ error('l''entier n doit être un entier naturel');\r
+end\r
+if ~((c==1) | (c==2) | (c==3) | (c==4))\r
+ error('c doit être un entier égal à 1, 2, 3 ou 4');\r
+end\r
+\r
+% Corps d'algorithme.\r
+poids=zeros(n+1,n+1);\r
+points=zeros(n+1,n+1);\r
+if (c~=2) \r
+ P=calcul_poly_gauss(c,n+1);\r
+ for k=0:n\r
+ C=(sort(roots(P(k+2,1:k+2))))';\r
+ [points(k+1,1:k+1),ind]=sort(C); \r
+ switch c\r
+ case 1\r
+ auxipoids=2./((k+1)*polyval(polyder(P(k+2,1:k+2)),C).*polyval(P(k+1,1:k+1),C));\r
+ case 3\r
+ auxipoids=(2^(k+2)*sqrt(pi)*factorial(k+1))./((polyval(polyder(P(k+2,1:k+2)),C)).^2);\r
+ case 4\r
+ auxipoids=1./(C.*(polyval(polyder(P(k+2,1:k+2)),C)).^2);\r
+ end\r
+ poids(k+1,1:k+1)=auxipoids(ind); \r
+ end\r
+else\r
+ for k=0:n\r
+ points(k+1,1:k+1)=cos(((2*(0:k)+1)/(k+1))*pi/2); \r
+ poids(k+1,1:k+1)=(pi/(k+1))*ones(1,k+1);\r
+ end\r
+end\r
--- /dev/null
+% fichier de démo du tp3C\r
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\r
+% Fonctions connexes appelées\r
+% \r
+% gener_signal,determin_periode,visu_integ\r
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\r
+\r
+global etendue\r
+etendue=1.2;\r
+% valeur modifiable mais attention aux effets éventuels; la méthode\r
+% est pensée pour cette valeur, conforme au problème initial.\r
+\r
+\r
+% génération d'un signal pseudo-aléatoire sinusoidal\r
+% ou acquisition de véritables mesures mises au format voulu\r
+[X,Z,T_th]=gener_signal(4,1000);\r
+\r
+% recherche de période\r
+[per,ind]=determin_periode(X,Z);\r
+\r
+% préparation de visualisation pour un 17 pouces\r
+% vous pouvez adapter en créant une figure, en récupérant son champ\r
+% position tel que vous le souhaitez; passez alors ces données\r
+% dans l'affectation de fen_pos ci-dessous.\r
+% close all;\r
+% fen_pos=[385 45 620 640];\r
+% figure(1);set(1,'position',fen_pos);\r
+\r
+% Vous pouvez aussi lancer l'exécution une fois, mettre la fenetre\r
+% à la taille souhaitée et avant une nouvelle exécution taper clf.\r
+\r
+% visualisation animée\r
+visu_integ(X,Z,ind);\r
+\r
+% variantes utilisateur!\r
+\r
--- /dev/null
+function [per,num]=determin_periode(X,Z)\r
+% détermine la période d'un signal sinusoidal par calcul d'intégrale\r
+%\r
+% variables d'entrée\r
+% X désigne le vecteur des dates régulièrement réparties du signal\r
+% Z désigne le vecteur des images du signal s : Z=s(X).\r
+% Il est essentiel que le signal issu de mesures a été toiletté\r
+% préalablement sinon les calculs d'intégrales menés par exemple\r
+% n'ont pas de sens.\r
+%\r
+% variable de sortie\r
+% per est la valeur approchée de la période obtenue\r
+% grace à la méthode retenue: voir sujet et fichier .doc.\r
+% num désigne l'indice du vecteur X tel que X(num)-X(1)=per.\r
+% On pourrait renvoyer comme paramètre de sortie aussi les deux\r
+% premiers indices en lesquels Z est nul.\r
+%\r
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\r
+% Fonctions connexes appelées\r
+% simpson,\r
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\r
+% Tests d'entrée\r
+if nargin~=2\r
+ error('Nombre de champs incorrect');\r
+end\r
+% controle des données\r
+if size(X)~=size(Z)\r
+ error('Champs incorrects. Voir controle des données');\r
+end\r
+\r
+\r
+format long e;\r
+%\r
+\r
+\r
+% paramètres indispensables\r
+pas_X=X(2)-X(1);\r
+lgr=size(X,2);\r
+\r
+% détermination du deuxième changement de signe de Z\r
+positifs=(Z>=0);\r
+chgt=find(diff(positifs));\r
+\r
+% Initialisation du cacul de l'intégrale de z=f(x)\r
+% entre X0 et le deuxième changement de signe de Z.\r
+% ind_deb, choisi pour disposer d'un nombre de points impairs,\r
+% sera l'indice de début dans le calcul des intégrales suivantes.\r
+ind_deb=chgt(2)+mod(chgt(2)+1,2);\r
+integ0=simpson(pas_X,Z,1,ind_deb);\r
+ind_fin=lgr-mod(lgr-ind_deb,2);\r
+integ=integ0;\r
+\r
+% recherche dichotomique de l'intégrale nulle\r
+% en fin de boucle\r
+% l'integrale entre 1 et ind_deb est d'un signe\r
+% l'integrale entre 1 et ind_fin est de l'autre\r
+% donc l'intégrale entre 1 et leur milieu est considérée nulle.\r
+\r
+while (ind_fin-ind_deb>2)\r
+ mil=(ind_deb+ind_fin)/2;\r
+ % vérification de la conformité des indices deb et fin\r
+ % assurant un nombre impair de points pour intégrer.\r
+ mil=mil-mod(mil-ind_deb,2);\r
+ integ_ajout=simpson(pas_X,Z,ind_deb,mil);\r
+ if (integ0*(integ+integ_ajout)>=0)\r
+ ind_deb=mil;\r
+ integ=integ+integ_ajout;\r
+ else\r
+ ind_fin=mil;\r
+ end\r
+end\r
+\r
+% sortie des paramètres attendus\r
+num=(ind_deb+ind_fin)/2;\r
+per=(num-1)*pas_X;\r
+% on pourrait sortit un vecteur ind_zeros_Z qui contiendrait\r
+% [chgt(1) chgt(2)].\r
+\r
+\r
+\r
+ \r
+\r
+\r
+\r
+\r
+ \r
+\r
+\r
+\r
+\r
--- /dev/null
+function [X,Z,T_th]=gener_signal(ampl,nb_int)\r
+% génère un signal sinusoidal aléatoire\r
+%\r
+% variables d'entrée\r
+% ampl désigne l'amplitude maximale du signal;\r
+% nb_int désigne le nombre d'intervalles entre mesures;\r
+% ainsi le vecteur des abscisses X comporte nb_int+1 valeurs.\r
+% Dans cette application on le minore à 500, en réalité\r
+% on acquiert 10000 mesures en 0.8 secondes environ!\r
+%\r
+% variables de sortie\r
+% X est le vecteur des abscisses\r
+% réparties sur 1,2 période environ comme dans l'application\r
+% industrielle qui a fondé ce développement; ce paramètre sera\r
+% global aux blocs qui le nécessitent sous le nom etendue.\r
+% Z est le vecteur des images associé à X défini par\r
+% Z= a*sin(omega*x+phi)\r
+% où a,omega et phi sont pseudo-aléatoires, définis plus loin.\r
+% T_th désigne la valeur théorique de période, sortie à des fins de\r
+% vérification. Elle n'a pas de sens dans l'application industrielle\r
+% puisqu'elle n'est pas connue!\r
+%\r
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\r
+% Fonctions connexes appelées\r
+%\r
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\r
+\r
+% Tests d'entrée\r
+if nargin~=2\r
+ error('Nombre de champs incorrects');\r
+end\r
+if (ampl>0)*(nb_int>500)==0\r
+ error('Champs incorrects. Voir tests d''entrée');\r
+end\r
+\r
+global etendue\r
+% valeur modifiable mais attention aux effets éventuels; la méthode\r
+% est pensée pour cette valeur, conforme au problème initial.\r
+\r
+format long e;\r
+\r
+% Génération du signal "aléatoire"\r
+% remplacé dans le réel par les données des capteurs\r
+% renvoyées au format matlab choisi ci-dessous.\r
+% Si t est élement de [0,1] comme les renvoie rand, alors\r
+% T=(b-a)t+a est élément de [a,b].\r
+\r
+aleas=rand(1,3);\r
+if aleas(2)==0\r
+ aleas(2)=1;\r
+end\r
+\r
+% définition de l'amplitude a choisie entre ampl/2 et ampl,\r
+% pour assurer la visibilité du signal produit.\r
+a=ampl/2*aleas(1)+ampl/2;\r
+% détermination de phi et omega\r
+omega=abs(aleas(2));\r
+% période théorique\r
+T_th=2*pi/omega;\r
+% phi est ramené dans [O,T_th]\r
+phi=T_th*aleas(3);\r
+\r
+% fabrication du vecteur X\r
+pas_X=etendue*T_th/nb_int;\r
+i=0:nb_int;\r
+X=pas_X.*i;\r
+\r
+% fabrication de Z\r
+Z=a.*sin(omega.*X+phi);\r
+\r
+\r
+\r
+\r
+\r
+\r
--- /dev/null
+function integ=simpson(h,y,ind_deb,ind_fin)\r
+% calcule de façon simplifiée une intégrale en méthode de simpson\r
+%\r
+% variables d'entrée\r
+% h est le demi-pas d'intégration au sens du cours;\r
+% y est le vecteur des valeurs de la fonction à intégrer;\r
+% ind_deb est l'indice de la borne basse de l'intervalle d'intégration;\r
+% ind_fin est l'indice de la borne haute de l'intervalle d'intégration;\r
+% Il est implicite que le nombre (ind_fin-ind_deb) est un entier pair\r
+% c'est-à-dire que le nombre de points d'intégration est impair.\r
+%\r
+% variables de sortie\r
+% integ est la valeur approchée par Simpson de l'intégrale cherchée\r
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\r
+% Fonctions connexes appelées\r
+%\r
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\r
+\r
+\r
+% Tests d'entrée\r
+if nargin~=4\r
+ error('Nombre de champs incorrect');\r
+end\r
+% controle de données\r
+bool1=(h>0)*(mod(ind_fin-ind_deb,2)==0)*(ind_deb<ind_fin);\r
+bool2=(floor(ind_deb)==ind_deb)*(floor(ind_fin)==ind_fin);\r
+if (bool1*bool2==0)\r
+ error('Problème de paramètres. Voir controle de données');\r
+end\r
+format long e;\r
+\r
+% génération des coefficients de Simpson\r
+lgr=ind_fin-ind_deb+1;\r
+coef=2*ones(1,lgr-2);\r
+impairs=1:2:lgr-2; % détermination des indices impairs dans coef\r
+coef(impairs)=coef(impairs)+2;\r
+coef=[1 coef 1]';\r
+\r
+% calcul de l'intégrale proprement dite\r
+integ=h/3*y(ind_deb:ind_fin)*coef;\r
--- /dev/null
+function visu_integ(X,Z,ind_int_nulle)\r
+% fonction qui visualise la recherche de période d'une fonction\r
+% sinusoidale par calcul d'intégrale.\r
+%\r
+% variables d'entrée\r
+% X et Z désignent respectivement abscisses et ordonnées\r
+% des points représentatifs de la fonction traitée.\r
+% ind_int_nulle désigne l'indice du vecteur X pour lequel\r
+% l'intégrale nulle est atteinte.\r
+% Autrement dit, la période est X(ind_int_nulle)-X(1).\r
+% Cet indice est produit par determin_periode.\r
+% La fonction visu_integ produit des images\r
+% qu'on pourra bien sur capter.\r
+\r
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\r
+% Fonctions connexes appelées\r
+% simpson,\r
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\r
+\r
+% Tests d'entrée\r
+if nargin~=3\r
+ error('Nombre de champs incorrect');\r
+end\r
+if sum(size(X)~=size(Z))>0\r
+ error('Champs incorrects. Voir controle des champs.');\r
+end\r
+\r
+global etendue\r
+% Voir remarques dans gener_signal ou demo_tp3C\r
+\r
+% paramètres généraux\r
+lgr=size(X,2);\r
+pas_X=X(2)-X(1);\r
+\r
+% calibrages\r
+\r
+% pour les fenetres 1 et 2.\r
+ampl1=etendue*max(Z);\r
+lim1=[X(1) X(lgr) -ampl1 ampl1];\r
+\r
+% outil intermédiaire : calcul de l'intégrale sur une demi-période\r
+% détermination du deuxième changement de signe de Z.\r
+% Peut etre remplacé par un passage de ces données issues\r
+% de determin_periode, ce qui éviterait leur calcul ici.\r
+positifs=(Z>=0);\r
+chgt=find(diff(positifs));\r
+\r
+ampl3=etendue*...\r
+ abs(simpson(pas_X,Z,chgt(1),chgt(2)+mod(chgt(2)-chgt(1),2)));\r
+lim3=[-ampl3 ampl3 -3 4];\r
+\r
+\r
+% tracé du signal brut\r
+subplot(3,1,1);\r
+plot(X,Z);\r
+axis(lim1);\r
+legend('Signal acquis',0);\r
+\r
+% tracé de l'intégrale en cours de calcul\r
+\r
+% choix de la finesse de découpe de l'intégrale à calculer\r
+% à modifier éventuellement.\r
+nb_iterations=50; unite=10/nb_iterations;\r
+pas=floor((lgr-chgt(2))/nb_iterations);\r
+\r
+% initialisation pour la deuxième fenetre\r
+subplot(3,1,2);\r
+title('Evolution de l''intégrale du signal');\r
+deb=1;fin=chgt(2)+mod(chgt(2)-deb,2);\r
+area(X(deb:fin),Z(deb:fin));\r
+axis(lim1);\r
+hold on;\r
+\r
+% initialisation de la troisieme fenetre\r
+h_3=subplot(3,1,3);\r
+set(h_3,'YTick',[]);\r
+title('Evolution de la valeur de l''intégrale');\r
+integ0=simpson(pas_X,Z,deb,fin);\r
+area([0 integ0],[1 1]);axis(lim3);\r
+pause(0.5);\r
+hold on;\r
+\r
+% initialisations avant boucle\r
+deb=fin;fin=deb+pas+mod(pas,2);\r
+ajout=simpson(pas_X,Z,deb,fin);\r
+integ=integ0+ajout;\r
+\r
+while integ*integ0>=0\r
+ \r
+ % visualisation de l'intégrale en cours de calcul\r
+ rx2=X(deb:fin);rz2=Z(deb:fin);\r
+ subplot(3,1,2);\r
+ title('Evolution de l''intégrale du signal');\r
+ area(rx2,rz2);axis(lim1);\r
+ hold on;\r
+ \r
+ % visualisation de la valeur de l'intégrale\r
+ h_3=subplot(3,1,3);\r
+ set(h_3,'YTick',[]);\r
+ title('Evolution de la valeur de l''intégrale');\r
+ cla;\r
+ area([0 integ],[1 1]);axis(lim3);\r
+ \r
+ % préparation de boucle suivante\r
+ pause(unite);\r
+ deb=fin;fin=deb+pas+mod(pas,2);\r
+ ajout=simpson(pas_X,Z,deb,fin);\r
+ integ=integ+ajout;\r
+ \r
+ % traitement particulier de fin de boucle\r
+ if fin>ind_int_nulle\r
+ \r
+ % fenetre 2 finale\r
+ rx2=X(1:ind_int_nulle);rz2=Z(1:ind_int_nulle);\r
+ subplot(3,1,2);\r
+ title('Evolution de l''intégrale du signal');\r
+ cla;\r
+ area(rx2,rz2);axis(lim1);\r
+ % fenetre 3 finale\r
+ h_3=subplot(3,1,3);\r
+ set(h_3,'YTick',[]);\r
+ title('Evolution de la valeur de l''intégrale');\r
+ cla;\r
+ area([0 ampl3/100],[1 1]);axis(lim3);\r
+ end\r
+ \r
+end\r
--- /dev/null
+function [W1,W2,W3]=choix_du_support(pd1,pd2,pd3,v1,v2,v3,verif)\r
+% calcule les poids explicites d'une formule de quadrature et vérifie\r
+% son caractère exact pour les fonctions polynomes de P2.\r
+%\r
+% variables d'entrée\r
+% pd1,pd2,pd3 sont les symboliques issus de la fonction\r
+% recherche_poids pour le problème considéré.\r
+% v1,v2,v3 sont trois valeurs distinctes de l'intervalle [-1,1]\r
+% qui particularisent les valeurs formelles.\r
+% verif est un booléen\r
+% si verif=1: le logiciel vérifie formellement que les intégrales\r
+% exacte et approchée coincident pour les fonctions considérées;\r
+% sinon, il omet cette vérification.\r
+%\r
+% variables de sortie\r
+% W1,W2,W3 désignent les poids de la formule de quadrature.\r
+% Ainsi l'intégrale I de la fonction f mesurée est donnée par:\r
+% I=W1f(v1)+W2f(v2)+W3f(v3).\r
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\r
+% Fonctions connexes appelées\r
+%\r
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\r
+\r
+% pour l'exemple, intervention de globales!\r
+global t1 t2 t3;\r
+\r
+% tests d'entrée\r
+if nargin~=7\r
+ error('Nombre des arguments incorrect');\r
+end\r
+v=diff(sort([v1 v2 v3]));\r
+if max(v.^2)>1\r
+ error('Les points ne sont pas tous dans [-1,1].Voir controle.');\r
+end\r
+if sum(v==0)>0\r
+ error('Les points ne sont pas distincts. Voir controle.');\r
+end\r
+\r
+% algorithme proprement dit\r
+v=[v1 v2 v3];\r
+v=sym(v,'r');\r
+poids=[pd1 pd2 pd3];\r
+poids_expl=sym(subs(poids,[t1 t2 t3],[v1 v2 v3]),'r');\r
+W1=poids_expl(1);W2=poids_expl(2);W3=poids_expl(3);\r
+\r
+% traitement de la vérification si l'utilisateur l'a demandée\r
+\r
+if verif==1\r
+ syms a b c x;\r
+ ch1='On veut intégrer sur [-1,1] la fonction f donnée par';\r
+ ch2='f(x)=ax^2+bx+c, où a,b,c sont symboliques.';\r
+ ch3='La valeur exacte de l''intégrale est :';\r
+ ch4='La valeur fournie par formule de quadrature est :';\r
+ ch5='obtenue à partir de la valeur du signal aux dates';\r
+ ch6='avec les poids respectifs';\r
+ ch7='L''écart entre les deux expressions est de :';\r
+ fx=a*x^2+b*x+c;\r
+ v_app=W1*subs(fx,x,v1)+W2*subs(fx,x,v2)+W3*subs(fx,x,v3);\r
+ % qu'on peut remplacer par un produit matriciel!\r
+ v_ex=int(fx,x,-1,1);\r
+ % l'indication de x est inutile en fait...\r
+ ecart=v_app-v_ex;\r
+ \r
+ % affichage des résultats\r
+ disp(ch1);disp(ch2);\r
+ disp(ch3);v_ex\r
+ disp(ch4);v_app\r
+ disp(ch5);v\r
+ disp(ch6);poids_expl\r
+ disp(ch7);ecart\r
+end\r
+ \r
--- /dev/null
+% fichier de démo du tp3D\r
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\r
+% Fonctions connexes appelées\r
+% \r
+% recherche_poids,choix_du_support\r
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\r
+\r
+global t1 t2 t3;\r
+syms t1 t2 t3;\r
+\r
+% solution du problème formel\r
+[w1,w2,w3]=recherche_poids(t1,t2,t3);\r
+\r
+% particularisation des valeurs des dates retenues\r
+\r
+% pour demande de vérification formelle\r
+verif=1;\r
+\r
+% variante 1\r
+[W1,W2,W3]=choix_du_support(w1,w2,w3,-0.5,0,0.5,verif);\r
+\r
+% variante 2\r
+% [W1,W2,W3]=choix_du_support(w1,w2,w3,-sqrt(2)/2,0,sqrt(2)/2,verif);\r
+\r
+% variantes utilisateur!\r
+\r
--- /dev/null
+function [w1,w2,w3]=recherche_poids(t1,t2,t3)\r
+% recherche les poids d'une formule de quadrature sur [-1,1]\r
+% exacte pour toute les fonctions polynomes de degré au plus deux;\r
+% Le traitement est effectué en symbolique.\r
+%\r
+% variables d'entrée\r
+% t1,t2,t3 désignent trois dates distinctes de [-1,1] en lesquelles\r
+% sont effectuées les mesures de la fonction à intégrer;\r
+% elles serviront de support pour la formule de quadrature.\r
+%\r
+% variables de sortie\r
+% w1,w2,w3 sont les poids associés qui rendent l'intégration exacte\r
+% pour toute fonction polynome de degré au plus deux. Voir documentation\r
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\r
+% Fonctions connexes appelées\r
+%\r
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\r
+\r
+% tests d'entrée\r
+if nargin~=3\r
+ error('Nombre d''arguments incorrect.');\r
+end\r
+\r
+% corps d'algorithme proprement dit\r
+modele=[t1,t1^2]';\r
+mat=sym(ones(3));\r
+mat(2:3,1)=modele;\r
+mat(2:3,2)=subs(modele,t1,t2);mat(2:3,3)=subs(modele,t1,t3);\r
+sol=(mat\sym([2 0 2/3]'))';\r
+w1=sol(1);w2=sol(2);w3=sol(3);\r
+\r
--- /dev/null
+function[base]=base_pn(x,X)\r
+% engendre la base de Pn utilisée dans l'écriture de Newton\r
+% à partir des symboliques contenus dans x.\r
+%\r
+% variables d'entrée\r
+% x est un vecteur de deg_max+1 symboliques repréentant les points\r
+% du support d'interpolation.\r
+% X représente la variable symbolique\r
+% générique dans les écritures polynomiales.\r
+%\r
+% variables de sortie\r
+% base est un vecteur de symboliques représentant la base\r
+% 1,(X-x0),...,(X-x0)...(X-xn-1) de Pn.\r
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\r
+% Fonctions connexes appelées\r
+%\r
+%\r
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\r
+\r
+% tests d'entrée\r
+if nargin~=2\r
+ error('Nombre d''arguments incorrect.');\r
+end\r
+\r
+% corps d'algorithme proprement dit\r
+\r
+% évite de passer une globale\r
+deg_max=size(x,2)-1;\r
+\r
+base=sym(ones(1,deg_max+1));gen=X*ones(1,deg_max)-x(1:deg_max);\r
+for i=2:deg_max+1,\r
+ base(i)=prod(gen(1:i-1));\r
+end\r
+\r
+\r
+\r
--- /dev/null
+% fichier script de demo_tp3E\r
+%\r
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\r
+% Fonctions connexes appelées\r
+%\r
+% outils_pol (donc diff_div_dist et base_pn),deriv_app\r
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\r
+\r
+\r
+% initialisations diverses\r
+global d base;\r
+\r
+% indéterminée classique des polynomes\r
+syms X real;\r
+deg_max=6;\r
+\r
+% Création des variables symboliques nécessaires;\r
+% pourrait se faire dans une fonction à part!\r
+x=[];y=[];\r
+ch1='x';ch2='y';\r
+for i=0:deg_max\r
+ sym([ch1 num2str(i)],'real');\r
+ x=[x sym([ch1 num2str(i)])];\r
+ sym([ch2 num2str(i)],'real');\r
+ y=[y sym([ch2 num2str(i)])];\r
+end\r
+\r
+% détermination une seule fois des outils pour le calcul\r
+% du polynome d'interpolation maximal.\r
+[d,base]=outils_pol(x,y,X);\r
+\r
+% boucle des recherches de formules de dérivation approchée\r
+\r
+% initialisation\r
+rep=1;\r
+while rep==1\r
+ \r
+ % Choix de l'ordre de dérivation et du degré du polynome d'interpolation;\r
+ % les acharnés échapperont au controle!\r
+ k=-1;compt=0;\r
+ while ((k<=0)|(k>deg_max))&(compt<4)\r
+ ch1=input('Choisissez un ordre de dérivation k (0<k<6)\n','s');\r
+ k=floor(str2num(ch1));\r
+ compt=compt+1;\r
+ % si compt==4 message d'injure...\r
+ end\r
+ n=-1;compt=0;\r
+ while ((n<=0)|(n<k)|(n>deg_max))&(compt<4)\r
+ ch2=input('Choisissez un degré n (n<7)de polynome d''interpolation cohérent\n','s');\r
+ n=floor(str2num(ch2));\r
+ compt=compt+1;\r
+ % si compt==4 message d'injure...\r
+ end\r
+ \r
+ % Calcul proprement dit\r
+ res=deriv_app(k,n,x,y,X);\r
+ \r
+ % Désir d'un autre calcul\r
+ ch=input('Voulez-vous effectuer d''autres calculs ?(si oui: taper 1) \n','s');\r
+ rep=str2num(ch);\r
+end\r
+ \r
+ \r
+ \r
+ \r
+\r
--- /dev/null
+function res=deriv_app(k,n,x,y,X)\r
+% fournit une valeur approchée de dérivée d'ordre k avec un polynome de degré n\r
+% \r
+% variables d'entrée\r
+% k est un entier naturel qui désigne l'ordre de dérivation demandé\r
+% n est un entier désignant le degré du polynome d'interpolation utilisé pour\r
+% la dérivation approchée.\r
+% Selon la parité de n,\r
+% f est supposée donnée en x=(x0,...,xn) centrés autour de t,\r
+% par les valeurs y=(y0,...,yn) via yi=f(xi).\r
+% X désigne l'indéterminée classique.\r
+% \r
+% variable de sortie\r
+% le résultat res uniquement défini comme un symbolique.\r
+\r
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\r
+% Fonctions connexes appelées\r
+%\r
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\r
+global d base;\r
+syms t h real;\r
+\r
+% tests d'entrée\r
+if nargin~=5\r
+ error('Nombre des arguments incorrect');\r
+end\r
+\r
+% effectué en amont... On peut choisir un autre style.\r
+\r
+% algorithme proprement dit\r
+\r
+\r
+% calcul du polynome interpolant adapté aux choix effectués\r
+% et calcul de sa dérivée formelle\r
+util=d(1:n+1)*(base(1:n+1))';\r
+deriv=diff(util,'X',k);\r
+\r
+% détermination du support centré selon parité de n\r
+% sachant qu'il y a n+1 points au support.\r
+if (2*fix(n/2)==n)\r
+ % n est pair\r
+ % détermination du centre parmi les valeurs xi\r
+ c=n/2+1;\r
+ \r
+ % écriture des centres\r
+ xcentre(c)=t;\r
+ for i=n/2:-1:1,\r
+ xcentre(c-i)=t-i*h;xcentre(c+i)=t+i*h;\r
+ end\r
+else\r
+ % n est impair\r
+ sup=(n+1)/2;\r
+ for i=1:sup,\r
+ xcentre(i)=t-(sup-i+1)*h;xcentre(n+2-i)=t+(sup-i+1)*h;\r
+ end\r
+end\r
+\r
+% valeur approchée de la dérivée en fonction des valeurs centrées\r
+res1=simple(subs(deriv,x(1:n+1),xcentre));\r
+\r
+% sortie des résultats\r
+disp('Les valeurs considérées en x sont :');\r
+disp(x(1:n+1));\r
+disp('soit encore, une fois centrées :');\r
+disp(xcentre);\r
+disp('auxquelles correspondent respectivement en f(x):');\r
+disp(y(1:n+1));\r
+sor=[];\r
+if (2*fix(n/2)==n)\r
+ sor=sprintf([sor '=D%df(t=x%d)'],k,c-1);\r
+end\r
+ch=sprintf(['La valeur approchée de D%df(t)' sor ' est,'],k);\r
+disp(ch);\r
+disp('sous forme classique :');\r
+pretty(simple(subs(res1,X,t)));\r
+res=simple(subs(res1,X,t));\r
+\r
+\r
+\r
+\r
+\r
--- /dev/null
+function[d,base]=outils_pol(x,y,X)\r
+% construit les outils de détermination du polynome d'interpolation\r
+% d'une fonction donnée.\r
+% \r
+% variables d'entrée\r
+% x est le vecteur symbolique des points de support d'interpolation;\r
+% y est le vecteur symbolique des valeurs prises par la fonction en\r
+% ces points.\r
+% X est une variable symbolique,nom de l'indéterminée.\r
+%\r
+% variables de sortie\r
+% d est le vecteur symbolique des différences divisées associées;\r
+% base représente la base de Newton associée en symbolique.\r
+%\r
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\r
+% Fonctions connexes appelées\r
+%\r
+% diff_div_dist, base_pn\r
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\r
+\r
+% tests d'entrée\r
+if nargin~=3\r
+ error('Nombre d''arguments incorrect.');\r
+end\r
+% tests éventuels de controle sur les tailles respectives\r
+% des symboliques x et y.\r
+\r
+% corps d'algorithme proprement dit\r
+\r
+d=diff_div_dist(x,y);\r
+base=base_pn(x,X);\r
+\r
+\r
+\r
+\r
--- /dev/null
+% script : demo_compar_methode_int compare les quatre méthodes d'intégrations \r
+% - des rectangles ,\r
+% - du point milieu ,\r
+% - des trapèzes ,\r
+% - de Simpson .\r
+% en comparant l'intégrale calculée avec l'intégrale exacte.\r
+% en terme d'erreur commise.\r
+%\r
+%\r
+% ************ Fonctions auxiliaires utilisées ************\r
+% \r
+% saisiefonction, int_fcn\r
+%\r
+% *********************************************************\r
+\r
+\r
+% ATTENTION : si erreur nulle, log(0)/log(10)=log10d0;\r
+log10d0=-20;\r
+\r
+a=input('Entrez l''extrémité inférieure de [a,b] : ');\r
+b=input('Entrez l''extrémité supérieure de [a,b] : ');\r
+nmin=input('Entrez la puissance de dix du nombre minimum de point de discrétisation : ');\r
+nmax=input('Entrez la puissance de dix du nombre maximum de point de discrétisation : ');\r
+p=input('Entrez le nombre total de point de calculs : ');\r
+disp(' ');\r
+disp(' ');\r
+disp('entrée de la fonction à intégrer');\r
+ch1=saisiefonction;\r
+disp(' ');\r
+disp(' ');\r
+disp('entrée de sa primitive');\r
+ch2=saisiefonction;\r
+x=zeros(1,p);\r
+erreur=zeros(4,p);\r
+nombrecalcul=zeros(4,p);\r
+% calcul des erreurs pour les quatre méthodes\r
+integraleexacte=feval(ch2,b)-feval(ch2,a);\r
+compteur=0;\r
+for k=logspace(nmin,nmax,p)\r
+ compteur=compteur+1;\r
+ for methode=1:4\r
+ kf=fix(k);\r
+ x(compteur)=kf;\r
+ intva=int_fcn(methode,kf,a,b,ch1);\r
+ err=abs(intva-integraleexacte);\r
+ if (err==0)\r
+ erreur(methode,compteur)=log10d0;\r
+ else\r
+ erreur(methode,compteur)=log10(err);\r
+ end\r
+ end\r
+end\r
+log10x=log10(x);\r
+% tracé des erreurs commises par les différentes méthodes\r
+plot(log10x,erreur(1,:),'b',...\r
+ log10x,erreur(2,:),'r',...\r
+ log10x,erreur(3,:),'g',...\r
+ log10x,erreur(4,:),'y');\r
+if exist(ch1)==1\r
+ title(['erreur d''intégration pour la fonction ','inline(',formula(ch1),')']);\r
+else\r
+ title(['erreur d''intégration pour la fonction ',ch1]);\r
+end\r
+xlabel('logarithme 10 du nombre de points d''intégration');\r
+ylabel('logarithme 10 de l''erreur d''intégration');\r
+legend('rectangle','trapèzes','milieux','Simpson',0);\r
+\r
+\r
--- /dev/null
+% script : demo_compar_methode_int_inc compare les quatre méthodes d'intégrations \r
+% - des rectangles ,\r
+% - du point milieu ,\r
+% - des trapèzes ,\r
+% - de Simpson .\r
+% en comparant \r
+% en comparant l'intégrale calculée avec N points \r
+% avec l'intégrale calculée avec 2N points\r
+% en terme d'erreur.\r
+%\r
+%\r
+% ************ Fonctions auxiliaires utilisées ************\r
+% \r
+% saisiefonction, int_fcn\r
+%\r
+% *********************************************************\r
+\r
+\r
+% ATTENTION : si erreur nulle, log(0)/log(10)=log10d0;\r
+log10d0=-20;\r
+\r
+a=input('Entrez l''extrémité inférieure de [a,b] : ');\r
+b=input('Entrez l''extrémité supérieure de [a,b] : ');\r
+nmin=input('Entrez la puissance de dix du nombre minimum de point de discrétisation : ');\r
+nmax=input('Entrez la puissance de dix du nombre maximum de point de discrétisation : ');\r
+p=input('Entrez le nombre total de point de calculs : ');\r
+disp(' ');\r
+disp('entrée de la fonction à intégrer');\r
+ch1=saisiefonction;\r
+x=zeros(1,p);\r
+erreur=zeros(4,p);\r
+temps=zeros(4,p);\r
+nombrecalcul=zeros(4,p);\r
+% calcul des erreurs pour les quatre méthodes\r
+compteur=0;\r
+for k=logspace(nmin,nmax,p)\r
+ compteur=compteur+1;\r
+ for methode=1:4\r
+ kf=fix(k);\r
+ x(compteur)=kf;\r
+ intva=int_fcn(methode,kf,a,b,ch1);\r
+ intvab=int_fcn(methode,2*kf,a,b,ch1);\r
+ err=abs(intva-intvab);\r
+ if (err==0)\r
+ erreur(methode,compteur)=log10d0;\r
+ else\r
+ erreur(methode,compteur)=log10(err);\r
+ end\r
+ end\r
+end\r
+\r
+\r
+log10x=log10(x);\r
+% tracé des erreurs commises par les différentes méthodes\r
+plot(log10x,erreur(1,:),'b',...\r
+ log10x,erreur(2,:),'r',...\r
+ log10x,erreur(3,:),'g',...\r
+ log10x,erreur(4,:),'y');\r
+if exist(ch1)==1\r
+ title(['erreur d''intégration pour la fonction ','inline(',formula(ch1),')']);\r
+else\r
+ title(['erreur d''intégration pour la fonction ',ch1]);\r
+end\r
+xlabel('logarithme 10 du nombre de points d''intégration');\r
+ylabel('logarithme 10 de l''erreur d''intégration');\r
+legend('rectangle','trapèzes','milieux','Simpson',0);\r
+\r
+\r
--- /dev/null
+function P=calcul_poly_gauss_symb(c,n)\r
+\r
+% calcul_poly_gauss_symb : calcul des polynômes de Gauss en symbolique (récurrence)\r
+%\r
+% *********************************************************\r
+%\r
+% P=calcul_poly_gauss_symb(c,n) renvoie les polynômes de Gauss P_0,P_1,...,P_n\r
+% pour les quatre méthodes génériques (Legendre, Tchebytchev, Hermite \r
+% et Laguerre; calcul par récurrence.\r
+%\r
+% variables d'entrées : \r
+% * n : entier naturel.\r
+% * c définit la méthode : \r
+% c=1 : Gauss-Legendre,\r
+% c=2 : Gauss-Tchebytchev,\r
+% c=3 : Gauss-Hermite,\r
+% c=4 : Gauss-Laguerre.\r
+% variables de sortie\r
+% * P : tableau de taille (n+1)*(n+1) tel que \r
+% pour tout i dans {1,...,n+1}, L(i,1:i) contient\r
+% le polynôme L_{i-1} (coefficient dominant en tête)\r
+% à coefficients symboliques\r
+% \r
+% \r
+% ************ Fonctions auxiliaires utilisées ************\r
+%\r
+% aucune\r
+%\r
+% *********************************************************\r
+%\r
+\r
+\r
+% Contrôles d'entrée\r
+% nombre d'arguments\r
+if nargin~=2\r
+ error('nombre d''arguments de la fonction incorrect');\r
+end\r
+% autres tests éventuels \r
+if (fix(n)~=n) | (n<0)\r
+ error('l''entier n doit être un entier naturel');\r
+end\r
+if ~((c==1) | (c==2) | (c==3) | (c==4))\r
+ error('c doit être un entier égal à 1, 2, 3 ou 4');\r
+end\r
+\r
+% Corps d'algorithme.\r
+P=zeros(n+1,n+1);\r
+P=sym(P);\r
+if (c~=2)\r
+ P(1,1)=1;\r
+ Lb=[];\r
+ La=[1];\r
+ for k=0:n-1 \r
+ sk=sym(k);\r
+ switch(c)\r
+ case 1\r
+ auxi0=1/(sk+1);\r
+ auxi1=(2*sk+1)*auxi0;\r
+ auxi2=-sk*auxi0;\r
+ Lc=[auxi1*La 0]+[0 0 auxi2*Lb];\r
+ case 3\r
+ Lc=[2*La 0]-[0 0 2*sk*Lb];\r
+ case 4\r
+ auxi0=1/(sk+1);\r
+ auxi1=(2*sk+1)*auxi0;\r
+ auxi2=-sk*auxi0;\r
+ Lc=[-auxi0*La 0]+[0 auxi1*La]+[0 0 auxi2*Lb]; \r
+ end\r
+ Lb=La;\r
+ La=Lc;\r
+ P(k+2,1:k+2)=Lc; \r
+ end\r
+else \r
+ P(1,1)=1;\r
+ if (n>=1)\r
+ P(2,1:2)=[1 0];\r
+ Lb=1;\r
+ La=[1 0];\r
+ for k=1:n-1 \r
+ Lc=[2*La 0]-[0 0 Lb];\r
+ Lb=La;\r
+ La=Lc;\r
+ P(k+2,1:k+2)=Lc; \r
+ end\r
+ end\r
+end\r
--- /dev/null
+function P=calcul_poly_gauss_symb_dir(c,n)\r
+\r
+% calcul_poly_gauss_symb_dir : calcul des polynômes de Gauss en symbolique directement\r
+%\r
+% *********************************************************\r
+%\r
+% P=calcul_poly_gauss_symb_dir(c,n) renvoie les polynômes de Gauss P_0,P_1,...,P_n\r
+% pour les quatre méthodes génériques (Legendre, Tchebytchev, Hermite \r
+% et Laguerre; calcul par l'expression explicite.\r
+%\r
+% variables d'entrées : \r
+% * n : entier naturel.\r
+% * c définit la méthode : \r
+% c=1 : Gauss-Legendre,\r
+% c=2 : Gauss-Tchebytchev,\r
+% c=3 : Gauss-Hermite,\r
+% c=4 : Gauss-Laguerre.\r
+% variables de sortie\r
+% * P : tableau de taille (n+1)*(n+1) tel que \r
+% pour tout i dans {1,...,n+1}, L(i,1:i) contient\r
+% le polynôme L_{i-1} (coefficient dominant en tête)\r
+% à coefficients symboliques\r
+% \r
+% \r
+% ************ Fonctions auxiliaires utilisées ************\r
+%\r
+% aucune\r
+%\r
+% *********************************************************\r
+%\r
+\r
+% Contrôles d'entrée\r
+% nombre d'arguments\r
+if nargin~=2\r
+ error('nombre d''arguments de la fonction incorrect');\r
+end\r
+% autres tests éventuels \r
+if (fix(n)~=n) | (n<0)\r
+ error('l''entier n doit être un entier naturel');\r
+end\r
+if ~((c==1) | (c==2) | (c==3) | (c==4))\r
+ error('c doit être un entier égal à 1, 2, 3 ou 4');\r
+end\r
+\r
+% Corps d'algorithme.\r
+P=zeros(n+1,n+1);\r
+P=sym(P);\r
+syms x;\r
+switch(c)\r
+ case 1\r
+ P(1)=sym(1);\r
+ Q=sym(1);\r
+ a=sym(1);\r
+ b=sym(1);\r
+ for k=1:n\r
+ Q=Q*(x^2-1);\r
+ a=a*sym(2);\r
+ b=b*sym(k);\r
+ R=diff(Q,k);\r
+ P(k+1,1:k+1)=sym(sym2poly(expand(simplify(1/(a*b)*R))));\r
+ end\r
+ case 2\r
+ for k=0:n\r
+ P(k+1,1:k+1)=sym(sym2poly(expand(cos(sym(k)*acos(x)))));\r
+ end \r
+ case 3\r
+ P(1)=sym(1);\r
+ R=exp(-x^2);\r
+ for k=1:n\r
+ R=diff(R);\r
+ P(k+1,1:k+1)=sym(sym2poly((-1)^k*expand(simplify(exp(x^2)*R))));\r
+ end\r
+ case 4\r
+ P(1)=sym(1);\r
+ a=sym(1);\r
+ c=sym(1);\r
+ for k=1:n\r
+ a=a*x;\r
+ c=c*sym(k);\r
+ Q=(exp(-x)*a);\r
+ R=diff(Q,k);\r
+ P(k+1,1:k+1)=sym(sym2poly(expand(simplify(exp(x)*R))/c));\r
+ end\r
+end\r
+
\ No newline at end of file
--- /dev/null
+% demo_compar_methode_poly_gauss : ce script permet de comparer les deux méthodes\r
+% de calcul des polynômes orthogonaux,\r
+% (par récurrence et directement) en terme de temps de calcul en faisant un graphe\r
+%\r
+%\r
+% ************ Fonctions auxiliaires utilisées ************\r
+%\r
+% calcul_poly_gauss_symb, calcul_poly_gauss_symb_dir\r
+%\r
+% *********************************************************\r
+\r
+clear all;\r
+c=input('entrez c : ');\r
+n=input('entrez n : ');\r
+temps1=zeros(1,n+1);\r
+nombreop1=zeros(1,n+1);\r
+temps2=zeros(1,n+1);\r
+nombreop2=zeros(1,n+1);\r
+for k=0:n\r
+ tic;\r
+ d1=calcul_poly_gauss_symb_dir(c,k);\r
+ temps1(k+1)=toc;\r
+ tic;\r
+ d2=calcul_poly_gauss_symb(c,k);\r
+ temps2(k+1)=toc;\r
+end\r
+plot(1:n+1,temps1,1:n+1,temps2,'-.');\r
+legend('méthode directe','méthode par récurrence')\r
+switch c\r
+ case 1\r
+ title('polynômes de Gauss-Legendre'); \r
+ case 2\r
+ title('polynômes de Gauss-Tchebychev'); \r
+ case 3\r
+ title('polynômes de Gauss-Hermite'); \r
+ case 4\r
+ title('polynômes de Gauss-Laguerre'); \r
+end \r
+xlabel('degré');\r
+ylabel('temps');\r
--- /dev/null
+function res=expression_part_symb(c,n)\r
+\r
+\r
+% expression_part_symb : calcul de l'intégrale de x^n*w(x) sur (a,b) (en symbolique)\r
+%\r
+% *********************************************************\r
+%\r
+% expression_part_symb(c,n) : calcul en symbolique de \int_a^b x^n w(x) dx\r
+% \r
+%\r
+% variables d'entrées : \r
+% * n : entier naturel.\r
+% * c définit le poids w : \r
+% c=1 : Gauss-Legendre,\r
+% c=2 : Gauss-Tchebytchev,\r
+% c=3 : Gauss-Hermite,\r
+% c=4 : Gauss-Laguerre.\r
+% variables de sortie\r
+% *res=valeur de l'inétrale\r
+% \r
+% \r
+% ************ Fonctions auxiliaires utilisées ************\r
+%\r
+% aucune\r
+%\r
+% *********************************************************\r
+%\r
+\r
+\r
+\r
+% Contrôles d'entrée\r
+% nombre d'arguments\r
+if nargin~=2\r
+ error('nombre d''arguments de la fonction incorrect');\r
+end\r
+% autres tests éventuels \r
+if ~((c==1) | (c==2) | (c==3) | (c==4))\r
+ error('c doit être un entier égal à 1, 2, 3 ou 4');\r
+end\r
+\r
+% Corps d'algorithme.\r
+syms x a b;\r
+switch c\r
+ case 1\r
+ a=sym(-1);\r
+ b=sym(1);\r
+ w=sym(1); \r
+ case 2\r
+ a=sym(-1);\r
+ b=sym(1);\r
+ w=1/sqrt(1-x^2); \r
+ case 3\r
+ a=-sym(inf);\r
+ b=sym(inf);\r
+ w=exp(-x^2);\r
+ case 4\r
+ a=sym(0);\r
+ b=sym(+inf);\r
+ w=exp(-x);\r
+end \r
+res=simplify(int(x^n*w,a,b));\r
--- /dev/null
+function [points,poids]=points_poids_gauss_symb(c,n)\r
+\r
+% points_poids_gauss_symb : calcul des poids et des points de Gauss (symbolique)\r
+% \r
+% *********************************************************\r
+%\r
+% [points,poids]=points_poids_gauss_symb(c,n) renvoie les points D_i et les points x_i\r
+% des formules d'intégration à l+1 points pour 0<=l<=n, pour \r
+% l'une des quatre méthodes : Legendre, Tchebytchev, Hermite ou Laguerre,\r
+% en symbolique \r
+%\r
+% variables d'entrées : \r
+% * n : entier naturel.\r
+% * c définit la méthode : \r
+% c=1 : méthode de Gauss-Legendre,\r
+% c=2 : méthode de Gauss-Tchebychev,\r
+% c=3 : méthode de Gauss-Hermite,\r
+% c=4 : méthode de Gauss-Laguerre;\r
+%\r
+% variables de sortie\r
+% * points : tableau de taille (n+1)*(n+1) tel que \r
+% pour tout l dans {0,...,n}, points(l+1,1:l+1) contient\r
+% les l+1 points x_i de la formule (à l+1 points)\r
+% * poids : tableau de taille (n+1)*(n+1) tel que \r
+% pour tout l dans {0,...,n}, poids(l+1,1:l+1) contient\r
+% les l+1 poids D_i de la formule (à l+1 points)\r
+%\r
+% Pour ces deux tableau, évaluation numérique (augmenter le nombre\r
+% de chiffre avec la fonction digits) ou formelle si possible.\r
+% méthode : points : recherche de zéro,\r
+% poids : utilisation des formules du cours (dérivée) \r
+%\r
+%\r
+% ************ Fonctions auxiliaires utilisées ************\r
+%\r
+% calcul_poly_gauss_symb, polyval_symb, polyder_symb\r
+%\r
+% *********************************************************\r
+\r
+% Contrôles d'entrée\r
+% nombre d'arguments\r
+if nargin~=2\r
+ error('nombre d''arguments de la fonction incorrect');\r
+end\r
+% autres tests éventuels \r
+if (fix(n)~=n) | (n<0)\r
+ error('l''entier n doit être un entier naturel');\r
+end\r
+\r
+% Corps d'algorithme.\r
+poids=zeros(n+1,n+1);\r
+points=zeros(n+1,n+1);\r
+poids=sym(poids);\r
+points=sym(points);\r
+spi=sym(pi);\r
+if (c~=2) \r
+ L=calcul_poly_gauss_symb(c,n+1);\r
+ if ((1<=c) & (c<=3))\r
+ points(1,1:1)=0;\r
+ else\r
+ points(1,1)=1;\r
+ end\r
+ switch c\r
+ case 1\r
+ poids(1,1)=2;\r
+ case 3\r
+ poids(1,1)=sqrt(spi);\r
+ case 4\r
+ poids(1,1)=1;\r
+ end\r
+ if (c==3)\r
+ auxis=sym(4)*sqrt(spi);\r
+ end\r
+ syms x;\r
+ for k=1:n\r
+ sk=sym(k);\r
+ C=polyval_symb(L(k+2,1:k+2),x);\r
+ E=solve(C);\r
+ points(k+1,1:k+1)=E; \r
+ switch c\r
+ case 1\r
+ Pp=polyder_symb(L(k+2,1:k+2));\r
+ for j=1:k+1\r
+ poids(k+1,j)=2./((sk+1)*polyval_symb(Pp,E(j)).*polyval_symb(L(k+1,1:k+1),E(j)));\r
+ end\r
+ case 3\r
+ Pp=polyder_symb(L(k+2,1:k+2));\r
+ auxis=2*auxis*(sk+1);\r
+ for j=1:k+1\r
+ poids(k+1,j)=auxis/(polyval_symb(Pp,E(j)))^2;\r
+ end\r
+ case 4\r
+ Pp=polyder_symb(L(k+2,1:k+2));\r
+ for j=1:k+1\r
+ poids(k+1,j)=1/(E(j)*(polyval_symb(Pp,E(j)))^2);\r
+ end\r
+ end\r
+ end\r
+else\r
+ for k=0:n\r
+ sk=sym(k);\r
+ points(1+k,1:1+k)=cos(((2*sym(0:k))+1)/(sk+1)*spi/2);\r
+ poids(1+k,1:1+k)=spi/(sk+1)*ones(1,k+1);\r
+ end\r
+end\r
+\r
--- /dev/null
+function [points,poids]=points_poids_gauss_vand(c,n)\r
+\r
+% points_poids_gauss_vand : calcul des poids et des points de Gauss (avec Vandermonde)\r
+% \r
+% *********************************************************\r
+%\r
+% [points,poids]=points_poids_gauss_vand(c,n) renvoie les points D_i et les points x_i\r
+% des formules d'intégration à l+1 points pour 0<=l<=n, pour \r
+% l'une des quatre méthodes : Legendre, Tchebytchev, Hermite ou Laguerre,\r
+% éventuellement en formel \r
+%\r
+% variables d'entrées : \r
+% * n : entier naturel.\r
+% * c définit la méthode : \r
+% c=1 : méthode de Gauss-Legendre,\r
+% c=2 : méthode de Gauss-Tchebychev,\r
+% c=3 : méthode de Gauss-Hermite,\r
+% c=4 : méthode de Gauss-Laguerre;\r
+%\r
+% variables de sortie\r
+% * points : tableau de taille (n+1)*(n+1) tel que \r
+% pour tout l dans {0,...,n}, points(l+1,1:l+1) contient\r
+% les l+1 points x_i de la formule (à l+1 points)\r
+% * poids : tableau de taille (n+1)*(n+1) tel que \r
+% pour tout l dans {0,...,n}, poids(l+1,1:l+1) contient\r
+% les l+1 poids D_i de la formule (à l+1 points)\r
+%\r
+% Pour ces deux tableau, évaluation numérique (augmenter le nombre\r
+% de chiffre avec la fonction digits) ou formelle si possible.\r
+% méthode : points : recherche de zéro,\r
+% poids : calcul à partir des points en inversant la matrice de Vandermonde\r
+%\r
+%\r
+% ************ Fonctions connexes utilisées ***************\r
+%\r
+% calcul_poly_gauss_symb, polyval_symb, expression_part_symb\r
+%\r
+% *********************************************************\r
+\r
+% Contrôles d'entrée\r
+% nombre d'arguments\r
+if nargin~=2\r
+ error('nombre d''arguments de la fonction incorrect');\r
+end\r
+% autres tests éventuels \r
+if (fix(n)~=n) | (n<0)\r
+ error('l''entier n doit être un entier naturel');\r
+end\r
+\r
+% Corps d'algorithme.\r
+poids=zeros(n+1,n+1);\r
+points=zeros(n+1,n+1);\r
+poids=sym(poids);\r
+points=sym(points);\r
+spi=sym(pi);\r
+if (c~=2) \r
+ L=calcul_poly_gauss_symb(c,n+1);\r
+ if ((1<=c) & (c<=3))\r
+ points(1,1:1)=0;\r
+ else\r
+ points(1,1)=1;\r
+ end\r
+ switch c\r
+ case 1\r
+ poids(1,1)=2;\r
+ case 3\r
+ poids(1,1)=sqrt(spi);\r
+ case 4\r
+ poids(1,1)=1;\r
+ end\r
+ U=zeros(n+1,1);\r
+ U=sym(U);\r
+ syms x;\r
+ for k=1:n\r
+ C=polyval_symb(L(k+2,1:k+2),x);\r
+ E=solve(C);\r
+ points(k+1,1:k+1)=E; \r
+ for i=0:k\r
+ U(i+1)=expression_part_symb(c,i);\r
+ end\r
+ M(1,1:k+1)=sym(ones(1,k+1));\r
+ for i=2:1+k\r
+ for j=1:k+1\r
+ M(i,j)=(points(k+1,j))^(i-1);\r
+ end\r
+ end\r
+ poids(k+1,1:k+1)=M\U(1:k+1);\r
+ end\r
+else\r
+ for k=0:n\r
+ sk=sym(k);\r
+ points(1+k,1:1+k)=cos((2*sym(0:k)+1)/(sk+1)*spi/2);\r
+ poids(1+k,1:1+k)=spi/(sk+1)*ones(1,k+1);\r
+ end\r
+end\r
--- /dev/null
+function res=polyder_symb(P)\r
+\r
+% polyder_symb : intégration formelle de polynôme\r
+%\r
+%\r
+% *********************************************************\r
+% ATTENTION, polyder ne marche pas sur un tableau \r
+% à coefficients formels !!\r
+%\r
+% *********************************************************\r
+%\r
+% res=polyval_sym(P,x) : renvoie la dérivée de P en x (en formel) :\r
+% si n+1 est la longueur de P : \r
+% res=[n*P(1) (n-1)*P(2) ... 2*P(n-1) P(n)]\r
+%\r
+% variables d'entrées : \r
+% * P : polynômes à coefficients formels\r
+% variables de sortie : \r
+% * res : tableau correspondant à la dérivée de P\r
+%\r
+%\r
+%\r
+% ************ Fonctions auxiliaires utilisées ************\r
+%\r
+% aucune\r
+%\r
+% *********************************************************\r
+%\r
+\r
+\r
+\r
+% Contrôles d'entrée\r
+% nombre d'arguments\r
+if nargin~=1\r
+ error('nombre d''arguments de la fonction incorrect');\r
+end\r
+\r
+\r
+% Corps d'algorithme.\r
+if (isempty(P)) | (P==0) \r
+ res=0;\r
+else\r
+ n=length(P)-1;\r
+ res=[P(1:n).*sym(n:-1:1)];\r
+end
\ No newline at end of file
--- /dev/null
+function res=polyval_symb(P,x)\r
+\r
+% polyval_symb : évaluation formelle de polynôme\r
+%\r
+% *********************************************************\r
+% ATTENTION, ni polyval ni poly2sym ne marchent sur un tableau \r
+% à coefficients formels !!\r
+%\r
+% *********************************************************\r
+%\r
+%\r
+% res=polyval_sym(P,x) : renvoie la valeur de P en x (en formel) :\r
+% si n est la longueur de P : \r
+% res=P(1)*x^(n-1)*+P(2)*x^(n-2)+...+P(n-1)*x+P(n).\r
+%\r
+% variables d'entrées : \r
+% * P : polynoômes à coefficients formels\r
+% * x : réel ou symbolique.\r
+% variables de sortie : \r
+% * res : valeur de P en x\r
+%\r
+%\r
+%\r
+% ************ Fonctions auxiliaires utilisées ************\r
+%\r
+% aucune\r
+%\r
+% *********************************************************\r
+%\r
+\r
+% Contrôles d'entrée\r
+% nombre d'arguments\r
+if nargin~=2\r
+ error('nombre d''arguments de la fonction incorrect');\r
+end\r
+\r
+\r
+% Corps d'algorithme.\r
+n=length(P);\r
+if (isempty(P))\r
+ res=0;\r
+else\r
+ if x==0 \r
+ res=P(n);\r
+ else\r
+ res=sum(P.*x.^(n-1:-1:0));\r
+ end\r
+end
\ No newline at end of file
--- /dev/null
+function [points,poids]=points_poids_gauss_diago(c,n)\r
+\r
+% points_poids_gauss_diago : calcul des poids et des points de Gauss par diagonalisation\r
+% \r
+% *********************************************************\r
+%\r
+% [points,poids]=points_poids_gauss_diago(c,n) renvoie les points D_i et les points x_i\r
+% des formules d'intégration à l+1 points pour 0<=l<=n, pour \r
+% l'une des quatre méthodes : Legendre, Tchebytchev, Hermite ou Laguerre,\r
+% calculés par diagonalisation d'une matrice tridiagonale. \r
+%\r
+% variables d'entrées : \r
+% * n : entier naturel.\r
+% * c définit la méthode : \r
+% c=1 : méthode de Gauss-Legendre,\r
+% c=2 : méthode de Gauss-Tchebychev,\r
+% c=3 : méthode de Gauss-Hermite,\r
+% c=4 : méthode de Gauss-Laguerre;\r
+%\r
+% variables de sortie\r
+% * points : tableau de taille (n+1)*(n+1) tel que \r
+% pour tout l dans {0,...,n}, points(l+1,1:l+1) contient\r
+% les l+1 points x_i de la formule (à l+1 points)\r
+% * poids : tableau de taille (n+1)*(n+1) tel que \r
+% pour tout l dans {0,...,n}, poids(l+1,1:l+1) contient\r
+% les l+1 poids D_i de la formule (à l+1 points)\r
+%\r
+% \r
+% \r
+% ************ Fonctions auxiliaires utilisées ************\r
+%\r
+% aucune\r
+%\r
+% *********************************************************\r
+\r
+\r
+% Contrôles d'entrée\r
+% nombre d'arguments\r
+if nargin~=2\r
+ error('nombre d''arguments de la fonction incorrect');\r
+end\r
+% autres tests éventuels \r
+if (fix(n)~=n) | (n<0)\r
+ error('l''entier n doit être un entier naturel');\r
+end\r
+\r
+% Corps d'algorithme.\r
+points=zeros(n+1,n+1);\r
+poids=zeros(n+1,n+1);\r
+switch c\r
+ case 1\r
+ points(1,1)=0;\r
+ poids(1,1)=2;\r
+ case 2\r
+ points(1,1)=0;\r
+ poids(1,1)=pi;\r
+ case 3\r
+ points(1,1)=0;\r
+ poids(1,1)=sqrt(pi);\r
+ case 4\r
+ points(1,1)=1;\r
+ poids(1,1)=1;\r
+end\r
+if (n>=1)\r
+ for k=1:n\r
+ if (c<=3)\r
+ B=zeros(1,k+1);\r
+ else\r
+ B=2*(0:k)+1;\r
+ end\r
+ switch c\r
+ case 1\r
+ gamma=1./(2*sqrt(1-1./(4*(1:k).^2)));\r
+ case 2\r
+ gamma=[1/sqrt(2) ones(1,k-1)/2];\r
+ case 3\r
+ gamma=sqrt((1:k)/2);\r
+ case 4\r
+ gamma=(1:k);\r
+ end\r
+ auxi=gallery('tridiag',gamma,B,gamma);\r
+ if (k<=4) \r
+ [Q,R]=eigs(auxi,k+1);\r
+ else\r
+ [Q,R]=eig(full(auxi));\r
+ end\r
+ R=diag(R);\r
+ U=(sqrt(sum(Q.^2)));\r
+ switch c\r
+ case 1\r
+ auxik=2;\r
+ case 2\r
+ auxik=pi;\r
+ case 3\r
+ auxik=sqrt(pi);\r
+ case 4\r
+ auxik=1;\r
+ end\r
+ Q=auxik*(Q(1,:)./U).^2;\r
+ [auxipoints,ind]=sort((flipud(R))');\r
+ auxi=fliplr(Q);\r
+ auxipoids=auxi(ind);\r
+ if (c<=3) \r
+ p=fix(k/2);\r
+ if ~(rem(k,2))\r
+ auxi=(auxipoints(p+2:k+1)-auxipoints(p:-1:1))/2; \r
+ auxipoints(p+2:k+1)=auxi;\r
+ auxipoints(1:p)=-fliplr(auxi);\r
+ auxipoints(p+1)=0;\r
+ auxi=(auxipoids(p+2:k+1)+auxipoids(p:-1:1))/2; \r
+ auxipoids(p+2:k+1)=auxi;\r
+ auxipoids(1:p)=fliplr(auxi);\r
+ else\r
+ auxi=(auxipoints(p+2:k+1)-auxipoints(p+1:-1:1))/2; \r
+ auxipoints(p+2:k+1)=auxi;\r
+ auxipoints(1:p+1)=-fliplr(auxi);\r
+ auxi=(auxipoids(p+2:k+1)+auxipoids(p+1:-1:1))/2; \r
+ auxipoids(p+2:k+1)=auxi;\r
+ auxipoids(1:p+1)=fliplr(auxi);\r
+ end\r
+ end\r
+ points(k+1,1:k+1)=auxipoints;\r
+ poids(k+1,1:k+1)=auxipoids;\r
+ end\r
+end\r
+\r
--- /dev/null
+% le script demo_stocke_points_poids permet de stocker sur le fichier pointspoids_comp\r
+% les différents points et de poids de gauss (pour les quatre méthodes) qui sont : \r
+% - calculés manuellement (voir TP3b)\r
+% - calculés de façon symbolique (voir TP3g)\r
+% - calculés par diagonalisation (voir TP3h). \r
+%\r
+% \r
+% ************ Fonctions auxiliaires utilisées ************\r
+%\r
+% points_poids_gauss, points_poids_gauss_symb, points_poids_gauss_diago\r
+%\r
+% *********************************************************\r
+\r
+\r
+clear nAmax nBmax nCmax ...\r
+ pointsleg poidsleg ...\r
+ pointslegsymb poidslegsymb ...\r
+ pointslegdiag poidslegdiag ...\r
+ pointstch poidstch ...\r
+ pointstchsymb poidstchsymb ...\r
+ pointstchdiag poidstchdiag ...\r
+ pointsher poidsher ...\r
+ pointshersymb poidshersymb ...\r
+ pointsherdiag poidsherdiag ...\r
+ pointslag poidslag ...\r
+ pointslagsymb poidslagsymb ...\r
+ pointslagdiag poidslagdiag ...\r
+\r
+disp('méthode directe : ');\r
+nAmax=input('entrez l''entier maximal : ') ;\r
+disp('méthode symbolique : ');\r
+nBmax=input('entrez l''entier maximal : ') ;\r
+disp('méthode par diagonalisation : ');\r
+nCmax=input('entrez l''entier maximal : ') ;\r
+\r
+% calcul des poids et points de Gauss-Legendre.\r
+% calcul manuel : \r
+[pointsleg,poidsleg]=points_poids_gauss(1,nAmax);\r
+% calcul symbolique : \r
+[pointslegsymb,poidslegsymb]=points_poids_gauss_symb(1,nBmax);\r
+% calcul par diagonalisation : \r
+[pointslegdiag,poidslegdiag]=points_poids_gauss_diago(1,nCmax);\r
+\r
+% calcul des poids et points de Gauss-Tchebychev.\r
+% calcul manuel : \r
+[pointstch,poidstch]=points_poids_gauss(2,nAmax);\r
+% calcul symbolique : \r
+[pointstchsymb,poidstchsymb]=points_poids_gauss_symb(2,nBmax);\r
+% calcul par diagonalisation : \r
+[pointstchdiag,poidstchdiag]=points_poids_gauss_diago(2,nCmax);\r
+\r
+% calcul des poids et points de Gauss-Hermite.\r
+% calcul manuel : \r
+[pointsher,poidsher]=points_poids_gauss(3,nAmax);\r
+% calcul symbolique : \r
+[pointshersymb,poidshersymb]=points_poids_gauss_symb(3,nBmax);\r
+% calcul par diagonalisation : \r
+[pointsherdiag,poidsherdiag]=points_poids_gauss_diago(3,nCmax);\r
+\r
+% calcul des poids et points de Gauss-Laguerre.\r
+% calcul manuel : \r
+[pointslag,poidslag]=points_poids_gauss(4,nAmax);\r
+% calcul symbolique : \r
+[pointslagsymb,poidslagsymb]=points_poids_gauss_symb(4,nBmax);\r
+% calcul par diagonalisation : \r
+[pointslagdiag,poidslagdiag]=points_poids_gauss_diago(4,nCmax);\r
+\r
+%Stockage sur fichier\r
+save pointspoids_comp ...\r
+ nAmax nBmax nCmax ...\r
+ pointsleg poidsleg ...\r
+ pointslegsymb poidslegsymb ...\r
+ pointslegdiag poidslegdiag ...\r
+ pointstch poidstch ...\r
+ pointstchsymb poidstchsymb ...\r
+ pointstchdiag poidstchdiag ...\r
+ pointsher poidsher ...\r
+ pointshersymb poidshersymb ...\r
+ pointsherdiag poidsherdiag ...\r
+ pointslag poidslag ...\r
+ pointslagsymb poidslagsymb ...\r
+ pointslagdiag poidslagdiag ...\r
+\r
+\r
--- /dev/null
+% le script trace_compar_gauss permet de comparer les différents\r
+% calculs de points et de poids de gauss en comparant l'intégrale exacte \r
+% et l'intégrale approchée d'une fonction selon que les poids et points\r
+% ont été calculés : \r
+% * par méthode directe;\r
+% * par méthode symbolique;\r
+% * ou par méthode par diagonalisation,\r
+% et ce pour chacune des quatre méthodes définies par c.\r
+% les poids et les points seront préalablements calculés selon chacune des trois méthodes\r
+% dans les tableaux : \r
+% pointsleg poidsleg ...\r
+% pointslegsymb poidslegsymb ...\r
+% pointslegdiag poidslegdiag ...\r
+% pointstch poidstch ...\r
+% pointstchsymb poidstchsymb ...\r
+% pointstchdiag poidstchdiag ...\r
+% pointsher poidsher ...\r
+% pointshersymb poidssherymb ...\r
+% pointsherdiag poidsherdiag ...\r
+% pointslag poidslag ...\r
+% pointslagsymb poidslagsymb ...\r
+% pointslagdiag poidslagdiag ...\r
+% voir script demo_stocke_points_poids \r
+%\r
+% \r
+% ************ Fonctions auxiliaires utilisées ************\r
+%\r
+% saisiefonction, int_gauss\r
+%\r
+% *********************************************************\r
+\r
+\r
+\r
+\r
+% logarithme de l'erreur nulle prise égale à log10zero\r
+log10zero=-35;\r
+\r
+\r
+clear xA yA xB yB xC yC Iexa erA erB erC;\r
+disp('choix de la méthode : ')\r
+c=input('entrez 1, 2, 3 ou 4 : ');\r
+disp(' ');\r
+disp('Entrée de la fonction r telle que r=f/w sur (a,b) où w est le poids ') ;\r
+disp(' ');\r
+fcn=saisiefonction;\r
+Iexa=input('entrez la valeur exacte de l''intégrale de r=f/w sur (a,b) : ') ;\r
+erA=zeros(1,nAmax+1);\r
+yA=zeros(1,nAmax+1);\r
+erB=zeros(1,nBmax+1);\r
+yB=zeros(1,nBmax+1);\r
+erC=zeros(1,nCmax+1);\r
+yC=zeros(1,nCmax+1);\r
+switch c\r
+ case 1\r
+ pointsA=pointsleg;\r
+ poidsA=poidsleg;\r
+ pointsB=pointslegsymb;\r
+ poidsB=poidslegsymb;\r
+ pointsC=pointslegdiag;\r
+ poidsC=poidslegdiag;\r
+ case 2\r
+ pointsA=pointstch;\r
+ poidsA=poidstch;\r
+ pointsB=pointstchsymb;\r
+ poidsB=poidstchsymb;\r
+ pointsC=pointstchdiag;\r
+ poidsC=poidstchdiag;\r
+ case 3\r
+ pointsA=pointsher;\r
+ poidsA=poidsher;\r
+ pointsB=pointshersymb;\r
+ poidsB=poidshersymb;\r
+ pointsC=pointsherdiag;\r
+ poidsC=poidsherdiag;\r
+ case 4\r
+ pointsA=pointslag;\r
+ poidsA=poidslag;\r
+ pointsB=pointslagsymb;\r
+ poidsB=poidslagsymb;\r
+ pointsC=pointslagdiag;\r
+ poidsC=poidslagdiag;\r
+end\r
+\r
+\r
+for k=0:nAmax\r
+ auxi=int_gauss(k,pointsA,poidsA,fcn);\r
+ erA(k+1)=abs(auxi-Iexa);\r
+end\r
+for k=0:nBmax\r
+ auxi=int_gauss(k,pointsB,poidsB,fcn);\r
+ auxi=vpa(auxi)-Iexa;\r
+ if ~(isnumeric(auxi))\r
+ auxi=double(auxi);\r
+ end\r
+ erB(k+1)=abs(auxi);\r
+end\r
+for k=0:nCmax\r
+ auxi=int_gauss(k,pointsC,poidsC,fcn);\r
+ erC(k+1)=abs(auxi-Iexa);\r
+end\r
+indnul=find(erA==0);\r
+indnonnul=find(erA~=0);\r
+yA(indnul)=log10zero;\r
+yA(indnonnul)=log10(erA(indnonnul));\r
+indnul=find(erB==0);\r
+indnonnul=find(erB~=0);\r
+yB(indnul)=log10zero;\r
+yB(indnonnul)=log10(erB(indnonnul));\r
+indnul=find(erC==0);\r
+indnonnul=find(erC~=0);\r
+yC(indnul)=log10zero;\r
+yC(indnonnul)=log10(erC(indnonnul));\r
+xA=log10(1:nAmax+1);\r
+xB=log10(1:nBmax+1);\r
+xC=log10(1:nCmax+1);\r
+clf;\r
+hold on;\r
+plot(xA,yA,'b',xB,yB,'r',xC,yC,'g');\r
+xlabel('logarithme 10 du nombre de points d''intégration');\r
+ylabel('logarithme 10 de l''erreur d''intégration');\r
+legend('directe','symbolique','diagonalisation',0);\r
+hold off;\r
+\r
+\r
+ \r
+\r
+\r
+\r
+\r
+\r
+\r
+\r
+\r
+\r
--- /dev/null
+function [eta1,eta2]=verifie_nullite_gauss(c,n)\r
+\r
+\r
+% verifie_nullite_gauss : calcul de l'orthogonalité et de la normalisation des polynômes calculés numériquement\r
+%\r
+% *********************************************************\r
+%\r
+% [eta1,eta2]=verifie_nullite_gauss(c,n) : \r
+% vérifie numériquement que les polynômes de Gauss P_0, ..., P_n\r
+% sont orthogonaux avec la condition de normalité :\r
+% P_r(1)=1 pour Legendre et Tchebytchev\r
+% P_r(0)=1 pour Laguerre\r
+% le coefficient domimant de P_r est 2^{r} pour Hermite\r
+%\r
+% variables d'entrées : \r
+% * n : entier naturel.\r
+% * c définit la méthode : \r
+% c=1 : Gauss-Legendre,\r
+% c=2 : Gauss-Tchebytchev,\r
+% c=3 : Gauss-Hermite,\r
+% c=4 : Gauss-Laguerre.\r
+% variables de sortie\r
+% * eta1= max_{0<=r<=n} |P_r(1)-1| pour Legendre et Tchebychev\r
+% eta1= max_{0<=r<=n} |P_r(0)-1| pour Laguerre\r
+% eta1= max_{0<=r<=n} |2^r-coefficient dominant(P_r)|=0 pour Hermite\r
+% et \r
+% eta2=max_{0<=r,s<=n, r~=s}|<P_r,P_s>|\r
+% (calculé par intégration en symbolique)\r
+%\r
+% eta1 et eta2 doivent être nuls.\r
+%\r
+% \r
+% ************ Fonctions auxiliaires utilisées ************\r
+%\r
+% calcul_poly_gauss\r
+%\r
+% *********************************************************\r
+\r
+\r
+% Contrôles d'entrée\r
+% nombre d'arguments\r
+if nargin~=2\r
+ error('nombre d''arguments de la fonction incorrect');\r
+end\r
+% autres tests éventuels \r
+if (fix(n)~=n) | (n<0)\r
+ error('l''entier n doit être un entier naturel');\r
+end\r
+if ~((c==1) | (c==2) | (c==3) | (c==4))\r
+ error('c doit être un entier égal à 1, 2, 3 ou 4');\r
+end\r
+\r
+% Corps d'algorithme.\r
+P=calcul_poly_gauss(c,n);\r
+ermax=0;\r
+if (c==1) | (c==2)\r
+ for r=0:n\r
+ er=abs(polyval(P(r+1,1:r+1),1)-1);\r
+ ermax=max(er,ermax);\r
+ end\r
+end\r
+if (c==3)\r
+ for r=0:n\r
+ er=abs(P(r+1,1)-2^r);\r
+ ermax=max(er,ermax);\r
+ end\r
+end\r
+if (c==4) \r
+ for r=0:n\r
+ er=abs(polyval(P(r+1,1:r+1),0)-1);\r
+ ermax=max(er,ermax);\r
+ end\r
+end\r
+eta1=ermax;\r
+syms x a b;\r
+switch c\r
+ case 1\r
+ a=sym(-1);\r
+ b=sym(1);\r
+ w=sym(1); \r
+ case 2\r
+ a=sym(-1);\r
+ b=sym(1);\r
+ w=1/sqrt(1-x^2); \r
+ case 3\r
+ a=-sym(inf);\r
+ b=sym(inf);\r
+ w=exp(-x^2);\r
+ case 4\r
+ a=sym(0);\r
+ b=sym(+inf);\r
+ w=exp(-x);\r
+end \r
+ermax=0;\r
+for r=0:n\r
+ for s=0:r-1\r
+ R=conv(P(r+1,1:r+1),P(s+1,1:s+1));\r
+ f=poly2sym(R);\r
+ er=double(abs(simplify(int(f*w,a,b))));\r
+ ermax=max(er,ermax);\r
+ end\r
+end\r
+eta2=ermax;\r
--- /dev/null
+function [eta1,eta2]=verifie_nullite_gauss_symb(c,n)\r
+\r
+\r
+% verifie_nullite_gauss_symb : calcul de l'orthogonalité et de la normalisation des polynômes en symbolique\r
+%\r
+% *********************************************************\r
+%\r
+% [eta1,eta2]=verifie_nullite_gauss_symb(c,n) : \r
+% vérifie en symbolique que les polynômes de Gauss P_0, ..., P_n\r
+% sont orthogonaux avec la condition de normalité :\r
+% P_r(1)=1 pour Legendre et Tchebytchev\r
+% P_r(0)=1 pour Laguerre\r
+% le coefficient domimant de P_r est 2^{r} pour Hermite\r
+%\r
+% variables d'entrées : \r
+% * n : entier naturel.\r
+% * c définit la méthode : \r
+% c=1 : Gauss-Legendre,\r
+% c=2 : Gauss-Tchebytchev,\r
+% c=3 : Gauss-Hermite,\r
+% c=4 : Gauss-Laguerre.\r
+% variables de sortie eta1 et eta2 où en symbolique, \r
+% eta1=0 si max_{0<=r<=n} |P_r(1)-1|=0 pour Legendre et Tchebychev\r
+% si max_{0<=r<=n} |P_r(0)-1|=0 pour Laguerre\r
+% si max_{0<=r<=n} |2^r-coefficient dominant(P_r)|=0 pour Hermite\r
+% et \r
+% eta2=0 si max_{0<=r,s<=n, r~=s}|<P_r,P_s>|=0 \r
+% (en symbolique)\r
+%\r
+% eta1 et eta2 doivent être nuls.\r
+%\r
+% \r
+% ************ Fonctions auxiliaires utilisées ************\r
+%\r
+% calcul_poly_gauss_symb, polyval_symb\r
+%\r
+% *********************************************************\r
+\r
+\r
+% Contrôles d'entrée\r
+% nombre d'arguments\r
+if nargin~=2\r
+ error('nombre d''arguments de la fonction incorrect');\r
+end\r
+% autres tests éventuels \r
+if (fix(n)~=n) | (n<0)\r
+ error('l''entier n doit être un entier naturel');\r
+end\r
+if ~((c==1) | (c==2) | (c==3) | (c==4))\r
+ error('c doit être un entier égal à 1, 2, 3 ou 4');\r
+end\r
+\r
+% Corps d'algorithme.\r
+P=calcul_poly_gauss_symb(c,n);\r
+ind=0;\r
+if (c==1) | (c==2)\r
+ for r=0:n\r
+ auxi=polyval_symb(P(r+1,1:r+1),1)-sym(1);\r
+ indloc=~(auxi==0);\r
+ ind=max(ind,indloc);\r
+ end\r
+end\r
+if (c==3)\r
+ for r=0:n\r
+ auxi=P(r+1,1);\r
+ auxi=auxi-2^(sym(r));\r
+ indloc=~(auxi==0);\r
+ ind=max(ind,indloc);\r
+ end\r
+end\r
+if (c==4) \r
+ for r=0:n\r
+ auxi=polyval_symb(P(r+1,1:r+1),0)-sym(1);\r
+ indloc=~(auxi==0);\r
+ ind=max(ind,indloc);\r
+ end\r
+end\r
+eta1=ind;\r
+disp('vérification initiale');\r
+if ~(ind)\r
+ disp('ok !!');\r
+else\r
+ disp('erreur !!');\r
+end\r
+syms x a b;\r
+switch c\r
+ case 1\r
+ a=sym(-1);\r
+ b=sym(1);\r
+ w=sym(1); \r
+ case 2\r
+ a=sym(-1);\r
+ b=sym(1);\r
+ w=1/sqrt(1-x^2); \r
+ case 3\r
+ a=-sym(inf);\r
+ b=sym(inf);\r
+ w=exp(-x^2);\r
+ case 4\r
+ a=sym(0);\r
+ b=sym(+inf);\r
+ w=exp(-x);\r
+ end \r
+ind=0; \r
+for r=0:n\r
+ for s=0:r-1\r
+ f=polyval_symb(P(r+1,1:r+1),x);\r
+ g=polyval_symb(P(s+1,1:s+1),x);\r
+ auxi=simplify(int(f*g*w,a,b));\r
+ indloc=~(auxi==0);\r
+ ind=max(indloc,ind);\r
+ end\r
+ disp(['vérification pour r=',int2str(r)]);\r
+ if ~(ind)\r
+ disp('ok !!');\r
+ else\r
+ disp('erreur !!');\r
+ end\r
+end\r
+eta2=ind;\r
--- /dev/null
+function eta=verifie_ordre_gauss(c,n,points,poids)\r
+\r
+\r
+% verifie_ordre_gauss : vérification de l'ordre des formules Gaussiennes\r
+%\r
+% *********************************************************\r
+%\r
+% eta=verifie_ordre_gauss(c,n,points,poids) calcule numériquement le max\r
+% de |I_{n,k}-int_a ^b x^k w(x)dx| pour 0<=k<=2n+1, où I_{n,k}\r
+% est l'intégrale approchée de x^kw(x) sur l'intervalle conventionnel (a,b) \r
+%\r
+% variables d'entrées : \r
+% * n : entier naturel.\r
+% * c définit la méthode : \r
+% c=1 : Gauss-Legendre,\r
+% c=2 : Gauss-Tchebytchev,\r
+% c=3 : Gauss-Hermite,\r
+% c=4 : Gauss-Laguerre.\r
+% * points : tableau de taille (q+1)*(q+1) (avec n<=q) tel que \r
+% pour tout l dans {0,...,q}, points(l+1,1:l+1) contient\r
+% les l+1 points x_i de la formule (à l+1 points)\r
+% * poids : tableau de taille (n+1)*(n+1) tel que \r
+% pour tout l dans {0,...,n}, poids(l+1,1:l+1) contient\r
+% les l+1 poids D_i de la formule (à l+1 points)\r
+% variable de sortie\r
+% * eta= max_{0<=k<=2n+1} |I_{n,k}-int_a ^b x^k w(x)dx|\r
+%\r
+% eta doit être nul.\r
+%\r
+% \r
+% ************ Fonctions auxiliaires utilisées ************\r
+%\r
+% expression_part_symb\r
+%\r
+% *********************************************************\r
+\r
+% Contrôles d'entrée\r
+% nombre d'arguments\r
+if nargin~=4\r
+ error('nombre d''arguments de la fonction incorrect');\r
+end\r
+% autres tests éventuels \r
+if ~((c==1) | (c==2) | (c==3) | (c==4))\r
+ error('c doit être un entier égal à 1, 2, 3 ou 4');\r
+end\r
+p=length(poids);\r
+if (2*n+1>=p)\r
+ error('n est trop grand');\r
+end\r
+\r
+\r
+% Corps d'algorithme.\r
+er=0;\r
+for k=0:2*n+1\r
+ I=sum(poids(k+1,1:k+1).*((points(k+1,1:k+1)).^k));\r
+ erloc=expression_part_symb(c,k)-I;\r
+ if ~(isnumeric(erloc))\r
+ erloc=double(vpa(erloc));\r
+ end\r
+ erloc=abs(erloc);\r
+ er=max(er,erloc);\r
+end\r
+eta=er;
\ No newline at end of file
--- /dev/null
+function D=diff_div_dist(X,Y)\r
+% \r
+%\r
+% diff_div_dist : calcul des différences divisées pour des points de supports distincts\r
+%\r
+% *********************************************************\r
+%\r
+% D=diff_div_dist(X,Y)\r
+% les différences divisées sont calculées par l'algorithme \r
+% pyramidal donné en cours.\r
+%\r
+% variables d'entrées : \r
+% * X : contient les valeurs x_i, pour 0 <=i<=n (deux à deux distinctes)\r
+% * Y : contient les valeurs f(x_i), pour 0 <=i<=n\r
+%\r
+% variables de sortie\r
+% * D : contient les différences divisées \r
+% f[x_0], f[x_0,x_1], ...., f[x_0,x_1,...,x_n]\r
+%\r
+%\r
+% ************ Fonctions auxiliaires utilisées ************\r
+%\r
+% aucune\r
+%\r
+% *********************************************************\r
+\r
+\r
+\r
+% Contrôles d'entrée\r
+%\r
+% nombre d'arguments\r
+if nargin~=2\r
+ error('nombre d''arguments de la fonction incorrect');\r
+end\r
+% taille des deux variables \r
+n=length(X)-1;\r
+np=length(Y)-1;\r
+if n~=np\r
+ error('les deux tableaux n''ont pas la même taille');\r
+end\r
+% vérification des éléments du support deux à deux disjoints \r
+% (si X non formel)\r
+if isnumeric(X)\r
+ Z=sort(X);\r
+ if min(diff(Z))==0\r
+ error('deux points du support sont égaux');\r
+ end\r
+end\r
+\r
+\r
+% Corps d'algorithme\r
+D=Y; \r
+for i=1:n;\r
+ for j=n:-1:i;\r
+ D(j+1)=(D(j+1)-D(j))/(X(j+1)-X(j-i+1));\r
+ end\r
+end\r
+\r
+\r
+\r
--- /dev/null
+function Z=eval_horner(T,C,D)\r
+% \r
+%\r
+% eval_horner : évaluation vectorielle d'un polynôme à partir de sa forme de Newton.\r
+%\r
+% *********************************************************\r
+%\r
+% Z=eval_horner(T,C,D)\r
+% L'évaluation est faite par l'algorithme de Hörner donné en cours,\r
+% Elle permet de calculer :\r
+% p_n(T)=d_0+d_1(T-c_1)+d_2(T-c_1)(T-c_2)+...+d_n(T-c_1)...(T-c_n)\r
+%\r
+% variables d'entrées : \r
+% * T : contient le tableau rectangulaire des réels où est évalué p_n\r
+% * C : contient les centres c_i, pour 1 <=i<=n\r
+% * D : contient les coefficients d_i, pour 0<=i<=n \r
+%\r
+% variables de sortie\r
+% * Z : contient le tableau rectangulaire des images de T par p_n \r
+%\r
+%\r
+% ************ Fonctions auxiliaires utilisées ************\r
+%\r
+% aucune\r
+%\r
+% *********************************************************\r
+\r
+\r
+% Contrôles d'entrée\r
+%\r
+% nombre d'arguments\r
+if nargin~=3\r
+ error('nombre d''arguments de la fonction incorrect');\r
+end\r
+% taille des variables C et D\r
+n=length(C);\r
+np=length(D)-1;\r
+if n~=np\r
+ error('les deux tableaux n''ont pas la taille adéquate');\r
+end\r
+\r
+\r
+% Corps d'algorithme\r
+O=ones(size(T));\r
+Auxi=D(n+1).*O;\r
+for i=n-1:-1:0\r
+ Auxi=(T-C(i+1)).*Auxi+D(i+1);\r
+end\r
+Z=Auxi;\r
--- /dev/null
+function z=eval_horner_sca(t,C,D)\r
+% \r
+%\r
+% eval_horner_sca : évaluation scalaire d'un polynôme à partir de sa forme de Newton.\r
+%\r
+% *********************************************************\r
+%\r
+% z=eval_horner_sca(t,C,D)\r
+% L'évaluation est faite par l'algorithme de Hörner donné en cours,\r
+% Elle permet de calculer :\r
+% p_n(t)=d_0+d_1(t-c_1)+d_2(t-c_1)(t-c_2)+...+d_n(t-c_1)...(t-c_n)\r
+%\r
+% variables d'entrées : \r
+% * t : contient le réel où est évalué p_n\r
+% * C : contient les centres c_i, pour 1 <=i<=n\r
+% * D : contient les coefficients d_i, pour 0<=i<=n \r
+%\r
+% variables de sortie\r
+% * z : contient p_n(t) \r
+%\r
+%\r
+% ************ Fonctions auxiliaires utilisées ************\r
+%\r
+% aucune\r
+%\r
+% *********************************************************\r
+\r
+\r
+% Contrôles d'entrée\r
+%\r
+% nombre d'arguments\r
+if nargin~=3\r
+ error('nombre d''arguments de la fonction incorrect');\r
+end\r
+% taille des variables C et D\r
+n=length(C);\r
+np=length(D)-1;\r
+if n~=np\r
+ error('les deux tableaux n''ont pas la taille adéquate');\r
+end\r
+\r
+\r
+% Corps d'algorithme\r
+auxi=D(n+1);\r
+for i=n-1:-1:0\r
+ auxi=(t-C(i+1))*auxi+D(i+1);\r
+end\r
+z=auxi;\r
+\r
+\r
+\r
--- /dev/null
+function R=test_diff_div_dist(T,X,Y) \r
+\r
+% test_diff_div_dist : fonction test pour le calcul du polynôme interpolateur (vectoriel)\r
+%\r
+%\r
+% *********************************************************\r
+%\r
+% R=test_diff_div_dist(T,X,Y) \r
+% calcul de la valeur du polynôme d'interpolation défini par le nuage de point X,Y\r
+% sur le tableau T (utilisation du calcul des différences divisées et \r
+% de l'algorithme d'évaluation de Horner).\r
+%\r
+% variables d'entrées : \r
+% * T : contient le tableau rectangulaire des réels où est évalué p_n\r
+% * X : contient les valeurs x_i, pour 0 <=i<=n (deux à deux distinctes)\r
+% * Y : contient les valeurs f(x_i), pour 0 <=i<=n\r
+%\r
+% variables de sortie\r
+% * R : contient le tableau rectangulaire des images de T par p_n,\r
+% polynôme d'interpolation de f sur le support x_i, pour 0 <=i<=n\r
+%\r
+% \r
+% ************ Fonctions auxiliaires utilisées ************\r
+%\r
+% diff_div_dist, eval_horner\r
+%\r
+% *********************************************************\r
+\r
+\r
+D=diff_div_dist(X,Y);\r
+R=eval_horner(T,X(1:end-1),D);\r
+\r
--- /dev/null
+function r=test_diff_div_dist_sca(t,X,Y) \r
+\r
+% test_diff_div_dist_sca : fonction test pour le calcul du polynôme interpolateur (scalaire)\r
+%\r
+%\r
+% *********************************************************\r
+%\r
+% R=test_diff_div_dist_sca(t,X,Y) \r
+% calcul de la valeur du polynôme d'interpolation défini par le nuage de point X,Y\r
+% en t (utilisation du calcul des différences divisées et \r
+% de l'algorithme d'évaluation de Hörner).\r
+%\r
+% variables d'entrées : \r
+% * t : contient le réel où est évalué p_n\r
+% * X : contient les valeurs x_i, pour 0 <=i<=n (deux à deux distinctes)\r
+% * Y : contient les valeurs f(x_i), pour 0 <=i<=n\r
+%\r
+% variables de sortie\r
+% * r : contient p_n(t)où p_n est le \r
+% polynôme d'interpolation de f sur le support x_i, pour 0 <=i<=n\r
+%\r
+% \r
+% ************ Fonctions auxiliaires utilisées ************\r
+%\r
+% diff_div_dist, eval_horner_sca\r
+%\r
+% *********************************************************\r
+\r
+\r
+D=diff_div_dist(X,Y);\r
+r=eval_horner_sca(t,X(1:end-1),D);\r
+\r
--- /dev/null
+function lect_courb(nb_chif)\r
+% lit les coordonnées des points d'une courbe\r
+%\r
+% variables d'entrée et fonctionnement\r
+% Tant que l'utilisateur clique gauche,\r
+% le système affiche les coordonnées du point\r
+% choisi à la souris.\r
+% nb_chif désigne le nombre de décimales demandées,\r
+% afin de ne pas encombrer l'écran en cas de lectures\r
+% multiples. On impose 0<=nb_chif<=3, aisément modifiable.\r
+% On sort en cliquant droit.\r
+%\r
+% variables de sortie\r
+% affichage des coordonnées du point cliqué.\r
+% \r
+% \r
+% ************ Fonctions connexes utilisées ***************\r
+% \r
+% *********************************************************\r
+\r
+% Contrôles d'entrée\r
+% nombre d'arguments\r
+if nargin~=1\r
+ error('Nombre d''argument incorrect. Revoir le source.');\r
+end\r
+\r
+\r
+% autres tests éventuels \r
+if (nb_chif<0)|(nb_chif>3)\r
+ error('Champ incorrect.Modifier le source si besoin');\r
+end\r
+\r
+ \r
+% Corps d'algorithme\r
+\r
+% traitement proprement dit\r
+bout=1;\r
+while bout==1\r
+ [x,y,bout]=ginput(1);\r
+ % réglage des sorties\r
+ entx=length(num2str(floor(x)));\r
+ enty=length(num2str(floor(y)));\r
+ fx=['%' num2str(entx) '.' num2str(nb_chif) 'f'];\r
+ fy=['%' num2str(enty) '.' num2str(nb_chif) 'f'];\r
+ text(x,y,['x=' num2str(x,fx) ' y=' num2str(y,fy)]);\r
+end\r
+\r
+\r
+% variante pour la sortie des résultats\r
+% L'utilisateur pourra afficher seulement le numéro des points\r
+% saisis sur la courbe; il remplira en meme temps une table\r
+% des coordonnées qu'il peut ajouter comme paramètre de sortie\r
+% de cette nouvelle fonction.\r
+\r
+\r
+% fin de fonction()\r
+\r
+\r
+\r
--- /dev/null
+function etude_support(a,b,n)\r
+% compare l'effet sur la qualité de l'interpolation\r
+% des points de Tchebychev et\r
+% de points régulièrement répartis dans [a,b].\r
+% \r
+% variables d'entrée\r
+% n est un entier naturel\r
+% tel que x0,...,xn sont les points d'interpolation \r
+% choisis dans [a,b] selon les deux variantes à comparer.\r
+% \r
+% variables de sortie\r
+% On visualise; on pourra capter l'image produite\r
+% et éventuellement renvoyer son handle.\r
+% \r
+% \r
+% ************ Fonctions auxiliaires utilisées ***************\r
+%\r
+% diff_div_dist, eval_horner\r
+%\r
+% *********************************************************\r
+\r
+% Paramètres modifiables\r
+format long e;\r
+nmax=19; % nb de points d'interpolation\r
+N=100; % détermine la taille des vecteurs à représenter\r
+pas=(b-a)/N;\r
+% Contrôles d'entrée\r
+\r
+% nombre d'arguments\r
+if nargin~=3\r
+ error('Nombre des arguments incorrects');\r
+end\r
+\r
+% autres tests éventuels\r
+if n>nmax\r
+ error('Modifiez le paramètre nmax en tete de fichier')\r
+end\r
+if b<=a\r
+ error('Choisissez un intervalle conventionnel')\r
+end\r
+ \r
+% Corps d'algorithme\r
+\r
+% préparation des deux familles de points de support\r
+i=0:n;\r
+% points régulièrement répartis\r
+x1=a+(b-a)/n.*i;\r
+% points de Tchebychev\r
+x2=(b-a)/2*cos(pi/2*(2.*i+1)/(n+1))+(b+a)/2;\r
+\r
+% détermination des images d'un vecteur x\r
+% par la fonction proposée;\r
+% on pourrait rajouter un champ de saisie\r
+% de la fonction à interpoler.\r
+X=a:pas:b;\r
+Y=exp(X);\r
+\r
+% détermination des polynomes d'interpolation\r
+% et des images du vecteur x obtenues par eux.\r
+y1=exp(x1);y2=exp(x2);\r
+d1=diff_div_dist(x1,y1);d2=diff_div_dist(x2,y2);\r
+Y1=eval_horner(X,x1(1:n),d1);\r
+Y2=eval_horner(X,x2(1:n),d2);\r
+\r
+% calcul des écarts entre fonction exacte\r
+% et polynomes d'interpolation\r
+E1=abs(Y-Y1);E2=abs(Y-Y2);\r
+\r
+% calibrage des images\r
+maxy=max(max(E1),max(E2));\r
+bordx=2*(b-a)/10;\r
+lim=[a-bordx b+bordx 0 1.1*maxy];\r
+\r
+clf;\r
+% représentation de E1 et E2\r
+subplot(3,1,1)\r
+plot(X,E1,'b:');\r
+axis(lim);\r
+title(['Erreurs d''interpolation à ' num2str(n+1) ' points pour exponentielle']);\r
+legend('Cas de points régulièrement répartis',0);\r
+\r
+subplot(3,1,2)\r
+plot(X,E2,'r-');\r
+axis(lim);\r
+legend('Cas de points de Tchebychev',0);\r
+\r
+subplot(3,1,3)\r
+plot(X,E1,'b:');\r
+axis(lim);\r
+legend('Erreurs comparées',0);\r
+hold on;\r
+plot(X,E2,'r-');\r
+axis(lim);\r
+\r
+\r
+\r
+\r
+\r
+\r
+\r
+\r
+\r
+\r
+\r
+% sortie des résultats\r
+\r
+\r
+\r
+% fin de fonction()\r
+\r
--- /dev/null
+% script demo_test_compar_methode : comparaison des différentes méthodes pour calculer un polynôme d'interpolation\r
+%\r
+%\r
+% Ce script permet de comparer, en terme d'évaluation numérique et graphique \r
+% le polynôme interpolateur p_n d'une fonction f sur le support (x_i) où, pour 0<=i<=n, \r
+% on a x_i=a+i*(b-a)/n, avec a, b, n et f donnée, en fonction des trois méthodes : \r
+% a) calcul en utilisant la forme de Newton et les différences divisées,\r
+% b) calcul à partir des polynômes de Lagranges l_i.\r
+% c) calcul à partir de la forme canonique de p_n\r
+%\r
+%\r
+% ************ Fonctions auxiliaires utilisées ************\r
+% \r
+% saisiefonction, diff_div_dist, eval_horner, \r
+% newton_cano, poly_eval_lagr\r
+%\r
+% *********************************************************\r
+\r
+clear all;\r
+a=input('Entrez l''abscisse minimale a : ');\r
+b=input('Entrez l''abscisse maximale b : ');\r
+pgra=input('Entrez le nombre de points pour le graphique : ');\r
+f=saisiefonction;\r
+n=input('Entrez l''entier n positif (égal au nombre de points oté de un) : ');\r
+beton=0;\r
+choixpoint='o';\r
+xgra=a:(b-a)/pgra:b;\r
+ygra=feval(f,xgra);\r
+while(n>=0)\r
+ if strcmp(choixpoint,'o')\r
+ choixpoint=input('Afficher le support ? entrez o ou n : ','s');\r
+ end \r
+ switch beton\r
+ case 0\r
+ choix=input('Conserver le graphique par calcul à partir de la forme canonique ? entrez o ou n : ','s');\r
+ if strcmp(choix,'n')\r
+ beton=1;\r
+ end\r
+ case 1\r
+ choix=input('Conserver le graphique par calcul à partir des polynômes de Lagrange ? entrez o ou n : ','s');\r
+ if strcmp(choix,'n')\r
+ beton=2;\r
+ end\r
+ end\r
+ if (n==0) \r
+ X=(a+b)/2;\r
+ else\r
+ X=a:(b-a)/n:b;\r
+ end\r
+ Y=feval(f,X);\r
+ D=diff_div_dist(X,Y);\r
+ ygranewton=eval_horner(xgra,X(1:end-1),D);\r
+ ygralagrange=poly_eval_lagr(xgra,X,Y);\r
+ P=newton_cano(D,X(1:end-1));\r
+ ygracanonique=polyval(P,xgra); \r
+ clf;\r
+ hold on;\r
+ if (strcmp(choixpoint,'o'))\r
+ switch beton\r
+ case 0\r
+ plot(X,Y,'go',xgra,ygra,xgra,ygranewton,xgra,ygralagrange,xgra,ygracanonique);\r
+ legend('Points du support','Fonction exacte','Newton','Lagrange','Canonique',0);\r
+ case 1\r
+ plot(X,Y,'go',xgra,ygra,xgra,ygranewton,xgra,ygralagrange);\r
+ legend('Points du support','Fonction exacte','Newton','Lagrange',0);\r
+ case 2\r
+ plot(X,Y,'go',xgra,ygra,xgra,ygranewton);\r
+ legend('Points du support','Fonction exacte','Newton',0);\r
+ end\r
+ else\r
+ switch beton\r
+ case 0\r
+ plot(xgra,ygra,xgra,ygranewton,xgra,ygralagrange,xgra,ygracanonique);\r
+ legend('Fonction exacte','Newton','Lagrange','Canonique',0);\r
+ case 1\r
+ plot(xgra,ygra,xgra,ygranewton,xgra,ygralagrange);\r
+ legend('Fonction exacte','Newton','Lagrange',0);\r
+ case 2\r
+ plot(xgra,ygra,xgra,ygranewton);\r
+ legend('Fonction exacte','Newton',0);\r
+ end\r
+ end\r
+ if exist(f)==1\r
+ title(['interpolation de la fonction ',formula(f),' avec ',int2str(n+1),' points']);\r
+ else\r
+ title(['interpolation de la fonction ',f,' avec ',int2str(n+1),' points']);\r
+ end\r
+ hold off;\r
+ n=input('pour continuer, entrez un nombre n positif (pour arrêter, le choisir négatif) : ');\r
+end
\ No newline at end of file
--- /dev/null
+function B=newton_cano(A,C)\r
+% \r
+%\r
+% newton_cano : passage de la forme de newton à la forme canonique.\r
+%\r
+% *********************************************************\r
+%\r
+% B=newton_cano(A,C)\r
+% L'algorithme repose sur l'algorithme d'Hörner réitéré n fois, avec\r
+% décalage successif des centres. Cette fonction permet de passer de \r
+% la forme de Newton :\r
+% p_n(x)=a_0+a_1(x-c_1)+a_2(x-c_1)(x-c_2)+...+a_n(x-c_1)...(x-c_n)\r
+% à la forme canonique \r
+% p_n(x)=b_0+b_1x+b_2x^2+...+b_nx^n\r
+%\r
+% variables d'entrées : \r
+% * C : contient les centres c_i, pour 1 <=i<=n\r
+% * A : contient les coefficients a_i, pour 0<=i<=n \r
+%\r
+% variables de sortie\r
+% * B : contient les coefficients b_n, b_(n-1),...,b_0\r
+% (dans cet ordre là) \r
+% \r
+% \r
+% ************ Fonctions auxiliaires utilisées ************\r
+%\r
+% aucune\r
+%\r
+% *********************************************************\r
+%\r
+\r
+\r
+% Contrôles d'entrée\r
+%\r
+% nombre d'arguments\r
+if nargin~=2\r
+ error('nombre d''arguments de la fonction incorrect');\r
+end\r
+% taille des variables X et D\r
+n=length(C);\r
+np=length(A)-1;\r
+if n~=np\r
+ error('les deux tableaux n''ont pas la taille adéquate');\r
+end\r
+\r
+\r
+% Corps d'algorithme\r
+Auxi=A;\r
+for j=1:n\r
+ for i=n-1:-1:j-1\r
+ Auxi(i+1)=Auxi(i+1)-C(i-j+2)*Auxi(i+2);\r
+ end\r
+end\r
+B=fliplr(Auxi);\r
--- /dev/null
+function Z=poly_eval_lagr(T,X,Y)\r
+\r
+% poly_lagrange : calcul du polynôme de Lagrange en T (vectoriel)\r
+%\r
+% *********************************************************\r
+%\r
+% Z=poly_eval_lagr(T,X,Y)\r
+% calcul de la valeur du polynôme p_n d'interpolation défini par le nuage de point X,Y\r
+% en T (à partir des polynômes de Lagrange l_i).\r
+%\r
+% variables d'entrées : \r
+% * T : contient le tableau ligne des réels où on évalue p_n\r
+% * X : contient les centres x_i, pour 0<=i<=n (deux à deux distincts)\r
+% * Y : contient les valeurs f(x_i), pour 0<=i<=n \r
+%\r
+% variables de sortie\r
+% * Z : contient l'image du tableau T par p_n (tableau ligne)\r
+%\r
+% \r
+% \r
+% ************ Fonctions auxiliaires utilisées ************\r
+%\r
+% poly_lagrange\r
+%\r
+% *********************************************************\r
+%\r
+\r
+\r
+\r
+\r
+\r
+% Contrôles d'entrée\r
+%\r
+% nombre d'arguments\r
+if nargin~=3\r
+ error('nombre d''arguments de la fonction incorrect');\r
+end\r
+na=length(X);\r
+nb=length(Y);\r
+if (na~=nb)\r
+ error('X et Y n''ont pas la même taille');\r
+end\r
+n=na-1;\r
+\r
+% Corps d'algorithme\r
+Auxi=Y(1)*poly_lagrange(0,T,X);\r
+for i=2:n+1\r
+ Auxi=Auxi+Y(i)*poly_lagrange(i-1,T,X);\r
+end\r
+Z=Auxi;\r
--- /dev/null
+function Z=poly_lagrange(i,T,X)\r
+\r
+% poly_lagrange : calcul du i-ième polynôme de Lagrange en T (vectoriel)\r
+%\r
+% *********************************************************\r
+%\r
+% z=poly_lagrange_sca(i,T,X)\r
+% Calcul de l_i(t) défini par \r
+% l_i(T)=((T-x_0)/(x_i-x_0))...((T-x_(i-1))/(x_i-x_(i-1)))\r
+% ((T-x_(i+1))/(x_i-x_(i+1)))...\r
+% ((T-x_n)/(x_i-x_n))\r
+%\r
+% variables d'entrées : \r
+% * i : contient l'indice i, compris entre 0 et n\r
+% * T : contient le tableau ligne des réels où on évalue l_i\r
+% * X : contient les centres x_i, pour 0<=i<=n (deux à deux distincts)\r
+%\r
+% variables de sortie\r
+% * Z : contient l'image du tableau T par l_i (tableau ligne)\r
+% \r
+% \r
+% ************ Fonctions auxiliaires utilisées ************\r
+%\r
+% aucune\r
+%\r
+% *********************************************************\r
+%\r
+\r
+\r
+% Contrôles d'entrée\r
+%\r
+% nombre d'arguments\r
+if nargin~=3\r
+ error('nombre d''arguments de la fonction incorrect');\r
+end\r
+n=length(X)-1;\r
+if (i<0) | (i>n)\r
+ error('i n''appartient pas à l''ensemble {0,...,n}')\r
+end\r
+% vérification des éléments du support deux à deux disjoints \r
+Z=sort(X);\r
+if min(diff(Z))==0\r
+ error('deux points du support sont égaux');\r
+end\r
+\r
+% Corps d'algorithme\r
+q=length(T);\r
+y=X(1:i);\r
+y(i+1:n)=X(i+2:n+1);\r
+Auxi=X(i+1)-X(1:i);\r
+Auxi(i+1:n)=X(i+1)-X(i+2:n+1);\r
+B=ones(n,1)*T-y'*ones(1,q);\r
+Z=prod(((1./Auxi)'*ones(1,q)).*B,1);\r
--- /dev/null
+function z=poly_lagrange_sca(i,t,X)\r
+\r
+% poly_lagrange_sca : calcul du i-ième polynôme de Lagrange en t (scalaire)\r
+%\r
+% *********************************************************\r
+%\r
+% z=poly_lagrange_sca(i,t,X)\r
+% Calcul de l_i(t) défini par \r
+% l_i(t)=((t-x_0)/(x_i-x_0))...((t-x_(i-1))/(x_i-x_(i-1)))\r
+% ((x-x_(i+1))/(x_i-x_(i+1)))...\r
+% ((x-x_n)/(x_i-x_n))\r
+%\r
+% variables d'entrées : \r
+% * i : contient l'indice i, compris entre 0 et n\r
+% * t : contient le réel t où on évalue l_i\r
+% * X : contient les centres x_i, pour 0<=i<=n (deux à deux distincts)\r
+%\r
+% variables de sortie\r
+% * z : contient l_i(t)\r
+% \r
+% \r
+% ************ Fonctions auxiliaires utilisées ************\r
+%\r
+% aucune\r
+%\r
+% *********************************************************\r
+%\r
+\r
+\r
+% Contrôles d'entrée\r
+%\r
+% nombre d'arguments\r
+if nargin~=3\r
+ error('nombre d''arguments de la fonction incorrect');\r
+end\r
+n=length(X)-1;\r
+if (i<0) | (i>n)\r
+ error('i n''appartient pas à l''ensemble {0,...,n}')\r
+end\r
+% vérification des éléments du support deux à deux disjoints \r
+Z=sort(X);\r
+if min(diff(Z))==0\r
+ error('deux points du support sont égaux');\r
+end\r
+\r
+% Corps d'algorithme\r
+y=X(1:i);\r
+y(i+1:n)=X(i+2:n+1);\r
+Auxi=X(i+1)-X(1:i);\r
+Auxi(i+1:n)=X(i+1)-X(i+2:n+1);\r
+z=prod((t-y)./Auxi);\r
--- /dev/null
+function [ch_pol,ch_elem,coef]=elem_simp(x,N)\r
+% décompose certaines fractions rationnelles en éléments simples\r
+%\r
+% variables d'entrée\r
+% x est le vecteur réel des poles de la fraction rationnelle,\r
+% dont sera issu par la fonction poly, le dénominateur D(x).\r
+% N est le numérateur de la fraction rationnelle,\r
+% passé comme un polynome matlab, c'est-à-dire un vecteur.\r
+%\r
+% variables de sortie\r
+% ch_pol est une chaine représentant la partie polynomiale, quotient\r
+% obtenu dans la division euclidienne de N par D(x)=(x-x1)...(x-xn).\r
+% ch_elem est une chaine représentant les éléments simples\r
+% au sens ordinaire en fonction de coefficients fournis dans coef.\r
+% coef peut etre forcé à une écriture symbolique (ici rationnelle).\r
+\r
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\r
+% Fonctions connexes appelées\r
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\r
+\r
+% Tests d'entrée généraux\r
+if nargin~=2\r
+ error('Nombre de chapms incorrect');\r
+end\r
+if isreal(x)==0\r
+ error('Les poles doivent etre réels pour l''instant');\r
+end\r
+\r
+\r
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\r
+% Mise sous forme conventionnelle de la fraction\r
+% calcul du dénominateur\r
+D=poly(x);\r
+[Q,R]=deconv(N,D);\r
+% désormais on travaille avec R/D qui correspond à l'étude\r
+% proposée au début dans le tp.\r
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\r
+\r
+\r
+% Premier élément du résultat\r
+ch_pol=poly2str(Q,'x');\r
+\r
+\r
+% recherche de l'existence de poles multiples dans x\r
+% tri de x pour faciliter le repérage des redondances\r
+x=sort(x);\r
+% détection du nombre de poles multiples\r
+pol_mult=sum(diff(x)==0);\r
+\r
+% ALGORITHME GENERAL\r
+\r
+switch pol_mult\r
+case 0,\r
+ % il s'agit de l'étude demandée dans ce tp.\r
+ \r
+ der=polyder(D);\r
+ coef=polyval(R,x)./polyval(der,x);\r
+ ch_elem=[];\r
+ for i=1:size(x,2)\r
+ switch sign(x(i))\r
+ case 1,\r
+ ch=['/(x-' num2str(x(i)) ')'];\r
+ case -1,\r
+ ch=['/(x+' num2str(-x(i)) ')'];\r
+ case 0,\r
+ ch='/x';\r
+ end\r
+ ch_elem=[ch_elem ' + a' num2str(i) ch];\r
+ end\r
+ % à supprimer éventuellement par transformation en commentaire!\r
+ coef=sym(coef,'r');\r
+ \r
+otherwise\r
+ % étude à compléter par l'utilisateur...\r
+ % Voir indications dans le fichier de documentation.\r
+ disp('Il existe au moins un pole multiple. Développez l''étude générale.')\r
+end\r
+\r
+\r
+\r
+\r
+\r
+\r
--- /dev/null
+% script demo_limite_diff_div: calcul et comparaisons de différences divisées par limite formelle et dérivation\r
+%\r
+%\r
+% ************ Fonctions auxiliaires utilisées ************\r
+% \r
+% diff_div\r
+%\r
+% *********************************************************\r
+%\r
+%\r
+\r
+% corps d'algorithme\r
+clear all;\r
+syms x0 x1 x2;\r
+syms y0 y1 y2;\r
+syms x;\r
+f=sym('f(x)');\r
+fp=diff(f);\r
+fpp=diff(f,2);\r
+y0=subs(f,x,x0);\r
+y1=subs(f,x,x1);\r
+y2=subs(f,x,x2);\r
+\r
+% calcul avec les trois valeurs distinctes\r
+disp(' ');\r
+disp(' ');\r
+disp('calcul avec les trois valeurs distinctes');\r
+disp('valeurs des trois différences divisées f[x0],f[x0,x1],f[x0,x1,x2]');\r
+disp(' ');\r
+D=diff_div([x0 x1 x2],[y0 y1 y2]);\r
+pretty(D);\r
+disp(' ');\r
+disp(' ');\r
+disp('appuyez sur une touche pour continuer');\r
+pause;\r
+\r
+% calcul avec deux valeurs égales et une distincte \r
+% premier calcul\r
+disp(' ');\r
+disp(' ');\r
+disp('premier calcul avec deux valeurs égales et une autre distinctes (x2=x1 et x0~=x1)');\r
+disp('valeurs des trois différences divisées f[x0],f[x0,x1],f[x0,x0,x1]');\r
+disp(' ');\r
+D1A=simplify(limit(D,x2,x1));\r
+D1B=simplify(diff_div([x0 x1 x1],[y0 y1 subs(fp,x,x1)]));\r
+disp('calcul par passage à la limite');\r
+pretty(D1A);\r
+disp('calcul par utilisation de diff_div');\r
+pretty(D1B);\r
+disp('comparaison entre les deux expressions');\r
+disp(simplify(D1A-D1B));\r
+disp(' ');\r
+disp(' ');\r
+disp('appuyez sur une touche pour continuer');\r
+pause;\r
+\r
+% second calcul\r
+disp(' ');\r
+disp(' ');\r
+disp('second calcul avec deux valeurs égales et une autre distinctes (x0=x1 et x2~=x1)');\r
+disp('valeurs des trois différences divisées f[x0],f[x0,x0],f[x0,x0,x2]');\r
+disp(' ');\r
+D1C=simplify(limit(D,x1,x0));\r
+D1D=simplify(diff_div([x0 x0 x2],[y0 subs(fp,x,x0) y2]));\r
+disp('calcul par passage à la limite');\r
+pretty(D1C);\r
+disp('calcul par utilisation de diff_div');\r
+pretty(D1D);\r
+disp('comparaison entre les deux expressions');\r
+disp(simplify(D1C-D1D));\r
+disp(' ');\r
+disp(' ');\r
+disp('appuyez sur une touche pour continuer');\r
+pause;\r
+\r
+% calcul avec les trois valeurs égales \r
+disp(' ');\r
+disp(' ');\r
+disp('calcul avec les valeurs égales (x0=x1=x2)');\r
+disp('valeurs des trois différences divisées f[x0],f[x0,x0],f[x0,x0,x0]');\r
+disp(' ');\r
+D2A=simplify(limit(limit(D,x2,x1),x1,x0));\r
+D2B=simplify(diff_div([x0 x0 x0],[y0 subs(fp,x,x0) subs(fpp,x,x0)]));\r
+disp('calcul par passage à la limite');\r
+pretty(D2A);\r
+disp('calcul par utilisation de diff_div');\r
+pretty(D2B);\r
+disp('comparaison entre les deux expressions');\r
+disp(simplify(D2A-D2B));\r
+disp(' ');\r
+disp(' ');\r
+disp('appuyez sur une touche pour continuer');\r
+pause;\r
+\r
+% un calcul de dérivée \r
+disp(' ');\r
+disp(' ');\r
+disp('calcul de la derivee de F : x-> f[x0,x1,x]');\r
+disp(' ');\r
+dodo=diff_div([x0 x1 x],[y0 y1 f]);\r
+F=dodo(3);\r
+D3A=simplify(diff(F,x));\r
+dudu=diff_div([x0 x1 x x],[y0 y1 f fp]);\r
+D3B=simplify(dudu(4));\r
+disp('expression de F''(x)');\r
+pretty(D3A);\r
+disp('appuyez sur une touche pour continuer');\r
+pause;\r
+disp('expression de f[x0,x1,x,x]');\r
+pretty(D3B);\r
+disp(' ');\r
+disp('comparaison entre les deux expressions');\r
+disp(simplify(D3A-D3B));\r
+disp(' ');\r
+disp(' ');\r
+disp('appuyez sur une touche pour continuer');\r
+pause;\r
+\r
+% dernier calcul : erreur !! \r
+disp('essai de calcul de f[x0],f[x0,x1],f[x0,x1,x1] par substitution maladroite');\r
+pretty(subs(D,x2,x1));
\ No newline at end of file
--- /dev/null
+% demo_trace_diff_div : script tracé de polynômes d'interpolation pour des supports quelconques.\r
+%\r
+%\r
+% ************ Fonctions auxiliaires utilisées ************\r
+% \r
+% diff_div, eval_horner\r
+%\r
+% *********************************************************\r
+\r
+clear all;\r
+choix=input('entrer les points à la main (taper m) ou en vecteur (taper v) : ','s');\r
+if strcmp(choix,'m')\r
+ n=input('Entrez l''entier n strictement positif (n-1 est le nombre total du point du support, en comptant les répétitions) : ');\r
+ auxix=input('Entrez le point du support numéro 0 : ');\r
+ auxiy=input('Entrez la valeur de la fonction en ce point : ');\r
+ Xb(1)=auxix;\r
+ Yb(1)=auxiy;\r
+ X=zeros(1,n+1);\r
+ Y=zeros(1,n+1);\r
+ X(1)=auxix;\r
+ Y(1)=auxiy;\r
+ r=auxix; \r
+ k=0;\r
+ for i=1:n\r
+ auxix=input(['Entrez le point du support numéro ',int2str(i),' : ']);\r
+ X(i+1)=auxix;\r
+ if (X(i+1))~=r\r
+ r=X(i+1);\r
+ k=0; \r
+ Xb=[Xb auxix]; \r
+ else\r
+ k=k+1;\r
+ end\r
+ if (k==0)\r
+ auxiy=input('Entrez la valeur de la fonction en ce point : ');\r
+ Y(i+1)=auxiy;\r
+ Yb=[Yb auxiy]; \r
+ else\r
+ Y(i+1)=input(['Entrez la valeur de la dérivée ',int2str(k),...\r
+ '-ième de la fonction en ce point : ']);\r
+ end\r
+ end\r
+else\r
+ X=input('Entrez le vecteur des abscisses : ');\r
+ Y=input('Entrez le vecteur des ordonnées : ');\r
+ n=length(X)-1;\r
+ Xb(1)=X(1);\r
+ Yb(1)=Y(1);\r
+ r=X(1); \r
+ for i=1:n\r
+ auxix=X(i+1);\r
+ if (auxix)~=r\r
+ r=auxix;\r
+ Xb=[Xb auxix]; \r
+ Yb=[Yb Y(i+1)]; \r
+ end\r
+ end\r
+end\r
+pgra=input('Entrez le nombre de points pour le graphique : ');\r
+a=X(1);\r
+b=X(n+1);\r
+xgra=a:(b-a)/pgra:b;\r
+D=diff_div(X,Y);\r
+ygra=eval_horner(xgra,X(1:end-1),D);\r
+hold on;\r
+plot(Xb,Yb,'go',xgra,ygra);\r
+legend('Points du support','polynôme interpolateur');\r
+title(['interpolation avec ',int2str(n+1),' points']);\r
+hold off;\r
+\r
+\r
+\r
+\r
--- /dev/null
+% script demo_verifie_formule : verification formelle de différences divisées.\r
+%\r
+%\r
+% ************ Fonctions auxiliaires utilisées ************\r
+% \r
+% diff_div, eval_horner\r
+%\r
+% *********************************************************\r
+\r
+\r
+clear all;\r
+syms x a b fa fpa fb fpb;\r
+X=[a a b b];\r
+Y=[fa fpa fb fpb];\r
+D=diff_div(X,Y);\r
+disp('affichage des différentes différences divisées : ');\r
+disp(' ');\r
+disp('Ici, fpa et fpb désignent f''(a) et f''(b)');\r
+disp(' ');\r
+disp('f[a] : ');\r
+disp(D(1));\r
+disp('f[a,a] : ');\r
+disp(D(2));\r
+disp('f[a,a,b] : ');\r
+disp(D(3));\r
+disp('f[a,a,b,b] : ');\r
+disp(D(4));\r
+disp('appuyez sur une touche pour continuer ');\r
+pause;\r
+disp(' ');\r
+disp(' ');\r
+disp('vérification des formules : ');\r
+disp('f[a]=f(a) : ');\r
+auxi=simplify(D(1)-(fa));\r
+if (auxi==0) \r
+ disp('ok !!!'); \r
+else\r
+ disp('erreur !!!'); \r
+end\r
+disp('f[a,a]=f''(a) : ');\r
+auxi=simplify(D(2)-(fpa));\r
+if (auxi==0) \r
+ disp('ok !!!'); \r
+else\r
+ disp('erreur !!!'); \r
+end \r
+disp('f[a,a,b]=(f(b)-f(a))/((b-a)^2)-(f''(a))/(b-a) : ');\r
+auxi=simplify(D(3)-((fb-fa)/((b-a)^2)-(fpa)/(b-a)));\r
+if (auxi==0) \r
+ disp('ok !!!'); \r
+else\r
+ disp('erreur !!!'); \r
+end \r
+disp('f[a,a,b,b]=(f''(a)+f''(b))/((b-a)^2)+2(f(a)-f(b))/((b-a)^3) : ');\r
+auxi=simplify(D(4)-((fpa+fpb)/((b-a)^2)+2*(fa-fb)/((b-a)^3)));\r
+if (auxi==0) \r
+ disp('ok !!!'); \r
+else\r
+ disp('erreur !!!'); \r
+end \r
--- /dev/null
+function D=diff_div(X,Y)\r
+\r
+\r
+% diff_div : calcul des différences divisées pour des points de supports quelconques\r
+%\r
+% *********************************************************\r
+%\r
+% D=diff_div(X,Y)\r
+% les différences divisées sont calculées par l'algorithme \r
+% pyramidal donné en TD.\r
+%\r
+% variables d'entrées : \r
+% * X : contient les valeurs x_i, pour 0 <=i<=n (dans l'ordre croissant)\r
+% * Y : contient les valeurs f^(r)(x_i), pour 0 <=i<=n, de telle sorte que :\r
+% si x_k est multiple avec x_{k-1}~=x_k=x_{k+1}=...=x_{k+r}~=x_{k+r+1} alors\r
+% y_k=f(x_k), y_{k+1}=f'(x_k), ..., y_{k+r}=f^(r)(x_k).\r
+%\r
+% variables de sortie\r
+% * D : contient les différences divisées (généralisée à support quelconque) \r
+% f[x_0], f[x_0,x_1], ...., f[x_0,x_1,...,x_n]\r
+%\r
+%\r
+%\r
+% ************ Fonctions auxiliaires utilisées ************\r
+%\r
+% val_derivee_multiple \r
+%\r
+% *********************************************************\r
+\r
+\r
+% Contrôles d'entrée\r
+%\r
+% nombre d'arguments\r
+if nargin~=2\r
+ error('nombre d''arguments de la fonction incorrect');\r
+end\r
+% taille des deux variables \r
+n=length(X)-1;\r
+np=length(Y)-1;\r
+if n~=np\r
+ error('les deux tableaux n''ont pas la même taille');\r
+end\r
+% vérification de l'ordre croissant des x_i \r
+% (si X non formel)\r
+if isnumeric(X)\r
+ if max(abs(sort(X)-X))~=0\r
+ error('support non ordonné');\r
+ end\r
+end\r
+\r
+% Corps d'algorithme\r
+i=0;\r
+while (i<=n)\r
+ [alpha,valfder]=val_derivee_multiple(i,X,Y);\r
+ D(i+1:i+alpha)=valfder(1)*ones(1,alpha);\r
+ i=i+alpha;\r
+end\r
+factoi=1;\r
+for i=1:n;\r
+ factoi=factoi*i;\r
+ for j=n:-1:i;\r
+ dx=X(j+1)-X(j-i+1);\r
+ if (dx==0)\r
+ [alpha,valfder]=val_derivee_multiple(j-i,X,Y);\r
+ D(j+1)=(valfder(i+1))/factoi;\r
+ else\r
+ D(j+1)=(D(j+1)-D(j))/(dx);\r
+ end\r
+ end\r
+end\r
--- /dev/null
+function R=test_diff_div(T,X,Y) \r
+\r
+% test_diff_div : fonction test pour le calcul du polynôme interpolateur support quelconque\r
+%\r
+%\r
+% *********************************************************\r
+%\r
+% R=test_diff_div(T,X,Y) \r
+% calcul de la valeur du polynôme d'interpolation défini par le nuage de point X,Y\r
+% sur le tableau T (utilisation du calcul des différences divisées et \r
+% de l'algorithme d'évaluation de Horner) pour support quelconque\r
+%\r
+% variables d'entrées : \r
+% * T : contient le tableau rectangulaire des réels où est évalué p_n\r
+% * X : contient les valeurs x_i, pour 0 <=i<=n (dans l'ordre croissant)\r
+% * Y : contient les valeurs f^(r)(x_i), pour 0 <=i<=n, de telle sorte que :\r
+% si x_k est multiple avec x_{k-1}~=x_k=x_{k+1}=...=x_{k+r}~=x_{k+r+1} alors\r
+% y_k=f(x_k), y_{k+1}=f'(x_k), ..., y_{k+r}=f^(r)(x_k).\r
+%\r
+% variables de sortie\r
+% * R : contient le tableau rectangulaire des images de T par p_n,\r
+% polynôme d'interpolation de f sur le support x_i, pour 0 <=i<=n\r
+%\r
+% \r
+% ************ Fonctions auxiliaires utilisées ************\r
+%\r
+% diff_div, eval_horner\r
+%\r
+% *********************************************************\r
+\r
+\r
+D=diff_div(X,Y);\r
+R=eval_horner(T,X(1:end-1),D);\r
+\r
--- /dev/null
+function [alpha,valfder]=val_derivee_multiple(i,X,Y)\r
+\r
+\r
+% val_derivee_multiple : sortie des valeurs des dérivées successives pour un support quelconque\r
+%\r
+% *********************************************************\r
+%\r
+% [alpha,valfder]=val_derivee_multiple(i,X,Y)\r
+% sorties des valeurs des dérivées successives (définies dans Y) \r
+% pour un support à n+1 points quelconque (ordonnée) stocké dans X,\r
+% pour un élément x_i de ce support.\r
+%\r
+%\r
+% variables d'entrées : \r
+% * i : entier compris entre 0 et n\r
+% * X : contient les valeurs x_j, pour 0 <=j<=n (dans l'ordre croissant)\r
+% * Y : contient les valeurs f^(r)(x_j), pour 0 <=j<=n, de telle sorte que :\r
+% si x_k est multiple avec x_{k-1}~=x_k=x_{k+1}=...=x_{k+r}~=x_{k+r+1} alors\r
+% y_k=f(x_k), y_{k+1}=f'(x_k), ..., y_{k+r}=f^(r)(x_k).\r
+%\r
+% variables de sortie\r
+% * alpha : nombre d'éléments du n+1 uplet (x_0,x_1,...,x_n) égaux à x_i. \r
+% * valfder : vecteur ligne de longueur alpha tel que :\r
+% pour tout l dans {0,...,alpha-1}; valfder(l+1)=f^{l}(x_i).\r
+% \r
+% \r
+% ************ Fonctions auxiliaires utilisées ************\r
+%\r
+% aucune\r
+%\r
+% *********************************************************\r
+%\r
+\r
+\r
+% Contrôles d'entrée\r
+%\r
+% nombre d'arguments\r
+if nargin~=3\r
+ error('nombre d''arguments de la fonction incorrect');\r
+end\r
+% taille des deux variables \r
+n=length(X)-1;\r
+np=length(Y)-1;\r
+if n~=np\r
+ error('les deux tableaux n''ont pas la même taille');\r
+end\r
+% vérification de l'ordre croissant des x_i \r
+% (si X non formel)\r
+if isnumeric(X)\r
+ if max(abs(sort(X)-X))~=0\r
+ error('support non ordonné');\r
+ end\r
+end\r
+% vérification de l'appartenance de i à {0,...,n}\r
+% vérification de l'ordre croissant des x_i \r
+if ~((0<=i) & (i<=n)) \r
+ error('le premier argument n''appartient pas à {0,...,n}');\r
+end\r
+\r
+\r
+% Corps d'algorithme\r
+k=find(X==X(i+1));\r
+alpha=length(k);\r
+valfder=Y(k);
\ No newline at end of file
--- /dev/null
+function res=verifie_diff_div(X,Y) \r
+\r
+% verifie_diff_div : verification pour le calcul du polynôme interpol. support quelconque\r
+%\r
+%\r
+% *********************************************************\r
+%\r
+% res=verifie_diff_div(X,Y) \r
+% vérification du calcul du polynôme d'interpolation défini par le nuage de point X,Y\r
+% pour support quelconque\r
+%\r
+% variables d'entrées : \r
+% * X : contient les valeurs x_i, pour 0 <=i<=n (dans l'ordre croissant)\r
+% * Y : contient les valeurs f^(r)(x_i), pour 0 <=i<=n, de telle sorte que :\r
+% si x_k est multiple avec x_{k-1}~=x_k=x_{k+1}=...=x_{k+r}~=x_{k+r+1} alors\r
+% y_k=f(x_k), y_{k+1}=f'(x_k), ..., y_{k+r}=f^(r)(x_k).\r
+%\r
+% variables de sortie\r
+% * res : contient le maximum des valeur absolue de \r
+% n-p où p est le degré du polynôme d'interpolation p_n\r
+% et n+1 est le nombre de points.\r
+% maximum sur i dans {0,...,n} maximum sur l dans alpha_i-1\r
+% de la quantitée p_n^(l)(x_i)-f^(l)(x_i) (dérivée l fois) où alpha_i est \r
+% le nombre d'éléments du n=1-uplet(x_0,...,x_n) égaux à x_i.\r
+%\r
+% Le calcul est correct si et seulement si res est nul.\r
+%\r
+%\r
+% \r
+% ************ Fonctions auxiliaires utilisées ************\r
+%\r
+% diff_div, newton_cano, val_derivee_multiple \r
+%\r
+% *********************************************************\r
+\r
+D=diff_div(X,Y);\r
+P=newton_cano(D,X(1:end-1));\r
+n=length(X)-1;\r
+p=length(P)-1;\r
+erdeg=abs(n-p);\r
+er=0;\r
+i=0;\r
+while (i<=n)\r
+ [alpha,valfder]=val_derivee_multiple(i,X,Y);\r
+ Q=P;\r
+ er=max(er,abs(polyval(P,X(i+1))-valfder(1)));\r
+ for l=1:alpha-1\r
+ Q=polyder(Q);\r
+ er=max(er,abs(polyval(Q,X(i+1))-valfder(l+1))); \r
+ end\r
+ i=i+alpha;\r
+end\r
+res=max(er,erdeg);\r
--- /dev/null
+function res=verifie_diff_div_symb(X,Y) \r
+\r
+% verifie_diff_div_symb : verification pour le calcul du polynôme interpol. support quelconque en symbolique\r
+%\r
+%\r
+% *********************************************************\r
+%\r
+% res=verifie_diff_div_symb(X,Y) \r
+% vérification du calcul du polynôme d'interpolation défini par le nuage de point X,Y\r
+% pour support quelconque où X et Y sont des vecteurs symboliques.\r
+% Vérification en formel.\r
+%\r
+%\r
+% variables d'entrées : \r
+% * X : contient les valeurs x_i, pour 0 <=i<=n (dans l'ordre croissant)\r
+% * Y : contient les valeurs f^(r)(x_i), pour 0 <=i<=n, de telle sorte que :\r
+% si x_k est multiple avec x_{k-1}~=x_k=x_{k+1}=...=x_{k+r}~=x_{k+r+1} alors\r
+% y_k=f(x_k), y_{k+1}=f'(x_k), ..., y_{k+r}=f^(r)(x_k).\r
+%\r
+% variables de sortie\r
+% * res : contient le maximum des valeur absolue de \r
+% n-p où p est le degré du polynôme d'interpolation p_n\r
+% et n+1 est le nombre de points.\r
+% maximum sur i dans {0,...,n} maximum sur l dans alpha_i-1\r
+% de la quantitée p_n^(l)(x_i)-f^(l)(x_i) (dérivée l fois) où alpha_i est \r
+% le nombre d'éléments du n=1-uplet(x_0,...,x_n) égaux à x_i.\r
+%\r
+% Le calcul est correct si et seulement si res est nul\r
+% et incorrect si res est egal à un \r
+%\r
+%\r
+% \r
+% ************ Fonctions auxiliaires utilisées ************\r
+%\r
+% diff_div, eval_horner, val_derivee_multiple \r
+%\r
+% *********************************************************\r
+\r
+D=diff_div(X,Y);\r
+syms x;\r
+R=eval_horner(x,X(1:end-1),D);\r
+er=0;\r
+i=0;\r
+n=length(X)-1;\r
+while (i<=n)\r
+ [alpha,valfder]=val_derivee_multiple(i,X,Y);\r
+ Q=R;\r
+ erloc=~(simplify(subs(R,'x',X(i+1)))==valfder(1));\r
+ er=max(er,erloc);\r
+ for l=1:alpha-1\r
+ Q=diff(Q);\r
+ erloc=~(simplify(subs(Q,'x',X(i+1)))==valfder(l+1));\r
+ er=max(er,erloc); \r
+ end\r
+ i=i+alpha;\r
+end\r
+res=er;
\ No newline at end of file
