\documentclass[a4paper,12pt]{article}

%%% Package
\usepackage{amssymb}
\usepackage[]{fancyhdr}
\usepackage{makeidx}
\makeindex

\usepackage[ansinew]{inputenc}
\usepackage[french]{babel}

%%% POSITIONNEMENT DE LA PAGE
\setlength{\textheight}{25.25cm}
\setlength{\textwidth}{16.0cm}
\setlength{\oddsidemargin}{-0.0cm}
\setlength{\evensidemargin}{-1.0cm}
\setlength{\parindent}{0.0cm}
\setlength{\topmargin}{-1.0cm} 

\setlength{\baselineskip}{0.0cm}
\setlength{\parskip}{0.0cm}
\setlength{\itemsep}{0.0cm}

\pagestyle{fancy}

%%% Commandes
\def\tr{\triangle}
\newcommand{\R}{\mathbb{R}}
\newcommand{\N}{\mathbb{N}}
\newcommand{\Z}{\mathbb{Z}}


\title{ {\huge Débuter en \textsc{Matlab}}\\
{\Large L3 MFA} \\
{\Large Universit\'{e} Paris-Sud} }

\author{Bernard H\'eron - Frédéric Pascal - Pierre Pansu}

\begin{document}

\maketitle

\rhead[]{Mathématiques : Université Paris-Sud}
\lhead[]{Introduction à \textsc{Matlab}}

{\scriptsize 
\tableofcontents}


\section{Introduction}

\textsc{Matlab} (matrix laboratory) est un système interactif de calcul
numérique utilisable comme une calculette et qui dispose d'un grand
nombre de fonctions, d'un langage de programmation et d'outils de
visualisation graphique.

La structure de base sur laquelle travaille \textsc{Matlab} est la matrice \index{matrice}. 
Cela se fait sans déclarations de type et les allocations de mémoire ou les 
redimensionnements sont effectués sans intervention de l'utilisateur, d'o\`u
une grande souplesse d'emploi.

\section{Fonctionnement}

\subsection{Lancement}
Pour lancer une session \textsc{Matlab}, se reporter aux feuilles de TP.


\subsection{L'environnement de travail}

\textsc{Matlab} met à disposition de l'utilisateurs plusieurs fenêtres (la
fenêtre de commandes, la fenêtre de l'éditeur, la fenêtre de l'aide,
la fenêtre de lancement, la fenêtre de l'historique, la fenêtre de
l'occupation mémoire, la fenêtre du répertoire).

Pour l'usage que l'on en fera, on utilisera EXCLUSIVEMENT
\begin{itemize}
\item la fenêtre de commandes dans laquelles seront tapées les commandes,
\item la fenêtre éditeur qui permet d'éditer des fichiers de commandes,
\item la fenêtre de l'aide.
\end{itemize}

\subsection{Les modes de travail}
\textsc{Matlab} fonctionne suivant deux modes, le mode interactif et le mode programmation. Dans les deux cas, 
l'utilisateur peut définir ses propres fonctions et les utiliser. Le premier est décrit au paragraphe \ref{calculette}, le second au paragraphe \ref{programmation}.

\subsection{Accès à l'aide en ligne}
Cliquer sur \textbf{?}.\index{aide en ligne}

\subsection{Les noms de variables et de fonctions}
Les noms de variables et de fonctions sont constitués d'une lettre suivie
d'au plus 30 autres caractères, chacun pouvant être un chiffre, une lettre
 ou le caractère souligné ({\sl underscore} en anglais). 
\textsc{Matlab} fait la distinction entre minuscules et majuscules.  \\ \\
\underline{Conseil} : Donner des noms significatifs aux variables et
aux fonctions.   \\ \\
\underline{Conseil} : Commencer toute nouvelle page d'instructions 
\textsc{Matlab} par {\tt clear all} \index{clear all@{\tt clear all}}. Cette instruction détruit toutes les 
variables personnelles créées auparavant. \\ \\ % dans l'espace de travail. \\ \\
\underline{Conseil} : La commande {\tt whos} liste les variables actives 
(en indiquant leur taille, ce qui est très utile pour débugger).

\section{Machine à calculer}

\subsection{Le mode interactif}
\label{interactif}
C'est le mode calculette. Les instructions sont tapées
  successivement dans l'ordre d'exécution dans la fenêtre de commande.
  Chaque ligne d'instructions est terminée par un retour-chariot (touche
  \textsl{Entrée}) qui
  valide la ligne. La ligne d'instructions est alors interprétée et
  les instructions qu'elle contient sont immédiatement exécutées. Le résultat
  (respectivement un message d'erreur) est affiché en cas de bon
  fonctionnement (respectivement en cas d'erreur). \\
  L'affichage du résultat d'une instruction est parfois indésirable :
  pour le supprimer, il suffit de terminer l'instruction par un point-virgule.
  \\ \\
  \underline{Conseil} : Utiliser la touche 
  \raisebox{2pt}{\framebox{$\; \uparrow \; $}} \index{\raisebox{2pt}{\framebox{$\; \uparrow \; $}}} pour 
  rappeler une commande antérieure, puis, après éventuelle modification,
  la relancer par un retour-chariot. \\

\subsection{Calcul sur des nombres} 
Même fonctionnement et même ordre de priorité que sur toutes les machines à 
calculer standard : d'abord l'élévation à une puissance ($\widehat{\;}$),
 puis la multiplication et la division ($*$ et $/$) et enfin l'addition et la
soustraction ($+$ et $-$). 
Pour modifier l'ordre des opérations ou encore pour le mettre en 
évidence, on utilise des parenthèses. \\ \\
\underline{Fonctions} :
{\tt  sin, cos, tan, cot, asin,
acos, atan, acot, cosh, sinh, tanh, coth, acosh, asinh, atanh, acoth,
exp, log, log10, sqrt, abs, sign, mod, rem, \\
round, floor, ceil, fix}.
\\ \\
\underline{Exemples} : 
\begin{verbatim}
x=3/2+1.9
y=1+3^4/2*5
z=(1+3)^4/2*5
a=abs(sin(x))+log(y)+exp(-z)
\end{verbatim}

\noindent
Les instructions ci-dessus donnent à $x,y,z$ les valeurs $3.4,\ 203.5,\ 640$.

\subsection{Tracé de courbes}

\subsubsection{Bien comprendre la syntaxe}

Pour tracer la courbe représentative de la fonction {\tt sin} sur l'intervalle $[0,2\pi]$, il suffit de taper  \index{courbe} \index{pi@$\pi$}
\begin{verbatim}
x=0:0.01:2*pi;
plot(x,sin(x))
\end{verbatim}

On a l'impression que la première commande définit un intervalle sur lequel est définie la fonction {\tt sin}, et que la seconde produit une courbe continue. Ce n'est pas du tout comme cela que \textsc{Matlab} interprète ces commandes. Pour le voir, lancer les instructions ci-dessus, en remplaçant $0.01$ par $1$, et en retirant le point-virgule à la fin de la première instruction (qui empêche l'affichage du résultat). \textsc{Matlab} ignore les intervalles et les fonctions d'une variable réelle, il ne connait que des listes de valeurs numériques. La commande \begin{verbatim}
x=0:1:2*pi
\end{verbatim}
crée une liste (aussi appelée vecteur-ligne) de nombres, 0 1 2 3 4 5 6. \texttt{
sin(x)} désigne la liste $\sin(0)$ $\sin(1)$ $\sin(2)$ $\sin(3)$ $\sin(4)$ $\sin(5)$ $\sin(6)$. Autrement dit, la fonction {\tt sin} est appliquée à chaque terme de la liste \texttt{x}. \texttt{plot(x,sin(x))} trace une ligne brisée reliant successivement les points $(0,\sin(0))$, $(1,\sin(1))$,..., $(6,\sin(6))$. Noter que \textsc{Matlab} ne fera aucune différence entre une courbe représentative de fonction et une courbe paramétrée. \index{courbe paramétrée}

\subsubsection{Piège}
\label{calculette}
Pourquoi l'instruction
\begin{verbatim}
x=0:1:2*pi;
y=x*sin(x)
\end{verbatim}
provoque-t-elle une erreur \index{*@\verb#*#}? Parce que, pour \textsc{Matlab}, les vecteurs-lignes sont des cas particuliers de matrices, que les matrices ont une façon bien particulière de se multiplier entre elles, qui diffère de la multiplication terme à terme (voir au paragraphe \ref{operations}). Au lieu de \verb#y=x*sin(x)#, il faut écrire \verb#y=x.*sin(x)#. \index{.*@\verb#.*#}. De même, au lieu de \verb#y=sin(x)/x#, il faut écrire \verb#y=sin(x)./x#\index{./@\verb#./#}, et au lieu de \verb#y=2^x#, il faut écrire \verb#y=2.^x#\index{.^@\verb#.^#}, lorsque \texttt{x} est un vecteur-ligne. \textbf{Cette erreur est très fréquente}.


\subsubsection{Principe de la commande \texttt{plot}}
\index{plot@{\tt plot}}
\begin{itemize}
\item  {\bf Tracé d'une ligne brisée} \\
Il s'agit plus exactement de tracés de lignes brisées.  Si $x, y$
sont deux vecteurs-lignes (ou deux vecteurs-colonnes) de même taille
$n$, la commande {\tt plot(x,y)} réalise le tracé de la ligne
brisée qui relie les points de coordonnées $(x(j),y(j))$ pour $j=1,\dots,n$ dans
une fenêtre graphique séparée.  On peut choisir la couleur et le
type du trait (trait plein, tirets, pointillés ou points isolés)
et placer des marqueurs (cercles, croix, triangles, etc.) aux sommets
de la ligne brisée \index{couleur} \index{trait} \index{ligne brisée}
(pour lister les possibilités, faire {\tt help plot}). \\

\underline{Exemple} : Pour tracer en rouge le graphe d'une fonction {\tt f}
définie dans un fichier {\tt f.m} (voir au paragraphe \ref{programmation}), il suffit en général (pour des fonctions
``lisses'') de 50 à 100 points d'abscisses équiréparties pour un
rendu satisfaisant. 
\begin{verbatim}
   x=-1+2*[0:100]/100;
   plot(x,f(x),'r')
\end{verbatim} 
Les \verb#'# \verb#'# sont là pour que la lettre \verb#r# soit interprétée comme une chaîne de caractères (en l'occurrence, la lettre r toute seule), et non comme une instruction.

\item  {\bf Tracé de plusieurs lignes brisées} \\
Chaque nouvelle commande {\tt plot} ouvre a priori un nouvel espace
graphique dans la fenêtre graphique et efface donc le précédent tracé.
Pour tracer plusieurs lignes brisées dans un même espace, on dispose de 2 possibilités.
\begin{itemize}
\item 1) les lignes brisées sont tracées simultanément~: \\
  par exemple \verb#plot(x,f(x),'ro', x,5*sin(x),'k--', x,0*x,'b')#
  trace la ligne brisée définie par $x$ et $0*x$ en trait plein
  bleu, celle définie par $x$ et $5*sin(x)$ en pointillés noirs et
  trace seulement un cercle rouge à l'emplacement des points
  définis par $x$ et $f(x)$.
\item 2) les lignes brisées sont tracées successivement en
  maintenant le tracé précédent, pour cela on dispose de la commande
  {\tt hold on} \index{hold on@{\tt hold on}}qui permet de conserver le tracé tant que {\tt hold off} \index{hold off@{\tt hold off}}ou {\tt
    clf} \index{clf@{\tt clf}}n'est pas appelée. Reprenons l'exemple précédent
  \begin{verbatim}
  plot(x,f(x),'ro')
  hold on
  plot(x,5*sin(x),'k--')
  plot(x,0*x,'b')
  hold off
  \end{verbatim}
\end{itemize}

Les fenêtres graphiques sont appelées Figure No 1 (fenêtre par
défaut), Figure No 2, etc.  La commande {\tt figure(n)} \index{figure@{\tt figure}} \index{numérotation des figures} permet
d'ouvrir (ou de préciser si elle est déjà ouverte) la fenêtre graphique Figure No $n$ dans laquelle on souhaite travailler. \\

La commande {\tt subplot} \index{subplot@{\tt subplot}}permet d'ouvrir plusieurs espaces graphiques dans une même fenêtre. \\


\item{\bf Options} \\
Les commandes {\tt title} \index{title@{\tt title}}, {\tt gtext} \index{gtext@{\tt gtext}}, {\tt legend} \index{legend@{\tt legend}}, {\tt xlabel} \index{xlabel@{\tt xlabel}}
permettent de documenter les tracés (pour afficher les règles d'emploi 
de ces options, faire {\tt help title}, {\tt help gtext},  etc). \\ 

La commande  {\tt axis} \index{axis@{\tt axis}}s'emploie après la commande {\tt plot} pour
recadrer le tracé. En particulier, la commande {\tt axis equal}
retrace la figure en axes orthonormés et la commande 
{\tt axis([xmin xmax ymin ymax])} reconstruit la partie du graphique limitée
 au rectangle {\tt [xmin,~xmax]}$\times${\tt[ymin,~ymax]}. \\

Signalons que Matlab dispose d'autres commandes de tracé, par exemple 
{\tt loglog}, {\tt semilogx}, {\tt semilogy}, {\tt polar}, {\tt plot3d},...

\end{itemize}

\subsection{Affichage des nombres}
\textsc{Matlab} offre au moins quatre types d'affichage (court ou long, 
scientifique ou non) que l'on sélectionne avec les commandes \index{format court}\index{format long}\index{format scientifique}
\begin{itemize}
\item {\tt format short } ~~~~~(qui est le format par défaut)
\item {\tt format short e }
\item {\tt format long }
\item {\tt format long e }  
\end{itemize} 
Pour le nombre $x=1/700$, 
ces formats donnent respectivement les affichages \\
\indent 0.0014 \\
\indent 1.4286e-03 \\
\indent 0.00142857142857 \\
\indent 1.428571428571429e-03 \\
mais (heureusement!) le changement de format n'affecte pas la valeur de $x$. 
\\
Le format sélectionné reste actif jusqu'au lancement 
d'une nouvelle commande {\tt format}.
\\ \\
\underline{Remarque} : Pour présenter des tableaux de valeurs numériques,
on préfère généralement définir des formats {\sl ad hoc} et on 
utilise alors la commande {\tt fprintf} avec une description du format 
d'affichage inspirée du langage C.

\subsection{Nombres complexes}
Les variables {\tt i} et {\tt j} désignent le nombre
complexe $\sqrt{-1}$ sauf si d'autres valeurs 
numériques leur ont été affectées par l'utilisateur (on évitera donc dans
ce cas d'utiliser {\tt i} ou {\tt j} comme indice de boucle). 
\\ \\
\underline{Exemples} : 
\begin{verbatim}
   z1=1+2i
   z2=(1+sqrt(3)*j)/2 
\end{verbatim} 
\underline{Fonctions complexes} : 
{\tt real, imag, conj, abs, angle}.\index{nombres complexes}\index{i}\index{abs}

\section{Les matrices}

Pour \textsc{Matlab}, tout est matrice. Une {\em matrice} \verb#A#, \index{matrice} c'est un tableau rectangulaire de valeurs numériques, appelés les {\em éléments} \index{elem@éléments} de la matrice, et repérés par leur position~: \verb#A(i,j)# est l'élément situé sur la $i$-ème ligne et la $j$-ème colonne. On parle de vecteurs-ligne \index{vecteur-ligne} pour désigner les matrices à une seule ligne, et de vecteurs-colonne \index{vecteur-colonne} pour désigner les matrices à une seule colonne.

\subsection{Construction} 
\begin{itemize}
\item {\bf Vecteurs-lignes à coefficients régulièrement espacés} :\\ 
On a déjà rencontré la syntaxe commode \index{:} \\
\null~~~{\tt u=debut$\!$:pas$\!$:fin} \ \ ou \ \ \ {\tt u=[debut$\!$:pas$\!$:fin]} \ \ 
et plus simplement \\
\null~~~{\tt v=debut:fin}  \ \ ou \ \ \ {\tt v=[debut:fin]} \ \ 
lorsque {\tt pas} vaut 1.\\ \\
\begin{tabular}{ll}
\underline{Exemples} : & {\tt u=-10:4:2} \  équivaut à \ {\tt u=[-10~-6~-2~2]}\\
                       & {\tt v=2:5} \  équivaut à \ {\tt v=2:1:5 }  c'est-à-dire à \ {\tt v=[2~3~4~5]} \\
                       & {\tt w=5:2} \  équivaut à \ {\tt w=5:1:2 }  c'est-à-dire à \ {\tt w=[]} \\ \\
\end{tabular}

\item {\bf In extenso à la main} :  \\ 
On peut aussi rentrer les coefficients un par un.\\
\null~-~Vecteur-ligne (matrice à 1 seule ligne) :  
    {\tt u=[10~-7~3~8]} \ ou bien \ \  {\tt u=[10,-7,3,8]} \\
\null~-~Vecteur-colonne (matrice à 1 seule colonne) : 
    {\tt v=[2;0;-5]}  \ ou bien \ \ {\tt v=[2~0~5]$'$}  \\
\null~-~Tableau à 2 indices : {\tt A=[10~7 ; 2~4 ; -5~0]} \ ou encore, 
    terme à terme \\
    \hspace*{4cm}{\tt A(1,1)=10; A(1,2)=7; A(2,1)=2; A(2,2)=4; A(3,1)=-5;} \\
    \hspace*{4cm}{\tt A(1,1)=10; A(1,2)=7; A(2,1)=2; A(2,2)=4; A(3,1)=-5;} \\

  \underline{Remarque} : Si {\tt A} est une matrice (à coefficients 
  complexes), alors {\tt A}$'$ désigne sa transconjuguée et {\tt A}$.'$ sa
  transposée.  \index{transposée}  \index{transconjuguée} Les deux co\"\i ncident si {\tt A} est à coefficients réels.
  \\ \\
  \underline{Remarque} : Si on omet de donner une valeur à certains 
  coefficients d'une matrice que l'on crée (ou que l'on complète),
  alors  \textsc{Matlab} leur affecte la valeur $0$. \\ 

\item {\bf Formes prédéfinies} :  \\
  Matlab dispose de fonctions définissant des matrices comme {\tt eye, ones, zeros, rand, magic, hilb}...   \index{zeroes} \index{ones} \index{eye}  \\

Par exemple {\tt eye(3)}  est la matrice identité d'ordre 3, {\tt zeros(2,4)}
 est la matrice nulle à deux lignes et 4 colonnes, {\tt ones(1,5)} est le 
vecteur ligne {\tt [1 1 1 1 1]}. \\
Attendu que si {\tt A} est un tableau à deux indices, 
l'instruction {\tt [nl,nc]=size(A)} affecte à la  variable
{\tt nl} (resp. {\tt nc}) le nombre de lignes (resp. de colonnes) de {\tt A},
l'instruction ~{\tt B=rand(size(A))}~ crée une matrice {\tt B} de 
même dimensions que {\tt A} et à coefficients {\sl aléatoires}  \index{aléatoire}  \index{hasard} \index{rand} dans
$[0,1]$.\\

\item {\bf Par concaténation de matrices de tailles compatibles}  \index{concaténation} :\\
Les instructions {\tt ~u=[1 7 9]} puis {\tt u=[u 3]} équivalent à
 {\tt ~u=[1 7 9 3]}. \\ 
L'instruction {\tt ~M=[ 5*ones(2,3)~~-eye(2) ; 1:3~~zeros(1,2) ] } 
crée la matrice \\ 
\[
M=\left(
\begin{array}{ccccc}
 5 & 5 & 5 & -1& 0 \\
 5 & 5 & 5 & 0 & -1 \\
 1 & 2 & 3 & 0 & 0 
\end{array}
\right)
\]
\end{itemize}

\subsection{Accès aux éléments d'une matrice} 
\begin{itemize}
\item {\bf Accès à un élément à l'aide des parenthèses et des numéros 
d'indices} :\\
{\tt u(2),~ A(1,3),~ v(end)}  \index{end} \\
\item {\bf Accès à une section d'une matrice à l'aide de vecteurs d'indices} :
 \\
  si {\tt L} et {\tt C} sont des vecteurs d'entiers (lignes ou colonnes peu
  importe), {\tt A(L,C)} est la 
  matrice composée des éléments {\tt A}$(i,j)$ avec $i \in\mbox{\tt L}$ et 
  $j \in\mbox{\tt C}$. Par exemple pour la matrice {\tt M} définie 
  précédemment {\tt M([1 3],[2:4])} est la matrice
\[
\left(
\begin{array}{ccc}
 5 & 5 & -1 \\
 2 & 3 & 0
\end{array}
\right)
\]
Si {\tt x} est un vecteur, le sous-vecteur formé des composantes d'indice
impair de {\tt x} est {\tt x(1:2:end)} tandis que {\tt x(end:-1:1)}  \index{end@:end} est le
vecteur déduit de {\tt x} en renversant l'ordre des composantes. On 
utilise le deux-points comme abréviation de {\tt [1:end]}. Ainsi, 
{\tt A(:,k)} (resp. {\tt A(k,:)}) désigne la colonne (resp. la ligne) 
d'indice {\tt k} de la matrice {\tt A}. De même, si {\tt C} est un vecteur 
d'entiers, alors {\tt A(:,C)} est la matrice {\tt A(1:end,C)}.

\end{itemize}

\subsection{Opérations}
\label{operations}
\begin{itemize}
\item {\bf Opérations matricielles :}  \index{opérations matricielles} \\
\verb#A+B, A*B, A-B #  \index{+@\texttt{+}}  \index{*@\texttt{*}}  \index{-@\texttt{-}}  \index{produit de matrices}  \index{somme de matrices}  \index{somme de vecteurs} \index{addition de vecteurs}  désignent les opérations matricielles au
 sens mathématique lorsque ces opérations ont un sens, c'est-à-dire quand 
les dimensions des matrices ou vecteurs \verb#A# et \verb#B#  sont compatibles. \\


\item {\bf Puissance de matrice carrée :} \\
Si $A$ est une matrice carrée alors  \index{^@\verb#^#}  \index{puissance d'une matrice} \\
\mbox{ }\hspace{0.5cm} \verb#A^n# avec $n \in \N$ est le produit répété $n$ fois de la matrice $A$, \\
\mbox{ }\hspace{0.5cm} \verb#A^(-n)# avec  $n \in \N$ est égale à   \verb#inv(A)^n#, \\
\mbox{ }\hspace{0.5cm} \verb#A^s# avec $s \notin \Z$ est égale à \verb#V*D^s*inv(V)#  où \verb#[V,D]=eig(A)#. \\

\item {\bf Division matricielle :}  \index{division des matrices} \\
  - \verb#A\B# est la solution {\tt X} (éventuellement au sens des moindres carrés) de {\tt AX=B} si les dimensions sont compatibles.\\
  - \verb#B/A# est la solution {\tt X} (éventuellement au sens des moindres carrés) de {\tt XA=B} si les dimensions sont compatibles. \\
  
  \underline{Remarque} : Si {\tt A} est une matrice carrée de dimension
  $[n,n]$, inversible et si {\tt B} est un vecteur colonne de
  dimension $[n,1]$ alors  \verb#A\B# et {\tt inv(A)*B} sont identiques
  mais le calcul n'est pas effectué de la même façon.  \index{inverse d'une matrice} \\

  \underline{Remarque} : Si {\tt A} est une matrice carrée de dimension
  $[n,n]$, inversible et si {\tt B} est un vecteur ligne de
  dimension $[1,n]$ alors \verb#B/A# et {\tt B*inv(A)} sont identiques
  mais le calcul n'est pas effectué de la même façon. \\

\item {\bf Opérations terme à terme :} \\
On les a déjà rencontrées (paragraphe \ref{calculette}) dans le cas particulier des vecteurs-lignes.\\
  Soit {\tt A} et {\tt B} deux matrices de mêmes dimensions \\
  - si {\tt op} est l'un des opérateurs \verb# ^, *, /# alors le
  résultat de \verb#A.op B# est la matrice de même dimension que {\tt
    A} ou {\tt B} et dont les éléments sont les~{\tt A}$(i,j)$ {\tt
    op} {\tt B}$(i,j)$ (règle analogue si {\tt A} et {\tt B} sont
  des vecteurs de mêmes dimensions).  \index{.^@\verb#.^#}  \index{.*@\verb#.*#} \index{./@\verb#./#}  \\
  - le résultat de \verb#A.\ B# \index{.\@\verb#.\#} est la matrice de même dimension que
  {\tt A} dont les éléments sont les~{\tt B}$(i,j)$ {\tt/}{\tt
    A}$(i,j)$ (règle analogue si {\tt A} et {\tt B} sont des
  vecteurs de mêmes dimensions). \\
  
  
  \item {\bf Opérations matrice (ou vecteur) - scalaire :} \\
  Si {\tt A} est une matrice, si {\tt b} est un scalaire  \\
  - et si {\tt op} est l'un des opérateurs \verb# +, -, *# alors
  {\tt A op b} ou {\tt b op A} est la matrice de même dimension que
  {\tt A} dont les éléments sont les ~{\tt A}$(i,j)$ {\tt op} {\tt
    b}~ (règle  analogue si {\tt A} est un vecteur). \\
  - alors {\tt A/b} $\equiv$ \verb#A./(b*ones(size(A)))# \\ 
  - alors \verb#A.\b# $\equiv$ \verb#b./A# $\equiv$ \verb#(b*ones(size(A))./A#  \\
  - alors \verb#A.^b# $\equiv$ \verb#A.^(b*ones(size(A)))# \\
  - alors \verb#b.^A# $\equiv$ \verb#(b*ones(size(A)).^A# \\
  
  
  \underline{Remarque} : Dans le cas de \verb#*# et \verb#/#,
  l'opération correspond à l'opération mathématique. \\

  \underline{Remarque} : Si  {\tt A} est carrée,  
  \verb#b^A# est la matrice  \verb#V*b.^D*inv(V)#  où \verb#[V,D]=eig(A)#. \\
  
\item {\bf Fonctions de matrices} \\
  On peut appliquer les fonctions numériques internes ({\tt sin,
    sqrt, exp, abs, ...})  énumérées en 2.1 et 2.3 à des
  vecteurs et des matrices.  Elles opèrent alors élément par
  élément.  Les fonctions numériques définies par
  l'utilisateur (cf. section 5) opèrent de même. \\
  
 
\item {\bf Fonctions de manipulations de matrices} \\
  Matlab dispose d'un grand nombre de fonctions intrinsèques sur les
  matrices~: {\tt sum}, {\tt prod}, {\tt max}, {\tt min}, {\tt det},
  {\tt cond}, {\tt inv}, {\tt eig}, {\tt svd}, {\tt lu}, {\tt spy},
  {\tt diag}, {\tt triu}, {\tt tril}, {\tt mean}, {\tt std}... \\

\end{itemize}

\underline{Exemple 1} : Si {\tt a < b } sont deux réels, les composantes du vecteur 
{\tt a+[0:10]/10*(b-a)} constituent une subdivision régulière de 
l'intervalle {\tt [a,b]} de pas {\tt (b-a)}/10 et est équivalent à
{\tt [a:(b-a)/10:b]}.  \\

\underline{Exemple 2} :

  Si on pose {\tt u=[1 4 2 5]} et {\tt v=[3 -1 0 2]} alors \\
  \mbox{ }\hspace{1cm} \verb#u+v# vaut {\tt [4 3 2 7]} \\
  \mbox{ }\hspace{1cm} \verb#u*v'# vaut {\tt [9]} \\ 
  \mbox{ }\hspace{1cm} \verb#u'*v# vaut la matrice carrée $4\times4$ {\tt [v ; 4*v ; 2*v ;5*v]} \\
  \mbox{ }\hspace{1cm} \verb#u*v#, \verb#u^v#, \verb#u^2#, \verb#2^u#  provoquent une erreur  \\
  \mbox{ }\hspace{1cm} \verb#u.*v# vaut {\tt [3 -4 0 10]} \\
  \mbox{ }\hspace{1cm} \verb#u.^v# vaut {\tt [1~0.25~1~25]} \\
  \mbox{ }\hspace{1cm} \verb#u./v# vaut {\tt [0.3333   -4.0000       Inf    2.5000]} avec  un warning \\
  \mbox{ }\hspace{1cm} \verb#u.\v# vaut {\tt [3.0000   -0.2500         0    0.4000]} \\ 
  \mbox{ }\hspace{1cm} \verb#u+2# vaut {\tt [3 6 4 7]} \\
  \mbox{ }\hspace{1cm} \verb#u/2# vaut {\tt [0.5  2  1  2.5]} \\
  \mbox{ }\hspace{1cm} \verb#u.\2#  et \verb#2./u# valent {\tt [2 0.5 1 0.4]} \\
  \mbox{ }\hspace{1cm} \verb#u.^2# vaut {\tt [1 16 4 25]} \\
  \mbox{ }\hspace{1cm} \verb#2.^u# vaut {\tt [2 16 4 32]} \\
  \mbox{ }\hspace{1cm} \verb#sqrt(u)# vaut {\tt [1.0000 2.0000 1.4142 2.2361]} \\
  \mbox{ }\hspace{1cm} \verb#u\2# vaut {\tt [0 ; 0 ; 0; 0.4]} 
  (solution au sens des moindres carrés de {\tt u*x=2})\\
  \mbox{ }\hspace{1cm} \verb#u\v# vaut
  $\left( \begin{array}{cccc}
            0      &      0     &       0    &        0 \\
            0      &      0     &       0    &        0 \\
            0      &      0     &       0    &        0 \\
            0.6    &    -0.2    &       0    &        0.4 \end{array} \right)$ 
        (solution au sens des moindres carrés de {\tt u*x=v})\\ \\


  \underline{Exemple 3} : Si {\tt A=[0 2 ; -1 0]} alors l'opération
  matricielle {\tt A*A} (ou \verb#A^2#) et l'opération terme à terme
  \verb#A.^2# donnent respectivement les matrices

\[
\left(
\begin{array}{cc}
-2 & 0 \\
 0 & -2
\end{array}
\right), \qquad
\left(
\begin{array}{cc}
 0 & 4 \\
 1 & 0
\end{array}
\right) .
\]



\section{Instructions de contr\^ole}

Ce sont les boucles et les branchements. Les boucles permettent de répéter
commodément une suite d'instructions ; le nombre de fois est soit connu 
d'avance (boucles inconditionnelles), soit déterminé 
au cours de l'exécution (boucles conditionnelles). Les branchements 
conditionnels (ou tests) permettent de choisir un traitement parmi plusieurs
possibles en fonction de critères évalués lors de l'exécution.

\subsection{Boucles inconditionnelles}
Leur forme générale est \index{for@\texttt{for}}\\ 
\hspace*{1cm}{\tt for} {\sl k} {\tt =} {\sl val} \\
\hspace*{1cm}~~~{\sl liste d'instructions} \\
\hspace*{1cm}{\tt end} \\
o\`u {\sl k} est une variable et {\sl val} est un {\bf vecteur-ligne}. \\
La {\sl liste d'instructions} est exécutée $m$ fois en donnant 
successivement 
à la variable {\sl k} les valeurs {\sl val\/}(1)$,\dots,$ {\sl val\/}($m$) 
o\`u $m$({\tt =length(val)}) désigne la taille du vecteur {\sl val}. \\ \\
\underline{Exemple} :
si $(x_n)$ est la suite récurrente définie par $x_0=1$ et \index{recurr@récurrence} 
$x_{n+1}=\sin(x_n)$ pour $n\geq 0$, on calcule $x_{10}$ en écrivant

\begin{verbatim}
   x=1;
   for n=1:10
      x=sin(x);
   end
   x
\end{verbatim}
\underline{Boucles imbriquées} : 
ces boucles peuvent être imbriquées comme dans l'exemple ci-dessous
(calcul des 6 premières lignes du triangle de Pascal)
\begin{verbatim}
   A=zeros(6);
   for i=1:6
      A(i,1)=1;
      for j=2:i
         A(i,j)=A(i-1,j-1)+A(i-1,j);
      end
   end
\end{verbatim}
 
\subsection{Boucles conditionnelles}
Elles s'écrivent \index{while@\texttt{while}}\\
\hspace*{1cm}{\tt while} {\sl condition} \\
\hspace*{1cm}~~~{\sl liste d'instructions} \\
\hspace*{1cm}{\tt end} \\
o\`u la {\sl condition} s'exprime à l'aide des opérateurs 
arithmétiques
\[
\begin{array}{lll}
\mbox{{\tt <}~~~(strictement inférieur à)} & \qquad & 
\mbox{{\tt <=}~~(inférieur ou égal à)} \\
\mbox{{\tt >}~~~(strictement supérieur à)} &\qquad &  
\mbox{{\tt >=}~~(supérieur ou égal à)} \\
\verb?~=?~~\mbox{(différent de)}  &\qquad & 
\mbox{{\tt ==}~~(égale)} 
\end{array}
\]
et des opérateurs logiques \index{opérateur logique} \index{logique}
\[
\begin{array}{ccl}
\verb?&? & \quad &  \mbox{ et } \\
\verb?|? & \quad &  \mbox{ ou } \\
\verb?~? & \quad &  \mbox{ non }
\end{array}
\]
A l'exécution, la {\sl liste d'instructions} est répétée aussi
longtemps que la {\sl condition} \index{condition} est satisfaite.
Par exemple, 
\begin{verbatim}
   n=0;
   x=0;
   while ( x <= 0.99 ) & ( x >= -0.99 )
      n=n+1;
      x=sin(n);
   end;
\end{verbatim}
calcule le plus petit entier positif $n$ tel que $| \sin(n) | >0.99$
et la valeur de $\sin(n)$. On peut afficher ces deux nombres avec 
l'instruction \verb?[n,x]? ou \verb?disp([n,x])? .
\\ \\
\underline{Remarque} : Pour écarter le risque de boucle infinie, mieux vaut
écrire\\
\hspace*{1cm}{\tt iter=0;} \\
\hspace*{1cm}{\tt while} {\sl condition} \verb# & ( iter < 1000 )# \\
\hspace*{1cm}~~~{\sl liste d'instructions} \\
\hspace*{1cm}~~~{\tt iter=iter+1;} \\
\hspace*{1cm}{\tt end} \\
Noter que si besoin, on peut interrompre un calcul de \textsc{Matlab} en 
maintenant la touche \fbox{{\sl Ctrl}} \index{\fbox{{\sl Ctrl}}} enfoncée et en tapant la touche C. 
\\ \\
\underline{Remarque} : Les opérandes des opérateurs arithmétiques 
doivent être un couple
de  scalaires ou de matrices de mêmes dimensions. Si {\sl op} est l'un des
6 opérateurs arithmétiques 
et si {\tt A} et {\tt B} sont deux matrices de mêmes 
dimensions, alors {\tt A} {\sl op} {\tt B} est une matrice {\tt C} de mêmes
dimensions que {\tt A} et {\tt B} dont les coefficients sont définis un à
un par {\tt C}$(i,j)=1 \mbox{ ou } 0$ selon que la relation 
{\tt A}$(i,j)$ {\sl op} {\tt B}$(i,j)$ est vraie ou non. \\
Pour \textsc{Matlab} 
la condition {\tt A} {\sl op} {\tt B} est vraie si et seulement si aucun
 coefficient de {\tt C} n'est nul, c'est-à-dire ssi \underline{toutes} les
relations {\tt A}$(i,j)$ {\sl op} {\tt B}$(i,j)$ sont vraies. \\
Les opérateurs logiques permettent de 
 combiner plusieurs  conditions.

\subsection{Branchements conditionnels}
Leur forme générale est \index{if@\texttt{if}} \index{elseif@\texttt{elseif}} \index{else@\texttt{else}}\\
\hspace*{1cm}{\tt if} {\sl condition}\verb?_?{\sl 1} \\
\hspace*{1cm}~~~{\sl liste}\verb?_?{\sl 1 d'instructions} \\
\hspace*{1cm}{\tt elseif} {\sl condition}\verb?_?{\sl 2} \\
\hspace*{1cm}~~~{\sl liste}\verb?_?{\sl 2 d'instructions} \\
\hspace*{1cm}~~~~~~~~~$\vdots$ \\
\hspace*{1cm}{\tt else} \\
\hspace*{1cm}~~~{\sl liste d'instructions} \\
\hspace*{1cm}{\tt end} \\
Le nombre de blocs ~{\tt elseif} {\sl condition}, {\sl liste d'instructions}~
est quelconque (éventuellement nul). De même, la
présence d'un bloc ~{\tt else} {\sl liste d'instructions}~ à la fin est
optionnelle.
\\
Seule la {\sl liste d'instructions} qui suit la première {\sl condition}
évaluée vraie est exécutée (il se peut très bien qu'il n'y en ait 
aucune).
Ensuite, l'exécution se poursuit par l'instruction qui vient immédiatement
après le {\tt end}. \\ \\
\underline{Exemple} : 
 si $a,b,c$ et $d$ sont des variables ayant re\c cu des valeurs 
réelles, le rayon spectral $\rho$ de la matrice 
$\left(\begin{array}{cc} a & b \\ c & d  \end{array} \right)$ peut se
calculer comme suit 
\begin{verbatim}
   delta= (a-d)^2 + 4*b*c;
   if delta <= 0
      rho=sqrt(a*d-b*c)
   else
      rho=( abs(a+d) + sqrt(delta) )/2
   end
\end{verbatim}

\section{Programmation}
\label{programmation}
\subsection{Le mode programmation}
A la différence du mode interactif, les instructions sont tapées
  successivement dans l'ordre d'exécution dans un fichier dont
  l'extension (fin du nom du fichier) est {\tt .m}, par exemple {\tt essai.m},
  et cela se fait en utilisant un éditeur de texte. Pour faire exécuter les
  instructions, il suffit alors de taper le nom du fichier sans l'extension 
  ({\tt essai} dans le cas de l'exemple) 
  dans la fenêtre de commandes. L'avantage de cette fa\c con de travailler est
  qu'en cas d'erreur dans
  l'une des instructions, il n'est pas nécessaire de tout retaper : il suffit
  de corriger l'erreur dans le fichier, de sauvegarder le fichier et de
  relancer la commande.  On désigne un tel fichier du nom de {\bf script}. \index{script}

  \subsection{Comment \textsc{Matlab} retrouve-t'il les scripts ?}

  Quand on lance la commande {\tt essai}, \textsc{Matlab} cherche le fichier 
    {\tt essai.m} dans le répertoire de travail\index{repert@répertoire de travail}. Il faut lui avoir préalablement indiqué le chemin \index{chemin} qui mène à ce répertoire. La procédure est indiquée dans la feuille de TP.
    \\ \\
  Si \textsc{Matlab} ne parvient pas à exécuter un script, il faut 
  d'abord s'assurer que le fichier {\tt .m} correspondant
  existe bien dans le répertoire de travail.

\subsection{Fonctions définies par l'utilisateur}
\label{fonctions}

\index{fonction} \index{sous-programme} Si un même traitement doit être appliqué à divers jeux de
paramètres, on a la possibilité de créer une fonction,
c'est-à-dire un programme qui explicite ce traitement sur des
arguments virtuels (= des noms de variables) et que l'on peut faire
exécuter sur tout ensemble convenable d'arguments
effectifs (= des nombres, des matrices ...). \\ \\
\underline{Attention} : Les lignes d'instructions d'une fonction de
nom {\tt truc} doivent impérativement être enregistrées dans un
fichier
de nom {\tt truc.m} \\ \\
Nous nous contenterons de montrer le principe des fonctions sur un
exemple simple.  Supposons qu'on ait créé un fichier {\tt
  moyenne.m} contenant les lignes
\begin{verbatim}
   function y=moyenne(x)
   % x (argument virtuel) est suppose etre un vecteur
   % y (argument de sortie) doit etre affecte d'une valeur
   y=sum(x)/length(x); 
\end{verbatim}
Alors, l'instruction {\tt mean=moyenne([1 3 -5 2 0])} affecte à {\tt mean}
la valeur $0.2$. \\ 
Une fonction peut avoir plusieurs arguments
de sortie. Pour illustrer ce point,  modifions comme suit le fichier 
{\tt moyenne.m}
\begin{verbatim}
   function [moy,etyp]=moyenne(x)
   % x (argument viruel) est suppose etre un vecteur
   % moy et etyp (arguments de sortie) doivent etre affectes
   m=length(x);
   % m est une variable locale donc inconnue a l'exterieur de cette fonction
   moy=sum(x)/m; 
   etyp=sqrt( sum(x.^2)/m - moy^2 );
\end{verbatim}
L'instruction  
{\tt [m e]=moyenne([1 3 -5 2 0])} affecte alors simultanément
à {\tt m} la valeur moyenne $0.2$ et à {\tt e} l'écart-type $2.7856\dots$
des nombres $1,3,-5,2,0$. Il est à noter que l'instruction 
{\tt mean=moyenne([1 3 -5 2 0])} affecte comme précédemment la valeur 
$0.2$  ({\sl i.e.} le premier argument de sortie) à {\tt mean}.\\ \\

\subsection{Recommandations}
\begin{enumerate}
  \item Ecrire une seule instruction par ligne. 
  \item Eviter de donner à un
  script le nom d'une fonction \textsc{Matlab}. Sinon, ce fichier 
  d'instructions remplacera la fonction \textsc{Matlab} pour la suite
  de la session de travail.
  \item Mettre des commentaires et sauter des lignes
  blanches pour faire bien ressortir la structure du programme. Les lignes de 
  commentaires commencent par le caractère {\tt \%}. \index{\%@{\tt \%}}
  \item Une instruction trop longue pour tenir sur une seule 
  ligne peut se continuer sur une nouvelle ligne (ou plusieurs) : il suffit 
  de taper  $\cdots$ (trois points consécutifs sans rien derrière) \index{$\cdots$} à la fin d'une ligne pour indiquer que l'instruction se poursuit sur la 
  ligne suivante.
\end{enumerate}

\section{Résolution approchée d'une équation différentielle du premier ordre}

\subsection{Principe}

Une équation différentielle du premier ordre s'écrit sous la forme $y'=F(t,y)$ où $t$ est le temps, $t\mapsto y(t)$ la fonction inconnue, $F$ une fonction de deux variables.
\\ \\
\underline{Exemples}. Dans l'équation $y'=ty$, $F(t,y)=ty$. Dans l'équation $y'=-2y+1$, $F(t,y)=-2y+1$ ne dépend pas de $t$. Dans l'équation $y'=\sin t$, $F(t,y)=\sin t$ ne dépend pas de $y$. 

\subsection{Mode d'emploi des solveurs de Matlab}

Il s'agit de résoudre l'équation différentielle $y'=F(t,y)$. On commence par programmer la fonction $F$ dans un fichier \texttt{F.m}.\\ \index{equation@équation différentielle}

Si, dans la fenêtre de commande, on tape \verb#[t  y]=ode45(@F,[t0 tfinal],y0)#, Matlab retourne un vecteur \emph{colonne} $t$, subdivision de l'intervalle $[\texttt{t0},\texttt{tfinal}]$, et un vecteur \emph{colonne} $y$ contenant les valeurs aux points de $t$ d'une solution approchée de $(\mathcal{E})$ sur l'intervalle $[\texttt{t0},\texttt{tfin}]$ de condition initiale $y(\texttt{t0})=\texttt{y0}$. \\ \\ \index{ode@\verb#ode45#}

\underline{Exemple}. Résoudre $y'=ty$ sur l'intervalle $[0,3]$ avec comme condition initiale $y(0)=1$.\\

On programme la fonction $F(t,y)=ty$ dans un fichier \verb#F.m#,
\begin{verbatim}
function z=F(t,y)
z=t*y;
\end{verbatim}
Puis on programme la résolution de l'équation différentielle, on trace la courbe représentative de la fonction obtenue, ou on récupère la valeur approchée de la solution en $t=1.645$.

\verb#[t y]=ode45(@F,[0 3],1);#\hfill \verb#sol=ode45(@F,[0 3],1);#\\
\verb#plot(t,y)#\hfill\verb#s=deval(sol,1.645);#\\

\medskip
\underline{Exemple}. Résoudre le système différentiel $y'=ty$ sur l'intervalle $[0,3]$ avec comme condition initiale $y'_1=-ty_2$, $y'_2=y_1$ sur l'intervalle $[0,3]$ avec comme conditions initiales $y_1 (0)=0$, $y_2 (0)=1$.\\

On programme la fonction vectorielle $F(t,y_1 ,y_2)=(-ty_2,y_1)$,
\begin{verbatim}
function v=F(t,y)
z(1)=-t*y(2);
z(2)=y(1);
v=z';
\end{verbatim}
Remarquer le $v=z'$ qui fait de $F(t,y)$ un vecteur colonne. Puis on résoud le système, et on représente les deux fonctions $t\mapsto y_1 (t)$ et $t\mapsto y_2 (t)$, ou bien la courbe paramétrée $t\mapsto y(t)=(y_1 (t),y_2 (t))$.\\ \index{courbe paramétrée}
\verb#[t y]=ode45(@F,[0 3],[0 1])#\hfill\verb#[t y]=ode45(@F,[0 3],[0 1])#\\
\verb#plot(y)#\hfill\verb#plot(y(:,1),y(:,2))#

\printindex

\end{document}

