\documentclass{article}
%\oddsidemargin 5 mm
%\evensidemargin 5 mm
%\textwidth 16cm
\usepackage{graphicx}
\usepackage[francais]{babel}
\usepackage[T1]{fontenc}
\usepackage{amsmath}
\usepackage{amsfonts}
\usepackage{latexsym}
\usepackage{amssymb}
\usepackage{times}
\usepackage{ifpdf}
\usepackage{makeidx}
\ifpdf
 \usepackage[pdftex,colorlinks]{hyperref}
\else
 \usepackage[ps2pdf,breaklinks=true,colorlinks=true,linkcolor=red,citecolor=green]{hyperref}
 \fi

\newtheorem{rem}{Remarque}
\newcommand{\R}{{\mathbb{R}}}
\newcommand{\C}{{\mathbb{C}}}
\newcommand{\Z}{{\mathbb{Z}}}
\newcommand{\N}{{\mathbb{N}}}
\newcommand{\faux}{$\square\;$}
\newcommand{\vrai}{$\square\;$}
%\newcommand{\vrai}{$\boxtimes\;$}
\newcommand{\itemf}{\item\faux}
\newcommand{\itemv}{\item\vrai}

\newtheorem{exo}{Exercice}[section]


\begin{document}

\noindent L2- mat231 \hfill TP de maths \hfill 2009/10\\
Ce document propose un petit guide de référence de Xcas, puis des énoncés de TP
pour 6 séances de 1h30~:
\begin{enumerate}
\item TP1: apprentissage de xcas
\item TP2: \'ecriture
sous forme matricielle des problemes d'algebre lineaire)
\item TP3,4: programmation du pivot de Gauss
et applications: inverse, base du noyau/de l'image,
\item TP5: polynome minimal et recherche des espaces propres
\item TP6: codes correcteurs (peut etre donné sous forme de mini-projets?)
\end{enumerate}

