% cours3tex (gH) : Courbes et Interpolation
%
\documentclass[a4paper,12pt]{article}
%
\usepackage{maple2e}
%
\parskip    0.35cm
\parindent  0.00cm
%
\renewcommand{\thesection}{\arabic{section}. }
\renewcommand{\thesubsection}{\arabic{section}.\arabic{subsection}}
%
\def\C{\mbox{l\hspace{-0.43em}C}}
\def\Maple{\textit{Maple}}
\def\L{\ensuremath{\mathcal{L}}}
\def\dz{\texttt{\symbol{'043}}}      % di\`{e}se
%
% pour une matrice 2x2
%
\newcommand{\mat}[4]{\ensuremath{%
\left(\begin{tabular}{cc}%
#1&#2\\#3&#4\\\end{tabular}\right)}
}% fin de definition de \mat
%
% pour simuler une entr\'{e}e (ligne) Maple
%
\newcommand{\mapleIn}[1]{\textsf{
\begin{tabular}{ll}
 $ > $ &#1
\end{tabular}
}}
%
% pour simuler une sortee (ligne) Maple
%
\newcommand{\mapleOut}[1]{\texttt{
\begin{tabular}{ll}
 \hspace{1.3cm} & #1
\end{tabular}
}}
%
% une entr\'{e}e et une sortie pour Maple longue
%
\newcommand{\mapleInt}[1]{\textsf{#1}}
\newcommand{\mapleOutLong}[1]{\texttt{#1}}
%
% des macros "locales" au sujet
%
\def\sl{$sl(2,\C)$}
\def\slm{\textit{sl}-matrix}
\def\slms{\textit{sl}-matrices}
\newcommand{\sym}[1]{$Sym^{#1}(\C^ 2)$}
%
%
\begin{document}
%
\title{3. Courbes et Interpolation}
\author{Gilles Hunault}
\date{}
\maketitle
%\tableofcontents
%
\section{Rappels} % ##
%
Nous vons vu la semaine derni\`{e}re la structure "suite d'expression"
et ses deux structures  d\'{e}riv\'{e}es, les listes et les ensembles.
Leur nombre d'\'{e}l\'{e}ment est donn\'{e} par op et on acc\`{e}de
aux \'{e}l\'{e}ments $S$ par $S[i]$ ou $op(S,i)$ o\`{u} $S$  est la structure et $i$ le num\'{e}ro
de l'objet. On se m\'{e}fiera de la fonction $length$ qui ne renvoie pas ce
qu'on pense !

Ainsi, pour  inverser une liste L sur elle-m\^{e}me on peut \'{e}crire\footnote{
Il ya de meilleures solutions  avec map..., reverse...
}~:~

\mapleIn{L := [\$1..10] ; n := nops(L) ; L := [seq(L[n+1-i],i=1..n)] ; length(L) ;}

\mapleOut{L := [1, \,2, \,3, \,4, \,5, \,6, \,7, \,8, \,9, \,10]}

\mapleOut{n := 10}

\mapleOut{L := [10, \,9, \,8, \,7, \,6, \,5, \,4, \,3, \,2, \,1]}

\mapleOut{24}

\mapleIn{S := \{\$1..10\} ; n := nops([S]) ; op(4,S)}

\mapleOut{S := \{1, \,2, \,3, \,4, \,5, \,6, \,7, \,8, \,9, \,10\}}

\mapleOut{n := 1}

\mapleOut{4}

Nous avons aussi vu des structures de programme : le test en si $if$,
la boucle pour $for$ et la boucle tant que $while$.
Nous redonnons ici la syntaxe de ces structures sur des exemples.

\mapleIn{\# On veut \'{e}crire si le nombre x est positif ou n\'{e}gatif :}

\mapleIn{if  x$>$0 then print(`nombre
positif`)else print(` nombre inf\'{e}rieur ou \'{e}gal \`{a} 0 `) : fi :}

On veut afficher les nombres de 1 \`{a} 28  par pas de 3 :

\mapleIn{nb := 1 : for i from 1 to 10 do : print(nb) :
nb := nb + 3 : od :}

\mapleOutLong{
\begin{tabular}{lr}
 \hspace{1.3cm} & 1 \\
                & 4 \\
                & 7 \\
                & ... \\
                & 28
\end{tabular}
}

On veut connaitre le premier nombre entier dont le carr\'{e} est sup\'{e}rieur
\`{a} 1000 ainsi que son carr\'{e} :

\mapleIn{i := 1 : while i*i$<$ 1000 do : i := i +1 : od
: i:= i-1 : i,i*i,(i+1),(i+1)**2 ;  }


\mapleOut{31, \,961, \,32, \,1024}


Remarquons que $solve$ pourrait nous aider, mais moins simplement :

\mapleIn{x := 'x' : solve(x*x$>$1000,\{x\}) ;}

\mapleOut{$\{x <  - 10\,\sqrt{10}\}, \,\{10\,\sqrt{10} < x\}$}

Passons maintenant \`{a} un algorithme classique : celui du calcul de la
racine carr\'{e}e d'un nombre $a$ comme limite de la suite de $Newton$
$u_n$ d\'{e}finie par une valeur $u_0$ et la relation de r\'{e}currence
$u_n=(u_n+a/u_n)/2$. On utilise comme crit\`{e}re d'arr\^{e}t la valeur absolue
de la diff\'{e}rence entre deux termes cons\'{e}cutifs (disons limit\'{e}e \`{a} $10^{-6}$).
\newpage
\mapleIn{Un := 2.0 : UnPrecedent := 0 : nbtour := 0:}

\mapleIn{to 20 while abs(Un-UnPrecedent)$>$10**(-8) do :}

\mapleIn{\hspace{0.5cm} UnPrecedent := Un : Un := (Un/2) + 1/Un :}

\mapleIn{\hspace{0.5cm} nbtour := nbtour + 1 : lprint(nbtour,Un) :}

\mapleIn{od : }

\begin{maplettyout}
      1   1.500000000
      2   1.416666667
      3   1.414215686
      4   1.414213562
      5   1.414213562
\end{maplettyout}

%
\section{Compl\'{e}ments sur les expressions} % ##
%
\Maple\ g\`{e}re les expressions par des arbres d'expressions. Ainsi
$sin(2*x+a)+b$ a 2 op\'{e}randes, $sin(2x+a)$ et $b$. L'op\'{e}rande
num\'{e}ro $i$ est obtenu par $op(i,S)$ o\`{u} $S$ est la structure consid\'{e}r\'{e}e.
A titre d'exemple, on pourra s'amuser \`{a} d\'{e}tailler les instructions
suivantes :


\mapleIn{f := x**2*exp(3/2)*sin(Pi/3-1/x) ;}

\mapleOut{$f := x^{2}\,e^{(3/2)}\,{\rm sin}({\displaystyle \frac {1}{3}} \,
\pi  - {\displaystyle \frac {1}{x}} $)}

\mapleIn{nops(f),[op(f) ],length(f),op(3,f) ; }

\mapleOut{$
3, \,[x^{2}, \,e^{(3/2)}, \,{\rm sin}({\displaystyle \frac {1}{3}
} \,\pi  - {\displaystyle \frac {1}{x}} )], \,50, \,{\rm sin}(
{\displaystyle \frac {1}{3}} \,\pi  - {\displaystyle \frac {1}{x}
} )$}

\mapleIn{op(1,op(op(3,f))) ;}

\mapleOut{${\displaystyle \frac {1}{3}} \,\pi$}

On peut agir sur les op\'{e}randes via $subsop$ (et non pas $subs$) qui requiert
\`{a} gauche de la relation de subsitution le num\'{e}ro de l'op\'{e}rande :

\mapleIn{subsop(3=cos(x),f) ;}

\mapleOut{$x^{2}\,e^{(3/2)}\,{\rm cos}(x)$}

\mapleIn{f ;}

\mapleOut{$x^{2}\,e^{(3/2)}\,{\rm sin}({\displaystyle \frac {1}{3}} \,\pi
 - {\displaystyle \frac {1}{x}} )$}

Il est alors ais\'{e} de fournir
une explication pour la non-substitution suivante :

\mapleIn{subs(n=2,1+n) ; subs(a+b=2,1+a+b) ; }

\mapleOut{ 3 ; 1+a+b}

\Maple\ est ici incapable de voir la chaine $a+b$ comme il voit la chaine
(r\'{e}duite \`{a} un seul caract\`{e}re) $n$ car elle est stock\'{e}e comme l'arbre (a,`+`,b).
Pour forcer \Maple\ \`{a} substituer, il faut ici recourir \`{a} un parcours entier
de l'arbre (couteux en temps) via :

\mapleIn{simplify(1+a+b,\{a+b=2\}) ;}

On notera au passage l'inversion de l'ordre des param\`{e}tres : on
dit $subs(rel,expr)$ mais $simplify(expr,rel)$, ce qu'on peut m\'{e}moriser
par les phrases "on substitue $rem$ dans $expr$" et "on simplifie $expr$
sachant que $rel$").

%
\section{Trac\'{e} de courbes} % ##
%
Un trac\'{e} de courbe est en math\'{e}matiques l'aboutissement de l'\'{e}tude
d'une fonction, \'{e}tude qui commence par la recherche du domaine de d\'{e}finition,
l'\'{e}tude de $f$ aux bornes de ce domaine et qui se poursuit par la recherche
du domaine de continuit\'{e}, de d\'{e}rivabilit\'{e}... En \Maple, on peut se contenter
de taper $plot(sin) ;$ pour tracer la fonction $sinus$. Tout est
(heureusement ou malheureusement ?) automatique : la plage de variation de
x, l'\'{e}tendue pour y, le nombre de points de trac\'{e}...

Il est bien s\^{u}r possible de d\'{e}finir soi-m\^{e}me ces valeurs, soit
par une expression comme

\mapleIn{plot(sin(t),t=-Pi..Pi,y=-2..2,style=point,}

\mapleIn{xtickmarks=7, ytickmarks=5, color=blue, title=`un BOSINUS`) :}

Le trac\'{e} \'{e}l\'{e}mentaire des deux fonctions $f$ et $g$ en m\^{e}me temps est donn\'{e}
par $plot(\{f,g\})$, le trac\'{e} d'une liste de points est donn\'{e} par
$plot([\ seq([u(i),v(i)]\ ])$.
\newpage
Le trac\'{e} param\'{e}trique de $f$ et $g$ est fourni
par $plot([f(t),g(t),t=...])$ alors que
 $plot([f(t),g(t)],t=...)$ ne fait que tracer
les courbes ensemble.  Un trac\'{e} en polaires se fait par
$plot(\rho,\theta,coords=polar)$.

Plus int\'{e}ressant, on peut stocker les objets que sont les courbes. Ainsi

\mapleInt{
\begin{tabular}{ll}
\hspace{0.9cm} & ddt := t = -0.5..Pi ; \\
 & p1 := plot(sint(t),ddt) ;\\
 & p2 := plot(t-t**3/3!,ddt) ; \\
 & plots$[$display$]$(\{p1,p2\}) ;
\end{tabular}
}

trace la fonction et son premier jet (c'est \`{a} dire la partie r\'{e}guli\`{e}re de
son d\'{e}veloppement limit\'{e} \`{a} l'ordre 1) sur un m\^{e}me graphe, via
la fonctin $display$ du "package" $plots$.

Si on veut illustrer la convergence de la somme de ces $d.l.$
vers $sinus$, on pourra utiliser :
\begin{verbatim}
plot( {sin(x),seq( convert(series(sin(x),x,i),polynom),i=1..10)},
       x=-0.5..3*Pi, y=-5..10,color=blue) ;
\end{verbatim}
%
\section{Interpolation} % ##
%
L'interpolation polynomiale de n points $(x_i,y_i)$, $i$ de 1 \`{a} $n$
consiste \`{a} trouver un polynome de degr\'{e} minimal qui passe par ces points.
Prenons par exemple les points $(3,28)$, $(4,40)$ et $(5,54)$. La m\'{e}thode de
\textbf{Lagrange} consiste \`{a} chercher le polynome  solution $P$\footnote{~ou
plutot la fonction poynomiale d\'{e}finie en $x$ par $P(x)$} sous la forme
$P(x)=\displaystyle \sum_{i=1}^n\ y_i.L_i(x)$ o\`{u} $L_i(x)$ vaut 1 pour $x=x_i$ et
0 pour $x=x_j$ avec $j\neq i$. Par exemple ici $L_1(x)$ peut \^{e}tre construit
par $L_1(x)=\displaystyle \frac{(x-4)}{(3-4)}.\frac{(x-5)}{(3-5)}$. L'expression math\'{e}matique globale pour $P(x)$ est donc

$$P(x)=\sum_{i=1}^n\ y_i.\left(\displaystyle \Pi_{j=1,n\ et j\neq i}^n
\frac{(x-x_j)}{(x_i-x_j)}\right)$$
\newpage
Si on veut demander \`{a} \Maple\ de trouver ce polynome, plusieurs m\'{e}thodes sont
possibles. Pour 3 points, on cherche un polynome de degr\'{e} deux~;~on peut donc
 essayer de r\'{e}soudre en $a,b,c$ les \'{e}quations $f(x_i)=y_i$ prenant pour
d\'{e}finition de $f$ la relation fonctionelle $f(x)=ax^2+bc+x$, soit :

\begin{verbatim}
     n   := 3 : x := [3,4,5] : y :=[28,40,50] :
     f   := t->a*t*t+b*t+c :
     equ := seq(y[i]=f(x[i]),i=1..n) ;
     pdt := subs(solve(equ,{a,b,c}),f(t))  ;
     P   := x-> subs(t=x,pdt) ;
\end{verbatim}

\Maple\ sait bien s\^{u}r effectuer directement une telle interpolation par
\begin{verbatim}
     pdt := interp([3,4,5],[28,40,54],t) ;
     P := x->subs(t=x,pdt) :
\end{verbatim}
%
Pour effectuer formellement le calcul de $P(x)$ avec le calcul explicite
de polynomes $L_i$, on peut \'{e}crire deux boucles imbriqu\'{e}es.

On \'{e}crira donc

\begin{verbatim}
     pdt := 0 :
     for i from 1 to n do :
         L_i_X := 1 ;
         for j from 1 to n do :
         if j<>i then
            L_i_X := L_i_X * (X-x[j])/(x[i]-x[j]) ;
         fi :
         od :
         pdt := pdt + y[i]*L_i_X ;
     od :
     P := x->subs(t=x,pdt) :
\end{verbatim}
%
\newpage
\section{Utilisation de solve} % ##
%
%
\end{document}