\section{Premiers pas avec Xcas}
Pour t\'el\'echarger Xcas, allez sur le site\\
\verb|http://www-fourier.ujf-grenoble.fr/~parisse/install_fr.html|\\
Pour traiter les exemples, il est conseill\'e d'ouvrir Xcas~:
\begin{itemize}
\item Sous Windows en installation locale, 
on clique sur l'icone \verb|xcasfr| du bureau.
\item Sous Linux avec Gnome, on clique sur Xcas du menu
Education. Sinon, ouvrir un terminal et taper \verb|xcas &|.
\item sur Mac, cliquez sur Xcas dans le menu Applications du Finder.
\end{itemize}
Lors de la
premi\`ere utilisation, choisissez {\tt Xcas} lorsqu'on vous demande
de choisir une syntaxe (sauf si vous connaissez le langage Maple).
Nous donnons ici seulement le minimum de l'interface \`a connaitre
pour commencer \`a programmer. On consultera plutot 
le manuel D\'ebuter en calcul formel ou les 
autres manuels (menu Aide) pour apprendre
\`a utiliser les fonctionnalit\'es de Xcas en calcul formel, g\'eom\'etrie,
tableur, etc..

L'interface appara\^\i t comme suit au lancement de {\tt Xcas}.
\vskip 2mm
\centerline{
\includegraphics[width=\textwidth]{demarr1}
}
Vous pouvez la redimensionner. De haut en bas cette interface
fait appara\^\i tre~:
\begin{itemize}
\item[$\bullet$]
un barre de menu gris cliquable~: \verb@Fich@, \verb@Edit@,
\verb@Cfg@, \verb@Aide@, \verb@CAS@,
\verb@Tableur@, \verb@Graphe@, \verb@Geo@,\ldots
\index{menus}
\item[$\bullet$]
un onglet indiquant le nom de la session, ou {\tt Unnamed} 
si la session n'a pas encore \'et\'e sauvegard\'ee,
\item[$\bullet$]
une zone de gestion de la session avec un bouton \verb|?| 
pour ouvrir l'index de l'aide
un bouton \verb@Save@ pour sauvegarder la session, 
un bouton \verb@Config: exact real ...@ affichant la configuration 
et permettant de la modifier,
un bouton \verb|STOP| permettant d'interrompre un calcul trop long,
un bouton \verb|Kbd| pour faire apparaitre un clavier ressemblant \`a celui d'une calculatrice, 
qui peut faciliter vos saisies, et un bouton \verb|x| pour fermer la session
\item[$\bullet$]
une zone rectangulaire blanche num\'erot\'ee 1 (premi\`ere ligne
de commande) dans laquelle vous pouvez taper
votre premi\`ere commande (cliquez si n\'ecessaire pour faire
apparaitre le curseur dans
cette ligne de commande)~: \verb@1+1@, suivi de la touche
"Entr\'ee" ("Enter" ou "Return" selon les claviers).
Le r\'esultat appara\^it au-dessous, et une nouvelle ligne de commande
s'ouvre, num\'erot\'ee 2. 
\end{itemize}
Vous pouvez modifier l'aspect de l'interface et sauvegarder vos
modifications pour les utilisations futures (menu \verb@Cfg@).
\vskip 2mm
Vous n'avez pour l'instant qu'\`a
entrer des commandes dans les lignes de commandes successives. 
Si vous utilisez la
version html de ce cours, vous pouvez copier-coller les commandes
propos\'ees depuis votre navigateur. 
Chaque ligne de commande saisie est ex\'ecut\'ee par la
touche "Entr\'ee". Essayez par exemple d'ex\'ecuter les
commandes suivantes.
\begin{verbatim}
1/3+1/4
sqrt(2)^5
resoudre(x+3=1,x)
50!
\end{verbatim}
Toutes les commandes sont gard\'ees en m\'emoire.
Vous pouvez donc remonter dans l'historique de votre session pour 
modifier des commandes ant\'erieures. Essayez par exemple de changer
les commandes pr\'ec\'edentes en~:
\begin{verbatim}
1/3+3/4
sqrt(5)^2
resoudre(2*x+3=0)
500!
\end{verbatim}

Notez que 
\begin{itemize}
\item pour effacer une ligne de commande, 
on clique dans le num\'ero de niveau
\`a gauche de la ligne de commande, qui apparait alors en surbrillance.
On appuie ensuite sur la touche d'effacement. On peut aussi d\'eplacer
une ligne de commande avec la souris.
\item 
Le menu \verb@Edit@ vous permet de pr\'eparer des sessions plus
\'elabor\'ees qu'une simple succession de commandes. Vous pouvez
cr\'eer des groupes de lignes de commandes (sections), 
ajouter des commentaires ou fusionner des niveaux en un seul niveau.
\item
Le menu \verb|Prg| contient la plupart des instructions utiles
pour programmer.
\end{itemize}

\section{Les objets du calcul formel}
%
\subsection{Les nombres}
%
\index{nombre!exact}
\index{nombre!approch\'e}
Les nombres peuvent \^etre exacts ou approch\'es.
Les nombres exacts sont les constantes pr\'ed\'efinies, les entiers, 
les fractions d'entiers et plus g\'en\'eralement toute  expression 
ne contenant que des entiers et des constantes, comme 
\verb|sqrt(2)*e^(i*pi/3)|.
Les nombres approch\'es sont not\'es avec la notation scientifique 
standard~: partie enti\`ere suivie du point de s\'eparation 
et partie fractionnaire (\'eventuellement
suivie de \verb|e| et d'un exposant).
Par exemple, \verb@2@ est un entier exact, 
\verb@2.0@ est la version approch\'ee du m\^eme
entier; \verb@1/2@ est un  rationnel, \verb@0.5@ 
est la version approch\'ee du m\^eme
rationnel.
{\tt Xcas} peut g\'erer des nombres entiers en pr\'ecision arbitraire~: 
essayez de taper \verb@500!@ et comptez le nombre de chiffres 
de la r\'eponse.

On passe d'une valeur exacte \`a une valeur approch\'ee par
\verb@evalf@, on transforme une valeur approch\'ee en un rationnel
exact par \verb@exact@
\index{exact@{\verb+exact+}}
\index{evalf@{\verb+evalf+}}
Les calculs sont effectu\'es en mode exact si tous les nombres qui
interviennent sont exacts. Ils sont effectu\'es en mode approch\'e si
un des nombres est approch\'e. Ainsi
\verb@1.5+1@ renvoie un nombre approch\'e alors que \verb@3/2+1@ 
renvoie un nombre exact.
\begin{verbatim}
sqrt(2)
evalf(sqrt(2))
sqrt(2)-evalf(sqrt(2))
exact(evalf(sqrt(2)))*10^9
exact(evalf(sqrt(2)*10^9))
\end{verbatim} 
\index{sqrt@{\verb+sqrt+}}
\index{precision@pr\'ecision}
Pour les nombres r\'eels approch\'es, la pr\'ecision par d\'efaut est
proche de 14 chiffres significatifs (la pr\'ecision relative est de 53
ou 45 bits pour les r\'eels flottants normalis\'es selon les versions de Xcas). 
Elle peut \^etre augment\'ee, en
donnant le nombre de d\'ecimales d\'esir\'e
comme second argument de \verb@evalf@.
\begin{verbatim}
evalf(sqrt(2),50)
evalf(pi,100)
\end{verbatim}
On peut aussi changer la pr\'ecision par d\'efaut pour tous les
calculs en modifiant
\index{digits@{\verb+Digits+}}
la variable \verb@Digits@.
\begin{verbatim}
Digits:=50
evalf(pi)
evalf(exp(pi*sqrt(163)))
\end{verbatim}

\index{i@{\verb+i+}}
La lettre \verb@i@ est r\'eserv\'ee \`a $\sqrt{-1}$ et ne peut \^etre
r\'eaffect\'ee~; en particulier on ne peut pas l'utiliser comme indice
de boucle.
\begin{verbatim}
(1+2*i)^2
(1+2*i)/(1-2*i)
e^(i*pi/3)
\end{verbatim}
\index{nombre!complexe}
\index{infinity@{\verb+infinity+}}
{\tt Xcas} distingue l'infini non sign\'e \verb@infinity@ ($\infty$), de
\verb@+infinity@ ($+\infty$) et de \verb@-infinity@ ($-\infty$).
\begin{verbatim}
1/0; (1/0)^2; -(1/0)^2 
\end{verbatim}
\vskip 2mm
\begin{center}
\begin{tabular}{|ll|}
\hline
\multicolumn{2}{|c|}{\bf Constantes pr\'ed\'efinies}\\
\hline\hline
\verb@pi@&$\pi\simeq 3.14159265359$ \\
\verb@e@&$e\simeq 2.71828182846$  \\
\verb@i@&$i=\sqrt{-1}$  \\
\verb@infinity@&$\infty$  \\
\verb@+infinity@&$+\infty$  \\
\verb@-infinity@&$-\infty$  \\
\hline
\end{tabular}
\end{center}
\index{e@{\verb+e+}}
\index{pi@{\verb+pi+}}
%
\subsection{Les caract\`eres et les cha\^{i}nes}
%
\index{caract\`ere}
\index{cha\^{i}ne}
Une cha\^{i}ne est parenth\'es\'ee par des guillemets ({\tt "}).
Un caract\`ere est une cha\^{i}ne ayant un seul \'el\'ement.
\begin{verbatim}
s:="azertyuiop"
size(s)
s[0]+s[3]+s[size(s)-1]
concat(s[0],concat(s[3],s[size(s)-1]))
head(s)
tail(s)
mid(s,3,2)
l:=asc(s)
ss:=char(l)
string(123)
expr(123)
expr(0123)
\end{verbatim}
\vskip 2mm
\begin{center}
\begin{tabular}{|ll|}
\hline
\multicolumn{2}{|c|}{\bf Cha\^{i}nes}\\
\hline\hline
\verb@asc@&cha\^{i}ne->liste des codes ASCII \\
\verb@char@&liste des codes ASCII->cha\^{i}ne \\
\verb@size@&nombre de caract\`eres \\
\verb@concat@ ou \verb@+@ &concat\'enation  \\
\verb@mid@&morceau de cha\^{i}ne\\
\verb@head@&premier caract\`ere  \\
\verb@tail@&cha\^{i}ne sans le 1ier caract\`ere\\
\verb@string@&nombre ou expression->cha\^{i}ne  \\
\verb@expr@&cha\^{i}ne->nombre (base 10 ou 8) ou expression  \\
\hline
\end{tabular}
\end{center}%
\subsection{Les variables}
%
\index{variable!formelle}
\index{variable!affect\'ee}
On dit qu'une variable est formelle si elle ne contient aucune valeur~: 
toutes les variables sont formelles tant qu'elles n'ont pas \'et\'e
affect\'ees (\`a une valeur).
\index{affectation}
L'affectation est not\'ee \verb@:=@. Au d\'ebut 
de la session  \verb@a@ 
est formelle, elle devient affect\'ee apr\`es l'instruction 
\verb@a:=3@, \verb|a| sera alors remplac\'e par 3 dans tous
les calculs qui suivent, et \verb|a+1| renverra 4. 
{\tt Xcas} conserve tout le contenu de votre session. Si vous voulez que la variable 
\verb@a@ apr\`es l'avoir affect\'ee, soit \`a nouveau une variable formelle, il
faut la "vider" par \verb@purge(a)@. Dans les exemples qui suivent, les 
variables utilis\'ees sont suppos\'ees avoir \'et\'e purg\'ees avant chaque
suite de commandes.
\index{purge@{\verb+purge+}}  
\vskip 2mm\noindent
Il ne faut pas confondre
\begin{itemize}
\item[$\bullet$] le signe \verb|:=| qui d\'esigne l'affectation
\item[$\bullet$] le signe \verb|==| qui d\'esigne une \'egalit\'e
  bool\'eenne~: c'est une op\'eration binaire qui retourne 1 ou 0 (1 pour true
qui veut dire Vrai et 0 pour false qui veut dire Faux) 
\item[$\bullet$] le signe \verb|=| utilis\'e pour d\'efinir une \'equation.
\end{itemize}
\index{egalite@\'egalit\'e}
\index{equation@\'equation}
\begin{verbatim}
a==b
a:=b
a==b
solve(a=b,a)
solve(2*a=b+1,a)
\end{verbatim}
\index{assume@{\verb+assume+}}
\index{hypoth\`ese}
On peut faire certains types d'hypoth\`eses sur une variable avec
la commande \verb|assume|, par exemple \verb|assume(a>2)|. Une
hypoth\`ese est une forme sp\'eciale d'affectation, elle efface
une \'eventuelle valeur pr\'ec\'edemment affect\'ee \`a la variable.
Lors d'un calcul, la variable n'est pas remplac\'ee mais
l'hypoth\`ese sera utilis\'ee dans la mesure du possible, par exemple
\verb|abs(a)| renverra \verb|a| si on fait l'hypoth\`ese \verb@a>2@.
\begin{verbatim}
sqrt(a^2)
assume(a<0)
sqrt(a^2)
assume(n,integer)
sin(n*pi)
\end{verbatim}
\index{subst@{\verb+subst+}}
La fonction \verb@subst@ permet de remplacer une variable dans une
expression par un nombre ou une autre expression, 
sans affecter cette variable.
\begin{verbatim}
subst(a^2+1,a=1)
subst(a^2+1,a=sqrt(b-1))
a^2+1
\end{verbatim} 

{\bf Remarque}~: pour stocker une valeur dans une variable par r\'ef\'erence,
par exemple pour modifier une valeur dans une liste (un vecteur, une
matrice), sans recr\'eer une nouvelle liste mais en modifiant
en place la liste existante, on utilise l'instruction \verb|=<|
au lieu de \verb|:=|.
Cette instruction est plus rapide que l'instruction \verb|:=|, car
elle \'economise le temps de copie de la liste.
%
\subsection{Les expressions}
%
\subsubsection{D\'efinition}
\index{expression}
Une expression est une combinaison de nombres et de variables
reli\'es entre eux par des op\'erations~: par exemple 
\verb@x^2+2*x+c@. 

Lorsqu'on valide une commande, {\tt Xcas}
remplace les variables par leur valeur si elles en ont une,
et ex\'ecute les op\'erations. 
\begin{verbatim}
(a-2)*x^2+a*x+1
a:=2
(a-2)*x^2+a*x+1
\end{verbatim}
\index{simplifications automatiques}
Certaines op\'erations de simplification sont ex\'ecut\'ees
automatiquement lors d'une \'evaluation~:
\begin{itemize}
\item[$\bullet$] les op\'erations sur les entiers et sur les 
fractions, y compris la mise
sous forme irr\'eductible
\item[$\bullet$] les simplifications triviales comme $x+0=x$,
$x-x=0$, $x^1=x$\ldots
\item[$\bullet$] quelques formes trigonom\'etriques~: 
$\cos(-x)=\cos(x)$, 
$\cos(\pi/4)=\sqrt{2}/2$,
$\tan(\pi/4)=1$\ldots
\end{itemize}
Nous verrons dans la section \ref{sec:simplify} 
comment obtenir plus de simplifications.

\subsubsection{D\'evelopper et simplifier une expression} \label{sec:simplify}
%
\index{developper@d\'evelopper}
\index{simplifier@simplifier}
En-dehors des r\`egles de la section pr\'ec\'edente,
il n'y a pas de simplification syst\'ematique. 
Il y a deux raisons \`a cela. La premi\`ere est que les 
simplifications non triviales sont parfois
co\^uteuses en temps, et le choix d'en faire ou non est laiss\'e 
\`a l'utilisateur~;
la deuxi\`eme est qu'il y a en g\'en\'eral plusieurs mani\`eres de
simplifier une m\^eme expression, selon l'usage que l'on veut en
faire. 
Les principales commandes pour transformer une expression 
sont les suivantes~:
\begin{itemize}
\item[$\bullet$]
\index{expand@{\verb+expand+}}
\verb|expand|~: d\'eveloppe une expression en tenant compte 
uniquement de la distributivit\'e de la multiplication sur l'addition et
du d\'eveloppement des puissances enti\`eres.
\item[$\bullet$]
\index{normal@{\verb+normal+}}
\index{ratnormal@{\verb+ratnormal+}}
\verb|normal| et \verb|ratnormal|~: 
d'un bon rapport temps d'ex\'ecution-simplification, elles
\'ecrivent une fraction rationnelle (rapport de deux polyn\^omes)
sous forme de fraction irr\'eductible d\'evelopp\'ee; \verb|normal|
tient compte des nombres alg\'ebriques (par exemple comme \verb|sqrt(2)|)
mais pas \verb|ratnormal|. Les deux ne tiennent pas compte des relations
entre fonctions transcendantes (par exemple comme \verb|sin| et \verb|cos|).
\item[$\bullet$] 
\index{factor@{\verb+factor+}}
\verb|factor|~: un peu plus lente que les pr\'ec\'edentes, elle
\'ecrit une fraction sous forme irr\'eductible factoris\'ee.
\item[$\bullet$] 
\index{simplify@{\verb+simplify+}}
\verb|simplify|~: elle essaie de se ramener \`a
des variables alg\'ebriquement ind\'ependantes avant d'appliquer
\verb|normal|. Ceci est plus co\^uteux en temps et "aveugle" (on
ne contr\^ole pas les r\'e\'ecritures interm\'ediaires).
Les simplifications faisant intervenir des extensions
alg\'ebriques (par exemple des racines carr\'ees) 
n\'ecessitent parfois deux appels et/ou des hypoth\`eses (\verb|assume|)
pour enlever des valeurs absolues avant d'obtenir la simplification
souhait\'ee.
\item[$\bullet$] 
\index{tsimplify@{\verb+tsimplify+}}
\verb|tsimplify| essaie de se ramener \`a des variables 
alg\'ebriquement ind\'ependantes mais sans appliquer \verb|normal|
ensuite.
\end{itemize}
Dans le menu \verb@Math@ du bandeau sup\'erieur, les 4 sous-menus
de r\'e\'ecriture
contiennent d'autres fonctions, pour des
transformations plus ou
moins sp\'ecialis\'ees.  
\begin{verbatim}
b:=sqrt(1-a^2)/sqrt(1-a)
ratnormal(b)
normal(b)
tsimplify(b)
simplify(b)
simplify(simplify(b))
assume(a<1)
simplify(b)   
simplify(simplify(b))
\end{verbatim}
\index{convert@{\verb+convert+}}
La fonction \verb@convert@ permet de passer d'une expression \`a une
autre \'equivalente, sous un format qui est sp\'ecifi\'e par le
deuxi\`eme argument. 
\begin{verbatim}
convert(exp(i*x),sincos)
convert(1/(x^4-1),partfrac)
convert(series(sin(x),x=0,6),polynom)
\end{verbatim}
\vskip 2mm
\begin{center}
\begin{tabular}{|ll|}
\hline
\multicolumn{2}{|c|}{\bf Transformations}\\
\hline\hline
\verb@simplify@& simplifier\\
\verb@tsimplify@& simplifier (moins puissant)\\
\verb@normal@& forme normale\\
\verb@ratnormal@& forme normale (moins puissant)\\
\verb@expand@& d\'evelopper\\
\verb@factor@& factoriser\\
\verb@assume@& rajout d'hypoth\`eses\\
\verb@convert@& transformer en un format sp\'ecifi\'e\\
\hline
\end{tabular}
\end{center}

%
\subsection{Les fonctions}
%
\subsubsection{Fonctions usuelles}
De nombreuses fonctions sont d\'ej\`a d\'efinies dans {\tt Xcas}, en
particulier les fonctions classiques. Les plus courantes figurent dans
le tableau ci-apr\`es; pour les autres, voir le menu \verb@Math@.
\vskip 2mm
\begin{center}
\begin{tabular}{|ll|}
\hline
\multicolumn{2}{|c|}{\bf Fonctions classiques}\\
\hline\hline
\verb@abs@ & valeur absolue\\
\verb@round@ & arrondi \\
\verb@floor@ & partie enti\`ere (plus grand entier $\leq$)\\
\verb@ceil@ & plus petit entier $\geq $\\
\hline
\verb@abs@ & module\\
\verb@arg@ & argument\\
\verb@conj@ & conjugu\'e\\
\hline
\verb@sqrt@ & racine carr\'ee\\
\verb@exp@ & exponentielle\\
\verb@log@ & logarithme naturel\\
\verb@ln@ & logarithme naturel\\
\verb@log10@ & logarithme en base 10\\
\hline
\verb@sin@ & sinus\\
\verb@cos@ & cosinus\\
\verb@tan@ & tangente\\
\verb@asin@ & arc sinus\\
\verb@acos@ & arc cosinus\\
\verb@atan@ & arc tangente\\
\hline
\verb@sinh@ & sinus hyperbolique\\
\verb@cosh@ & cosinus hyperbolique\\
\verb@tanh@ & tangente hyperbolique\\
\verb@asinh@ & argument sinus hyperbolique\\
\verb@acosh@ & argument cosinus hyperbolique\\
\verb@atanh@ & argument tangente hyperbolique\\
\hline
\end{tabular}
\end{center}
\index{abs@{\verb+abs+}}
\index{valeur absolue}
\index{round@{\verb+round+}}
\index{arrondi}
\index{floor@{\verb+floor+}}
\index{ceil@{\verb+ceil+}}
\index{partie enti\`ere}
\index{re@{\verb+re+}}
\index{partie r\'eelle}
\index{im@{\verb+im+}}
\index{partie imaginaire}
\index{conj@{\verb+conj+}}
\index{conjugu\'e}
\index{sqrt@{\verb+sqrt+}}
\index{racine carr\'ee}
\index{exp@{\verb+exp+}}
\index{log@{\verb+log+}}
\index{ln@{\verb+ln+}}
\index{logarithme!naturel}
\index{logarithme!en base 10}
\index{log10@{\verb+log10+}}
\index{sin@{\verb+sin+}}
\index{sinus}
\index{cos@{\verb+cos+}}
\index{cosinus}
\index{tan@{\verb+tan+}}
\index{tangente}
\index{sinh@{\verb+sinh+}}
\index{sinus!hyperbolique}
\index{cosh@{\verb+cosh+}}
\index{cosinus!hyperbolique}
\index{tanh@{\verb+tanh+}}
\index{tangente!hyperbolique}
\index{asin@{\verb+asin+}}
\index{arc!sinus}
\index{acos@{\verb+acos+}}
\index{arc!cosinus}
\index{atan@{\verb+atan+}}
\index{arc!tangente}
\index{asinh@{\verb+asinh+}}
\index{argument!sinus hyperbolique}
\index{acosh@{\verb+acosh+}}
\index{argument!cosinus hyperbolique}
\index{atanh@{\verb+atanh+}}
\index{argument!tangente hyperbolique}

\subsubsection{Fonctions alg\'ebriques d\'efinies par l'utilisateur}
Pour cr\'eer une nouvelle fonction, il faut la d\'eclarer \`a l'aide 
d'une expression contenant la variable. 
Par exemple l'expression $x^2-1$ est 
d\'efinie par \verb@x^2-1@. Pour la transformer en la fonction $f$ qui
\`a $x$ associe $x^2-1$, trois possibilit\'es existent~:
\begin{verbatim}
f(x):= x^2-1
f:=x->x^2-1
f:=unapply(x^2-1,x)
f(2); f(a^2)
\end{verbatim}
\index{fonction!d\'efinition d'une}
\index{fonction}
\index{expression}
\index{unapply@{\verb+unapply+}}

On peut d\'efinir des fonctions de plusieurs variables \`a valeurs dans 
$\mathbb R$ comme \verb@f(x,y):=x+2*y@ et des fonctions de plusieurs 
variables \`a valeurs dans $\mathbb R^p$
par exemple \verb@f(x,y):=(x+2*y,x-y)@ 

\subsubsection{Distinguer expression et fonction}
Si \verb@f@ est une fonction d'une variable et \verb@E@ est une
expression, \verb@f(E)@ est une autre expression.
Il est essentiel de ne pas confondre fonction et expression.
Si on d\'efinit : \verb@E:=x^2-1@, alors la variable \verb@E@ 
contient l'expression $x^2-1$. Pour avoir la valeur de cette
expression en $x=2$ il faut 
\'ecrire \verb@subst(E,x=2)@ et non \verb@E(2)@
car \verb@E@ n'est pas une fonction.
Lorsqu'on d\'efinit une fonction,
le membre de droite de l'affectation n'est pas \'evalu\'e.
Ainsi l'\'ecriture \verb@E:=x^2-1; f(x):=E@
d\'efinit la fonction $f: x \mapsto E$ car \verb@E@ n'est pas \'evalu\'e.
Par contre \verb@E:= x^2-1; f:=unapply(E,x)@ d\'efinit bien la
fonction $f: x\mapsto x^2-1$ car \verb@E@ est \'evalu\'e.

La fonction \verb@diff@ permet de calculer la d\'eriv\'ee d'une
expression par rapport \`a une ou plusieurs de ses variables. Pour
d\'eriver une fonction $f$, 
on peut appliquer \verb@diff@ \`a l'expression $f(x)$, mais alors le
r\'esultat est une expression. Si on souhaite d\'efinir la fonction
d\'eriv\'ee, il faut utiliser \verb@function_diff@.
\begin{verbatim}
E:=x^2-1
diff(E)
f:=unapply(E,x)
diff(f(x))
f1:=function_diff(f)
\end{verbatim}
Il ne {\bf faut pas} d\'efinir la fonction d\'eriv\'ee par
\verb|f1(x):=diff(f(x))|, car \verb|x| aurait dans cette d\'efinition
deux sens incompatibles~: c'est d'une part la
variable formelle de d\'erivation et d'autre part l'argument
de la fonction \verb|f1|. D'autre part, cette d\'efinition
\'evaluerait \verb|diff| \`a chaque appel de la fonction (car
le membre de droite d'une affectation n'est jamais \'evalu\'e), ce 
qui serait inefficace. Il faut donc soit utiliser
\verb|f1:=function_diff(f)|, 
soit \verb|f1:=unapply(diff(f(x)),x)|.

\subsubsection{Op\'erations sur les fonctions}
\index{fonction!composition des}
\index{compos\'ee}
On peut ajouter et multiplier des fonctions,
par exemple \verb@f:=sin*exp@. Pour composer des fonctions, on utilise 
l'op\'erateur \verb|@| et pour composer plusieurs fois une fonction 
avec elle-m\^eme, on utilise l'op\'erateur \verb|@@|.
\begin{verbatim}
f:=x->x^2-1
f1:=f@sin
f2:=f@f
f3:=f@@3
f1(a)
f2(a)
f3(a)
\end{verbatim} 
%

\subsection{Listes, s\'equences, ensembles}
%
\index{liste}
\index{sequence@s\'equence}
\index{ensemble}
{\tt Xcas} distingue plusieurs sortes de collections d'objets, 
s\'epar\'es par des virgules~: 
\begin{itemize}
\item[$\bullet$] les listes (entre crochets)
\item[$\bullet$]  les s\'equences (entre parenth\`eses) 
\item[$\bullet$]  les ensembles (entre pourcentage-accolades)
\end{itemize}
\begin{verbatim}
liste:=[1,2,4,2]
sequence:=(1,2,4,2)
ensemble:=%{1,2,4,2%}
\end{verbatim}
Les listes peuvent contenir des listes (c'est le cas des matrices), 
alors que les s\'equences sont plates (un \'el\'ement d'une s\'equence
ne peut pas \^etre une s\'equence). Dans un ensemble,
l'ordre n'a pas d'importance et chaque objet est unique. 
Il existe une autre structure, appel\'ee table, dont nous
reparlerons plus loin.

Il suffit de mettre une s\'equence entre crochets pour en faire une liste
ou entre accolades pr\'ec\'ed\'ees de \verb@%@ pour en faire un ensemble.
On passe d'une liste \`a sa s\'equence associ\'ee par \verb@op@, 
d'une s\'equence \`a sa liste associ\'ee en la mettant entre crochets
ou avec la fonction \verb@nop@.
Le nombre d'\'el\'ements d'une liste est donn\'e par \verb@size@ 
(ou \verb@nops@).
\index{op@{\verb+op+}}
\index{nop@{\verb+nop+}}
\index{nops@{\verb+nops+}}
\index{size@{\verb+size+}}
\index{nombre!d'\'el\'ements}
\begin{verbatim}
se:=(1,2,4,2)
li:=[se]
op(li)
nop(se)
nops(se)
%{se%}
size([se])
size(%{se%})
\end{verbatim}
\index{it\'eration}
\index{seq@{\verb+seq+}}
\index{makelist@{\verb+makelist+}}
Pour fabriquer une liste ou une s\'equence, on utilise des commandes
d'it\'eration comme {\tt \$} ou \verb@seq@ (qui it\`erent une
expression) ou \verb@makelist@ (qui d\'efinit une liste \`a l'aide d'une 
fonction).  
\begin{verbatim}
1$5
k^2 $ (k=-2..2)
seq(k^2,k=-2..2)
seq(k^2,k,-2..2)
[k^2$(k=-2..2)]
seq(k^2,k,-2,2)
seq(k^2,k,-2,2,2)
makelist(x->x^2,-2,2)
seq(k^2,k,-2,2,2)
makelist(x->x^2,-2,2,2)
\end{verbatim}
\index{NULL@{\verb+NULL+}}
\index{liste!vide}
\index{sequence@s\'equence!vide}

La s\'equence vide est not\'ee \verb|NULL|, la liste vide
\verb|[]|. Pour ajouter un \'el\'ement \`a une s\'equence il suffit
d'\'ecrire la s\'equence et '\'el\'ement s\'epar\'es par une virgule. 
\index{append@{\verb+append+}}
Pour ajouter un
\'el\'ement \`a une liste on utilise \verb|append|.
On acc\`ede \`a un \'el\'ement d'une liste ou d'une s\'equence gr\^ace 
\`a son indice mis entre 
crochets, le premier \'el\'ement \'etant d'indice 0.
\begin{verbatim}
se:=NULL; se:=se,k^2$(k=-2..2); se:=se,1
li:=[1,2]; (li:=append(li,k^2))$(k=-2..2)
li[0],li[1],li[2]
\end{verbatim}

Les polyn\^omes sont souvent d\'efinis par une expression, mais
ils peuvent aussi \^etre repr\'esent\'es 
par la liste de leurs coefficients par ordre
de degr\'e d\'ecroissant, avec comme d\'elimiteurs \verb|poly1[| et \verb|]|.
Il existe aussi une repr\'esentation
pour les polyn\^omes \`a plusieurs variables. Les fonctions
\verb|symb2poly| et \verb|poly2symb| permettent
de passer de la repr\'esentation expression \`a la repr\'esentation
par liste et inversement, 
le deuxi\`eme argument d\'etermine s'il s'agit de polyn\^omes
en une variable (on met le nom de la variable) ou de
polyn\^omes \`a plusieurs variables (on met la liste des variables).
\vskip 2mm
\begin{center}
\begin{tabular}{|ll|}
\hline
\multicolumn{2}{|c|}{\bf S\'equences et listes}\\
\hline\hline
\verb@E$(k=n..m)@ &cr\'eer une s\'equence\\
\verb@seq(E,k=n..m)@ &cr\'eer une s\'equence\\
\verb@[E$(k=n..m)]@ & cr\'eer une liste\\
%$
\verb@makelist(f,k,n,m,p)@ & cr\'eer une liste\\
\verb@op(li)@ & passer de liste \`a s\'equence\\
\verb@nop(se)@ & passer de s\'equence \`a liste\\
\verb@nops(li)@ & nombre d'\'el\'ements\\
\verb@size(li)@ & nombre d'\'el\'ements\\
\verb@sum@ & somme des \'el\'ements\\
\verb@product@ & produit des \'el\'ements\\
\verb@cumSum@ & sommes cumul\'ees des \'el\'ements\\
\verb@apply(f,li)@ & appliquer une fonction \`a une liste\\
\verb@map(li,f)@ & appliquer une fonction \`a une liste\\
\verb@poly2symb@ & polyn\^ome associ\'e \`a une liste\\
\verb@symb2poly@ & coefficients d'un polyn\^ome\\
\hline
\end{tabular}
\end{center}
\index{sum@{\verb+somme+}}
\index{somme}
\index{product@{\verb+product+}}
\index{produit}
\index{cumsum@{\verb+cumSum+}}
\index{sommes cumul\'ees}
\index{apply@{\verb+apply+}}
\index{fonction!appliqu\'ee \`a une liste}
\index{map@{\verb+map+}}
\index{poly2symb@{\verb+poly2symb+}}
\index{symb2poly@{\verb+symb2poly+}}
\index{liste!des coefficients}
%

\subsection{Instructions graphiques} \label{sec:graphique}
Toutes les instructions du menu \verb|Geo| ont un r\'esultat graphique,
par exemple \verb|point(1,2)| affiche le point de coordonn\'ees
1 et 2, \verb|droite(A,B)| la droite passant par deux points $A$ et
$B$ d\'efinis auparavant. 
On peut donner des attributs graphiques aux objets graphiques
en ajoutant \`a la fin de l'instruction graphique
l'argument \verb|affichage=...| dont la
saisie est facilit\'ee par le menu \verb|Graphic->Attributs|.

Lorsqu'une ligne de commande contient une instruction
graphique, le r\'esultat est affich\'e dans un rep\`ere 2-d ou 3-d selon
la nature de l'objet g\'en\'er\'e. On peut controler
le rep\`ere avec les boutons situ\'es \`a droite du graphique,
par exemple orthonormaliser avec le bouton \verb@_|_@.
Si une ligne de commande contient des instructions graphique et non
graphiques, c'est la nature de la derni\`ere instruction qui d\'ecide
du type d'affichage.

L'instruction \verb|A:=click()| permet de 
d\'efinir une variable contenant l'affixe d'un 
point du plan que l'on clique
avec la souris. 


\subsection{Aide en ligne}
Les commandes de Xcas sont regroup\'ees par th\`emes dans les
menus du bandeau gris sup\'erieur~: \verb|CAS|, \verb|Graphic|,
\verb@Geo@, \verb@Cmds@, \verb@Phys@, \ldots~ 
Lorsqu'on s\'electionne une commande dans un menu, 
\begin{itemize}
\item soit l'index de l'aide s'ouvre \`a la commande s\'electionn\'ee (par
exemple pour les commandes du menu \verb|CAS|). Cliquez sur le bouton
\verb|Details| pour afficher la page du manuel correspondant \`a la commande
dans votre navigateur.
\item soit une boite de dialogue s'ouvre vous permettant de sp\'ecifier
les arguments de la commande (par exemple pour tracer une courbe
depuis le menu \verb|Graphic|)
\item soit la commande est recopi\'ee dans la ligne de commande. Pour connaitre
la syntaxe de cette commande, appuyez sur le bouton \verb|?| en haut \`a gauche,
ou faites afficher la zone de \verb@Messages@ (en utilisant le menu \verb@Cfg@,).
Vous pouvez aussi configurer Xcas (menu \verb|Cfg| puis \verb|Configuration generale|
puis cocher la case \verb@Aide HTML automatique@) 
pour que la page correspondante du manuel 
s'ouvre automatiquement dans votre navigateur.
\end{itemize}
Le menu \verb@Aide@ contient les diff\'erentes formes d'aide possible~:
un guide de l'utilisateur (interface), un guide de r\'ef\'erence
(\verb@Manuels->Calcul formel@, aide detaill\'ee sur chaque commande), 
un \verb@Index@ (liste des commandes class\'ees par ordre 
alphab\'etique avec une ligne d'entr\'ee permettant de se d\'eplacer
facilement) et une recherche par mots clefs.
\index{aide en ligne}
\index{help@{\verb+help+}}

Si vous connaissez d\'ej\`a le nom d'une commande et que vous d\'esirez
v\'erifier sa syntaxe (par exemple \verb@factor@), vous pouvez
saisir le d\'ebut du nom de commande 
(disons \verb|fact|)
puis taper sur la touche de tabulation
(situ\'ee \`a gauche de la touche A sur un clavier
fran\c{c}ais) ou cliquer sur le bouton \verb|?| en haut \`a gauche. 
L'index des commandes appara\^\i t alors dans une fen\^etre, positionn\'e 
\`a la premi\`ere compl\'etion possible, avec une aide succinte sur chaque
commande. 
Par exemple, vous voulez factoriser un polyn\^ome, vous supposez que le nom de
commande commence par \verb|fact|, vous tapez donc \verb|fact| puis
la touche de tabulation, vous s\'electionnez \`a la souris
\verb|factor| (ou un des exemples) puis vous cliquez sur OK.

Vous pouvez aussi saisir \verb@?factor@ pour avoir l'aide succinte
en r\'eponse. Si le nom que vous avez saisi n'est pas reconnu, des
commandes proches vous sont sugg\'er\'ees.

\subsection{Temps de calcul, place m\'emoire}
%
Le principal probl\`eme du calcul formel est la complexit\'e des 
calculs interm\'ediaires. Elle se traduit \`a la fois par le temps
n\'ecessaire \`a l'ex\'ecution des commandes et par la place m\'emoire
requise. Les algorithmes impl\'ement\'es dans les fonctions
de {\tt Xcas} sont performants, mais ils ne
\index{time@{\verb+time+}}
\index{temps de calcul}
peuvent pas \^etre optimaux dans tous les cas. La fonction \verb@time@ 
permet de conna\^\i tre le temps d'ex\'ecution d'une commande (si ce temps
est tr\`es court, {\tt Xcas} ex\'ecute plusieurs fois la commande pour
afficher un r\'esultat plus pr\'ecis). La m\'emoire utilis\'ee 
appara\^\i t dans les versions Unix dans la ligne d'\'etat
(en rouge \`a bas \`a gauche). Si le temps d'ex\'ecution d'une
commande d\'epasse quelques secondes, il est possible que vous ayez
commis une erreur de saisie. N'h\'esitez pas \`a interrompre
l'ex\'ecution (bouton orange \verb@stop@ en bas \`a droite, il est
conseill\'e de faire une sauvegarde de votre session auparavant).


\section{Programmation}
Comme le texte d\'efinissant un programme ne tient en g\'en\'eral pas
sur une ou deux lignes, il est commode d'utiliser un \'editeur
de programmes. Pour cela, on utilise
le menu \verb|Prg->Nouveau programme| de Xcas. Le menu 
\verb|Prg->Ajouter|
facilite aussi la saisie des principales structures de controle 
de programmation.

\subsection{Tests}
On peut tester l'\'egalit\'e de 2 expressions en utilisant l'instruction
\verb|==|, alors que \verb|!=| teste si 2 expressions ne sont pas
\'egales. On peut aussi tester l'ordre entre 2 expressions 
avec \verb|<|, \verb|<=|, \verb|>|, \verb|>=|, il s'agit
de l'ordre habituel sur les r\'eels pour des donn\'ees num\'eriques
ou de l'ordre lexicographique pour les chaines de caract\`eres.

Un test renvoie 1 s'il est vrai, 0 s'il est faux. On peut combiner
le r\'esultat de deux tests au moyen des op\'erateurs logiques {\tt \&\&}
(et logique), {\tt ||} (ou logique) et on peut calculer la n\'egation logique
d'un r\'esultat de test {\tt !} (n\'egation logique).
On utilise ensuite
souvent la valeur du test pour ex\'ecuter une instruction
conditionnelle \verb|si ... alors ... sinon ... fsi|.
N.B.~: Xcas admet aussi une syntaxe compatible avec le langage C\\
\verb|if (condition) { bloc_vrai } else { bloc_faux }|.
 
Par exemple, on pourrait stocker la valeur absolue d'un r\'eel $x$
dans $y$ par~:
\begin{center}
\verb|si x>0 alors y:=x; sinon y:=-x; fsi;|
\end{center}
(on peut bien sur utiliser directement \verb|y:=abs(x)|).

Exemples~: Tester si un triangle dont on fait cliquer les 3 sommets \`a
l'utilisateur est rectangle. 

\subsection{Boucles}
On peut ex\'ecuter des instructions plusieurs fois de suite en utilisant
une boucle d\'efinie (le nombre d'ex\'ecutions est fix\'e au d\'ebut) ou
ind\'efinie (le nombre d'ex\'ecutions n'est pas connu).
On utilise en g\'en\'eral une variable de controle (indice de boucle
ou variable de terminaison).
\begin{itemize}
\item Boucle d\'efinie\\
\verb|for(init;condition;incrementation){ instructions }|\\
\verb|for ... from ... to ... do ... od|\\
Exemple, calcul de 10!\\
\verb|f:=1; for (j:=1;j<=10;j++){ f:=f*j; }|\\
\verb|f:=1; for j from 1 to 10 do f:=f*j; od;|\\
{\bf Attention}, vous ne pouvez pas utiliser \verb|i| comme indice
de boucle, car \verb|i| est pr\'ed\'efini (comme $\sqrt{-1}$)
\item Boucle ind\'efinie\\
\verb|while (...) { ... }|\\
Exemple, algorithme d'Euclide\\
\verb|while (b!=0){ r:=irem(a,b); a:=b; b:=r;}|
\end{itemize}
Xcas accepte aussi l'arr\^et de boucle en cours d'ex\'ecution
(\verb|if (...) break;|) dont
l'usage peut \'eviter l'utilisation de variables de controle 
compliqu\'ees.


\subsection{Fonctions (non alg\'ebriques)}
La plupart des fonctions ne peuvent avoir une d\'efinition par une formule alg\'ebrique. On doit souvent calculer des donn\'ees
interm\'ediaires, faire des tests et des boucles. Il faut alors d\'efinir
la fonction par une suite d'instructions, d\'elimit\'ees par \verb|{ ... }|.
La valeur calcul\'ee par la fonction est alors la valeur calcul\'ee
par la derni\`ere instruction ou peut \^etre explicit\'ee en utilisant le 
mot-clef \verb|return| suivi de la valeur \`a renvoyer (N.B.: l'ex\'ecution
de \verb|return| met un terme \`a la fonction m\^eme s'il y a encore
des instructions apr\`es).

Pour \'eviter que les donn\'ees interm\'ediaires n'interf\`erent
avec les variables de la session principale, 
on utilise un type sp\'ecial de variables,
les variables locales, dont la valeur ne peut \^etre modifi\'ee ou acc\'ed\'ee
qu'\`a l'int\'erieur de la fonction. On utilise \`a cet effet le mot-clef
\verb|local| suivi par les noms des variables locales s\'epar\'es par
des virgules.
Si une fonction calcule plusieurs donn\'ees on peut les renvoyer dans
une liste.


Exemple~: le PGCD 
\begin{verbatim}
pgcd(a,b):={
  local r;
  while (b!=0){ 
    r:=irem(a,b);
    a:=b;
    b:=r;
  }
  return a;
}
\end{verbatim}
On clique ensuite sur le bouton OK, si tout va bien, le programme 
\verb|pgcd| est d\'efini et on peut le tester dans une ligne de commande
par exemple par \verb|pgcd(25,15)|.

Dans la section suivante, on va voir comment ex\'ecuter en mode pas \`a
pas un programme, ce qui peut servir \`a comprendre le d\'eroulement d'un
algorithme, mais aussi \`a corriger un programme erron\'e.

\subsection{Ex\'ecuter en pas \`a pas et mettre au point}
La commande {\tt debug} permet de lancer un programme en mode
d'ex\'ecution pas \`a pas. Elle ouvre une fen\^etre permettant
de diriger l'ex\'ecution du programme pass\'e en argument.
Par exemple, on entre le programme~:
\begin{verbatim}
carres(n):={
  local j,k;
  k:=0;
  for (j:=1;j<n+1;j++) {
    k:=k+j^2;
  }
  return k;
}:;
\end{verbatim}
On tape pour debugger le programme {\tt carres} ci-dessus~:
\begin{center}
{\tt debug(carres(5))}
\end{center}
cela ouvre la fen\^etre du debugger.
En cliquant sur le bouton {\tt sst} on peut ex\'ecuter pas \`a pas
le programme en visualisant l'\'evolution des valeurs des variables
locales et des param\`etres du programme. Cela permet de d\'etecter
la grande majorit\'e des erreurs qui font qu'un programme ne fait
pas ce que l'on souhaite. Pour des programmes plus longs, 
le debugger permet de controler
assez finement l'ex\'ecution du programme en placant par exemple
des points d'arr\^et.

Exercice~: ex\'ecuter en mode pas \`a pas le programme \verb|pgcd|
pour quelques valeurs des arguments.

\pagebreak

\section{TP1 prise en main}

%\subsection{Utilisation interactive}
\begin{enumerate}
\item \'Ecrire le polyn\^ome $(x+3)^7 \times (x-5)^6$ selon les puissances
d\'ecroissantes de $x$.

\item Simplifier les expressions suivantes:
\[ \quad \sqrt{3+2\sqrt{2}},
\quad \frac{1+\sqrt{2}}{1+2\sqrt{2}}, \quad
e^{i\pi/6}, \quad 4\mbox{atan}(\frac{1}{5})-\mbox{atan}(\frac{1}{239}) \]

\item Factoriser~:
\[ x^8-3x^7-25x^6+99x^5+60x^4-756x^3+1328x^2-960x+256 \]
\[ x^6-2x^3+1, \quad (-y+x)z^2-xy^2+x^2y \]

\item Calculez les int\'egrales et simplifiez le r\'esultat:
\[ \int \frac{1}{e^x-1} \ dx, \quad
\int  \frac{1}{x\ln(x)} \ln(\ln(x)) dx, \quad \int e^{x^2} \ dx,
\quad \int x\sin(x)e^{x} \ dx \]
V\'erifiez en d\'erivant les expressions obtenues.

\item D\'eterminer la valeur de:
\[\int _1^2\frac{1}{(1+x^2)^3}, \quad  \int _1^2 \frac{1}{x^3+1} \ dx \]

\item Calculer les sommes suivantes
\[\sum_{k=1}^N k,\ \sum_{k=1}^N k^2,\ \sum_{k=1}^\infty \frac{1}{k^2}\]

\item D\'evelopper $\sin(3x)$, lin\'eariser l'expression obtenue
et v\'erifier qu'on retrouve l'expression initiale.

\item Calculer le d\'eveloppement de Taylor en $x=0$ \`a l'ordre 4
de:
\[ \ln(1+x+x^2),\quad
\frac{\exp(\sin(x))-1}{x+x^2} , \quad \sqrt{1+e^{x}}, \quad
\frac{\ln(1+x)}{\exp(x)-\sin(x)} \]

\item Trouver les entiers $n$ tels que le reste de la division
euclidienne de $123 n $ par 256 soit 17.

\item D\'eterminer la liste des diviseurs de 45768. \\
Factoriser 100!

\item R\'esoudre le syst\`eme lin\'eaire:
\[ \left\{ \begin{array}{lllllll}
 x &+& y &+& az&=&1\\
 x & +& a y&+& z&=&2 \\
 ax & +&y &+& z&=&3 
\end{array}\right. \]

\item D\'eterminer l'inverse de la matrice~:
\[ A=\left(\begin{array}{llll}
 1 & 1 & 1 & a \\
 1 & 1 & a & 1 \\
 1 & a & 1 & 1 \\
 a & 1 & 1 & 1
\end{array}\right)\]
%Diagonaliser la matrice $A$.
\end{enumerate}


\section{TP 2: ramener un problème d'algèbre linéaire à un pivot de Gauss}
Les instructions de Xcas correspondantes sont dans le menu \verb|Cmds->Alglin->Gauss|.

{\bf Exercice 1}
\'Ecrire le syst\`eme lin\'eaire sous forme matricielle:
\[ \left\{ \begin{array}{lllllll}
 x &+& y &+& az&=&1\\
 x & +& a y&+& z&=&2 \\
 ax & +&y &+& z&=&3 
\end{array}\right. \]
puis le résoudre avec l'instruction de réduction sous forme échelonnée \verb|rref|.

{\bf Exercice 2}\\
Calcul de la somme de deux sous-espaces vectoriels.\\
On donne deux sous-espaces vectoriels $E_1$ et $E_2$
de $\R^n$ par deux familles g\'eneratrices (c'est-\`a-dire
une liste de vecteurs), il s'agit d'\'ecrire un algorithme permettant
\begin{itemize}
\item de trouver une base de $E_1+E_2$
\item de trouver une \'ecriture d'un \'el\'ement de $E_1+E_2$
comme somme d'un \'el\'ement de $E_1$ et d'un \'el\'ement de $E_2$
\end{itemize}
On pourra utiliser les fonctions {\tt rref} ou/et {\tt ker} de Xcas.
Tester avec deux sous-espaces de dimension 2 de $\R^5$.
N'oubliez pas de r\'ediger une justification math\'ematique de la
m\'ethode mise en oeuvre.

\vspace{1cm}

{\bf Exercice 3}\\
Calcul de l'intersection de deux sous-espaces vectoriels.\\
On donne deux sous-espaces vectoriels $E_1$ et $E_2$
de $\R^n$ par deux familles g\'eneratrices (c'est-\`a-dire
une liste de vecteurs), il s'agit d'\'ecrire un algorithme permettant
de trouver une base de $E_1 \cup E_2$.
On pourra utiliser les fonctions {\tt rref} ou/et {\tt ker} de Xcas.
Tester avec 2 sous-espace de dimension 3 de $\R^4$.
N'oubliez pas de r\'ediger une justification math\'ematique de la
m\'ethode mise en oeuvre.

\vspace{1cm}

{\bf Exercice 4}\\
Mise en oeuvre du th\'eor\`eme de la base incompl\`ete. On donne
une famille de vecteurs de $\R^n$ (liste de vecteurs), 
il s'agit d'\'ecrire un algorithme permettant d'extraire 
une base du sous-espace engendr\'e, 
puis de compl\'eter par des vecteurs afin de former une base
de $\R^n$ tout entier, et enfin d'\'ecrire un vecteur de $\R^n$
comme combinaison lin\'eaire des vecteurs de la base compl\'et\'ee.
On pourra utiliser les fonctions {\tt rref} ou/et {\tt ker} de Xcas.
Tester avec une famille de 3 vecteurs de $\R^5$.
N'oubliez pas de r\'ediger une justification math\'ematique de la
m\'ethode mise en oeuvre.


\section{TP3,4: pivot de Gauss et applications}

\subsection{Programmation}
On rappelle qu'en mode Xcas, les indices commencent \`a 0 (en mode maple
les indices commencent \`a 1).
Etant donn\'e une matrice $M$ ayant $L$ lignes et $C$ colonnes,
on demande de programmer l'algorithme du pivot de Gauss que
l'on rappelle~:
\begin{enumerate}
\item Initialiser la ligne courante $l$ et la colonne courante $c$ \`a 0
\item Tant que $l<L$ et $c<C$ faire
\item Chercher dans la colonne $c$ \`a partir de la ligne $l$ un 
coefficient non nul (appel\'e pivot)
\item S'il n'y en a pas, incr\'ementer $c$ et revenir \`a l'\'etape 2
\item S'il y en a un, \'echanger la ligne $l$ avec la ligne du pivot
(\verb|rowSwap(matrice,l1,l2)|)
\item Pour les lignes $j$ variant de $l+1$ \`a $L-1$ ou de 0 \`a $L-1$ \`a
l'exclusion de la ligne $l$ (selon que l'on effectue une
r\'eduction sous-diagonale ou compl\`ete),
remplacer la ligne $L_j$ par $L_j-\alpha L_l$ o\`u $\alpha$
est calcul\'e pour annuler le coefficient de la colonne $c$ de $L_j$
(\verb|mRowAdd(coeff,matrice,l1,l2)|)
\item Incr\'ementer $l$ et $c$ et revenir \`a l'\'etape 2.
\item Normaliser \`a 1 le premier coefficient non nul de chaque ligne
(en divisant la ligne par ce coefficient) 
\end{enumerate}

\subsection{Inverse d'une matrice}
Pour calculer l'inverse d'une matrice $M$ carr\'ee de taille $n$, 
on peut r\'esoudre simultan\'ement $n$ syst\`emes lin\'eaires du type
$Mx_k=y_k$ o\`u $y_k$ repr\'esente (en colonne) les coordonn\'ees du $k$-i\`eme
vecteur de la base canonique pour $k$ variant de 1 \`a $n$. On \'ecrit
donc la matrice $M$ puis les colonnes des coordonn\'ees de ces 
$n$ vecteurs, donc la matrice identit\'e de taille $n$. On r\'eduit 
compl\`etement la matrice par l'algorithme du pivot de Gauss. 
Si $M$ est inversible,
les $n$ premi\`eres colonnes apr\`es r\'eduction doivent \^etre la matrice
identit\'e de taille $n$, alors que les $n$ colonnes qui suivent sont
les coordonn\'ees des $x_k$ donc ces $n$ colonnes constituent $M^{-1}$.
\'Ecrire un programme de calcul d'inverse de matrice par cet
algorithme.

\subsection{Noyau d'une application lin\'eaire}
Soit $M$ la matrice d'une application lin\'eaire dont on veut calculer
une base du noyau. On r\'eduit compl\`etement $M$ par le pivot de Gauss.
On enl\`eve les lignes de 0 finales de $M$.
Puis on ins\`ere des lignes de 0 pour placer les
pivots (premier coefficient non nul de chaque ligne) sur la
diagonale principale. On obtient ainsi une matrice carr\'ee $M_r$ de taille
le nombre de colonnes de $M$. On parcourt la diagonale de $M_r$,
et chaque fois qu'on rencontre un 0, on ajoute un vecteur \`a la base
du noyau, ce vecteur ayant pour coordonn\'ees la colonne actuelle
o\`u on a remplac\'e le 0 de la diagonale par -1.

\subsection{Algorithme de Gauss-Bareiss}
Lorsque les coefficients de la matrice $M=(m_{j,k})_{0 \leq j <L, 0
  \leq k < C}$ sont entiers, on peut
souhaiter \'eviter de faire des calculs dans les rationnels, et
pr\'ef\'erer utiliser une combinaison lin\'eaire de lignes ne faisant
intervenir que des coefficients entiers. 
On peut par exemple effectuer l'op\'eration (o\`u $l,c$ d\'esignent
la ligne et colonne du pivot)
\[ L_j \leftarrow m_{l,c} L_j - m_{j,c} L_l \]
 Tester la taille des
coefficients obtenus pour une matrice carr\'ee al\'eatoire de taille 5
puis 10. L'id\'ee est-elle bonne~?

On peut montrer qu'on peut toujours
diviser par le pivot utilis\'e pour r\'eduire
la colonne pr\'ec\'edente (initialis\'e \`a 1 lors de la r\'eduction
de la premi\`ere colonne)
\[ L_j \leftarrow \frac{1}{p_{\mbox{\small prec}}}(m_{l,c} L_j - m_{j,c} L_l) \]
Tester \`a nouveau sur des matrices carr\'ees de taille 5, 10, v\'erifier
que les calculs sont bien effectu\'es dans $\Z$. Comparer le 
dernier coefficient en bas \`a droite avec le d\'eterminant de la matrice
(si vous avez vu les propri\'et\'es des d\'eterminants, d\'emontrez
ce r\'esultat. Plus difficile: en d\'eduire qu'on peut bien diviser
par le pivot de la colonne pr\'ec\'edente en consid\'erant des
d\'eterminants de matrices extraites)

%\vspace{1cm}


\section{TP5: polynome minimal et caract\'eristique.}
On propose ici quelques algorithmes de calcul du polyn\^ome minimal $M$
et/ou caract\'eristique $P$ d'une matrice carr\'ee $A$ de taille $n$.
On peut bien sur calculer le polyn\^ome caract\'eristique en calculant
directement le d\'eterminant (par exemple avec l'algorithme de 
Gauss-Bareiss pour \'eviter les fractions de polyn\^omes), mais
c'est souvent plus couteux que d'utiliser un des deux algorithmes
ci-dessous.

\subsection{Interpolation de Lagrange}
On sait que le degr\'e de $P$ est $n$, il suffit donc de connaitre
la valeur de $P$ en $n+1$ points distincts pour connaitre $P$.
Par exemple, on calcule $P(k)$ pour $k=0,...,n$, et en utilisant
l'instruction \verb|lagrange| de Xcas, on en d\'eduit le
polyn\^ome caract\'eristique. Programmer cet algorithme et testez
votre programme en comparant le r\'esultat de votre programme
et de l'instruction \verb|charpoly| de Xcas sur quelques
matrices.

\subsection{Algorithme probabiliste.}
Cet algorithme permet de calculer le polyn\^ome caract\'eristique $C$ dans
presque tous les cas, en recherchant le polyn\^ome minimal $M$ de $A$
(on note $m$ le degr\'e de $M$). Cf. le DM 3 pour un exemple de mise 
en oeuvre.

On sait que $M(A)=0$, donc pour tout vecteur $v$, $M(A)v=0$. 
Si $M(x)=\sum_{k=0}^{m} M_k x^k$, alors 
\[ 0 = M(A)v=\sum_{k=0}^{m} M_k A^k v \]  
On va donc rechercher les relations lin\'eaires qui existent
entre les $n+1$ vecteurs $v, ..., A^nv$. Cela revient \`a d\'eterminer
le noyau $K$ de l'application lin\'eaire dont la matrice
a pour colonnes $v,...,A^nv$. 
On sait que le vecteur $(M_0,...,M_m,0,...,0) \in \R^{n+1}$
des coefficients de $M$ (compl\'et\'e par des 0 si $m<n$) 
appartient \`a ce noyau $K$.
Si le noyau $K$ est de dimension 1, alors $m=n$, et les
coefficients de $M$ sont proportionnels aux coefficients du vecteur
de la base du noyau calcul\'e. On en d\'eduit 
alors le polyn\^ome minimal $M$ 
et comme $m=n$, et aussi le polyn\^ome caract\'eristique $C=M$.

Programmer cet algorithme en prenant un vecteur $v$ al\'eatoire. 
Attention, pour calculer $A^kv$ on formera la suite r\'ecurrente
$v_k=Av_{k-1}$, pourquoi?

Si on n'a pas de chances dans le choix de $v$, on trouvera un
noyau de dimension plus grande que 1 bien que le polynome
minimal soit de degr\'e $n$. On peut alors recommencer
avec un autre vecteur. On peut aussi chercher la relation de degr\'e
minimal pour un $v$ donn\'e (elle apparait automatiquement 
comme premier vecteur de la base dans 
l'algorithme de calcul du noyau donn\'e au TP2), prendre le PPCM
$P$ des polynomes pour 2 ou 3 vecteurs al\'eatoires et conclure s'il
est de degr\'e $n$.
Programmer cette variante.

Si le polynome minimal est de degr\'e $m<n$, on peut tester si le
PPCM $P$ est le polynome minimal en calculant $P(A)$ mais
ce calcul est couteux. On peut aussi faire confiance au hasard,
supposer que le polynome minimal est bien $M=P$ et essayer de
d\'eterminer $C/M$ par d'autres moyens, par exemple la trace si
$n=m+1$. On dispose alors d'un moyen de v\'erification en
calculant l'espace caract\'eristique correspondant \`a la valeur
propre double.
Programmer cette variante.

%\pagebreak

\section{TP6: codes correcteurs lin\'eaires.}
La transmission (ou la lecture)
d'information de mani\`ere fiable a pris une importance
grandissante avec le d\'eveloppement des r\'eseaux informatiques, la
num\'erisation des donn\'ees (y compris audio et vid\'eo) mais
aussi la communication \`a grande distance (par exemple sonde
spatiale sur Mars). Il a fallu trouver des moyens \'economiques~:
\begin{itemize}
\item de d\'etecter des erreurs de lecture ou de transmission
\item de corriger une erreur de lecture ou de transmission 
sans avoir besoin de la relire ou de la r\'e\'emettre (pour \'eviter
une coupure dans la lecture d'un flux audio ou vid\'eo, ou
un d\'elai trop long par exemple pour communiquer avec une sonde
spatiale)
\end{itemize}
On pr\'esente dans ce TP quelques m\'ethodes de d\'etection et correction
d'erreurs qui utilisent de l'alg\`ebre lin\'eaire et des polyn\^omes
dont les coefficients au lieu d'\^etre des r\'eels ou des complexes
sont des entiers modulo un nombre premier, en g\'en\'eral 2, qui forment
un corps. Dans Xcas, on repr\'esente les nombres ou les vecteurs
ou les polyn\^omes modulo 2 en ajoutant \verb|mod 2| ou \verb|%2|,
par exemple \verb|1%2|, \verb|[1,2] %2|, \verb|(x^3+3x+1)%2| 

On appellera symbole d'information l'unit\'e de base transmise, qu'on
supposera appartenir \`a un corps fini $K$, par
exemple pour un bit un \'el\'ement de $K=\Z/2\Z$ (pour un octet 
on pourrait utiliser un \'el\'ement du corps \`a 256 \'el\'ements 
$K=GF(2,8)$ mais l'\'etude de ce corps est hors programme).

On veut coder un message de longueur $k$ avec des possibilit\'es
de d\'etection et de correction d'erreurs, pour cela on rajoute
des symboles calcul\'es \`a partir des pr\'ec\'edents, et
on envoie un mot ayant $n$ symboles (avec $n>k$).

\subsection{Le bit de parit\'e.}
On prend $k=7$ bits et $n=8$ bits. On compte
le nombre de 1 parmi les 7 bits envoy\'es, si ce nombre est pair, 
on envoie 0 comme 8i\`eme bit, sinon 1. 
Au final le nombre de bits \`a 1 de l'octet (1 octet=8 bits)
est pair. On peut ainsi d\'etecter une erreur de transmission si
\`a la r\'eception le nombre de bits d'un octet est impair, mais on
ne peut pas corriger d'erreurs.
On peut aussi dire que l'octet
repr\'esente un polyn\^ome \`a coefficients dans $\Z/2\Z$ divisible
par $X+1$.

{\bf Exercice}~:
\'Ecrire un programme Xcas permettant de rajouter un bit de parit\'e
\`a une liste compos\'ee de 7 bits. Puis un programme de v\'erification
qui accepte ou non un octet selon sa parit\'e. On peut 
convertir un entier en une liste de bits par 
\verb|convert(j,base,2)|
(le bit de poids fort est \`a droite)
puis en un polynome avec \verb|symb2poly|.
On peut effectuer la v\'erification de deux mani\`eres, en comptant
le nombre de 1 ou avec l'instruction \verb|rem|.

\subsection{Codes lin\'eaires}
{\bf D\'efinition}~:
On multiplie le vecteur $v$ des $k$ symboles \`a transmettre par
une matrice $M$ \`a coefficients dans $K$ de taille $n \times k$
et on transmet l'image $Mv$.
Pour assurer qu'on peut identifier un ant\'ec\'edent
unique \`a partir d'une image, il faut que $M$ corresponde 
\`a une application lin\'eaire injective (ce qui entraine $n\geq k$). 
On dit qu'un vecteur de $n$ symboles est un mot du code 
s'il est dans l'image de l'application lin\'eaire.

Pour assurer l'injectivit\'e tout en facilitant le d\'ecodage, 
on utilise souvent une matrice identit\'e $k,k$ comme sous-bloc
de la matrice $n,k$, par exemple on prend l'identit\'e pour
les $k$ premi\`eres lignes de $M$, on ajoute ensuite $n-k$ lignes.

Pour savoir si un vecteur $w$ est un mot de code, il faut v\'erifier
qu'il est dans l'image de $M$. On peut par exemple v\'erifier
qu'en ajoutant la colonne de ses coordonn\'ees \`a $M$, on ne change
pas le rang de $M$ (qui doit \^etre $k$) ou, lorsque $M$ a comme
premier sous-bloc une matrice identit\'e, on teste si $w$ est
bien l'image de l'ant\'ec\'edent calcul\'e \`a partir des
$k$ premi\`eres coordonn\'ees de $w$.

{\bf Exercice}~: cr\'eez une matrice $M$ de taille 7,4 injective. Puis
un programme qui teste si un vecteur $w$ est un mot de code et en
extrait alors la partie avant codage, c'est-\`a-dire le vecteur $v$ tel
que $Mv=w$. V\'erifiez votre programme~:
si on prend un vecteur $v \in K^k$ et $w=Mv$, 
on doit retrouver $v$ \`a partir de $w$.\\
Instructions utiles~: \verb|idn| (matrice identit\'e)
\verb|ker| (noyau d'une application lin\'eaire), \verb|rank| (rang),
\verb|tran| (tranpos\'ee), ... Pour cr\'eer une matrice, on peut coller
les lignes de 2 matrices $A$ et $B$ par \verb|[op(A),op(B)]| ou avec
\verb|blockmatrix|.

\subsection{Codes polynomiaux}
{\bf D\'efinition}~:
Il s'agit d'un cas particulier de codes lin\'eaires.
On se donne un polyn\^ome $g(x)$ de degr\'e $n-k$,
On repr\'esente le message de longueur $k$ \`a coder par un polyn\^ome 
$P$ de degr\'e $k-1$ dont les coefficients sont les symboles du message.
On multiplie $P$ par $x^{n-k}$, on calcule le reste $R$ de la division
euclidiennt de $P x^{n-k}$ par $g$. 
On \'emet alors $P x^{n-k}-R$ qui est divisible
par $g$. 
Un des int\'er\^ets des codes polynomiaux est que la v\'erification
d'appartenance au code est tr\`es simple~: 
les mots de code correspondent \`a des polyn\^omes divisibles par $g$.

{\bf Exercice}~: \'ecrire de cette facon le codage du bit de parit\'e. Puis
une proc\'edure Xcas de codage utilisant $g=X^7+X^3+1$ 
(ce polyn\^ome \'etait utilis\'e par le Minitel).

\subsection{D\'etection et correction d'erreur}
Si le mot recu n'est pas dans l'image de l'application
lin\'eaire il y a eu erreur de transmission. Sinon, il n'y
a pas eu d'erreur {\em d\'etectable\/} (il pourrait y avoir eu plusieurs
erreurs qui se ``compensent'').

Plut\^ot que de demander la r\'e\'emission du mot mal transmis
(ce qui serait par exemple impossible en temps r\'eel 
depuis un robot en orbite autour de Mars),
on essaie d'ajouter suffisamment d'information pour 
pouvoir corriger des erreurs en supposant
que leur nombre est major\'e par un entier $N$.

{\bf Remarque~:}\\ 
Si les erreurs de
transmissions sont ind\'ependantes, la probabilit\'e d'avoir
au moins $N+1$ erreurs dans un message de longueur $p$
est $\sum_{k=N+1}^p \left( ^p_{k} \right) \epsilon^{k} (1-\epsilon)^{p-k}$, 
o\`u $\epsilon$ est la probabilit\'e d'une erreur
de transmission. Par exemple, pour un message de $10^3$ caract\`eres,
chacun ayant une probabilit\'e d'erreur de transmission de $10^{-3}$,
si on prend $N=3$, alors la probabilit\'e d'avoir au moins 4 erreurs
est de 0.019 (arrondi par exc\`es)~:\\
\verb|P(N,eps,p):=sum(comb(p,k)*eps^k*(1-eps)^(p-k),k,N+1,p):;|\\
\verb|P(3,1e-3,10^3)|\\
Selon la nature du message, on acceptera une probabilit\'e d'avoir au
moins $N+1$ erreurs plus ou moins petite.

{\bf Exemple}~: On ne peut pas corriger d'erreur avec le bit de parit\'e.

\subsection{Distances}
La distance de Hamming de 2 mots est le nombre de symboles qui diff\`erent.
(il s'agit bien d'une distance au sens math\'ematique, 
elle v\'erifie l'in\'egalit\'e triangulaire). 

{\bf Exercice}~: 
\'ecrire une proc\'edure de calcul de la distance de Hamming
de 2 mots (la fonction Xcas correspondante s'appelle {\tt hamdist}).

La distance d'un code est la distance de Hamming minimale
de 2 mots diff\'erents du code.
Pour un code lin\'eaire, la distance est aussi le nombre minimal
de coefficients non nuls d'un vecteur non nul de l'image.
Pour un code polynomial, la distance du code
est le nombre minimal de coefficients non nuls d'un multiple
de $g$ de degr\'e inf\'erieur \`a $n$.

{\bf Exercice}~: quelle est la distance du code lin\'eaire que
vous avez cr\'e\'e plus haut~?

{\bf Majoration de la distance du code:}\\
La distance minimale d'un code lin\'eaire est inf\'erieure ou 
\'egale \`a $n-k+1$~: en effet on \'ecrit en ligne les coordonn\'ees
des images de la base canonique (ce qui revient \`a transposer la
matrice) et on r\'eduit par le pivot de Gauss,
comme l'application lin\'eaire est injective, le rang de la matrice
est $k$, donc la r\'eduction de Gauss cr\'ee $k-1$
z\'eros dans chaque ligne, donc le nombre de coefficients non nuls
de ces $k$ lignes (qui sont toujours des mots de code) est 
au plus de $n-k+1$.

{\bf Exercice}~: si votre code lin\'eaire n'est pas de distance 3, modifiez
les 3 derni\`eres lignes pour r\'ealiser un code de distance 3. On
ne peut pas obtenir une distance $n-k+1=4$ avec $n=7$ et $k=4$ 
dans $\Z/2\Z$, essayez! Essayez sur $\Z/3\Z$ et $\Z/5\Z$.

N.B.~: Pour les codes non
polynomiaux, par exemple convolutifs, la distance n'est pas
forc\'ement le
param\`etre le mieux adapt\'e \`a la correction d'erreurs.

\subsection{Correction au mot le plus proche}
Une strat\'egie de correction bas\'ee sur la distance consiste \`a
trouver le mot de code le plus proche d'un mot donn\'e.
Si la distance d'un code est sup\'erieure ou \'egale
\`a $2t+1$, et s'il existe un mot de code de distance 
inf\'erieure ou \'egale \`a $t$ au mot donn\'e, 
alors ce mot de code est unique.
On corrige alors le mot transmis en le remplacant par le mot de code
le plus proche.

{\bf Exercice}~: \'ecrivez un programme permettant de corriger une erreur
dans un mot dans votre code lin\'eaire.

On dit qu'un code $t$-correcteur est parfait si la r\'eunion des boules
de centre un mot de code et de rayon $t$ (pour la distance de Hamming)
est disjointe et recouvre l'ensemble des mots ($K^n$).

{\bf Exercice}~: votre code lin\'eaire sur $\Z/2\Z$ (celui de distance 3) 
est-il un code 1-correcteur parfait~?

{\bf Remarque~:}\\
Pour avoir un syst\`eme de codage efficace, la correction d'une erreur 
au mot le plus proche doit pouvoir \^etre effectu\'ee plus rapidement
que par recherche d'un mot de code parmi les mots 
ayant 1, 2, ..., $t$ symboles diff\'erents du mot recu. Certains codes
polynomiaux le permettent. Il en est ainsi pour les codes
de Reed-Solomon, utilis\'es par exemple pour corriger des erreurs
de lecture sur les CD audio, l'algorithme de recherche
du mot de code est une version modifi\'ee de l'algorithme de B\'ezout
pour les polyn\^omes (avec des coefficients dans le corps fini
\`a 256 \'el\'ements).

%\vspace{1cm}

\end{document}

\section{TP1: famille libre, application lin\'eaire}

Dans le plan, on associe au vecteur $v \in \R^2$ le point $M$ tel
que $\overrightarrow{OM}=v$ ($O$ l'origine), 
de m\^eme dans l'espace pour $v\in \R^3$.

\begin{enumerate}

\item Repr\'esenter dans le plan 
(menu \verb|Geo->Nouvelle figure->graph geo2d|) les vecteurs $v(1,2)$
et $w(-1,1)$ en utilisant l'instruction \verb|vecteur|
et 0 comme origine (par exemple \verb|v:=vecteur(0,[1,2])|). 
Repr\'esenter graphiquement le vecteur
$z(3,4)$ comme combinaison lin\'eaire de $v$ et $w$.
{\bf Attention, ne pas utiliser de combinaison lin\'eaire avec le
signe -, utiliser + et un coefficient n\'egatif entre parenth\`eses}.

\item Repr\'esenter dans l'espace 
(menu \verb|Geo->Nouvelle figure->graph geo3d|)
les point $O(0,0,0)$,
$A(1,1,2)$, $B(-1,2,1)$ ainsi que les vecteurs 
$\overrightarrow{OA}$ et $\overrightarrow{OB}$ et le plan passant par
$O,A,B$ (remarque: pour faire bouger le point de vue, utilisez
la souris {\bf en-dehors du cube de visualisation}. Pour zoomer, utiliser
les boutons in et out.
Vous pouvez aussi donner des attributs aux objets graphiques
avec le menu \verb|Graphic->Attributs|)\\
Quel est l'ensemble des points $M$ tels que la famille
$\{ \overrightarrow{OA}, \overrightarrow{OB}, \overrightarrow{OM}\}$ 
est li\'ee~?\\
Soit $N(1,1,1)$. En regardant la position de $N$ 
par rapport aux constructions pr\'ec\'edentes, dire si
la famille $\{ \overrightarrow{OA}, \overrightarrow{OB},
\overrightarrow{ON}\}$ est libre. Trouver un point $P$
distinct de $A, O, B$ tel que la famille 
$\{ \overrightarrow{OA}, \overrightarrow{OB},
\overrightarrow{OP}\}$ soit li\'ee.
Pour un point $M$ de l'espace (par exemple (2,2,-2)),
 repr\'esenter le vecteur $\overrightarrow{OM}$ comme combinaison
lin\'eaire de $\overrightarrow{OA}, \overrightarrow{OB}, 
\overrightarrow{ON}$ (attention, utilisez des sommes avec \'eventuellement
un coefficient n\'egatif)\\
Soit $A,B,C$ trois points de l'espace.
Enoncer une condition g\'eom\'etrique qui permet de d\'ecider
si $\overrightarrow{OA},\overrightarrow{OB},\overrightarrow{OC}$ est
une famille libre.

\item 
On consid\`ere l'application $l$ correspondant \`a la sym\'etrie
par rapport \`a l'axe des $x$ (instruction \verb|symetrie| dans Xcas).
Traduire g\'eom\'etriquement ce que signifie la lin\'earit\'e de $l$~:
ainsi pour calculer la somme de 2 vecteurs, on repr\'esentera le
parall\'elogramme d\'efini par l'origine et les 2 vecteurs comme c\^ot\'es 
adjacents issus de l'origine.
D\'eterminer le noyau et l'image de $l$.

\item Dans le plan on consid\`ere la projection orthogonale
sur l'axe $y=x$ et l'application $l$ correspondante comme ci-dessus.
Traduire g\'eom\'etriquement comme ci-dessus la lin\'earit\'e de $l$
et repr\'esenter les points correspondants aux vecteurs
du noyau et de l'image de $l$. 
Calculer l'image des deux vecteurs de la base canonique de $\R^2$,
en d\'eduire la matrice de $l$ relativement \`a la base canonique.
Faire de m\^eme pour la base compos\'ee de $(1,0)$ et de $l((1,0))$.

\item On consid\`ere l'application lin\'eaire de $\R^3$ dans $\R^2$ 
associ\'ee \`a la projection sur la droite $x=0,z=0$ parall\`element
au plan $y=0$ avec identification de $\R^2$ avec le plan $z=0$. 
Repr\'esenter les points de l'espace correspondant
au noyau de $p$ et les points du plan correspondant \`a l'image
de $p$.

\end{enumerate}

\pagebreak