diff --git a/DemoProjets/AutomateCellulaire/Sujet/automates.tex~ b/DemoProjets/AutomateCellulaire/Sujet/automates.tex~
deleted file mode 100755
index c4690fe547c64c914739700e107f88460209fd26..0000000000000000000000000000000000000000
--- a/DemoProjets/AutomateCellulaire/Sujet/automates.tex~
+++ /dev/null
@@ -1,167 +0,0 @@
-\documentclass[a4paper,12pt]{article}
-\usepackage[utf8]{inputenc}
-\usepackage[T1]{fontenc}
-\usepackage{../../../TP/exos}
-
-\title{Projet C : automates cellulaires}
-\author{Guyet T.}
-\date{2011-2012}
-
-\begin{document}
-
-\maketitle
-
-%Le présent exercice consiste à implémenter en C une version sur damier torique d'un automate cellulaire, en particulier avec les règles du jeu de la vie de John Conway.
-
-\section{Présentation du jeu}
-
-L'objectif de ce projet est d'implémenter le mécanisme d'application des règles d'un automate cellulaire. Ce type de modèle dynamique de l'espace est utilisé en écologie du paysage pour simuler des processus physiques spaciaux (progression d'un feu dans une forêt, colonisation par des insectes, transfert de gènes entre parcelles agricoles, ...)
-
-Un automate cellulaire représente l'espace sous la forme d'une grille en 2 dimensions. Chaque case de la grille contient un entier (valeur définie dans un ensemble fini de valeurs, par exemple, dans le ``jeu de la vie'' seules deux valeurs sont possibles, mais on va ici généraliser). Chaque valeur correspond à un ``état'' de la case.
-
-%La grille est remplie de valeurs parmis les valeurs acceptables (aucune case vide). En particulier, il faut un état initial à votre grille qui sera chargé à partir d'un fichier.
-
-Un ensemble de règles permet de définir l'évolution des valeurs de la grille dans le temps. Dans un contexte de feu de forêt, on peut mettre des règles du genre ``si la cellule est de la forêt et qu'au moins deux cellules voisines sont en
-feu, alors la cellule devient feu''. On peut ainsi observer l'évolution d'un phénomène.
-
-Globalement, le programme suit l'algorithme suivant~:
-
-\begin{verbatim}
-PROGRAMME:
- Initialiser la grille G;
- REPETER:
- Afficher la grille G;
- Compute(G);
- sleep(100);
-\end{verbatim}
-
-La fonction \texttt{Compute} sera vue par la suite, elle permet de transformer la grille G. la fonction \lstinline!sleep(100)! est une fonction C de la librairie \texttt{time.h}, qui permet de suspendre l'exécution du programme pendant 100ms le temps que l'utilisateur visualise le résultat de l'affichage.
-
-\section{Représentation de la grille}
-
-On pourra représenter la grille par un tableau d'entiers. En préambule du programme, vous définirez une constante correspondant à la taille de la grille.
-Même si il est généralement conseillé d'éviter de déclarer des variables globales, vous définirez la grille en variable globale, \ie une variable qui sera visible par toutes les fonctions et qui évitera de la passer toujours en paramètre.
-
-
-
-\begin{lstlisting}[numbers=none]
-#define SIZE 30
-
-int monde[SIZE][SIZE];
-\end{lstlisting}
-
-\question{Créer une fonction \lstinline!void init_alea(int val_max)! une fonction de génération aléatoire des valeurs de la grille. Les valeurs de la grille seront choisies entre 0 et \lstinline!val_max!.}
-
-\question{Écrire le programme principal ci-dessous qui vous permettra de tester l'affichage avec les fonctions fournies (dans une fenêtre ou dans un terminal).}
-
-\begin{verbatim}
-G[20][20];
-
-PROGRAMME:
- val_max=10;
- init_alea(val_max);
- REPETER:
- Afficher la grille G;
- init_alea(val_max);
- sleep(100);
-\end{verbatim}
-
-\subsection{Grille torique}
-Représenter la grille de l'automate cellulaire par un tableau est la solution la plus simple. Mais il y reste le problème des bords pour l'application des règles. Comme on ne peut pas représenter un tableau infini, plusieurs choix sont alors possibles pour résoudre cette limite~:
-\begin{itemize}
- \item considérer l'absence de voisin (au bord du tableau) comme une cellule dans un état particulier;
- \item jouer sur un damier torique.
-\end{itemize}
-
-La seconde solution, respecte mieux le jeu initial. On doit considérer que les bords droit et gauche du
-tableau sont reliés entre eux, ainsi que les bords supérieurs et inférieurs. Le voisinage des points est donc
-le suivant :
-
-\includegraphics{GrilleTorique}
-
-Ceci devra être pris en compte dans la suite.
-
-
-\section{Évolution}
-
-La principale difficulté de ce projet se trouve dans la fonction d'évolution de la grille. À côté de la grille se trouvent un ensemble de règles de transformation qui indique la valeur que doit prendre une case au temps $t+1$ en fonction des valeurs des cases voisines au temps $t$. Les cases voisines d'une case $(i,j)$ comprennent $(i,j)$ elle-même, les cases qui touches $(i,j)$, par exemple $(i+1, j)$, et éventuellement des cases plus lointaines $(i+2,j)$. On se restreindra aux cases immédiatement en contact d'une case à modifier.
-
-
-Le principe de cette évolution est illustré par l'algorithme ci-dessous.
-
-\begin{verbatim}
-Compute(Grille G1):
- G2 = copie(G1);
- POUR CHAQUE CASE (i,j) de G2:
- nv <- regle(G2, [i,j]);
- G1[i,j] <- nv;
- detruire G2;
-\end{verbatim}
-
-La solution proposée ici consiste à utiliser une grille annexe, \texttt{G2}, qui représente la grille au temps $t$ pour modifier tranquillement la grille \texttt{G1} (passée en paramètre), qui représente la grille au temps $t+1$.
-
-La difficultée qu'il vous reste à traiter est celle de la fonction \lstinline!regle! qui consiste à implémenter une règle en fonction des cellules de \texttt{G2} autour de la position $[i,j]$ permettant de trouver la nouvelle valeur $nv$ de \texttt{G1}
-
-\espace
-
-Dans ce projet, on vous demande de réaliser deux jeux de règles (\cf sections suivantes), il est donc important de conserver l'idée d'avoir une fonction \lstinline!regle()! pour appliquer les modifications de la grille. Votre programme devra donc fonctionner indépendamment des transformation de cette fonction pour la modifier facilement.
-
-\question{Créer une fonction \lstinline!regle()! qui retourne la valeur de la cellule $(i,j)$ de la grille en paramètre (\ie une règle qui ne fait rien).}
-\question{Implémenter la fonction \lstinline!compute()!}
-\question{Modifier votre programme précédant pour faire appliquer les transformations de la fonction \lstinline!compute()!}
-
-\section{Le jeu de la vie}
-
-\subsection{Historique}
-John Conway était un mathématicien de l'Université de Cambridge. Très prolifique en matière de jeux
-mathématiques, il décrivit en 1970 le jeu de la vie, visant à modéliser d'une façon simple l'évolution
-d'organismes vivants. Le jeu de la vie est une application particulière d'automates cellulaires.
-
-\subsection{Règles du jeu de la vie}
-Le jeu de la vie évolue normalement sur un damier infini. Chaque case est occupée par une cellule qui peut
-être vivante ou morte. À chaque génération, chaque cellule peut naître, mourir, ou rester dans son état. Les
-règles qui permettent de passer d'une génération à l'autre sont précises et ont été choisies avec soin pour
-que l'évolution des organismes soit intéressante et imprévisible. En premier lieu, notons que sur un damier
-infini, chaque case a exactement 8 voisins. Les règles données par J. Conway sont les suivante :
-\begin{itemize}
- \item Une cellule ayant exactement 2 ou 3 voisins vivants survit à la génération suivante.
-\item Une cellule ayant au moins 4 cellules voisines vivantes meurt d'étouffement à la génération suivante.
-\item Une cellule ayant au plus une cellule voisine vivante meurt d'isolement à la génération suivante.
-\item Sur une case vide ayant exactement 3 voisins vivants, une cellule naîtra à la génération suivante.
-\end{itemize}
-
-Notons que c'est l'ensemble de la génération actuelle qui doit être pris en compte pour l'établissement de
-l'état des cellules à la génération suivante.
-Voici un exemple de figure sur un petit damier. Les cellules qui devront mourir à la génération suivante
-sont grisées :
-
-%\begin{figure}
- \includegraphics[width=\textwidth]{GrillesGeneration.png}
-%\end{figure}
-
-\question{Créer une fonction \lstinline!regle_conway()! qui implémente les règles du jeu de la vie.}
-%\question{Créer une fonction \lstinline!regle_conway()! qui implémente les règles du jeu de la vie.}
-
-\subsection{Intérêt du jeu de la vie}
-Malgré son apparente simplicité, le jeu de la vie recèle de nombreuses surprises. En partant d'un tableau
-aléatoire, on peut difficilement les observer même si l'apparition d'un planeur (voir l'exemple du début)
-ou de formes périodiques (à la fin) ne sont pas rares.
-Certaines personnes ont répertoriées des centaines des formes aux propriétés particulières :
-\begin{itemize}
- \item générateurs de planeurs (les lanceurs),
- \item portes logiques,
- \item formes périodiques de grande période,
- \item formes stables...
-\end{itemize}
-
-La possibilité d'initialiser le damier avec une forme particulière est donc intéressante pour pouvoir observer
-ces phénomènes. On pourra donc permettre à l'utilisateur de lire l'état des cases dans un fichier, afin qu'il
-choisisse l'état initial du damier.
-
-\section{Application aux feux de forêt}
-
-Le modèle d'évolution du feu de forêt de Christophe Le Page, François Bousquet (Cirad) (\cf \url{http://cormas.cirad.fr/fr/applica/fireautomata.htm}) illustre les principes des automates cellulaires. Chaque cellule peut se trouver dans quatre états: \texttt{feu}; \texttt{arbre}; \texttt{cendre}; \texttt{vide}. Chaque cellule de la grille spatiale est initialement, selon une probabilité $p$, un arbre, et selon une probabilité $1-p$, vide. On met le feu à une cellule et on suit la diffusion du feu à travers la grille spatiale selon la fonction de transition suivante: une cellule prend feu au temps $t$ si l'une au moins de ses 4 voisines (nord, est, sud, ouest) est en feu au temps $t-1$. Les cellules en feu passeront en cendres au temps suivant, les cellules en cendres deviendront vides au temps suivant.
-
-\question{Créer une fonction \lstinline!regle_feuforet()! qui implémente ce modèle et reproduit les expérimentations.}
-
-\end{document}
diff --git a/DemoProjets/BatailleNavale/Sujet/BatailleNavale.tex~ b/DemoProjets/BatailleNavale/Sujet/BatailleNavale.tex~
deleted file mode 100644
index 8f38edba8e64219ab684c4ae01224949bf820884..0000000000000000000000000000000000000000
--- a/DemoProjets/BatailleNavale/Sujet/BatailleNavale.tex~
+++ /dev/null
@@ -1,170 +0,0 @@
-\documentclass[a4paper,12pt]{article}
-\usepackage[utf8]{inputenc}
-\usepackage[T1]{fontenc}
-\usepackage{../../../TP/exos}
-
-\title{Projet C : bataille navale}
-\author{Guyet T.}
-\date{2011-2012}
-
-\begin{document}
-\maketitle
-
-\section{Présentation du jeu}
-La grille de jeu est un carré SIZExSIZE (SIZE=10).
-Chaque joueur possède les mêmes navires, dont le nombre et le type dépendent des règles du jeu choisies.
-Une disposition peut ainsi comporter~:
-\begin{itemize}
- \item 1 porte-avions (5 cases)
- \item 2 croiseur (4 cases)
- \item 1 contre-torpilleurs (3 cases)
- \item 1 sous-marin (3 cases)
- \item 2 torpilleurs (2 cases)
-\end{itemize}
-
-À chaque tour, un joueur annonce les coordonnées d'une case. Les trois réponses sont ``touché'', ``coulé'' ou ``dans l'eau'' en fonction de la présence d'un bateau ou non.
-Les joueurs jouent successivement. Pour simplifier, on ne donne pas d'avantage au joueur qui touche ou coule un bateau.
-
-Un joueur a gagné lorsqu'il a touché tous les bateaux de l'adversaire avant ce dernier.
-
-\espace
-
-L'objectif de ce projet est de réaliser un jeu de bataille navale qui permette de jouer contre l'ordinateur. Le développement d'une statégie de l'utilisateur ne fait pas partie du sujet (pour le fera joué de manière aléatoire).
-
-\section{Représentation du jeu}
-
-Lors de la réalisation d'un programme, la première difficulté est de trouver des structures de données qui vont permettre de programmer facilement les traitements à réaliser.
-
-Nous allons représenter une grille de jeu (``océan'' de l'adversaire) avec deux tableaux de taille SIZExSIZE:
-\begin{itemize}
- \item une grille de masquage qui ne comportera que des 0 et des 1. Cette grille servira à représenter les cases qui ont été tirée par rapport aux cases qui ne l'ont pas été. Pour l'utilisateur, seule les cases tirées sont visibles.
- \item une grille de bateaux qui positionne les bateaux en représentant chaque bateau par un entier (le -1 pourra servir à coder l'absence de bateau).
-\end{itemize}
-
-On définit également quelques constantes utiles :
-\begin{lstlisting}[numbers=none]
-#define SIZE 10 //< taille de la matrice de jeu
-
-//Définition des tailles de tableau par type
-#define SIZE_PORTEAVION 5
-#define SIZE_CROISEUR 4
-#define SIZE_CONTRETORPILLEUR 3
-#define SIZE_SOUSMARIN 3
-#define SIZE_TORPILLEUR 2
-\end{lstlisting}
-
-\question{Créer une fonction \lstinline!int **alloc_matrix()! qui vous permettra d'allouer des tableaux de taille SIZExSIZE}
-
-\question{Écrire une fonction \lstinline!void init(int **bateaux, int **ocean)! qui initialise les tableaux d'une grille de jeu : sans bateaux, tous couverts}
-
-\question{Écrire une fonction \lstinline!void print(int **bateaux, int **ocean)! qui affiche une grille au joueur en fonction des cases visibles}
-Pour des raisons de test, je conseille de faire en sorte que l'affichage visualise le numéro de bateaux (et pas uniquement l'existance d'un bateau comme le jeu devra le faire à la fin).
-
-Exemple d'affichage sur une grille 10x10 (les * indiquent les zones masquées, les numéros indiquent les bateaux 1 et 6, et les espaces indiquent l'eau ...) :
-\begin{verbatim}
-|----------|
-|**********|
-|**********|
-|**** 1****|
-|**** 1****|
-|**** 1****|
-|***661 ***|
-|**** ****|
-|**********|
-|**********|
-|**********|
-|----------|
-\end{verbatim}
-
-\section{Principe général du jeu}
-
-L'algorithme général du jeu sera le suivant :
-
-\begin{verbatim}
-GrilleHumain, GrilleOrdinateur
-initialiser les grilles
-positionner les bateaux de l'ordinateur dans grilleHumain (aléatoire)
-positionner les bateaux de l'humain dans grilleOrdinateur (aléatoire également)
-REPETER:
- printf("Tour ordinateur");
- (x,y) <- jouer_auto;
- modifier grilleOrdinateur
- SI( Ordinateur a gagné ):
- printf("vous avez perdu");
- sortir
-
- printf("Tour ordinateur");
- (x,y) <- scanf();
- modifier grilleHumain
- afficher grilleHumain
- SI( Humain a gagné ):
- printf("vous avez gagné");
- sortir
-TANT QUE 1
-\end{verbatim}
-
-
-Je n'ai personnellement pas implémenté de fonction spécifique pour que le joueur humain positionne ses bateaux, je réutilise la génération aléatoire du l'ordinateur. Vous pouvez implémenter une telle fonction en complément (mais après, c'est très long pour tester et ça sert à rien !!)
-
-La suite du sujet vous dirige dans la réalisation des différentes fonctions qui me semblent utiles à la réalisation de ce programme.
-\begin{itemize}
- \item Fonctions pour la génération aléatoire des positions des bateaux
- \item Fonction pour modifier une grille et afficher à l'utilisateur ``touché'', ``coulé'', ou ``dans l'eau''.
- \item Fonction pour évaluer la fin du jeu,
-\end{itemize}
-
-
-\espace
-
-Pour commencer votre projet, vous n'êtes pas obligé de travailler sur le jeu à deux joueurs. Avec le programme ci-dessous, vous pouvez tester vos fonctions sans avoir d'adversaire :
-
-\begin{verbatim}
-GrilleHumain
-initialiser la grilles
-positionner les bateaux (aléatoirement)
-REPETER:
- printf("Jouer");
- (x,y) <- scanf();
- modifier grilleHumain
- afficher grilleHumain
- SI( Humain a gagné ):
- printf("vous avez gagné");
- sortir
-TANT QUE 1
-\end{verbatim}
-
-
-\section{Positionnement des bateaux(\hard)}
-
-La difficulté de cette étape est de positionner successivement des bateaux dans un espace limité sans que ceux-ci puisse se superposés.
-
-Je propose d'utiliser une méthode stochastique pour le positionnement des bateaux. Pour cela, vous aurez besoin de trois fonctions :
-\begin{itemize}
- \item \lstinline!int * positionner_alea(int nb_porteavion, int nb_croiseur, int nb_contretorpilleur, int nb_ssmarin, int nb_torpilleur, int **bateaux)! : cette fonction positionne l'ensemble des bateaux dans le tableau. Les paramètres donnent le nombre de bateau à insérer par type.
- \item \lstinline!void positionner_bateau_alea(int size, int id, int **bateaux)! : cette méthode permet de positionner un bateau $id$ de taille $size$ dans le tableau de bateaux.
- \item \lstinline!int test_insertion(int x, int y, int size, int orientation, int **bateaux)! : cette fonction teste si l'insertion d'un bateau à la case $(x,y)$ avec l'orientation choisie (0 pour bas et 1 pour droite par exemple) est possible dans le tableau des bateaux.
-\end{itemize}
-
-L'idée de la méthode stochastique est d'insérer successivement chaque bateau (les plus grands d'abord). Pour chaque bateau, vous generez aléatoirement des positions et orientation d'insertion et vous testerez si l'insertion est possible (\ie que cela ne se superpose pas avec un bateau déjà placé). Si le test n'est pas bon, alors, vous générez une nouvelle position aléatoire, etc.
-
-Pour éviter de boucler indéfiniement lorsque l'espace est très contraint, vous testerez au maximum \lstinline!MAXT! position aléatoire avant d'abandonner le programme !
-
-La première fonction retourne un tableau d'entier de taille $nb\_porteavion+nb\_croiseur+nb\_contretorpilleur+nb\_ssmarin+nb\_torpilleur$ contenant les tailles de chacun des bateaux. Par exemple, si on retourne $[4, 2, 2]$, il y a 3 bateaux : le bateau 0 est de taille 4, le bateau 1 est de taille 2 et le bateau 2 est de taille 2.
-Ce tableau servira à savoir combien de case d'un bateau sont encore à toucher avant de le couler !!
-
-\question{Écrire ces trois fonctions}
-
-\section{Évaluation des coups d'un joueur}
-
-Deux fonctions sont utiles pour tester les coups d'un joueur
-\begin{itemize}
- \item \lstinline!void coule(int i, int j, int *couler, int **bateaux)! qui affiche à l'écran les informations sur ce qui se passe à la case $(i,j)$ et modifie le tableau \lstinline!couler! en conséquent.
- \item \lstinline!int gagne(int **bateaux, int **ocean)! qui retourne 1 si la grille indique que le joueur a découvert tous les bateaux ou 0 sinon.
-\end{itemize}
-
-
-
-\question{Écrire ces deux fonctions.}
-
-
-\end{document}
\ No newline at end of file
diff --git a/DemoProjets/Demineur/Sujet/demineur.c~ b/DemoProjets/Demineur/Sujet/demineur.c~
deleted file mode 100644
index 82fc1a52fde814d6b5c68a7e9fa52f81fa043c67..0000000000000000000000000000000000000000
--- a/DemoProjets/Demineur/Sujet/demineur.c~
+++ /dev/null
@@ -1,176 +0,0 @@
-\documentclass[a4paper,12pt]{article}
-\usepackage[utf8]{inputenc}
-\usepackage[T1]{fontenc}
-\usepackage{../../../TP/exos}
-
-\title{Projet C : démineur}
-\author{Guyet T.}
-\date{2011-2012}
-
-\begin{document}
-\maketitle
-
-\section{Présentation du jeu}
-
-Le jeu se présente sous la forme d'un tableau de cases à deux dimensions. Certaines cases contiennent des mines. Au départ toutes les cases sont masquées (et on ne voit donc pas les mines). L'objectif est de localiser les mines (le nombre de mines restant à localiser étant donné au joueur). Le joueur peut au choix découvrir le contenu d'une case, ou la marquer pour signaler la présence d'une mine (c'est son hypothèse et le décompte des mines se fixe là dessus). Les cases découvertes affichent le nombre de mines dans les 8 cases voisines, sauf si la case contient elle même une mine (auquel cas le joueur meurt et la partie est terminée). Si le joueur n'est pas mort, la partie se termine lorsque le joueur a découvert toutes les cases (sauf celles avec les mines).
-
-Dans la version originale, le score est le temps mis pour terminer une grille. Dans notre cas, on ne prend pas en compte le temps (extension possible).
-
-\section{Principe générale du programme}
-Le principe général de ce programme est décrit dans l'algorithme ci-dessous :
-\begin{verbatim}
-Initialiser les mines
-REPETER:
- afficher grille
- (x,y)<-scanf
- SI mine en (x,y) ALORS
- printf("perdu");
- SINON
- demasquer(x,y);
-TANT QUE pas gagne()
-\end{verbatim}
-
-
-Les éléments principaux du développement sont donc :
-\begin{enumerate}
-\item l'initialisation des mines (tirage aléatoire du tableau à deux dimensions),
-\item la définition d'un affichage d'une grille de mines,
-\item la procédure permettant de desmaquer des zones continue sans mines,
-\item la fonction de test de fin de jeu
-\end{enumerate}
-
-
-\section{Structures de données}
-
-Lors de la réalisation d'un programme, la première difficulté est de trouver des structures de données qui vont permettre de programmer facilement les traitements à réaliser.
-
-Dans le cas de ce problème, on vous propose de représenter une grille de démineur par deux matrices d'entiers de taille DIMxDIM :
-\begin{itemize}
- \item un tableau \lstinline!int **masque[DIM][DIM]! : une grille qui code par 1 les cases visibles par l'utilisateur et par 0 les cases non-visibles
- \item un tableau \lstinline!int **mines[DIM][DIM]! : qui contient les positions des mines (-1 si il y a une mine) et si il n'y a pas de mines, la case indique le nombre de mines qui sont adjacentes à la case.
-\end{itemize}
-
-Bien que ce ne soit généralement pas une bonne pratique, vous placerez ces deux matrices en variable globale, \ie déclarée au début du fichier. Elles seront ainsi utilisables dans toutes les fonctions sans avoir à les passer en paramètre.
-
-Le début du fichier contiendra les lignes suivantes~:
-\begin{lstlisting}[numbers=none]
-#define DIM 8 //Taille de tableau
-#define NBMINES 4 //Nombre de mines dans le tableau
-
-int masque[DIM][DIM];
-int mines[DIM][DIM];
-\end{lstlisting}
-
-\section{Première version simple}
-
-On va d'abord traiter une version simple dans laquelle on ne se posera pas la question des espaces continues et des
-
-On simplifie à la réalisation de l'algorithme ci-dessous :
-\begin{verbatim}
-Initialiser les mines
-REPETER:
- afficher grille
- (x,y)<-scanf
- SI mine en (x,y) ALORS
- printf("perdu");
- SINON
- masque[x][y]=1; //rendre la case visible
-TANT QUE gagne()
-\end{verbatim}
-
-\subsection{Affichage d'une grille}
-
-\question{Implémenter une fonction \lstinline!void print()! qui affiche une grille de jeu}
-
-Dans cette question, il ne faut pas se poser de questions sur le choix des cases à afficher ou non. Il faut utiliser les informations du masque qui indiquent ce qu'il faut afficher ou non. De même, les nombre à afficher sont disponibles dans la matrice \lstinline!mines!.
-
-L'illustration ci-dessous donne un exemple d'affichage à obtenir pour une grille 4x4~:
-\begin{verbatim}
-? ? ? ?
-? ? ?
-? X ?
-? ? ? ?
-\end{verbatim}
-
-\begin{itemize}
- \item "?" est utilisé pour les cases encore couvertes,
- \item les cases vides sont des cases sans mines,
- \item vous pouvez dessiner la présence d'une mine par une croix.
-\end{itemize}
-
-\subsection{Fonctions de fin de jeu}
-
-\question{Implémenter une fonction \lstinline!int boom(int i, int j)! qui retourne 1 si il y a une mine en $(i,j)$ et 0 sinon.}
-
-\question{Implémenter une fonction \lstinline!int gagne()! qui retourne 0 si le jeu n'est pas gagné et 1 sinon}
-
-On rappelle que le jeu sera fini et gagné lorsqu'il ne restera plus que des mines sous les points d'interrogation.
-
-
-\subsection{Initialisation des mines}
-
-Aller ... encore une petite fonction et on pourra jouer !! En effet, il nous faut encore pouvoir initialiser le jeu.
-
-\question{Implémenter une fonction \lstinline!void init_mines()! qui positionne aléatoirement \lstinline!NBMINES! dans le jeu}
-
-\underline{Attention~:} tout n'est pas aussi simple que ça ! Ici, on veut qu'il y ait exactement \lstinline!NBMINES! dans le jeu !!
-
-\subsection{Réalisation de la première version}
-
-\question{Écrire le programme pour la première version du jeu du démineur}
-
-Vous pouvez maintenant jouer avec une version simplifiée du démineur ... mais pas de temps à perdre, il y a encore un peu de boulot qui vous attends !
-
-\section{Seconde version quasi-complete}
-
-À ce niveau, il est conseillé de faire une sauvegarde de votre travail précédent. Vous allez apporter des modifications à vos fonctions, et mieux vaut conserver une trace d'une version d'étape pour éventuellement y revenir.
-
-\espace
-
-Dans cette nouvelle version, on veut pouvoir :
-\begin{itemize}
- \item afficher le nombre de mines dans les cases adjacentes,
- \item découvrir les zones continues sans mines.
-\end{itemize}
-
-Nous allons avoir comme stratégie de précalculer, lors de l'initialisation des mines, les nombres de mines dans les cases adjacentes (en effet, il est connue dès le départ) et mettre cette information dans le tableau \lstinline!mines!.
-
-Ceci nous permettra normalement de ne changer que peu de chose à l'affichage : si une case n'est pas de mines, soit elle est vide et on n'affiche rien, soit on affiche le nombre de mines adjacentes (contenue dans \lstinline!mines!) ...
-
-Ensuite, on pourra utiliser cette information pour découvrir les zones continues.
-
-\subsection{Précalcul des nombres de mines adjacentes}
-
-\question{Écrire une fonction \lstinline!int comptermines(int i, int j)! qui compte le nombre de mines adjacentes à la case $(i,j)$ et retourne cette valeur.}
-
-\underline{Attention~:} faites très attention aux bords !!! Pour la gestion des bords, il y a des versions longues (tester manuellement tous les cas) et pour lesquelles beaucoup d'erreurs sont possibles et des solutions élégantes.
-
-\question{Modifier la fonction \lstinline!init_mines()! pour que le tableau \lstinline!mines! contiennent les nombres de mines adjacentes à toutes les positions pour lesquelles il n'y a pas de mine.}
-
-\subsection{Découverte des zones continues}
-
-On rappelle ici que découvrir une case consiste à mettre la valeur 1 pour la case correspondante du masque.
-
-\question{Écrire une fonction récursive \lstinline!void decouvre(int i, int j)! qui découvre une zone continue.}
-
-Le principe de cette fonction est la suivante~: si la case est déjà découverte ou qu'il y a une mine, alors il ne faut rien faire, sinon il faut découvrir la case et tenter de découvrir toutes les cases voisines.
-
-\underline{Attention~:} De nouveau, il faut faire attention aux bords pour la récursion !!
-
-\subsection{Finalisation}
-
-Vous avez maintenant tous les éléments nécessaire à la réalisation d'un programme Démineur complet.
-
-\question{Finaliser votre programme}.
-
-\section{Extensions possibles}
-
-Quelques idées d'extension~:
-\begin{itemize}
- \item ajouter la possibilité de mettre des drapeaux pour signaler les mines : permet de bloquer l'utilisation de la case (pour éviter mes mauvaises manipulations), et aide le joueur à être efficace,
- \item ajouter un chrono (voir sur internet l'utilisation des différences d'heures),
- \item ajouter la gestion des meilleurs scores avec un fichier.
-\end{itemize}
-
-
-\end{document}
\ No newline at end of file
diff --git a/DemoProjets/EDO/Sujet_EDO.tex~ b/DemoProjets/EDO/Sujet_EDO.tex~
deleted file mode 100755
index f24be2ff5cdef3821a1d4923fd0eac53616728d6..0000000000000000000000000000000000000000
--- a/DemoProjets/EDO/Sujet_EDO.tex~
+++ /dev/null
@@ -1,213 +0,0 @@
-\documentclass[a4paper,12pt]{article}
-\usepackage[utf8]{inputenc}
-\usepackage[T1]{fontenc}
-\usepackage{../../TP/exos}
-
-\author{Thomas Guyet}
-\title{EDO : Equation différentielles ordinaires}
-\date{2011-2012}
-
-\begin{document}
-
-\maketitle
-
-\section{Résolution numérique d'équations différentielles}
-
-\subsection{Équation à une dimension}
-
-Une équation différentielle ordinaire est de la forme~:
-$$\frac{dy(t)}{dt}=f(t,y), \; y(0)=y_0$$
-
-La méthode de résolution numérique d'une équation différentielle consiste à calculer, de proche en proche, les valeurs de $y(t)$.
-
-La méthode d'Euler est la méthode la plus simple pour faire cela. Elle permet de calculer $y(t+h)$ à partir de $y(t)$ de la manière suivante~:
-\begin{equation}
- y(t+h) = y(t) + h*f(t)
-\label{equ:euler}
-\end{equation}
-
-où $h$ est une petite valeur qui désigne le pas de la méthode. Plus le pas sera petit, plus la résolution sera précise (mais plus elle sera longue à calculer).
-
-En fait, par définition de la différentielle suivante~: $$\frac{dy(t)}{dt} = \lim_{h->0} \frac{y(t+h) - y(t)}{h},$$ si $h$ est petit on a $$\frac{dy(t)}{dt} = \frac{y(t+h) - y(t)}{h} + O(h^2)\approx \frac{y(t+h) - y(t)}{h}.$$ Soit $$f(t,y)\approx \frac{y(t+h) - y(t)}{h},$$ et donc on en déduit la formule de calcul de $y(t+h)$ ci-dessus (\ref{equ:euler}).
-
-La méthode de Runge-Kutta d'ordre 2 (Equation (\ref{equ:rk2})) et d'ordre 4 (Equation (\ref{equ:rk4})) affinent l'approximation par des schémas de calcul réduisant l'erreur d'approximation commise à chaque pas~:
-
-\begin{equation}
-y(t+h) = y(t) + h f(t+h/2, y(t)) + O(h^3)
-\label{equ:rk2}
-\end{equation}
-\begin{equation}
-y(t+h) = y(t) + h/6 * (k1+2.k2+2.k3+k4)+ O(h^5)
-\label{equ:rk4}
-\end{equation}
-
-avec $$k1 = h*f(t, y(t)),\; k2 = h*f(t+h/2, y(t) + k1),$$ $$k3 = h*f(t+h/2, y(t) + k2),\;k4 = h*f(t+h, y(t) + k3)$$
-
-
-La Figure \ref{fig:Euler} illustre le fonctionnement des méthodes d'Euler et de Runge-Kutta d'ordre 2.
-\begin{figure}[ht]
- \begin{center}
- \includegraphics[width=7cm, bb=0 0 658 374]{euler.png}
- \includegraphics[width=7cm, bb=0 0 658 381]{rungekutta2.png}
-\end{center}
-\caption{Illustration de la méthode d'Euler (à gauche) et de Runge-Kutta d'ordre 2 (à droite).}
-\label{fig:Euler}
-\end{figure}
-
-
-\begin{exercice}[Étude de la divergence des méthodes]
-On considère l'equation différentielle ordinaire~:
-$$\dot{y}(t) = y(t)^2;\; y(0) = 1$$
-
-\question{Résoudre cette équation numériquement avec la méthode d'Euler sur $[0, 1]$ (en fonction de $h$). Pour différentes valeurs de $h$, comparer à la solution exacte $y(t)=-\frac{1}{t-1}$ en calculant la valeur suivante~:}
-$$\sum_{t=0}^{1}{ \left(\tilde{y}(t)+\frac{1}{t-1}\right)^2 } $$
-\question{Résoudre cette équation numériquement avec la méthode RK2 et RK4 sur $[0, 1]$. Faire les mêmes comparaisons avec la solution exacte.}
-\question{Tracer les courbes comparant les erreurs des différentes méthodes en fonction de $h$.}
-\end{exercice}
-
-
-\subsection{Système d'équations différentielles}
-
-Dans le cas d'un problème différentiel à plusieurs variables, l'équation générale s'écrit alors ainsi :
-$$\frac{d\vec{X}(t)}{dt}=\vec{f}(t,\vec{X}), \; X(0)=X_0$$
-où $\vec{X}=\{x_1, x_2, ...,x_n\}$ est un vecteur, et $X_0$ est l'état initial du système.
-
-Le problème s'exprime alors comme un système d'équations différentielles :
-
-$$\left\{ \begin{array}{l}
-\frac{dx_1}{dt}= f_1(t,x_1, x_2, ...,x_n) \\
-\frac{dx_2}{dt}= f_2(t,x_1, x_2, ...,x_n) \\
-...\\
-\frac{dx_n}{dt}= f_n(t,x_1, x_2, ...,x_n) \\
-\end{array} \right.$$
-
-Ce système se résout de la même manière que précédemment. Par exemple, avec le schéma d'Euler, on aura :
-
-$$\left\{ \begin{array}{l}
-x_1(t+h)= x_1(t) +h*f_1(t,x_1(t), x_2(t), ...,x_n(t)) \\
-x_2(t+h)= x_2(t) +h*f_2(t,x_1(t), x_2(t), ...,x_n(t)) \\
-...\\
-x_n(t+h)= x_n(t) +h*f_n(t,x_1(t), x_2(t), ...,x_n(t)) \\
-\end{array} \right.$$
-
-
-
-\section{Trajectoire d'une balle de tennis}
-
-Comment se comporte une balle de tennis en l'air~? La trajectoire est difficile à calculer car, il faut tenir compte de plusieurs forces. Cette trajectoire ne peut pas être obtenue analytiquement. Il faut donc passer par des approximations numériques.
-
-\subsection{Modélisation du système}
-
-On souhaite construire des trajectoires réalistes d'une balle de tennis au service du joueur que l'on entraine. Pour cela, on utilise un modèle réaliste en 2 dimensions tenant compte des forces suivantes :
-\begin{itemize}
- \item le poids $\vec{G}=m.\vec{g}$ où $\vec{g}=(0,-g)$ est le vecteur de l'accélération due à la gravitation;
- \item la force de frottement $\vec{S}=-S \frac{\vec{v}}{\|\vec{v}\|}$, dont la direction est opposée à celle de $v$, le vecteur de vitesse de la balle;
- \item la force de Magnus $\vec{M}=M \frac{\vec{\omega} \times \vec{v}}{\|\vec{v}\|}$ cette force est perpendicuaire à $\vec{v}$ et $\vec{\omega}$, où $\vec{\omega}$ est le vecteur représentant la rotation de la balle.
-\end{itemize}
-
-Pour une balle de tennis, on peut négliger la décélération de la révolution de la balle, donc on considère que $\omega$ est constant. Dans la mesure où on travail en 2 dimension, on suppose que le vecteur $\vec{\omega}$ est perpendiculaire au plan d'étude.
-
-Les grandeurs des forces de frottement $S$ et de Magnus $M$ sont des coefficients que l'on suppose être obtenus expérimentalement ($S$ dépend de la surface de section de la balle dans l'air, $M$ dépend de la texture de la balle et les deux dépendent de paramètres de l'air comme sa densité).
-
-
-La trajectoire de la balle est alors définie par les équations de Newton pour le vecteur de position $\vec{r}(t)$ :
-
-$$ m \frac{d^2\vec{r}(t)}{dt^2}=m.\vec{g}-S \frac{\vec{v}(t)}{\|\vec{v}(t)\|} + M \frac{\vec{\omega} \times \vec{v}(t)}{\|\vec{v}(t)\|}$$
-
-avec les conditions initiales :
-$$ \vec{v}(0) = \vec{v}_0, \vec{r}(0) = \vec{r}_0$$
-
-En projetant sur les axes, on obtient les équations suivantes :
-
-$$
-\ddot{x} = -\frac{S}{m} \frac{\dot{x}}{v} + \frac{\omega.M}{m.v}\dot{y}
-$$
-$$
-\ddot{y} = -g -\frac{S}{m} \frac{\dot{y}}{v} - \frac{\omega.M}{m.v}\dot{x}
-$$
-
-où $v=\sqrt{\dot{x}^2+\dot{y}^2}$
-
-En raison de la nature non linéraire du problème, il faut utiliser des méthodes numériques pour le résoudre. Il faut dans un premier temps le mettre sous une forme permettant de le résoudre numériquement par les méthodes usuelles, c'est-à-dire sous la forme :
-$$\frac{d\vec{X}(t)}{dt}=\vec{f}(t,\vec{X})$$
-
-Ici, le vecteur $\vec{X}$ aura cette allure :
-$$\vec{X}=\left[ \begin{array}{c}
- X_1 \\X_2 \\X_3\\X_4\\X_5
- \end{array}\right]=
-\left[ \begin{array}{c}
- \dot{x} \\\dot{y} \\x\\y \\w
- \end{array}\right]
-$$
-
-et le système différentiel pourra s'écrire ainsi :
-$$\left\{ \begin{array}{c}
-\frac{dX_1}{dt}= -\frac{S}{m.\sqrt{X_1^2+X_2^2}} X_1 + \frac{\omega.M}{m.\sqrt{X_1^2+X_2^2}}X_2 \\
-\frac{dX_2}{dt}= -g -\frac{S}{m.\sqrt{X_1^2+X_2^2}} X_2 - \frac{\omega.M}{m.\sqrt{X_1^2+X_2^2}}X_1 \\
-\frac{dX_3}{dt}= X_1\\
-\frac{dX_4}{dt}= X_2\\
-\frac{dX_5}{dt}= 0
-\end{array} \right.$$
-
-\subsection{Programme de résolution}
-
-Maintenant, on passe (enfin) à la partie programmation en C ...
-
-\question{Définir un nouveau type de données \lstinline!struct Vecteur! qui permette de représenter un vecteur d'état $\vec{X}$.}
-
-\question{Écrire deux fonctions \lstinline!double f1(double, double, double)! et \lstinline!double f2(double, double, double)! qui réalisent les calculs suivants :}
-
-$$f_1(vx, vy, \omega)= -\frac{S}{m.\sqrt{vx^2+vy^2}}vx + \frac{\omega.M}{m.\sqrt{vx^2+vy^2}}vy$$
-$$f_2(vx,vy, \omega)= -g -\frac{S}{m.\sqrt{vx^2+vy^2}}vy - \frac{\omega.M}{m.\sqrt{vx^2+vy^2}}vx$$
-
-\underline{Remarque :} Pour chaque constante du problème vous pourrez les définir comme des variables globales ou\footnote{Pour savoir si vous devez définir une variable globale ou une constante, vous devez savoir, par exemple, si un utilisateur pourrait avoir à modifier ces valeurs} des constantes du programme (à destination du préprocesseur). Voici la liste des valeurs pouvant être utilisées pour ces constantes (en unité du système internationnal)\footnote{Attention, \textit{a priori} ce n'est pas très réaliste ...} :
-\begin{itemize}
- \item $g = 9.81$ : gravité,
- \item $x_0=0$, $y_0=2.7$ : position de départ de la balle au service,
- \item $\dot{x}_0=v\_init*cos(theta)$, $\dot{y}_0=v\_init*sin(theta)$ : vitesse de départ de la balle avec $v\_init=200$, $theta=-M\_PI/30$\footnote{$M\_PI$ est la valeur du $\pi$ disponible dans la librairie \texttt{math.h})},
- \item $w = 50$ : vitesse de rotation de la balle,
- \item $m = 0.058$ : poids d'une balle de tennis,
- \item $S = 0.002$ : constante de frottement,
- \item $M = 0.2$ : constante de Magnus (peut être négatif)
-\end{itemize}
-
-\question{Écrire une fonction \lstinline!Vecteur d_dt_euler(Vecteur V_t, double h)! qui retourne le vecteur au pas de temps $t+h$ à partir du vecteur au pas de temps $t$. $h$ est la valeur du pas de temps.}
-
-\question{Écrire un programme qui implémente la méthode d'Euler et qui enregistre toutes les positions calculées dans un fichier \texttt{traj.dat}}
-
-Le fichier devra comprendre uniquement deux colonnes (position en 2D de la balle) formatées ainsi ``\lstinline!%g %g!''.
-
-\textbf{Vous arrêterez les calculs lorsque la ``balle touche le sol'' ou que le nombre de d'itération dépasse une valeur prédéfinie.}
-
-\question{Tracé d'une trajectoire}
-Pour tracer les trajectoires calculées, vous pouvez utiliser \texttt{gnuplot} sous linux, un tableur, Excel ou OOCalc, ou encore R. Avec \texttt{gnuplot}, on fournit un script \texttt{tennis.pl} dans les ressources du sujet. Pour se servir de ce script, il faut :
-\begin{itemize}
- \item copier le script dans le répertoire contenant le fichier \texttt{traj.dat}
- \item depuis un terminal, lancer le script avec la commande suivante : \texttt{\$ gnuplot tennis.pl}
-\end{itemize}
-Le dessin qui s'affiche la courbe et figure les limites d'un terrain de tennis (le bord de l'affichage), et le filet.
-
-\subsection{Améliorations du programme}
-
-\subsubsection{Améliorations de la résolution numérique}
-
-Si le programme est bien conçues, les modifications suivantes permettent de n'apporter que quelques modifications mineurs au programme en plus de la création de fonctions spécifiques.
-
-\question{Refaire les calculs en ajoutant du vent (uniquement sur l'axe $x$)}
-
-\question{Utiliser la méthode de Runge-Kutta d'ordre 2, puis d'ordre 4 pour faire le calcul des trajectoires}
-
-%\question{Modifier le programme pour calculer les trajectoires en 3D (nécessite de projecter le système d'équations différentielles)}
-
-\subsubsection{Service interactif}
-
-\question{Construire un programme qui demande à l'utilisateur la vitesse initiale et l'angle de frappe et qui indique si le service est bon ou non ?}
-
-\subsubsection{Estimer l'angle idéal (\hard)}
-
-On veut maintenant se servir de la simulation pour aider le joueur qu'on entraine à améliorer son service.
-
-\question{Construire un programme qui demande à l'utilisateur la vitesse initiale de frappe et qui estime l'angle de frappe idéal (\ie qui tombe sur la ligne du carré de service à $18.29m$ de la ligne de service)}
-
-
-\end{document}
diff --git a/DemoProjets/MasterMind/Sujet/MasterMind.tex~ b/DemoProjets/MasterMind/Sujet/MasterMind.tex~
deleted file mode 100644
index c9c4c09afda5766b370fcfc39aca419379dcd215..0000000000000000000000000000000000000000
--- a/DemoProjets/MasterMind/Sujet/MasterMind.tex~
+++ /dev/null
@@ -1,125 +0,0 @@
-\documentclass[a4paper,12pt]{article}
-\usepackage[utf8]{inputenc}
-\usepackage[T1]{fontenc}
-\usepackage{../../../TP/exos}
-
-\title{Projet C : Master Mind}
-\author{Guyet T.}
-\date{2011-2012}
-
-\begin{document}
-\maketitle
-
-L'objectif de ce projet est de créer un programme qui permet à un utilisateur de jouer au MasterMind en découvrant la combinaison tirée par l'ordinateur. On vous propose de réaliser différentes variante du jeu.
-
-\section{Présentation du jeu}
-
-Vous commencerez votre programme en définissant quelques constantes pour préciser le cadre de fonctionnement du jeu. Ces constantes pourront être utilisées dans la suite.
-
-\begin{lstlisting}[numbers=none]
-#define NB_TENTATIVES 12 //<nombre maximum de tentative pour trouver la combinaison
-#define LINESIZE 6 //< taille de la combinaison
-#define COLORMAX 6
-char colors[COLORMAX]={'r', 'g', 'b', 'y', 'm', 'w'};
-
-//Une ligne est un ensemble d'entiers (pas de vérification de la limite de valeur) !
-typedef char line[LINESIZE];
-\end{lstlisting}
-
-\lstinline!NB_TENTATIVES! et \lstinline!LINESIZE! sont des constantes qui pourront être modifiées facilement. On reste avec un nombre de couleurs égal à 6.
-
-\espace
-
-Quelques explications sont nécessaires pour la dernière ligne. Le mot clé \lstinline!typedef! permet de déclarer un nouveau type de données. Ici, on définit un nouveau type de données \lstinline!line! qui correspond à un tableau de caractères de taille \lstinline!LINESIZE!. Ceci permettra de faciliter la déclaration des fonctions.
-
-\espace
-
-L'algorithme général du jeu est plutôt simple. Il peut être résumé ainsi :
-\begin{verbatim}
-Generer une ligne aléatoire
-REPETER:
- récupérer une tentative auprès de l'utilisateur
- afficher les erreurs de la tentative
- SI gagne ALORS
- break;
-TANT QUE il reste des tentatives
-\end{verbatim}
-
-Les variantes proposées sont les suivantes :
-\begin{enumerate}
- \item On affiche ``ok'' si identique et ``non'' dans le cas contraire,
- \item On affiche les positions des pions bien placés,
- \item On affiche le nombre de positions des pions bien placés et le nombre de couleurs correctes,
-\end{enumerate}
-
-Vous noterez que ces variantes ne change qu'une seule ligne de l'algorithme du programme ci-dessus. Sinon tout reste identique.
-
-\section{Première version}
-
-\question{Écrire une fonction \lstinline!void generate_line(line l)! qui initialise aléatoirement la ligne \lstinline!l! avec des valeurs}
-
-\underline{Remarque 1 :} pour que la ligne générée soit valable, il est nécessaire que les lettres soient dans le vocabulaire possible des couleurs. Ce dictionnaire est disponible dans le tableau \lstinline!colors!. Vous noterez que ce tableau assure une correspondance entre des entiers de 0 à 5 et des lettres.
-
-\underline{Remarque 2 :} on traite la variante difficile du MasterMind en autorisant les doublons de couleurs.
-
-\question{Écrire une fonction \lstinline!void print(line l)! qui affiche à l'écran la combinaison de couleur données en paramètre.}
-
-Vous pouvez ainsi tester votre générateur de couleurs ...
-
-
-\question{Écrire une fonction \lstinline!int cmp_v1(line l, line modele)! qui affiche à l'écran les messages nécessaires à la variante 1 et retourne 1 si la combinaison a été trouvée et 0 sinon.}
-
-\espace
-
-Il faut maintenant une dernière fonction pour la saisie par l'utilisateur. Cette fonction n'est pas nécessairement très facile à réaliser ... La solution proposée est la suivante~:
-\begin{itemize}
- \item l'utilisateur saisiera une chaîne de caractères \lstinline!s! que vous récupérez avec un \lstinline!scanf!,
- \item ensuite, il faudra tester si la saisie est correcte (chaque caractère doit être dans le vocabulaire !),
- \item en cas d'erreur, vous la signalerez le plus précisément possible à l'utilisateur, et vous lui proposerez de recommencer (jsuqu'à ce que la saisie soit bonne).
-\end{itemize}
-
-\question{Écrire une fonction \lstinline!void scanline(line l)! qui effectue la saisie par l'utilisateur de la ligne \lstinline!l!.}
-
-\question{Écrire le programme principal pour jouer au MasterMind avec la variante 1.}
-
-\section{Variantes}
-
-Dans cette partie, vous ne ferez qu'ajouter de nouvelles fonctions (ne supprimez pas les anciennes.
-
-\question{Écrire une fonction \lstinline!int cmp_v2(line l, line modele)! qui affiche à l'écran les messages nécessaires à la variante 2 et retourne 1 si la combinaison a été trouvée et 0 sinon.}
-
-\question{Écrire une fonction \lstinline!int cmp_v3(line l, line modele)! qui affiche à l'écran les messages nécessaires à la variante 3 et retourne 1 si la combinaison a été trouvée et 0 sinon.}
-
-Dans cette dernière variante, il s'agit d'afficher :
-\begin{itemize}
- \item le nombre de couleurs bien placés,
- \item le nombre de couleurs correctes (sans tenir compte des pions déjà bien placés).
-\end{itemize}
-
-Ce problème nécessite de bien poser le problème algorithmique ... sa résolution est accessible.
-
-
-\section{Version à deux joueurs}
-
-À ce niveau, il est recommander de sauvegarder une version de votre programme fonctionnel avant de commencer à apporter des modifications aux fichiers.
-
-\question{Modifier le programme pour que deux joueurs puissent s'affronter}
-
-Le déroulement du jeu sera le suivant~:
-\begin{enumerate}
- \item chaque joueur saisiera d'abord sa combinaison dans l'ordinateur,
- \item successivement, chaque joueur jouera alternativement,
- \item c'est l'ordinateur qui indiquera au joueur s'il a bon ou non,
- \item le premier joueur à trouver la combinaison a gagné.
-\end{enumerate}
-
-
-\underline{Attention~:} la modification peut avoir d'importante conséquences sur l'organisation du code. En soit, ce n'est pas difficile, mais il ne faudra pas hésiter à modifier l'existent ! (\textit{d'où la sauvegarde}).
-
-\section{Extensions}
-
-\question{Modifier votre programme pour que l'utilisateur puisse choisir la variante avec laquelle il souhaite jouer.}
-
-
-
-\end{document}
\ No newline at end of file
diff --git a/DemoProjets/Sudoku/README~ b/DemoProjets/Sudoku/README~
deleted file mode 100755
index 2975218d026fc09b0e42c611b4e5d7b3d4c357ae..0000000000000000000000000000000000000000
--- a/DemoProjets/Sudoku/README~
+++ /dev/null
@@ -1,12 +0,0 @@
-Résolution d'un sudoku avec deux implémentations du backtracking:
-- backtracking iteratif;
-- backtracking recursif;
-
-Author: T. Guyet, AGROCAMPUS-OUEST, 2010
-
-
-Compilation :
-gcc -Wall -o sudoku sudoku_btrec.c
-
-Execution :
-sudoku ./test.sudoku
diff --git a/DemoProjets/Video/Sujet/TraitementVideo.tex~ b/DemoProjets/Video/Sujet/TraitementVideo.tex~
deleted file mode 100644
index dee131e15ba8dd20f27526bdb71cb2cac83169bf..0000000000000000000000000000000000000000
--- a/DemoProjets/Video/Sujet/TraitementVideo.tex~
+++ /dev/null
@@ -1,187 +0,0 @@
-\documentclass[a4paper,10pt]{article}
-\usepackage[utf8]{inputenc}
-\usepackage[T1]{fontenc}
-\usepackage{../../../TP/exos}
-
-\author{Thomas Guyet}
-\title{Traitement vidéo avec OpenCV}
-\date{2011-2012}
-
-\begin{document}
-
-\maketitle
-
-L'objectif de ce projet est de réaliser un programme d'inscrustration d'une personne filmée par une webcam sur une image de fond. La technique utilisée est dite du ``fond bleu''. Son principe est simple : vous prenez une image de fond F, pour toute image I de la vidéo, il faut remplacer les pixels ``bleus'' de I par le pixel correspondant de F (\ie le pixel à la même position dans l'image).
-
-En général, il est difficile d'utiliser des périphériques dans des programmes en C. La webcam ne fait pas exception ! D'autant plus qu'il existe des dixaines de webcam différentes. Pour résoudre ce problème, nous allons utiliser une librairie de fonctions extérieures qui résout tous les problèmes difficiles de gestion de la webcam. En contrepartie, il va être nécessaire de comprendre un peu la librairie : pas ces détails, mais savoir ce qu'elle peut faire (quelles fonctions sont disponibles) et comment les utiliser. Pour cela, vous aurez peut être un peu de lecture à faire, mais dans tous les cas il faudra s'inspirer des exemples.
-
-La librairie que nous allons utiliser est la librairie OpenCV -- Open Source Computer Vision -- (\url{http://opencv.willowgarage.com/wiki/}). Les côtés techniques n'étant pas centraux dans ce projet, nous fournissons une clé USB sur laquelle sont installés tous les éléments nécessaires à la réalisation du projet dans un environnement Linux :
-\begin{itemize}
- \item installation des librairies openCV,
- \item projet Code::Block facilitant la compilation (repartir de ce projet pour vos programmes).
-\end{itemize}
-
-
-\section{Images et vidéos}
-
-Le programme donné en annexe illustre l'utilisation de la bibliothèque OpenCV. Ce programme à pour effet d'inverser les couleurs de la vidéo. La difficulté du projet réside également dans la compréhension (globale) et l'utilisation de nouveaux types de données et de nouvelles fonctions. On s'éloigne du C pur.
-
-\section{Première version : remplacement d'une couleur données}
-
-\subsection{Stratégie}
-Dans cette première version, il s'agit de faire un programme qui
-
-\subsection{Implémentation d'une fonction de binarisation}
-
-Les fonctions ci-dessous peuvent être utilisées pour créer des images de la taille souhaitée, et libérer la mémoire d'une image qui n'est plus utile~:
-\begin{lstlisting}[numbers=none]
-IplImage* cvCreateImage( CvSize size, int depth, int channels );
-void cvReleaseImage( IplImage** image );
-\end{lstlisting}
-
-L'exemple illustre l'utilisation de la fonction. Vous créez ici une nouvelle image \lstinline!new_image! de la même taille que l'image \lstinline!frame!
-\begin{lstlisting}[numbers=none]
-CvSize size=cvGetSize(frame);
-IplImage* new_image = cvCreateImage(size, IPL_DEPTH_32S, 4);
-\end{lstlisting}
-
-
-\question{Créer une fonction \lstinline!IplImage *binarisation( IplImage *img, CvScalar model )! qui créé une nouvelle image dont les pixels sont blancs si leur couleur est ``proche'' de \lstinline!model! et noirs sinon.}
-
-\underline{Aide :} les couleurs sont proches si la mesure $(R1-R2)^2 + (B1-B2)^2 + (V1-V2)^2$ est inférieure à 20000.
-
-Vous pouvez prendre comme modèle de couleur pour du bleu le modèle suivant~:
-\begin{lstlisting}[numbers=none]
-CvScalar model;
-model.val[0]=230;
-model.val[1]=10;
-model.val[2]=10;
-\end{lstlisting}
-
-Vous définierez également les deux pixels de ``blanc'' et ``noir'' :
-\begin{lstlisting}[numbers=none]
-CvScalar pixel_blanc;
-pixel_blanc.val[0]=255;
-pixel_blanc.val[1]=255;
-pixel_blanc.val[2]=255;
-CvScalar pixel_noir;
-pixel_noir.val[0]=0;
-pixel_noir.val[1]=0;
-pixel_noir.val[2]=0;
-\end{lstlisting}
-
-\question{Modifier le programme exemple pour faire afficher à chaque image l'image binaire correspondante dans la seconde fenêtre de vidéo.}
-
-\underline{Attention :} Si votre fonction \lstinline!binarisation()! créer une image, il faut bien penser à la libérer quand vous n'en avez plus besoin !!
-
-Voici, un exemple de résultat attendu est donné dans la Figure \ref{fig:masqueNB}.
-
-\begin{figure}
-\includegraphics[width=0.45\textwidth]{images/image_masqueNB} \hfill
-\includegraphics[width=0.45\textwidth]{images/masqueNB}
-\caption{Illustration du calcul d'un masque ``bleu''.}
-\label{fig:masqueNB}
-\end{figure}
-
-\subsection{Fonction pour fusionner les images}
-
-Le masque va servir à faire la fusion de deux images :
-\begin{itemize}
- \item Une image de fond qui sera acquise au préalable (ou image enregistrée),
- \item Une image du flux vidéo.
-\end{itemize}
-
-La première sera positionnée à l'endroit où les pixels du masque sont noirs, tandis que l'autre sera positionnés là où les pixels sont blancs.
-
-Pour chaque image de la vidéo, l'opération à réaliser est donc : 1) calculer l'image du masque, et 2) fusionner les deux images (video + extérieure) selon le masque, pixel à pixel.
-
-\question{Créer une fonction \lstinline!void fusion( IplImage *img_modified, IplImage *img_fond, IplImage *img_masque )! qui fusionne l'image de fond dans l'image \lstinline!img_Modified! lorsque les pixels du masque valent 1.}
-
-
-Le petit bout de code ci-dessous permet de charger l'image ``\texttt{fond.png}''. Ce code peut être utilisé pour construire la variable à passer en second paramètre de la fonction \lstinline!fusion!.
-\begin{lstlisting}
-IplImage* img_fond=0;
-img_fond=cvLoadImage("fond.png", CV_LOAD_IMAGE_COLOR);
-if(!img_fond) {
- printf("Could not load image file\n");
- exit(1);
-}
-\end{lstlisting}
-
-
-\question{Modifier le programme principal pour faire appel à la fonction \lstinline!fusion!. Le programme permettra de faire apparaître l'image de fond pour les pixels de la couleur visée par le masque (\cf Figure \ref{fig:masque_fond}.}
-
-
-\begin{figure}
-\includegraphics[width=0.45\textwidth]{images/fond} \hfill
-\includegraphics[width=0.45\textwidth]{images/image_fond}
-\caption{Illustration de la fusion du masque ``bleu'' avec l'image de fond (sur le gauche).}
-\label{fig:masque_fond}
-\end{figure}
-
-
-\section{Amélioration : création d'un histogramme de couleurs}
-
-Pour faire un programme plus générique, nous n'allons pas nous limiter à une détection d'une couleur. Ça ne marche pas bien.
-
-L'idée est de créer un histogramme des couleurs à reconnaître... qu'est ce que c'est ! En fait, c'est une matrice à trois dimensions (\lstinline!float histo[SIZEH][SIZEH][SIZEH]!) dont chaque dimension correspond à une composante colorée (rouge, vert, bleu). Lorsque \lstinline!SIZEH! vaut 255, une valeur de ce tableau correspond à la probabilité (entre 0 et 1) d'avoir un pixel correspondant à la couleur d'intérêt.
-
-Par exemple, \lstinline!float histo[10][2][34]! donne la probabilité que la couleur $(10,2,34)$ soit une couleur à détecter.
-
-\espace
-
-Contrairement à l'appoche précédente (couleur unique), vous pouvez donc détecter plusieurs couleurs comme couleur de ``fond bleu'', et qu'il y a beaucoup plus de flexibilité dans la définition des couleurs d'intérêt. Le second intérêt de cet histogramme est qu'il est possible de le construire à partir d'images qui vont servir d'exemple.
-
-
-\subsection{Construction de l'histogramme (\hard)}
-
-Vous aurez définie au préalable la constante de préprocessing suivante~: \lstinline!#define SIZEH 20!. Il n'est pas possible de travailler avec un histogramme complet~: il faudrait beaucoup (trop) de mémoire pour représenter l'histogramme et les résultats ne seront pas bon car de nouveau trop spécifiques (l'histogramme serait très creux à moins d'avoir des centaines d'images pour exemple). On utilise alors simplement un histogramme qui regroupe des couleurs similaires ensemble.
-
-\question{Construire une fonction \lstinline!void modifier_histo(IplImage *img, int x, int y, int w, int h, float histo[SIZEH][SIZEH][SIZEH], int *nb)!}
-
-Cette fonction modifiera l'histogramme selon le principe de l'algorithme suivante~:
-\begin{verbatim}
-Pour i=x à x+w Faire
- Pour j=y à y+h Faire
- pixel = get_pixel(x,y)
- histo[ SIZEH*pixel[2]/256 ][ SIZEH*pixel[2]/256 ][ SIZEH*pixel[2]/256 ] = ...
- histo[ SIZEH*pixel[2]/256 ][ SIZEH*pixel[2]/256 ][ SIZEH*pixel[2]/256 ] + 1
-nb = nb+w*h
-\end{verbatim}
-
-\underline{NB :} la normalisation de l'histogramme se fera à l'extérieur de la fonction.
-
-\question{(\hard)Construire une fonction \lstinline!void construct_histo(histo[SIZEH][SIZEH][SIZEH], int *nb)! qui lance la capture vidéo. Lorsque la touche ``\texttt{g}'' est appuyée alors l'image courante est utiliser pour modifier l'histogramme avec la fonction de la question précédente en ne considérant qu'une petite partie de l'image. Lorsque la touche ``\texttt{q}'' est appuyé vous finaliser la construction de l'histogramme}
-
-\underline{Aide :} cette fonction est nécessaire mais difficile ... si besoin, et si la question précédente est comprise, elle vous sera transmise toute faite !!
-
-\subsection{Détection avec histogramme}
-
-\question{Modifier la fonction \lstinline!binarisation! de sorte quelle est le profil ci-dessous. Cette fonction retournera une image binaire (avec du blanc et du noir uniquement). Les pixels blancs correspondront à des couleurs pour la probabilité donnée dans l'histogramme est supérieure à un seuil fixé (par exemple $0.1$).}
-
-\begin{lstlisting}[numbers=none]
- IplImage *binarisation( IplImage *img, float histo[SIZEH][SIZEH][SIZEH])
-\end{lstlisting}
-
-
-\subsection{Ajustement du seuil de détection}
-
-\question{Modifier la fonction \lstinline!binarisation! pour qu'elle prenne en paramètre le seuil de reconnaissance d'une couleur.}
-
-\question{Modifier votre programme principal de fusion de ``fond bleu'' pour permettre à l'utilisateur d'ajuster le seuil de reconnaissance pendant cette reconnaissance en insérant le bout de code ci-dessous dans la boucle le lecture de la vidéo.}
-
-\begin{lstlisting}[numbers=none]
-if( key=='p' || key==1048688) {
- seuil*=2;
- printf("seuil : %f\n", seuil);
-} else if( key=='m' || key==1048685) {
- seuil/=2;
- printf("seuil : %f\n", seuil);
-}
-\end{lstlisting}
-
-
-\section*{Annexes}
-\lstinputlisting{../invert_video_color.c}
-
-\end{document}
\ No newline at end of file
diff --git a/Polyc/AlgoC.tex~ b/Polyc/AlgoC.tex~
deleted file mode 100644
index 69cd7fd28e675b3bcf1d5cefb6ee9e3cfd8647ab..0000000000000000000000000000000000000000
--- a/Polyc/AlgoC.tex~
+++ /dev/null
@@ -1,1998 +0,0 @@
-\chapter{Éléments de langage C}
-\Opensolutionfile{solutions}{}
-
-Dans cette partie du cours, je donne les bases de la syntaxe du langage C (en norme ANSI 89).
-
-Après avoir donner, dans une première partie, le classique exemple du \textit{Hello world}, la seconde section sera consacrée à la déclaration, à l'initialisation et la manipulation de variables simples. Dans la troisème partie, je présenterai la syntaxe des structures de contrôles usuelles en algorithmique : la condition et l'iteration. Finalement, la dernière partie sera consacrée aux entrées/sorties, c'est-à-dire à la lecture et à l'écriture de variables.
-
-À l'issue de cette partie de cours vous serez en mesure d'écrire un programme simple en C. Mais ce n'est là que de la technique, le couteau du sculteur. Il ne sera de bon programmeur C sans une maîtrise quasi-complète de ce chapitre tout comme il ne peut y avoir d'artiste sans une maîtrise de la technique.
-
-\section{Un premier programme}
-Voici un exemple de programme C très simple, qui changera un peu du classique \textit{HelloWorld} dans le sens où ce qu'il affiche est légèrement différent~:
-
-\begin{lstlisting}[caption=Hello world nouvelle formule ...]
-#include <stdio.h>
-
-/*
-Ceci sera mon premier programme
-*/
-
-int main(void)
-{
- printf("Je teste mon premier programme !\n");
- printf("Et en plus il est en C !\n"); // Encore un commentaire
- return 0;
-}
-\end{lstlisting}
-
-Quelques commentaires à propos de ce programme~:
-\begin{itemize}
-\item La directive \lstinline!#include! permet d'importer des définitions de fonctions utiles (ici, il est nécessaire d'inclure la bibliothèque \lstinline!stdio.h! pour pouvoir utiliser la fonction \lstinline!printf!). C'est une directive du préprocesseur (voir le chapitre sur la compilation pour plus de détails).
-\item Tout ce qui est écrit entre \lstinline!/* ... */! et après \lstinline!//! est considéré comme un commentaire de programme. Tout ce qui est en commentaire sera totalement ignoré lors de la compilation.
-\item Les lignes vides ne sont pas prises en compte.
-\item Un programme C doit \textbf{impérativement contenir une fonction nommée} \lstinline!main()!. Cette fonction sert de point d'entrée pour un programme C. On sait alors que le programme va commencer par faire l'instruction de la ligne 8.
-\item Les accolades (``\{'', ``\}'') définissent les limites de la fonction \lstinline!main()!. On parle alors de \textbf{blocs d'instructions}.
-Aucune instruction ne peut écrite en dehors d'un bloc d'instructions. Ici, la dernière instruction exécutée sera celle de la ligne 11.
-\item \textbf{Toutes} les instructions doivent se terminées par un point virgule (``;''). Il faut alors remarquer que dans ce programme exemple, il n'y a que 3 instructions, et en particulier~:
-
-\begin{itemize}
-\item \lstinline!int main(void)! n'est pas une instruction ! Il s'agit du profil de la fonction associée au bloc d'instructions (entre accolades) qui le suit.
-\item les lignes 3 à 5 sont des commentaires, il n'est pas nécessaire d'ajouter des ``;'',
-\item en revanche, à la ligne 9, le point virgule doit impérativement être positionné avant les commentaires sinon il sera ignoré et il y aura une erreur de syntaxe.
-\end{itemize}
-
-\item \lstinline!printf! est une \textbf{fonction~}: toutes les fonctions sont repérés par l'utilisation de parenthèses entre lesquels il faut placer \textbf{les paramètres de la fonction} séparés par des virgules. Ici, la fonction prend un seul paramètre (une chaîne de caractères). Cette fonction affiche la chaîne de caractère dans le terminal d'exécution.
-\item Les \textbf{chaînes de caractères} sont écrites entre \textbf{guillemets doubles} ``\lstinline!"!''. Les guillemets simples servent à définir un caractère (et un seul caractère).
-\item L'instruction \lstinline!return 0! donne fin à la fonction \lstinline!main()! en ``retournant'' la valeur 0. Pour le système, cela signifie que tout c'est bien passé (sinon, vous pouvez faire un \lstinline!return 1!). On comprendra un peu plus cette instruction lorsqu'on parlera des fonctions.
-\item La dernière ligne d'un programme doit être vide~! Je ne sais pas pourquoi, mais si vous ne le faites pas, le compilateur ne manquera pas de vous le signaler~!
-\end{itemize}
-
-Si vous écrivez ce programme dans un éditeur avancé (tel que \texttt{gedit} ou \texttt{Code::Blocks}) qui vous fera la coloration syntaxique du programme vous pourrez mieux comprendre ce que ``lit'' l'ordinateur. En effet, la typographie permet de distinguer facilement les mots clés (\lstinline!int!, \lstinline!#include!, \lstinline!void!, \lstinline!return!), les instructions, les commentaires et les chaînes de caractères.
-
-\section{Les variables}
-\subsection{Déclaration et affectation d'une variable}
-
-\begin{definition} [Déclaration d'une variable] Déclarer une variable est une instruction qui indique au programme qu'on aura besoin d'une variable. Cette variable sera identifiée par un nom.
-
-L'instruction a pour effet d'allouer un espace mémoire correspondant à la taille mémoire des valeurs que peut contenir la variable.
-\end{definition}
-
-Pour déclarer une variable, il faut donner son type (un entier, un caractère, une structure complexe, ...). Lorsqu'on déclare une variable, le système
-alloue un espace mémoire dans lequel la valeur de cette variable sera retenue (sous forme binaire). Le type sert~:
-\begin{itemize}
-\item (à la déclaration) à savoir quel est la taille mémoire à allouer pour contenir une valeur,
-\item (à l'utilisation de la variable) à savoir comment interpréter les bits contenus dans l'espace mémoire de la variable.
-\end{itemize}
-
-Une variable se déclare en donnant son type puis son nom~:
-
-{\centering\itshape
-type\_variable nom\_variable;
-\par
-}
-
-\begin{exemple}
-Par exemple~:
-\begin{lstlisting}[numbers=none]
-int i;
-long j;
-\end{lstlisting}
-
-permet de déclarer une variable, nommée \lstinline!i!, de type \lstinline!int! (nombre entier sur 32 bits), et une variable \lstinline!j! de type long (nombre entier sur 64 bits). Ainsi, on aura en mémoire~:
-
-\end{exemple}
-\begin{figure}[ht]
- \centering
- \includegraphics[width=0.8\textwidth]{\Figures/AlgoC_mem1}
- \label{fig:AlgoC_mem1}
-\end{figure}
-
-\begin{warning}
-Toute variable d'un programme doit être déclarée. Sinon, le programme ne sait pas de quoi vous parlez !
-\end{warning}
-
-\begin{definition}[Affectation]
-L'\textbf{affectation} consiste à attribuer une valeur à une variable. Une instruction d'affectation s'écrit ainsi~:
-
-
-On distingue généralement trois types d'affectation~:
-\begin{itemize}
- \item l'affectation par valeur~: on donne alors directement la valeur à attribuer à une variable
-
-{\centering\itshape
-nom\_variable = valeur;
-\par}
-
- \item l'affectation par une variable~: l'instruction recopie le contenue de la variable à droite du ``='' dans la variable de gauche
-
-{\centering\itshape
-nom\_variable1 = nom\_variable2;
-\par}
-
-\item l'affectation par le résultat d'une opération~: l'instruction recopie le résultat d'une opération (par exemple une opération arthmétique)
-\end{itemize}
-\end{definition}
-
-
-Par exemple, l'affectation de la variable par une valeur
-\begin{lstlisting}[numbers=none]
-i=0;
-\end{lstlisting}
-
-L'affectation consiste à remplir les cases de l'emplacement mémoire d'une variable avec une valeur. L'illustration suivante représente le résultat de l'affectation de la variable \lstinline!i! de l'exemple précédent.
-
-\begin{figure}[ht]
- \centering
- \includegraphics[width=0.8\textwidth]{\Figures/AlgoC_mem2}
- \label{fig:AlgoC_mem2}
-\end{figure}
-
-Dans la mesure où la variable \lstinline!j! n'a pas été initialisée, on ne sait pas ce que contient la variable \lstinline!j!. En C, il est très \textbf{fortement conseillé} d'affecter une variable dès sa déclaration~! Ceci évite d'avoir des points d'intérrogation dans les cases mémoire ... (\cf illutration \ref{fig:AlgoC_mem2}) On parle alors d'\textbf{initialisation}\index{initialisation} d'une variable.
-
-
-Il a déjà été indiqué que le langage C est un langage fortement typé. En particulier, l'opération d'affectation est une opération \textbf{typée}. C'est-à-dire que le type de la valeur doit être compatible avec le type de la variable à affecter. On comprend bien qu'il n'est pas possible, par exemple, de mettre une valeur flottante dans une variable qui a été déclaré comme un entier~!
-
-
-
-\begin{warning}
-Quelques avertissements à propos de l'égalité :
-\begin{itemize}
- \item le ``='' ne doit pas se lire comme une égalité !
- \item le signe ``='' est l'indication d'une affectation qui se lit TOUJOURS de droite à gauche~: la variable à gauche de l'égalité prend la valeur à droite.
-\end{itemize}
-\end{warning}
-
-\espace
-
-L'initialisation d'une variable peut se faire en même temps que sa déclaration ainsi~:
-\begin{lstlisting}[numbers=none]
-int i = 0;
-\end{lstlisting}
-
-On peut affecter une variable à partir d'une autre variable. Par exemple~:
-
-\begin{lstlisting}
-int i, j; // declare deux variables de type entier
-j=10;
-i=j;
-\end{lstlisting}
-
-On peut également affecter une variable en récupérant la valeur d'une opération~:
-
-\begin{lstlisting}
-int i, j;
-float k; // declare trois variables de type entier
-j=10;
-i=2;
-k=j+10*i;
-\end{lstlisting}
-
-\subsection{Types de bases et leurs opérateurs usuels}
-\subsubsection{Les nombres}
-\begin{center}
-\tablefirsthead{}
-\tablehead{}
-\tabletail{}
-\tablelasttail{}
-\begin{supertabular}{|m{3cm}|m{8.3cm}|}
-\hline
-\lstinline!int! & Entier relatif\\\hline
-\lstinline!long! & Entier relatif long\\\hline
-\lstinline!unsigned int! & Entier (positif)\\\hline
-\lstinline!float! & Nombre en virgule flottante sur 32 bits (architecture usuelle)\\\hline
-\lstinline!double! & Nombre à virgule flottante double précision (64 bits)\\\hline
-\lstinline!long double! & Nombre à virgule flottante quadruple précision (128 bits)\\\hline
-\end{supertabular}
-\end{center}
-
-Les nombres disposent des opérateurs mathématiques usuels~: \lstinline!+!, \lstinline!*!, \lstinline!/!, \lstinline!-!, \% (reste de la division). Pour récupérer le résultat d'une opération arithmétique, vous utilisez naturellement l'instruction d'affectation~:
-
-\begin{lstlisting}
-int i =10, j=3, k;
-k=i+j;
-k=i/j; //k vaut 3
-k=i%j; //k vaut 1 (le reste de la division)
-\end{lstlisting}
-
-Comme en mathématique l'usage des parenthèses permettent de modifier les ordres de priorité des opérations (ordre de priorité usuels).
-
-\begin{remarque}[Division entière et division ``à virgule'']
-
-L'opérateur \lstinline!/! à deux significations en fonction des opérandes. Si les opérandes sont des nombres entiers, alors il s'agit d'une division entière~: le résultat de l'opération sera alors un entier. Par exemple, la division de 3 par 2 donnera comme résultat 1.
-
-En revanche, si les opérandes sont des nombres flottants, alors l'opérateur sera une division à virgule flottante. Le résultat de cette division sera un flottant (\lstinline!float! ou \lstinline!double!). Par exemple, la division de 3.0\footnote{Pour indiquer qu'une constante est un nombre flottant, vous pouvez ajouter simplement un ``.0''.} par 2.0 donnera comme résultat 1.5.
-
-Cette erreur est courante, et parfois difficile à trouver. Dans l'exemple ci-dessous, on pourrait s'attendre à ce que le résultat affiché soit 39.75 (34,5+5.25). Mais l'opération décrite sur la ligne 3 va conduire le processeur à faire la division \textbf{entière} entre \lstinline!i! et 4 qui aura pour résultat un entier (5). Le résultat affiché sera ainsi 39.5 !
-\begin{lstlisting}
- double x=34.5;
- int i=21;
- double y = x + i/4;
- printf("%lf\n", y);
-\end{lstlisting}
-
-Cette différence est tout sauf anodine ...
-\end{remarque}
-
-
-\begin{remarque}[Calcul d'une puissance]
-Il faut faire très attention à l'opérateur \lstinline!^! qui n'est pas un opérateur ``puissance'' !!
-En fait, il n'existe pas d'opérateur basique pour le calcul d'une puissance. Si vous voulez calculer le cube d'une valeur \lstinline!x!, il vaut calculer \lstinline!x*x*x!.
-
-\espace
-
-Si vous avez néanmoins des puissances à calculer, il est possible d'utiliser la fonction \lstinline!double pow(double x, int i)!
-disponible dans la librairie de fonctions mathématiques \lstinline!<math.h>!.
-
-\end{remarque}
-
-Pour les entiers, on dispose également d'opérateurs unaires très utiles~: incrémentation (\lstinline!++!, \lstinline!+=!) et décrémentation (\lstinline!--!, \lstinline!-=!). Ces opérateurs peuvent se réécrire de la sorte~:
-\begin{itemize}
-\item \lstinline!i++;! est équivalent à \lstinline!i=i+1;!
-\item \lstinline!i+=5;! est équivalent à \lstinline!i=i+5;!
-\end{itemize}
-
-Ces opérateurs unaires permettent d'écrire rapidement des opérations usuelles et en plus, elles sont plus efficaces que leur équivalent (ils correspondent généralement à de vrais instructions machine).
-
-\begin{exemple}
-\begin{lstlisting}
-int i=10, j=3;
-i++;
-i--;
-i+=3;
-j-=2;
-\end{lstlisting}
-À la fin de ces instructions, \lstinline!i! vaut 13 et \lstinline!j! vaut 1.
-\end{exemple}
-
-
-\subsubsection{Autres types de base}
-\begin{center}
-\tablefirsthead{}
-\tablehead{}
-\tabletail{}
-\tablelasttail{}
-\begin{supertabular}{|m{2cm}|m{10cm}|}
-\hline
-\lstinline!char! & Caractère de texte (en fait un entier entre 0 et 255)\\\hline
-\lstinline!void! & Sans type\\\hline
-\end{supertabular}
-\end{center}
-
-
-\begin{warning}
-Dans la norme ANSI, il n'y a pas de booléen, il s'agit simplement d'un entier qui vaut 0 pour la valeur \lstinline!false! ou différent de 0 (par exemple 1) pour la valeur \lstinline!true!.
-
-Néanmoins, en utilisant la librairie \lstinline!<stdlib.h>!, vous pouvez bénéficier d'un type \lstinline!bool! et des valeurs \lstinline!true! et \lstinline!false! habituelles.
-\end{warning}
-
-%Pas d'opérations spécifiques pour le moment !
-
-Pour affecter une valeur à un caractère, on utilise des guillemets simples (les guillemets doubles servent à définir un texte)~:
-\begin{lstlisting}[numbers=none]
- char c ='e';
-\end{lstlisting}
-
-
-\subsubsection{Opérateurs de comparaison}
-Les opérateurs de comparaison permettent de comparer deux nombres et retourne une valeur booléenne\footnote{En fait, c'est un nombre, mais vous devez le traiter comme un booléen.}
-
-\begin{center}
-\tablefirsthead{}
-\tablehead{}
-\tabletail{}
-\tablelasttail{}
-\begin{supertabular}{|m{2cm}|m{10cm}|}
-\hline
-\lstinline!==! & Opérateur d'égalité\\\hline
-\lstinline!<!, \lstinline!<=! & Inférieur, Inférieur ou égal\\\hline
-\lstinline!>!, \lstinline!>=! & Supérieur, supérieur ou égal\\\hline
-!= & Différent de ...\\\hline
-\end{supertabular}
-\end{center}
-
-\begin{exemple}
-\begin{lstlisting}
-int i = 20, j=5, k=5, r;
-r = (i == j); // r vaut 0
-r = (i != j); // r vaut 1 (autre chose que 0)
-r = (i=j); // r vaut 5
-r = (j==k); // r vaut 1
-r = (j>k); // r vaut 0
-r = (j>=k); // r vaut 1
-\end{lstlisting}
-
-À la ligne 2, \lstinline!i! n'est pas pas égale à \lstinline!j! donc \lstinline!r! vaut 0, et à la ligne 3 il vaut donc 1. À la ligne 4, en revanche, il ne s'agit pas d'une comparaison mais d'une affectation (simple-égal), et ici \lstinline!r! va valloir 5 (comme \lstinline!i! et \lstinline!j!).
-À la ligne 5, \lstinline!j! est bien égal à \lstinline!k!, donc \lstinline!r! vaut 1. À la ligne 6 et 7, on voit que la comparaison avec \lstinline!>! est une comparaison stricte.
-\end{exemple}
-
-
-\begin{warning}
-Le test d'égalité est un double-égal '\lstinline!==!' ! Le '\lstinline!=!' est l'opérateur d'affectation~! Cette erreur est l'une des plus classique pour les débutants en programmation C.
-\end{warning}
-
-\subsubsection{Opérateurs logiques}
-Les opérateurs logiques permettent de combiner des valeurs booléennes~:
-
-\begin{center}
-\tablefirsthead{}
-\tablehead{}
-\tabletail{}
-\tablelasttail{}
-\begin{supertabular}{|m{3cm}|m{8.3cm}|}
-\hline
-\lstinline!&&! & Et logique\\\hline
-\lstinline!||! & Ou logique\\\hline
-\lstinline!!! & Non logique\\\hline
-\end{supertabular}
-\end{center}
-
-Le parenthésage suit les règles usuelles de priorité (le '\lstinline!&&!' est prioritaire sur le '\lstinline!||!').
-
-\begin{exemple}
-On donne l'exemple de code ci-dessous~:
-\begin{lstlisting}
-int i = 20, j=5, k=5, m=1, r;
-r = (i<=j) || (j>k); // r vaut 0
-r = ( (j==k) && m ); // r vaut 1
-r = ( (i/2) == (j + k) ); // r vaut 1
-\end{lstlisting}
-
-Pour la ligne 2, \lstinline!j! n'est pas supérieur à \lstinline!k! donc \lstinline!r! vaut 0. Pour la ligne 3, \lstinline!j! est bien égal à \lstinline!k! et \lstinline!m! (pris comme une valeur booléenne) représente la valeur \lstinline!vrai!, \lstinline!r! vaut donc 1. Pour la ligne 4, on compare le résultat de la division (entière) avec le résultat de l'addition de \lstinline!j! avec \lstinline!k!. Ces deux résultats étant égaux, \lstinline!r! vaut 1.
-\end{exemple}
-
-
-\begin{warning}
-Les opérateurs ET et OU sont des signes doubles ('\lstinline!&&!' ou '\lstinline!||!') et pas des signes simples. Le '\lstinline!&!' et le
-'\lstinline!|!' ont des significations assez différentes que nous ne verrons pas~: faites attention à \textbf{ne pas les utiliser} !
-\end{warning}
-
-\subsubsection{Conversion entre types / ``cast explicite''}
-
-Dans certains cas, il peut être intéressant de demander des conversions dans les différents types de nombre. En mauvais franglais, les informaticiens parlent de ``\textit{cast explicite}''~: l'opération de \textit{cast} désigne une opération de conversion, et elle est dite explicite (le programmeur la demande), par opposition à certaines opérations de conversion qui sont implicitement réalisée par l'ordinateur.
- En pratique, une conversion explicite se fait de la façon suivante~:
-
-{\centering\itshape
-nom\_variable1 = {\bf(nouveau\_type)}nom\_variable2
-\par}
-
-\begin{lstlisting}
-double d;
-int i=23, j=4;
-d=i/j; // Effectue une division entiere
-d= (double)i/(double)j; //effectue une division en virgule flottante
-i=(int)d; //troncature
-char c='e';
-i=(int)c; //Conversion d'apres la table ascii !!
-\end{lstlisting}
-
-\begin{warning}
-Les conversions se font sous la responsabilité du programmeur~: le programme ne vérifie pas la validité de la conversion~! En dehors des cas normaux de conversion, rien n'est garantis sur le résultat.
-
-Toutes les conversions ne sont pas possibles ! S'il est possible de transmutter des serviettes en torchons, et des bananes en oranges, il n'est pas nécessairement possible de transformer des bananes en torchons... même si on le demande.
-
-\end{warning}
-
-\begin{lstlisting}
-int i = -54;
-uint j;
-j=(uint)i; //Le compilateur envoie un Warning
-\end{lstlisting}
-
-\section{Les tableaux}
-
-\subsection{Déclaration}
-\begin{definition}Un \textbf{tableau} est une variable qui contient une
-succession de valeurs \textbf{du même type} et en \textbf{nombre
-défini et fixé}.
-\end{definition}
-Pour déclarer un tableau en C, la syntaxe est la suivante~:
-
-{\centering
-type nom\_variable\textbf{[}taille\_du\_tableau\textbf{]}
-\par}
-
-\begin{exemple}
-Exemple~:
-\begin{lstlisting}
-int tab[3];
-char string[23];
-double d[10];
-\end{lstlisting}
-Pour le tableau \lstinline!tab!, on parle de ``tableau d'entiers de taille 3''. La taille en mémoire d'un \lstinline!int! étant de 32 bits, la taille en mémoire du tableau sera de 3*32=96bits et sera disposé ainsi~:
-
-{
- \centering
- \includegraphics[width=0.8\textwidth]{\Figures/AlgoC_mem3}
-}
-\end{exemple}
-
-\begin{remarque}[Taille fixe des tableaux]
- Les tableaux sont de taille \textbf{définie et fixée à la compilation}~! En particulier, il est \textbf{impossible} d'avoir une variable\footnote{Dans des cas particuliers, vous pourriez rencontrer l'utilisation de variables dans les tableaux, mais ce serait avec des variables dites ``constantes''. Soit qu'elles soient des variables de préprocessing, soient qu'elles soient explicitement déclarées comme constantes} comme taille de tableau.
-
- L'exemple ci-dessous \textbf{ne compile pas}~! Ce n'est pas correct en langage C.
- \begin{lstlisting}
- int t;
- t=34;
- double tab[t];
-\end{lstlisting}
-
- Ce problème met en évidence la nécessité de disposer de structure de données plus complexes comme des listes pour gérer des collections de données dont on ne connait pas a priori la taille. Ces structures de données seront vues dans une section spécifique du cours.
-\end{remarque}
-
-
-
-\subsection{Désigner un emplacement du tableau}
-Pour désigner un emplacement du tableau, il faut indiquer la position dans le tableau entre crochets~:
-
-{\centering\itshape
-nom\_tableau\textbf{[}position\textbf{]}
-\par}
-
-\begin{warning}
-En C, la première position est repérée par la position 0 !
-\end{warning}
-
-\begin{exemple}
-Par exemple, \textup{d[5]} est le sixième double dans le tableau précédent.
-\end{exemple}
-
-En désignant un emplacement du tableau, on peut~:
-\begin{itemize}
-\item utiliser la valeur que contient cet emplacement~: cette valeur sera du type déclaré pour le tableau,
-\item modifier la valeur de l'emplacement à l'aide de l'instruction d'affectation.
-\end{itemize}
-
-\begin{exemple}
-Exemple de modification du contenu du tableau~:
-\begin{lstlisting}
-tab[0] = 1;
-tab[1] = 243;
-tab[2] = 98;
-\end{lstlisting}
-
-Exemple d'utilisation de la valeur d'un emplacement du tableau~:
-\begin{lstlisting}
-int a=tab[1]; //Utilisation d'une valeur du tableau
-tab[3] = a + tab[2]; //Modification d'une valeur du tableau
-\end{lstlisting}
-\end{exemple}
-
-
-\begin{warning}
-Le compilateur ne vérifie jamais que vous accéder à des positions valides d'un tableau !! Une erreur très classique est de lire ou d'écrire en dehors d'un tableau.
-\end{warning}
-
-\begin{warning}
-La ligne 2 du dernier exemple va provoquer une erreur grave au moment de l'exécution du programme !
-\end{warning}
-
-Par leur organisation en mémoire, les tableaux sont très contraints~:
-
-\begin{itemize}
-\item il est impossible de modifier la taille d'un tableau. Il faut donc initialement prévoir quelle doit être la bonne taille du tableau pour faire la tâche assignée au programme,
-\item l'initialisation du tableau doit se faire manuellement, emplacement par emplacement (il n'est pas possible d'écrire quelque chose comme \lstinline!int tab[5]=0!~: ça n'a pas de sens de mettre un nombre dans un tableau de nombre !!),
-\item tous les éléments d'un tableau doivent être du même type (ce qui est différent des structures de liste de R ou python).
-\item il n'existe pas d'opérateurs prédéfinis sur les tableaux (addition, produit , ...)\footnote{\c{C}a serait utile pour des opérations matricielles~: addition de vecteurs, produit scalaire, etc.}
-\end{itemize}
-
-\subsection{Les tableaux à multiple dimensions}
-Il est tout naturellement possible d'utiliser des tableaux à dimensions multiple. Un tableau à dimensions multiple se déclare ainsi~:
-{\centering\itshape
-type nom\_tableau\textbf{[taille\_dim1][taille\_dim2][taille\_dim3]...}
-\par}
-
-\begin{exemple}
-Exemple de tableau en dimension 2~:
-\begin{lstlisting}[numbers=none]
-int tab[3][2];
-\end{lstlisting}
-\end{exemple}
-
-Pour désigner un emplacement d'un tableau multiple il faut utiliser une notation similaire à la notation de la déclaration (utiliser plusieurs crochets et non des virgules entre les dimensions)~:
-
-\lstinline!tab[1][0]! désigne un entier du tableau à deux dimensions. Cet emplacement peut être utilisé pour des affectations ou des calculs~:
-
-\begin{lstlisting}[numbers=none]
-tab[1][0] = 1;
-int x=1 + tab[1][0];
-\end{lstlisting}
-
-En fait, un tableau à dimension multiple est un tableau de tableaux de tableaux de ... De cette remarque, on déduit l'organisation en mémoire de ces données.
-
-\begin{exemple}
-Sur l'exemple \lstinline!tab! est un tableau d'entiers à deux dimensions. En fait, c'est un tableau de comprenant 2 tableaux de taille 3 (lecture de droite à gauche). Sa représentation en mémoire est la suivante~:
-\end{exemple}
-\begin{figure}[ht]
- \centering
- \includegraphics[width=0.8\textwidth]{\Figures/AlgoC_mem4}
- \label{fig:AlgoC_mem4}
-\end{figure}
-
-Il vient également des possibilités syntaxiques dangereuses en pratique. Sur l'exemple, vous pouvez écrire \lstinline!tab[1]! sans problème, mais cet emplacement désigne une variable de type \lstinline!int[3]! , et donc, ce n'est pas une variable sur laquelle on sait faire des opérations.
-
-En particulier, les instructions suivantes ne sont pas possibles~:
-\begin{itemize}
-\item \lstinline!tab[1]=2!~: pas possible de mettre un nombre dans un tableau
-\item \lstinline!tab[0]=tab[1]!~: C'est moins débile, mais dans ce cas, le C n'est pas très aidant puisque l'exemple compile bien, mais c'est, a priori, une grosse bétise si vous souhaitiez recopier un sous-tableau~: pour recopier deux tableaux, il faut tout faire soit même, case par case~!
-\item \lstinline!tab[0] + tab[1]!~: A fortiori, il faut également faire les opérations entre tableaux à la main. De nouveau, cet exemple doit quand même compiler, mais son exécution risque d'être catastrophique ...
-\end{itemize}
-
-Autre conséquence, les tableaux à dimension multiples répondent aux mêmes contraintes que les tableaux en simple dimension~: tous les éléments sont du même type et sa taille ne peut pas varier, l'initialisation est manuelle, il n'y a pas d'opérateurs pour manipuler les valeurs du tableau dans leur ensemble, ...
-
-\subsection{Les chaînes de caractères}
-
-\begin{definition}[Chaînes de caractères]
-Une chaîne de caractères est un tableau de caractères dont l'emplacement indiquant la fin de chaîne contient la valeur nulle (``0'' écrit en nombre et noté également \lstinline!'\0'!, le caractère nul). La taille du tableau fixe la taille limite de la chaîne.
-\end{definition}
-
-Pour déclarer une chaîne de caractères~:
-
-{\centering \bf
-char ma\_chaine[taille\_chaine]
-\par}
-
-\begin{exemple}
-L'instruction suivante déclare une chaîne de caractères de longueur maximale 299~:
-\begin{lstlisting}[numbers=none]
- char s[300];
-\end{lstlisting}
-\end{exemple}
-
-Du fait de la nature tabulaire d'une chaîne de caractères, il est \textbf{impossible} d'affecter une valeur à la variable de la sorte~:
-\begin{lstlisting}[numbers=none]
-s="coucou";
-\end{lstlisting}
-
-En revanche, il est tout à fait possible d'écrire~:
-\begin{lstlisting}[numbers=none]
-s[0]='c';
-s[1]='o';
-s[2]='u';
-s[3]='c';
-s[4]='o';
-s[5]='u';
-s[6]='\0';
-\end{lstlisting}
-
-Pour chaque emplacement, de type \lstinline!char!, on assigne ainsi une valeur de cet emplacement mémoire à partir d'une valeur de type \lstinline!char! également.
-
-On ajoute finalement la valeur \lstinline!\0! à l'emplacement 6 du tableau. Ainsi, par convention, on sait que c'est la fin de la chaîne de caractères et que les 293 autres emplacements mémoires ne sont pas utilisé (mais ils pourront l'être si on décide de modifier le contenu du tableau ...).
-
-\begin{warning}
-On voit ici la différence entre guillemets simples et guillemets doubles. Les guillemets simples indiquent des caractères, les guillemets doubles indiquent des chaînes de caractères.
-\end{warning}
-
-On verra lors d'un TD les fonctions de la librairie \lstinline!<string.h>! qui permettent de manipuler les chaînes de caractères sans passer systématiquement par les caractères.
-
-En attendant, une solution simple a été prévue pour déclarer rapidement de longues chaînes de caractères~:
-\begin{lstlisting}[numbers=none]
-char string[] = "ceci est un texte";
-\end{lstlisting}
-
-Lors de cette initialisation, la taille du tableau est automatiquement définie. Ici, c'est un tableau de taille \textbf{18}~: 17 caractères + 1 caractère de fin \lstinline!\0!.
-
-
-\subsection{Les indices sont aussi des variables ...}
-
-%L'utilisation des tableaux est intéressant pour faire des opérations similaires sur ces cases ou même travailler sur plusieurs cases en même temps.
-
-%\subsubsection{Utilisation d'une variable pour désigner une case d'un tableau}
-
-L'indice utilisé pour désigner une case d'un tableau est une valeur entière. Cette valeur entière peut être un nombre constant \textbf{ou une variable}.
-
-\begin{exemple}
-
-Dans le programme ci-dessous, on utilise une chaîne de caractères comme un tableau de caractères. L'instruction \lstinline!string[i]! permet de désigner la i-ème case du tableau \lstinline!string!. À la ligne 3, cela permet d'affecter la variable \lstinline!c! avec le contenu de la i-ème case du tableau. Comme \lstinline!i! vaut 5, il s'agit en fait de la 6-eme case... puisque les indices commencent à 0.
-
-Lorsque la valeur de \lstinline!i! change, la case désignée par \lstinline!string[i]! change également. À la ligne 5, on désigne la 11ème case du tableau.
-
-Finalement, on illustre un problème classique du C, le débordement de tableau. La dernière ligne de l'exemple fonctionne, mais affiche n'importe quoi. Il est possible de demander d'accéder à la case numéro 45, même si elle n'existe pas.
-
-\begin{lstlisting}
-char string[] = "ceci est un texte";
-int i=5;
-char c= string[i]; //Utilisation de la variable i comme indice
-printf("caractère à la position %d : %c\n", i+1, c);
-i=10;
-printf("caractère à la position %d : %c\n", i+1, string[i] );
-i=45;
-printf("caractère à la position %d : %c\n", i+1, string[i] );
-\end{lstlisting}
-
-Le programme affichera~:
-\begin{verbatim}
-caractère à la position 6 : e
-caractère à la position 11 : e
-caractère à la position 46 : £
-\end{verbatim}
-
-\end{exemple}
-
-
-\begin{remarque}[Connaître la taille d'un tableau ?]
- Supposons qu'un tableau ait été déclaré dans une partie du programme et que vous cherchiez à l'utiliser dans une autre partie, mais sans savoir qui et comment il a été déclaré. Vous ne connaissez pas a priori sa taille ...
- Le problème est que, en C, vous n'aurez AUCUN moyen de retrouver la taille du tableau. Il sera donc nécessaire de toujours conserver une trace de la taille du tableau.
-
- Ceci sera particulièrement utile (et sensé) lorsque vous travaillerez avec des fonctions. En paramètre d'une fonction qui traite un tableau (en paramètre), il est souvent indispensable de passer également un paramètre contenant la taille de ce tableau.
-\end{remarque}
-
-\subsubsection{Opérations sur les indices}
-
-Si les indices peuvent être des valeurs ou des variables, la logique des choses veux qu'ils puissent également être le résultat d'opérations.
-
-\begin{lstlisting}
-char string[] = "ceci est un texte";
-int i=5;
-char c= string[i];
-
-if( c=='e' ) {
- c = string[i+1]; //désigne le caractère suivant de celui de la case i
- printf("caractère après la position d'un e : %c\n", c);
-}
-\end{lstlisting}
-
-\subsection{Exercices}
-
-\begin{exercice}[Instructions sur tableau]
-On utilise les déclarations suivantes~:
-\begin{lstlisting}
-const int TAILLE = 10;
-int tab[TAILLE] = {1, 2, 3, 0, 5, -1, -2, -3, -4, -5};//< initialisation du tableau tab avec les valeurs entre crochets
-int indice, ind1, ind2;
-int t[7] = {1, 2 ,4, 8, 16, 32, 64}; //< initialisation du tableau t avec les valeurs entre crochets
-\end{lstlisting}
-
-\question{Indiquer le contenu du tableau $tab$ après la séquence d'instruction suivante (les instructions menant à des erreurs seront signalées et ignorées) :}
-\begin{lstlisting}
-tab[7]=0;
-tab[0]=7;
-tab[6]+tab[2]=3;
-tab[6]=tab[2]+3;
-tab[tab[4]]=tab[8];
-tab[tab[9]]=4;
-tab[tab[2]] = tab[tab[3]];
-\end{lstlisting}
-
-\begin{Solution}
-\question{contenu de tab}
-\begin{itemize}
- \item tab = [1, 2, 3, 0, 5, -1, -2, 0, -4, -5]
- \item tab = [7, 2, 3, 0, 5, -1, -2, 0, -4, -5]
- \item Erreur ! On ne peut pas affecter la partie gauche !
- \item tab = [7, 2, 3, 0, 5, -1, 6, 0, -4, -5]
- \item tab = [7, 2, 3, 0, 5, -4, 6, 0, -4, -5]
- \item Erreur ! tab[9]=-5 : hors des limites du tableau
- \item tab = [7, 2, 0, 7, 5, -4, 6, 0, -4, -5]
-\end{itemize}
-\end{Solution}
-
-\question{Faire un tableau d'évolution des variables pour le programme ci-dessous. Affichage ?}
-\begin{lstlisting}
-indice = 0;
-while(indice < TAILLE && tab[indice] >= 0) {
- indice ++;
-}
-printf("premier nombre negatif : %d\n", tab[indice]);
-\end{lstlisting}
-
-\question{Faire un tableau d'évolution des variables pour le programme ci-dessous. Contenu de \texttt{tab} à la fin ?}
-\begin{lstlisting}
-for(ind1=0; ind1 <= TAILLE/2; ind1++) {
- tab[2*ind1] = ind1;
-}
-\end{lstlisting}
-
-\question{Faire un tableau d'évolution des variables pour le programme ci-dessous. Affichage ? Contenu de \texttt{tab} à la fin ?}
-\begin{lstlisting}
-ind1 = ind2 = 0;
-while(ind1<TAILLE) {
- if (tab[ind1] > tab[ind2])
- ind2 = ind2 + 2;
- else
- ind1 = ind1 + 2;
- printf("tab[%d] = %d\n", ind1, tab[ind1]);
-}
-\end{lstlisting}
-\end{exercice}
-
-\section{Les structures de contrôles}
-Les structures de contrôles permettent de définir dans quel ordre doivent être réalisées les instructions.
-
-\subsection{Les instructions conditionnelles \texttt{if}}
-\subsubsection{Syntaxe}
-\begin{lstlisting}[emph={if, else}]
-if(condition)
-{
- ... //instructions a realiser si la condition est vraie (!=0)
-} else {
- ... //instruction a realiser si la condition est fausse (=0)
-}
-\end{lstlisting}
-
-\begin{warning}
-Pour des questions de lisibilité, il faut indenter le code !!!
-\end{warning}
-
-Les conditions sont construites à partir des opérateurs de comparaison et des opérateurs binaires~:
-\begin{exemple}
-\begin{lstlisting}[emph={if, else}]
-if( a==1 && b<=20 ) {
- printf("je suis ici");
-} else {
- printf("je suis la");
-}
-\end{lstlisting}
-\end{exemple}
-
-\subsubsection{Variantes des syntaxes conditionnelles}
-
-Sans \lstinline!sinon!~:
-\begin{lstlisting}[emph={if, else}]
-if(condition)
-{
- ...
-}
-\end{lstlisting}
-
-
-Conditions \lstinline!sinon si!~:
-\begin{lstlisting}[emph={if, else}]
-if(condition1) {
- ...
-} else if (condition2) {
- ...
-} else if (condition3) {
- ...
-} else {
- ...
-}
-\end{lstlisting}
-
-\begin{exemple}
-\begin{lstlisting}[emph={if, else}]
-int i=2;
-if(i>0) {
- printf("i (%d) est strictement positif \n",i);
-} else if(i<0) {
- printf("i (%d) est strictement negatif \n",i);
-} else {
- printf("null");
-}
-\end{lstlisting}
-\end{exemple}
-
-\begin{exercice}
-Écrire en C une suite d'instructions permettant de faire ceci~:
-\begin{verbatim}
-soit c un caractère,
-si c est la lettre 'h' ou 'a', alors afficher ``Aide'',
-si c est la lettre 'q', alors afficher ``quitter'',
-dans tout les autres cas, afficher ``autre''.
-\end{verbatim}
-\begin{Solution}
-Dans un main :
-
-\begin{lstlisting}
-void main() {
- char c;
- //...
- if (c=='h' || c=='a') {
- printf("Aide\n");
- } else if (c=='q') {
- printf("Quitter\n");
- } else {
- printf("Autre\n");
- }
-}
-\end{lstlisting}
-\end{Solution}
-\end{exercice}
-
-\subsubsection{Opérateur triadique}
-Pour les conditions simples, du type ``si vrai telle valeur, sinon une autre valeur'', alors il est possible d'utiliser un opérateur particulier (que je nomme ``triadique'' parce que je me souviens plus de son vrai nom dans la norme ANSI ...). Sa syntaxe est la suivante~:
-
-\begin{center}
-\textbf{(}\textit{condition }\textbf{?} \textit{valeur\_si\_vrai} \textbf{:} \textit{valeur\_sinon} \textbf{)}
-\end{center}
-
-Par exemple, par calculer le maximum de deux valeurs \texttt{x} et \texttt{y} vous pouvez écrire~:
-\begin{lstlisting}
-double max = (x>y ? y : x );
-\end{lstlisting}
-
-\subsection{Les structures itératives}
-
-\subsubsection{Les boucles \texttt{while}}
-Une boucle permet de répéter des instructions similaires tant qu'une condition est vraie~:
-\begin{lstlisting}[emph={while}]
-while( condition )
-{
- ... //instructions
-}
-\end{lstlisting}
-
-\begin{exemple}
-\begin{lstlisting}[emph={while}]
-int i, j;
-i=0;
-j=6;
-while( i!=j ) {
- i++;
- j--;
-}
-printf("%d %d\n", i,j);
-\end{lstlisting}
-\end{exemple}
-
-Le tableau suivant illustre l'évolution des variables au cours des boucles~:
-\begin{center}
-\tablefirsthead{}
-\tablehead{}
-\tabletail{}
-\tablelasttail{}
-\begin{supertabular}{|m{2.102cm}|m{1.8899999cm}|m{2.049cm}|m{2.4459999cm}|}
-\hline
-\centering \bfseries Ligne courante &
-\centering \bfseries i &
-\centering \bfseries j &
- \bfseries test i!=j\\\hline
-\centering 1 &
-\centering ? &
-\centering ? &
-\\\hline
-\centering 2 &
-\centering 0 &
-\centering ? &
-\\\hline
-\centering 3 &
-\centering 0 &
-\centering 6 &
-\\\hline
-\centering 4 &
-\centering 0 &
-\centering 6 &
- VRAI\\\hline
-\centering 5 &
-\centering 1 &
-\centering 6 &
-\\\hline
-\centering 6 &
-\centering 1 &
-\centering 5 &
-\\\hline
-\centering 4 &
-\centering 1 &
-\centering 5 &
- VRAI\\\hline
-\centering 5 &
-\centering 2 &
-\centering 5 &
-\\\hline
-\centering 6 &
-\centering 2 &
-\centering 4 &
-\\\hline
-\centering 4 &
-\centering 2 &
-\centering 4 &
- VRAI\\\hline
-\centering 5 &
-\centering 3 &
-\centering 4 &
-\\\hline
-\centering 6 &
-\centering 3 &
-\centering 3 &
-\\\hline
-\centering 4 &
-\centering 3 &
-\centering 3 &
- FAUX\\\hline
-\centering 8 &
-\centering 3 &
-\centering 3 &
-\\\hline
-\end{supertabular}
-\end{center}
-
-
-\begin{exercice}
-
-Cet exemple utilisant la fonction \lstinline!sqrt! nécessite l'utilisation de la librairie mathémathique~: ajouter \lstinline!#include <math.h>! en haut de votre programme.
-
-\begin{lstlisting}
-float f=81.0;
-int nbTours=0;
-while( f>5 ) {
- f = sqrt(f);
- nbTours++;
-}
-\end{lstlisting}
-
-\question{Faire un tableau qui illustre l'évolution des variables au cours des boucles~!}
-\question{Quel est en résultat~?}
-\question{Même question avec la condition~: \lstinline!f<5!}
-\begin{Solution}
- \question{Tableau d'évolution}
-
-
-\begin{supertabular}{|m{2.102cm}|m{1.8899999cm}|m{2.049cm}|m{2.4459999cm}|}
-\hline
-\bfseries Ligne courante & \bfseries f & \bfseries nbTours & test f>5\\\hline
-1 & 81 & ? & \\\hline
-2 & 81 & 0 & \\\hline
-3 & 81 & 0 & FAUX \\\hline
-4 & 9 & 0 & \\\hline
-5 & 9 & 1 & \\\hline
-3 & 9 & 1 & FAUX \\\hline
-4 & 3 & 1 & \\\hline
-5 & 3 & 2 & \\\hline
-3 & 3 & 2 & VRAI \\\hline
-6 & 3 & 2 & \\\hline
-\end{supertabular}
-\question{Le résultat est donc $f=3$}
-\question{Avec \lstinline!f<5! on ne rentre pas du tout dans la boucle et ni \lstinline!f! ni \lstinline!nbTours! n'est modifié}
-\end{Solution}
-\end{exercice}
-
-\begin{exercice}
-Écrire une suite d'instructions en C réalisant l'algorithme suivant~: compter le nombre de caractères que contient une chaîne de caractères \lstinline!S! (rappel: le dernière caractère est nécessairement le caractère \lstinline!\0!)
-\begin{Solution}
-Comptage du nombre de caractère d'une chaîne de caractères :
- \begin{lstlisting}
-char S[200];// Texte de taille maximum 200
-int i=0;
-while( S[i] != 0 ) {
- i++;
-}
-printf("Nombre de caractères : %d\n", i+1 );
- \end{lstlisting}
-\end{Solution}
-\end{exercice}
-
-La syntaxe suivante est également possible pour une boucle \lstinline!while!. Dans cette syntaxe la condition se place en fin de boucle. Ceci peut être pratique lorsqu'il faut effectivement réaliser une première iteration avant un test.
-
-\begin{lstlisting}[emph={while,do}]
-do{
- ...
-} while(condition)
-\end{lstlisting}
-
-\subsubsection{Boucles \textit{for}}
-Une autre manière d'écrire une boucle est d'écrire un \lstinline!for!. Le principe d'un \lstinline!for! est de parcourir un ensemble de valeurs.
-
-\begin{lstlisting}[emph={for}]
-for( initialisation; condition; incrementation) {
- ... //instructions
-}
-\end{lstlisting}
-
-Pour comprendre ce que fait cette structure de contrôle, il faut voir que celle-ci peut être réécrite sous la forme d'un \lstinline!while! de la manière suivante~:
-
-\begin{lstlisting}
-initialisation;
-while(condition) {
- ...//instructions
- incrementation;
-}
-\end{lstlisting}
-
-\begin{exemple}
-Voici un exemple très usuel pour traiter les cas pour \lstinline!i! allant de 0 à 25~:
-\begin{lstlisting}[emph={for}]
-int i;
-for(i=0; i<25; i++) {
- printf("%d",i);
-}
-\end{lstlisting}
-\end{exemple}
-
-L'initialisation, la condition et l'incrémentation peuvent contenir des ``instructions'' complexes~:
-
-\begin{itemize}
-\item Il est possible de déclarer des variables dans l'initialisation (\cf problèmes de portée des variables), par exemple~:
-\begin{lstlisting}[emph={for}]
-for(int i=0; i<25; i++) {
- printf("%d",i);
-}
-\end{lstlisting}
-Cette écriture se croise assez souvent et est plutôt pratique. Néanmoins, cette notation n'est pas toujours acceptée par les compilateurs.
-
-\item La condition peut contenir une combinaison de conditions (combinées avec des \lstinline!&&! et des \lstinline!||!). Par exemple~:
-\begin{lstlisting}[emph={for}]
-for(int i=0; i<25 || c='\0'; i++) {
- printf("%d",i);
-}
-\end{lstlisting}
-
-\item L'initialisation et l'incrémentation peuvent contenir l'initialisation et l'incrémentation de plusieurs variables (séparées par des virgules), par exemple~:
-\begin{lstlisting}[emph={for}]
-int i,j;
-for(i=0, j=10; i<25; i++, j--) {
- printf("%d %d",i, j);
-}
-\end{lstlisting}
-\end{itemize}
-
-\begin{exemple}
-Exemple d'incrémentation non linéaire~:
-\begin{lstlisting}
-int j=100;
-double d= 13;
-for(j=16; j >= 1 ; j=j/2 ) {
- d=d/2;
-}
-printf("result~: d=%f\n",d);
-\end{lstlisting}
-\end{exemple}
-
-\begin{exemple}[Calcul de $\pi$]
-
-Dans cet exemple, on illustre les boucles sur un problème du calcul des décimales de $\pi$.
-
-Tout d'abord, quelques rappels de mathématiques et plus précisément sur les séries numériques. On peut montrer que~:
-
-$$ \frac{\pi}{6} = \sum_{k=1}^{\infty}\frac{1}{k^2}$$
-
-C'est à dire que si on somme $\frac{1}{1^2} + \frac{1}{2^2} + \frac{1}{3^2} + \frac{1}{4^2} + ...$ alors on s'approche progressivement de la valeurs $\frac{\pi}{6}$.
-Pour approcher la valeur de $\pi$, une méthode consiste à calculer cette somme avec le plus de termes possibles.
-
-Le programme ci-dessous réalise le calcul de cette somme.
-
-\begin{lstlisting}
-int nbtermes=10000, i;
-double somme = 0;
-for(i=1; i<nbtermes ; i++ ) {
- somme=somme + 1/((double)(i*i));
-}
-printf("pi~=%lf\n",6*somme);
-\end{lstlisting}
-
-Quelques remarque~:
-\begin{itemize}
- \item \lstinline!nbtermes! est une variable qui permet de définir le nombre de terme de la somme à calculer. Il est plus pratique de définir une variable que d'avoir à modifier la boucle \texttt{for}.
- \item il ne faut pas oublier d'initialiser la variable \lstinline!somme! à 0.
- \item on commence à itérer à partir de 1 et non pas de 0, sinon la division provoquerait un bug.
-\end{itemize}
-
-
-\end{exemple}
-
-
-\begin{exercice}[Approximation polynomiale (\hard)]
-Le but de l'exercice est de construire un programme qui fait l'approximation de la valeur $\frac{1}{1-x}$ pour tout $x$ tel que $|x|<1$. Pour cela, on utilise les développements limités\footnote{\cf cours de maths ...} qui permet une approximation polynomiale d'ordre $n$ avec la formule suivante :
-
-$$\forall x, |x|<1, \; \frac{1}{1-x} \approx 1+x+x^2+...+x^{n-1} $$
-
-L'approximation qui est faite par l'équation ci-dessus est faite à $x^{n}$. Avec $|x|<1$, plus $n$ est grand, plus on s'approche de la valeur réelle de $\frac{1}{1-x}$.
-
-\question{Déduire un algorithme pour calculer l'approximation de $\frac{1}{1-x}$ à l'ordre $n$, où $x$ et $n$ seront des variables du programme.}
-\question{Traduire l'algorithme en C.}
-
-\question{Déduire un algorithme pour calculer l'approximation de $\frac{1}{1-x}$ avec une précision $\epsilon$, où $x$ et $\epsilon$ seront des variables du programme.}
-\question{Traduire l'algorithme en C.}
-
-%\begin{Solution}
-
-%\end{Solution}
-
-\end{exercice}
-
-
-\subsubsection{Parcours d'un tableau}
-L'utilisation des tableaux est intéressant pour faire des opérations similaires sur tous les éléments du tableau. Pour abstraire des traitements, il est donc utile de faire des parcours de ce tableau grâce à des boucles.
-
-Voici quelques exemples classiques qu'il faut avoir bien compris~:
-\begin{itemize}
- \item Notez bien les limites de parcours donnés dans la boucle~: commencez avec une valeur d'indice de 0 et terminer en testant
- \item la variable \lstinline!i! sert d'indice de la case du tableau~: à chaque tour de boucle on traite la \lstinline!i!-eme case, mais la valeur de \lstinline!i! change
-\end{itemize}
-
-
-\begin{exemple}[Initialisation des valeurs d'un tableau]
-L'exemple ci-dessous initialise un tableau de taille 23 avec les valeurs 1, 2, 3, ... 23.
-\begin{lstlisting}
-double tab[23];
-int i;
-for( i=0; i<23; i++) {
- tab[i]=i+1;
-}
-\end{lstlisting}
-\end{exemple}
-
-
-\begin{exemple}[Traitement des valeurs d'un tableau]
-À la suite de l'exemple précédent, voici un exemple qui utilise les valeurs successives du tableau pour réaliser une tâche (sommer les 23 premiers entiers).
-\begin{lstlisting}
-int i;
-int somme=0;
-for( i=0; i<23; i++) {
- somme = somme + tab[i];
-}
-printf("somme : %lf\n", somme);
-\end{lstlisting}
-
-Équivalent avec un \lstinline!while! :
-\begin{lstlisting}
-int i=0; //attention à bien initialiser l'iterateur !!
-int somme=0;
-while(i<23) {
- somme = somme + tab[i];
- i++; //attention à ne pas oublier d'incrémenter votre iterateur
-}
-printf("somme : %lf\n", somme);
-\end{lstlisting}
-\end{exemple}
-
-\begin{exemple}
-L'exemple ci-dessous affiche tous les caractères de la chaîne, un à un. Ici, la condition d'arrêt de la boucle ne se fait pas sur la longueur de la chaîne, mais lorsqu'on tombe sur un caractère nul.
-
-\begin{lstlisting}
-char string[] = "ceci est un texte";
-int i;
-for( i=0; string[i]!='\0'; i++) {
- char c= string[i] //Utilisation de la variable i comme indice
- printf("caractère à la position %d : %c\n", i, c);
-}
-\end{lstlisting}
-\end{exemple}
-
-
-\subsubsection{Opérations sur les indices}
-
-C'est là que l'algorithmique se complexifie un peu. Mais, bien évidemment, l'algorithmique commence à être intéressante quand on traite ce genre de problème.
-
-\begin{exemple}
-
-Voici un exemple plutôt simple. On commence par initialiser une tableau \lstinline!tab!, puis on construit un second tableau \lstinline!tab2!. La ligne intéressante est la ligne 9~: sur cette ligne, on indique que dans la ième case du tableau \lstinline!tab2!, on met la moyenne de la case de droite et de la case de gauche du tableau \lstinline!tab!.
-
-\begin{center}
- \includegraphics[width=.4\textwidth]{\Figures/Tableau_ExempleopIndices}
-\end{center}
-
-\begin{lstlisting}
-double tab[7], tab2[5];
-int i;
-//Initialisation du tableau tab avec des valeurs de 0 à 12
-for( i=0; i<7; i++) {
- tab[i]=2*i;
-}
-
-//Construction de tab2
-for( i=0; i<5; i++) {
- tab2[i]=(tab[i-1]+tab[i+1])/2; // <- utilisation d'opération sur les indices
-}
-\end{lstlisting}
-
-\end{exemple}
-
-
-
-
-\begin{exercice}[Traitement d'une chaîne de caractères]
-
-On donne le programme ci-dessous~:
-
-\begin{lstlisting}
-char text[] = "voici un texte";
-char c;
-for(int i=0; c != '\0'; i+=2) {
- c=text[i];
- printf("%c?", c);
-}
-printf("\n");
-\end{lstlisting}
-\question{Que fait cet exemple~?}
-\question{Réécrire cet exemple sous la forme d'une boucle \lstinline!while!}
-
-\begin{Solution}
- \question{Le programme affiche le texte en masquant un caractère sur deux. Le texte affiché sera ainsi : \texttt{v?i?i ?n ?e?t?}}
- \question{Récriture avec un while}
-\begin{lstlisting}
-char text[] = "voici un texte";
-char c;
-int i=0;
-while( c != '\0' )) {
- c=text[i];
- printf("%c?", c);
- i+=2;
-}
-printf("\n");
-\end{lstlisting}
-\end{Solution}
-\end{exercice}
-
-
-\subsection{Combiner les structures de contrôle}
-\subsubsection{Imbrication de structures de contrôle}
-Les structures de contrôle peuvent s'imbriquer à l'infinie, par exemple~:
-
-\begin{lstlisting}
-for(... ; ... ; ...) {
- if(...) {
- //...
- } else {
- while( ...) {
- //..
- }
- }
- while(...) {
- //...
- }
-}
-\end{lstlisting}
-\begin{warning}
-L'indentation est nécessaire pour que le code soit lisible~!!
-\end{warning}
-
-\begin{exercice}[Double boucles] \label{bkm:RefNumPara37150713}
-
-Exemple de double boucles~:
-
-\begin{lstlisting}
-for(int i=0; i< 4; i++) {
- for(int j=0; j <4; j++) {
- // faire quelque chose avec i et j
- }
-}
-\end{lstlisting}
-
-\question{Faire un tableau d'évolution des variables au cours de l'exécution du programme}
-
-\begin{lstlisting}
-int s=0;
-for(int i=0; i< 10; i++) {
- s-=i;
- for(int j=0; j <10; j++) {
- s++;
- }
-}
-\end{lstlisting}
-
-\question{Faire un tableau d'évolution des variables pour le début de l'exécution du programme}
-\question{À partir du fonctionnement compris des boucles, indiquer quel sera la valeur finale de la variable \lstinline!s! ?}
-
-\begin{Solution}
-\question{}
-
-\begin{supertabular}{|m{2cm}|m{1.5cm}|m{1.5cm}|m{2cm}|}
-\hline
-\bfseries Ligne courante & \bfseries i & \bfseries j\\\hline
-3 & 1 & 1 \\\hline
-3 & 1 & 2 \\\hline
-3 & 1 & 3 \\\hline
-3 & 2 & 1 \\\hline
-3 & 2 & 2 \\\hline
-3 & 2 & 3 \\\hline
-3 & 3 & 1 \\\hline
-3 & 3 & 2 \\\hline
-3 & 3 & 3 \\\hline
-\end{supertabular}
-
-
-\end{Solution}
-\end{exercice}
-
-\subsubsection{\texttt{break}, \texttt{continue}~: modification du déroulement d'une boucle}
-L'instruction break permet au programme de sortir directement de la boucle \textbf{la plus proche}.
-
-\begin{lstlisting}
-for(... ; ... ; ...) {
- ...// instructions
- if( condition ) {
- break;
- }
-}
-\end{lstlisting}
-L'instruction continue permet de passer directement à la fin de la boucle et de passer au tour suivant~:
-
-\begin{itemize}
-\item pour les \lstinline!for!, l'incrémentation est réalisée,
-\item les conditions sont évaluées avant de rentrer dans le tour de boucle suivant.
-\end{itemize}
-
-\begin{lstlisting}
-while(...) {
- ...// instructions
- if( condition ) {
- continue;
- }
- ...// instructions 2
-}
-\end{lstlisting}
-
-\begin{exemple}[Recherche avec arrêt]
-L'exemple suivant permet d'illustrer un \textbf{algorithme de recherche avec arrêt}.
-
-Le programme suivant recherche une occurrence du caractère 'e' dans une chaîne de caractère et affiché ``présent'' ou ``non-présent''. Dès qu'on a trouvé la première occurrence de 'e' alors, ca ne sert à rien de continuer, alors on sort de la boucle. L'algorithme ressemble alors à~:
-
-\begin{lstlisting}
-char *str="chaine de test";
-int i=0;
-while( str[i]!= '\0' ) //test si c'est la fin de la chaine
-{
- if( str[i] == 'e' ) {
- //ICI, on c'est qu'il existe un 'e'
- break;
- }
- i++;
-}
-// ICI : on ne sait rien !!!!
-\end{lstlisting}
-
-On pourrait afficher ``présent'' lorsqu'on est à la ligne 10, mais à quelle ligne peut-on afficher ``non-présent'' ? Car à la ligne 10, on ne sait pas comment on est arrivé là. On peut être arrivé là après un break, o\`u bien simplement à la fin de la boucle, auquel cas, on n'a pas trouvé de '\texttt{e}' !!
-
-La seule solution est de retenir dans une variable qu'on a bien trouvé un '\texttt{e}' dans la chaîne de caractères, et le programme résultant est celui-ci~:
-\begin{lstlisting}
-char *str="chaine de test";
-int i=0;
-int found=0;
-while( str[i]!= '\0' ) //test si c'est la fin de la chaine
-{
- if( str[i] == 'e' ) {
- //ICI, on c'est qu'il existe un 'e'
- found=1;
- break;
- }
- i++;
-}
-// ICI : on sait que si found est faux, alors on n'a rien trouve
-if( found) {
- //ICI on sait que un 'e' a ete trouve
- printf("present\n");
-} else {
- //ICI on sait qu'aucun 'e' n'a ete trouve
- printf("non-present\n");
-}
-\end{lstlisting}
-\end{exemple}
-
-\begin{exercice}
-\begin{lstlisting}
-for(int i=0; i< 4; i++) {
- for(int j=0; j <4; j++) {
- if( j>=i ) {
- break;
- }
- }
-}
-\end{lstlisting}
-\question{Faire un tableau d'évolution des variables au cours de l'exécution du programme.}
-\question{Modifier le programme pour supprimer le \lstinline!break! et utiliser un \lstinline!while!.}
-\question{Répondre de nouveau aux deux questions précédentes en remplacant le \lstinline!break! par un \lstinline!continue!.}
-\end{exercice}
-
-\subsection{Écritures courtes}
-Lorsque le code qui est entre crochet ne comporte qu'une seule instruction, il est possible de supprimer les accolades. Vous pouvez donc rencontrer ces écritures, mais il est déconseillé de les utiliser.
-Les codes suivants sont équivalents~:
-
-\begin{lstlisting}
-for(int i=0; i<max; i++) {
- printf("%d\n",i);
-}
-
-for(int i=0; i<max; i++)
- printf("%d\n",i);
-
-for(int i=0; i<max; i++) printf("%d'\n",i);
-\end{lstlisting}
-
-Les codes suivants sont également équivalents~:
-\begin{lstlisting}
-if(...) {
- printf("vrai\n");
-} else {
- printf("faux\n");
-}
-
-if(...)
- printf("vrai\n");
-else
- printf("faux\n");
-
-if(...) printf("vrai\n"); else printf("faux\n");
-\end{lstlisting}
-
-
-\begin{warning}
-L'imbrication des structures de contrôle (en particulier les structures conditionnelles) peuvent être ambigu\"e à lire~! Par exemple, le programme suivant peut être lu de plusieurs manières
-\begin{lstlisting}[numbers=none]
-if(a==1)
- printf("A\n");
-else if(a==2)
- printf("B\n");
-else
- printf("C\n");
-\end{lstlisting}
-
-\textbf{Mieux vaut mettre des accolades systématiquement sur les blocs d'instructions}
-\end{warning}
-
-\section{Les entrées/sorties }
-Les instructions d'entrée/sortie (\textit{in/out}) désignent les instructions qui permettent à un programme d'échanger des informations avec un utilisateur. Par défaut, le C (norme ANSI 89) ne propose pas d'instructions simples pour les entrées/sorties.
-Néanmoins, toutes les distributions usuelles de C disposent de la librairie standard \lstinline!<stdio.h>!\footnote{Détails de la librairies \lstinline!<stdio.h>!~: \href{www.cplusplus.com/reference/clibrary/cstdio/}{www.cplusplus.com/reference/clibrary/cstdio/}}. Cette librairie définie des instructions d'entrée/sortie que nous allons
-présenter dans cette partie du cours.
-
-De part la proximité du C avec les Unix et son bas niveau, les entrées/sorties possibles sont simplement possible sous la forme de texte (pour dessiner sur un écran, il faut utiliser des librairies très évoluées comme la Xlib ou les librairies
-Motif\footnote{Motif~: www.openmotif.org}, gtk\footnote{GTK~: \href{www.gtk.org}{www.gtk.org}} ou ncurses\footnote{NCurses~: \href{www.gnu.org/software/ncurses/ncurses.html}{www.gnu.org/software/ncurses/ncurses.html}}).
-
-Un programme peut écrire ou lire du texte~:
-\begin{itemize}
-\item à partir d'un terminal d'exécution,
-\item à partir de fichier.
-\end{itemize}
-
-Pour l'affichage dans un terminal, on parle de ``sortie standard'' (nommée stdout), mais vous pouvez également affichée sur la sortie ``erreurs'' (nommée \lstinline!stderr!).
-L'``entrée standard'' (nommée \lstinline!stdin!) désigne le canal par lequel les caractères tapées au clavier peuvent être récupérés. C'est concepts sont très liés aux systèmes Linux. Ils ne vous sont donc certainement pas très familiers.
-
-\subsection{L'affichage d'un texte dans un terminal avec \texttt{printf}}
-L'instruction \lstinline!printf! permet de faire des affichages (de texte) dans la sortie standard du terminal. Sa syntaxe est la suivante~:
-
-{\centering \bf
-int printf( const char *format [, arg [, arg]...]);
-\par}
-
-Contrairement à la plupart des fonctions C, la fonction \lstinline!printf! n'a pas un nombre fixé de paramètres~: elle en a au moins un (\textit{la chaîne de format}) ou plus (les arguments). De ce point de vue, c'est une des fonctions C les plus complexes que vous devriez rencontrer.
-
-Dans la suite, on présente donc cette fonction par des exemples pratiques usuels.
-
-\subsubsection{Affichage d'un texte simple (sans variable)}
-Le premier argument de la fonction doit toujours être une chaîne de caractères. Ce sera la chaîne de caractères qui indique ce qui va être écris dans le terminal.
-
-Cette chaîne de caractères peut être directement écrite entre les parenthèses de la fonction, ou bien dans une variable (de type \lstinline!char *! ou \lstinline!const char *!\footnote{Le ``const'' signifie que le contenu de l'emplacement mémoire de la variable ne doit pas être modifié, c'est une manière de programmer en ``protégeant'' son code.}).
-
-Il est préférable de systématiquement terminer la chaîne de caractères que vous souhaitez afficher par le caractère spécial \lstinline!\n! qui indique qu'il faut faire un saut de ligne.
-Si vous ne le faites pas, d'une part, ce sera illisible et, d'autre part, vous risquez de ne voir apparaître vos textes qu'une fois le programme terminer et de croire que c'est un problème de programmation~! alors que (pour une fois ...) non~!
-
-\begin{exemple}
-\begin{lstlisting}
-printf("le texte que je souhaite afficher\n");
-\end{lstlisting}
-
-ou
-
-\begin{lstlisting}
-char texte[]="le texte que je souhaite afficher";
-printf( texte );
-\end{lstlisting}
-\end{exemple}
-
-
-Les caractères spéciaux utiles~:
-\begin{center}
-\tablefirsthead{}
-\tablehead{}
-\tabletail{}
-\tablelasttail{}
-\begin{supertabular}{|m{2cm}|m{4cm}|}
-\hline
-\lstinline!\n! & Fin de ligne\\\hline
-\lstinline!\t! & Tabulation\\\hline
-\end{supertabular}
-\end{center}
-
-\begin{remarque}
-L'affichage est, généralement, mis à jour uniquement lorsqu'on demande d'afficher un retour à la ligne~!
-\end{remarque}
-
-\begin{remarque}
-Vous devez éviter les accents dans les chaînes de caractères que vous voulez afficher. Ils risquent de ne pas être bien retranscrits.
-\end{remarque}
-
-\subsubsection{Affichage d'une variable}
-Pour afficher une variable, il faut toujours utiliser une première chaîne de caractères dans laquelle vous aller décrire comment afficher une variable, et ensuite, le second argument de la fonction indiquera le nom de la variable à afficher.
-
-L'affichage d'une variable se fait de la sorte~:
-
-\begin{lstlisting}
-printf("%...", arg);
-\end{lstlisting}
-
-\begin{exemple}
-\begin{lstlisting}
-int i;
-printf("%d", i);
-\end{lstlisting}
-\end{exemple}
-
-\begin{itemize}
-\item \lstinline!%! est un caractère spéciale indiquant qu'il faut écrire dans le terminal la valeur d'une variable,
-\item \lstinline!%d! indique qu'il faut afficher une variable de type int (\cf tableau suivant pour les autres codes possibles)
-\item la variable affichée est celle qui est donnée en second argument de la fonction (ici \lstinline!i!) !
-\end{itemize}
-
-C'est au programmeur d'indiquer comment afficher une variable en disant s'il s'agit d'un entier, un flottant ou un caractère. On parle de ``code de format''~:
-
-\begin{center}
-\tablefirsthead{}
-\tablehead{}
-\tabletail{}
-\tablelasttail{}
-\begin{supertabular}{|m{8.298cm}|m{8.3cm}|}
-\hline
-\lstinline!%d!, \lstinline!%i! & Nombre entier (relatif ou non)\\\hline
-\lstinline!%ld!, \lstinline!%li! & Nombre entier long (relatif ou non)\\\hline
-\lstinline!%f!, \lstinline!%g!, \lstinline!%e! & Nombre à virgule flottante\\\hline
-\lstinline!%lf!, \lstinline!%lg!, \lstinline!%le! & Nombre à virgule flottante double précision\\\hline
-\lstinline!%c! & Un caractère\\\hline
-\lstinline!%s! & Une chaîne de caractères\\\hline
-\lstinline!%x! & Affichage de la valeur héxadécimal\\\hline
-\end{supertabular}
-\end{center}
-
-L'affichage de nombre à virgule flottante peut se paramétrer à volonté (nombre de chiffre significatifs, nombre de chiffre avant et après la virgule, notation exponentielle...). Il faut se référer à la documentation\footnote{ou de regarder sur internet : par exemple sur le site \url{www.cplusplus.com}.} de la fonction \lstinline!printf! pour tous ces détails.
-
-\begin{exemple}
-Quelques exemples d'affichage de nombres à virgule flottante~:
-
-Avec \lstinline!printf("%f", x)!
-\begin{itemize}
-\item si x=1.2345,
-\begin{verbatim}
-1.234500
-\end{verbatim}
-\item si x=12.3456789,
-\begin{verbatim}
-12.3456789
-\end{verbatim}
-\end{itemize}
-
-Avec \lstinline!printf("%10f", x)!
-\begin{itemize}
-\item si x=1.2345,
-\begin{verbatim}
-__1.234500
-\end{verbatim}
-\item si x=12.345,
-\begin{verbatim}
-_12.345000
-\end{verbatim}
-\item si x=12.345e5,
-\begin{verbatim}
-1234500.00000
-\end{verbatim}
-\end{itemize}
-
-Avec \lstinline!printf("%10.3f", x)!
-\begin{itemize}
-\item si x=1.2345,
-\begin{verbatim}
-_____1.235
-\end{verbatim}
-\item si x=1.2345e5,
-\begin{verbatim}
-__1234.500
-\end{verbatim}
-\end{itemize}
-
-Avec \lstinline!printf("%e", x)!
-\begin{itemize}
-\item si x=1.2345,
-\begin{verbatim}
-1.234500e+000
-\end{verbatim}
-\item si x=123.45,
-\begin{verbatim}
-1.2345000e+002
-\end{verbatim}
-\end{itemize}
-
-Avec \lstinline!printf("%12.4e", x)!
-\begin{itemize}
-\item si x=1.2345,
-\begin{verbatim}
-_1.2345e+000
-\end{verbatim}
-\item si x=123.456789e8,
-\begin{verbatim}
-_12346e+010
-\end{verbatim}
-\end{itemize}
-\end{exemple}
-
-On peut faire des conversions directement par l'affichage. Par exemple~:
-
-\begin{lstlisting}
-char a='c';
-printf("%d", c);
-\end{lstlisting}
-affiche le code ascii du caractère.
-
-\begin{warning}
-Le compilateur de vérifie pas que ce qu'il doit vous afficher correspond aux variables.
-\begin{lstlisting}
-double f;
-printf("%s", f); //Aucun resultat garantis !!
-\end{lstlisting}
-\end{warning}
-
-\subsubsection{Formatage d'une chaîne de caractères}
-On peut mélanger le texte et les variables. L'ordre des paramètres doit correspondre à l'ordre des insertion à faire dans la chaîne de caractères.
-
-\begin{lstlisting}
-char texte[]="suite du texte";
-int i=4;
-float f=45.6;
-printf("ceci est un entier %d, la un float (%f), et voici la %s.\n", i, f, texte);
-\end{lstlisting}
-Résultat de l'affichage~:
-\begin{verbatim}
-> ceci est un entier 4, la un float (45.6), et voici la
-suite du texte.
-\end{verbatim}
-
-
-\begin{warning}
-Le compilateur ne vérifie pas si le nombre d'arguments est correct.
-\end{warning}
-
-\begin{exemple}
-Exemple d'affichage de nombre sous différentes formes~:
-\begin{lstlisting}
-/* printf example */
-#include <stdio.h>
-int main()
-{
- printf("Characters: %c %c \n", 'a', 65);
- printf("Decimals: %d %ld\n", 1977, 650000L);
- printf("Preceding with blanks: %10d \n", 1977);
- printf("Preceding with zeros: %010d \n", 1977);
- printf("Some different radixes: %d %x %o %#x %#o \n", 100, 100, 100, 100, 100);
- printf("floats: %4.2f %+.0e %E \n", 3.1416, 3.1416, 3.1416);
- printf("Width trick: %*d \n", 5, 10);
- printf("%s \n", "A string");
- return 0;
-}
-\end{lstlisting}
-
-Le résultat de l'affichage sera alors~:
-\begin{verbatim}
-Characters: a A
-Decimals: 1977 650000
-Preceding with blanks: 1977
-Preceding with zeros: 0000001977
-Some different radixes: 100 64 144 0x64 0144
-floats: 3.14 +3e+000 3.141600E+000
-Width trick: 10
-A string
-\end{verbatim}
-\end{exemple}
-
-\subsection{Lire une valeur du clavier avec \texttt{scanf}}
-L'instruction scanf permet de lire (du texte) à partir de l'entrée standard (clavier utilisé depuis le terminal). Sa syntaxe est la suivante~:
-
-{\centering \bf
-int scanf( const char *format [, arg [, arg]...]);
-\par}
-
-L'instruction suivante illustre la lecture d'un entier depuis l'entrée standard~:
-\begin{lstlisting}
-int n;
-scanf ("%d",&n);
-\end{lstlisting}
-
-Dans cet exemple, le chiffre qui sera donné par l'utilisateur (et validé par l'utilisation de la touche \texttt{Entrée}) permettra d'affecter une valeur à la variable \lstinline!n!.
-
-Cette fonction montre une certaine ressemblance avec \lstinline!printf!, et fait appel aussi à des ``codes de format''.
-Globalement, les codes formats présentés dans la section précédente peuvent être utilisés avec la même sémantique
-(par exemple, \lstinline!%d! parle d'un entier, \lstinline!%lf! d'un long float).
-
-En revanche, les arguments définissant les variables dont vous cherchez à modifier la valeur doivent être systématiquement précédés d'un \lstinline!&!. On verra plus loin que cette expression désigne un pointeur sur la variable \lstinline!n!.
-
-\begin{warning}
-Dans la fonction \lstinline!scanf!, vous devez mettre un \lstinline!&! avant le nom de la variable dont vous souhaitez modifier la valeur.
-\end{warning}
-
-\subsection{Repérer les erreurs de saisie de l'utilisateur}
-Lorsque le type de la variable ne correspond pas au ``code de format'', la fonction \lstinline!scanf! retourne la valeur 0 pour indiquer qu'elle n'a pas reconnue le format annoncé dans l'entrée standard.
-
-Ainsi, le code suivant permet de récupérer une erreur de saisie~:
-
-\begin{lstlisting}
-int main(void) {
- int n=0;
- printf("Donne moi un entier\n");
- if( !scanf("%d",&n) ) {
- //ici, l'utilisateur a fait une erreur
- printf("Il aurait fallu donner un nombre\n");
- return 1;
- }
- //Ici, l'utilisateur a bien fait son job !
- printf("bien\n");
- return 0;
-}
-\end{lstlisting}
-
-\begin{remarque}
-Aucune erreur ne peut être rattrapée si vous demandez un texte à l'utilisateur et que, par exemple, il rentre un nombre. Un nombre sera alors vu comme une suite de caractères figurant des chiffres~!
-\end{remarque}
-
-\begin{exercice}[Calcul IMC]\label{bkm:RefNumPara37145413}
-Écrire un programme demandant à l'utilisateur d'entrer son prénom, son poids et sa taille et qui
-affiche ensuite à l'écran le prénom, et l'IMC de la personne.
-
-L'IMC sera caculée par la formule ci-dessous~:
-$$\mathit{IMC}=\frac{\mathit{poids}}{\mathit{taille}^{2}}$$
-\begin{Solution}
-Programme attendu:
-
-\begin{lstlisting}
-#include <stdio.h>
-void main() {
- char prenom[10];
- int age;
- printf("Entrez votre prenom :");
- scanf("%s",&prenom);
- printf("\nEntrez votre age :");
- scanf("%d",&age);
- printf("\nBonjour %s, vous avez %d ans et vous avez vecu au moins %d jours\n", prenom, age);
-}
-\end{lstlisting}
-\end{Solution}
-
-\end{exercice}
-%
-% \begin{exercice}[Sur le fil ...]\label{bkm:RefNumPara37144813}
-% Écrire un programme qui calcule la longueur $L$ d'un câble entre deux pylônes, grâce à la formule~:
-% $$L=a\left(1+\frac{2}{3}\left(\frac{2f}{a}\right)^{2}\right)$$
-% o\`u $a$ est la distance entre les pylônes et $f$ la flèche mesurée perpendiculairement au milieu du câble. Ces deux paramètres seront donnés par l'utilisateur.
-%
-% \begin{Solution}
-% Programme attendu:
-%
-% \begin{lstlisting}
-% #include <stdio.h>
-% #include <math.h>
-% void main() {
-% float l, f, a;
-% printf("Distance entre les pylones ?");
-% scanf("%f",&a);
-% printf("Fleche (mesuree au milieu du cable) ?");
-% scanf("%f",&f);
-% l = a*(1.0+2.0/3.0*pow(2.0*f/a,2));
-% printf("Longueur de cable = %f\n", l);
-% }
-% \end{lstlisting}
-% \end{Solution}
-% \end{exercice}
-
-\begin{exercice}[``Le capital'']\label{bkm:RefNumPara37135313}
-Dans le même esprit, écrire un programme qui calcule le capital $A$ produit par $x$ euros, placés au taux $r$ au bout de $n$ années, avec~: $$A=x\left(1+r\right)^{n}$$
-
-Aide~: Dans la librairie \lstinline!<math.h>!, vous pourrez utiliser la fonction \lstinline!double pow(double a, int n)! qui permet de calculer $a$ à la puissance $n$ ($a^n$).
-\begin{Solution}
-Programme attendu:
-
-\begin{lstlisting}
-void main() {
- float x, r, A;
- int n;
- printf("Taux d'interet ?");
- scanf("%f",&r);
- printf("Capital initial ?");
- scanf("%f",&x);
- printf("Nombre d'annees ?");
- scanf("%d",&n);
- A = x*pow(1+r,n);
- printf("Capital final = %f\n", A);
-}
-\end{lstlisting}
-\end{Solution}
-\end{exercice}
-
-\begin{exercice}[Calcul en place]
-On souhaite écrire un petit programme qui calcule la moyenne et l'écart type d'une série de notes. Les notes sont saisies une à une. À chaque saisie on affiche la moyenne courante et l'écart type courant.
-
-Dans cet exercice, vous demande un algorithme qui n'utilise pas de tableau. Une solution ``simpliste'' serait effectivement de retenir toutes les valeurs saisies et de refaire à chaque fois les calculs des moyennes et écart-types. Mais il y a beaucoup plus malin que cela (on parle d'algorithme ``en place''). Les questions ci-dessous vous dirigent vers la construction de l'algorithme.
-
-
-
-\question{Identifier et établir les formules mathématiques qui permettent de calculer ces deux grandeurs.}
-\question{Exprimer ces formules au rang N en fonction du rang N-1.}
-\question{Rechercher les variables nécessaires à la saisie et à mémoriser l'état précédent (rang N-1).}
-\question{Décrire l'algorithme du programme qui effectue la boucle de saisie.}
-\question{Indiquer comment on termine le programme.}
-\question{Écrire le programme C.}
-
-\question{Quel est l'avantage de la solution proposée par rapport à une solution utilisant un tableau}
-
-\begin{Solution}
-
-\question{Identifier et établir les formules mathématiques qui permettent de calculer ces deux grandeurs.}
-$$\mu={n}=\frac{(t_{1} + t_{2} + ... + t_{n})}{n} \;\sigma_{n} = \sqrt{ \frac{( (t_{1} - \overline{t_{n}})^{2} + (t_{2} - \overline{t_{n}})^{2} + ... + (t_{n} - \overline{t_{n}})^{2} )}{n} } $$
-\question{Exprimer ces formules au rang N en fonction du rang N-1.}
-$$\mu_{n} = \frac{(\mu_{n-1} (n-1) + t_{n})}{n}\;{\sigma_{n}}^{2} = (\frac{n-1}{n})^{2} {\sigma_{n-1}}^{2} + \frac{n-1}{n^{2}} (\mu_{n-1} - t_{n})^{2}$$
-\question{Rechercher les variables nécessaires à la saisie et à mémoriser l'état précédent (rang N-1).}
-\begin{itemize}
- \item la note courante
- \item la moyenne du rang courant
- \item le sigma du rang courant
-\end{itemize}
-\question{Décrire l'algorithme du programme qui effectue la boucle de saisie.}
- \begin{verbatim}
-Tant que pas fini {
- Saisir nouvelle note
- Calculer nouvelle moyenne
- Calculer nouvel écart type
- Afficher moyenne
- Afficher ecart type
-}
-\end{verbatim}
-\question{Indiquer comment on termine le programme.}
-On peut faire la moyenne uniquement sur des saisies de nombres positifs, et arrêter lorsque la saisie est négative (par exemple)
-
-\question{Écrire le programme C.}
-
-\begin{lstlisting}
-#include <stdio.h>
-#include <stdlib.h>
-#include <math.h>
-
-int main(int argc, char *argv[])
-{
- float moyenne;
- float sigma;
- float variance;
-
- int note;
- int i;
-
- printf("Calcul de moyenne et de sigma.\nEntrez une note : ");
- scanf("%d", ¬e);
- i = 0;
-
- while ((note >= 0) && (note <= 20)) {
- if (i == 0) {
- moyenne = note;
- sigma = 0;
- }
- else {
- variance = sigma * sigma;
- variance = ((float)i / ((float)i + 1))
- * ((float)i / ((float)i + 1)) * variance
- + ((float)i / (((float)i + 1) * ((float)i + 1)) )
- * (moyenne - note) * (moyenne - note) ;
- sigma = sqrt(variance);
- moyenne = (moyenne * (float)i + note ) / ((float)i + 1);
- }
-
- /* impression */
- printf("note : %d\n", note);
- printf("moyenne : %f\n", moyenne);
- printf("sigma : %f\n", sigma);
-
- /* instructions de boucle */
- i++;
- scanf("%d", ¬e);
- }
- printf("au revoir.\n");
- return 0;
-}
-\end{lstlisting}
-
-
-\question{Quel est l'avantage de la solution proposée par rapport à une solution utilisant un tableau}
-L'avantage de la solution proposée (sans tableau) est de ne pas dépendre du nombre de saisies. Une solution avec tableau impose de limiter le nombre de saisies en fixant la taille du tableau. Admettons qu'il faille 1 milliard de saisie, il faut un taille de 1 milliard ... c'est pas pratique (ni même possible). Alors qu'avec notre algorithme, quelque soit le nombre de saisie, l'espace mémoire (le nombre de variable) nécessaire sera toujours le même. On parle alors de calcul \textbf{en place}.
-\end{Solution}
-
-\end{exercice}
-
-\subsection{Lectures et écritures dans des fichiers~: \texttt{fprintf} et \texttt{fscanf}}
-Écrire ou lire dans un fichier est très similaire à écrire ou à lire dans les sorties/entrées standard. Les fonctions \lstinline!printf! et \lstinline!scanf! ont leur équivalent qui fonctionne de manière très similaire. Ces fonctionnalités sont disponibles grâce à la librairie \lstinline!<stdio.h>!.
-
-
-Les deux différences sont, d'une part, la désignation d'un fichier dans lequel il faudra écrire à l'aide d'une variable de type \lstinline!FILE*! et, d'autre part, l'utilisation des fonctions \lstinline!fprintf! et \lstinline!fscanf! à la place de\lstinline!printf! et \lstinline!scanf! (je vous laisse noter la différence !).
-
-Les étapes principales pour écrire ou lire dans un fichier sont le suivantes~:
-\begin{enumerate}
-\item Ouvrir un fichier (en lecture ou en écriture) (fonction \lstinline!fopen!)
-\item Utiliser le fichier à l'aide de \lstinline!fprintf! et de \lstinline!fscanf!
-\item Fermer le fichier (fonction \lstinline!fclose!)
-\end{enumerate}
-
-\subsubsection{Ouverture et fermeture d'un fichier}
-La fonction \lstinline!FILE *fopen(char *nomfic, char *mode)! ouvre le fichier dont le nom est donné comme premier argument, selon le mode d'ouverture précisé (\lstinline!w! = écriture, \lstinline!r! = lecture, \lstinline!a! = ajout en fin de fichier) et l'assigne à un flux, i.e. à une variable de type \lstinline!FILE *! (c'est un nouveau type qui désigne un fichier, on parle de \textit{pointeur de fichier}).
-
-Dans le programme ci-dessous, \lstinline!nom_fic! est une chaîne de caractères qui contient le nom du fichier à ouvrir, et \lstinline!fic! est une variable de type \lstinline!FILE *!.
-
-\begin{lstlisting}
-// ouverture du fichier
-FILE *fic = fopen(nom_fic, "r"); // ouvrir en mode lecture
-if(fic == NULL){
- printf("Impossible d'ouvrir le fichier %s\n", nom_fic);
-} else {
- printf("Ouverture du fichier %s\n", nom_fic);
-}
-\end{lstlisting}
-
-Les différents types d'accès à un fichier sont les suivants~:
-\begin{itemize}
-\item \lstinline!r!~:ouverture d'un fichier en lecture, le fichier doit exister, autrement la fonction retourne la
-valeur \lstinline!NULL! ;
-\item \lstinline!w!~:création et ouverture d'un fichier en écriture, si le fichier existe, son contenu est détruit;
-\item \lstinline!a!~: ouverture d'un fichier en écriture à la fin du fichier, si le fichier n'existe pas, il est
-créé;
-\item \lstinline!r+!~: ouverture d'un fichier en lecture et écriture, le fichier doit exister, autrement la fonction \lstinline!fopen! retourne la valeur \lstinline!NULL!;
-\item \lstinline!w+!~: création et ouverture d'un fichier en lecture et écriture, si le fichier existe, son contenu est
-détruit;
-\item \lstinline!a+!~: ouverture d'un fichier en lecture et en écriture à la fin du fichier, si le fichier n'existe
-pas, il est créé.
-\end{itemize}
-
-La fermeture d'un fichier utilise la fonction \lstinline!void fclose(FILE *)!.
-
-\begin{lstlisting}
-// fermeture du fichier
-if( fclose(fic)==EOF ){
- printf("Probleme de fermeture du fichier %s", nom_fic);
-} else {
- printf("Fermeture du fichier %s\n", nom_fic);
-}
-\end{lstlisting}
-
-Ici, la constante \lstinline!EOF!, définie dans la bibliothèque \lstinline!<stdio.h>!, caractérise la fin d'un fichier. En particulier, cette valeur est retournée par la fonction \lstinline!fclose! lorsque la fermeture ne s'est pas bien passée.
-
-La fonction \lstinline!feof! de la bibliothèque \lstinline!<stdio.h>! retourne une valeur non nulle (vrai) lorsque la fin d'un fichier est atteinte ou qu'une erreur de lecture est survenue. Cette deuxième possibilité est très souvent oubliée, et cela conduit à l'écriture de programmes faux.
-
-\subsubsection{Écriture et lecture d'un fichier}
-Des fonctions similaires à \lstinline!printf! et à \lstinline!scanf! existent pour écrire ou lire dans des fichiers. Leurs syntaxes sont les suivantes~:
-
-{\centering \bf
-void fprintf(FILE *, const char *format [, arg [, arg]...]);
-\par}
-
-{\centering \bf
-int fscanf(FILE *, const char *format [, arg [, arg]...]);
-\par}
-
-En ce qui concerne l'usage des chaînes de caractères formatés, le fonctionnement est identique aux fonctions \lstinline!printf! et \lstinline!scanf!. La seule différence est que ces fonctions doivent impérativement avoir comme
-premier paramètre un pointeur de fichier (\lstinline!FILE *!) qui aura été préalablement construit grâce à l'instruction \lstinline!fopen!.
-
-\begin{remarque}
-La fonction \lstinline!fscanf! ne peut être utilisé que si un fichier qui est ouvert en écriture, et \lstinline!fprintf! ne peut être utilisé que sur un fichier ouvert en lecture.
-\end{remarque}
-
-\subsubsection{Un exercice ``pratique''}
-Voici un exemple dans lequel on recopie (quasiment) un fichier bancaire. Ce fichier contient les noms des clients de la banque avec leur capital actuel. Ce fichier ressemble à cela~:
-
-\texttt{fichier.txt}~:
-\begin{verbatim}
-Alice Machine 500
-Albert Einstein 2300
-Tryphon Tournesol 10
-Thomas Guyet 300
-Truc Much 450
-\end{verbatim}
-
-\begin{lstlisting}
-#include <stdio.h>
-int main()
-{
- char strnom [80], strprenom [80];
- int valeur;
- FILE *fin, *fout;
- fin = fopen("fichier.txt","r");
- fout = fopen("copie.txt","w+");
- fscanf(fin,"%s %s %d", strprenom, strnom, &valeur);
- if( !strcmp(strnom, "Guyet") && !strcmp(strprenom, "Thomas") ) {
- valeur += 10;
- }
- fprintf (fout, "%s %s %d", strprenom, strnom, valeur);
- fclose (fin);
- fclose (fout);
- return 0;
-}
-\end{lstlisting}
-
-\begin{exercice} [Banco!]\label{exo:banque}
-Écrire le fichier \texttt{copie.txt} après l'exécution du programme. Que fait ce programme~?
-
-\begin{Solution}
- Alors voilà enfin un programme utile~: le programme recopie la liste du fichier bancaire, mais ajoute 10 pour le compte de ``Thomas Guyet'' ...
-\end{Solution}
-\end{exercice}
-
-
-\section{Correction des exercices}
-\Closesolutionfile{solutions}
-\Readsolutionfile{solutions}
\ No newline at end of file
diff --git a/Polyc/Archi.tex~ b/Polyc/Archi.tex~
deleted file mode 100644
index 2a4c66eab0c5a6dbdcc6a2a0b53b57013046c101..0000000000000000000000000000000000000000
--- a/Polyc/Archi.tex~
+++ /dev/null
@@ -1,648 +0,0 @@
-
-\chapter{Architecture des ordinateurs} \label{chp:archi}
-\Opensolutionfile{solutions}{}
-
-Le langage C est un langage dit de ``bas niveau'', c'est-à-dire que ce qui est écris dans un programme en C est très proche de ce que fait le processeur lors de l'exécution du programme. J'entends par là que lors qu'on écrit une instruction C, on écrit quasiment ce que va faire le processeur lors de l'exécution du programme.
-Ce langage se différencie donc très fortement des langages tels que Java, R ou Python pour lesquels les instructions écrites peuvent être très ``loin'' de la façon dont cela se déroulera sur le processeur.
-
-Ceci se traduit également sur les objets qui sont manipulés (les variables). En C, il est facilement possible de connaître quel est le codage informatique qui est fait d'une variable, alors qu'en R, par exemple, cette connaissance est loin d'être immédiate (et en pratique nécessite beaucoup de connaissance en C).
-
-Il est donc très utile de comprendre le fonctionnement d'un processeur. S'il n'est pas nécessaire de comprendre tous les détails, des images très générales de son fonctionnement pourront se montrer très utiles par la suite. C'est ce à quoi s'intéresse l'architecture des ordinateurs
-
-\begin{definition} [Architecture des ordinateurs]
-L'architecture des ordinateurs (ou architecture des processeurs) décrit :
-\begin{itemize}
- \item (architecture matérielle, interne) l'agencement de composants électroniques ainsi que leurs interactions,
- \item (architecture externe) le modèle de fonctionnement du processeur.
-\end{itemize}
-
-L'architecture comprend notamment la donnée d'un \textbf{jeu d'instructions}, d'un ensemble de \textbf{registres} visibles par le programmeur, d'une \textbf{organisation de la mémoire} et des entrées sorties, des modalités d'un éventuel support multiprocesseurs, etc. (\textit{source Wikipedia})
-\end{definition}
-
-
-\section{Codage binaire de l'information}
-Tout l'art de l'informatique consiste à faire traiter des informations pour un ordinateur. Mais ces informations sont d'une nature particulière, elles sont numériques~: toutes les informations sont échantillonnées et, en particulier, les nombres sont approximés. Techniquement, nous allons voir que ces nombres sont codés en utilisant un codage binaire.
-
-Dans les cursus de programmation avancé, l'étude de l'algorithmique est toujours associé à l'étude des structures de données. Pour des données complexes (par exemple, un annuaire de personnes, une chaîne d'ADN, ...), il est très souvent possible de représenter l'information de plusieurs manière sous une forme numérique. En conséquent, les algorithmes de traitement de cette information seront également différents. Pour réaliser une tâche, le choix d'une bonne structure de données et d'un bon algorithme va de pair.
-
-Mais les choix de la structure de l'information touchent également les informations de bas niveau telles que la représentation des nombres. Dans la suite de ce chapitre, on comprendra que la récente apparition des processeurs de calcul sur 64 bits induit des représentations des données différentes des processeurs 32 bits et que cela à des conséquences pratiques, en particulier, pour les applications de calcul numérique pour lesquels la représentation des nombres à un effet très important.
-
-Dans la suite de cette section, on présente la représentation des données élémentaires.
-%Pour la représentation des données structurées, il faut se référer, en particulier, à la section \ref{chp:structuresdonnees}.
-
-\subsection{Bits et mots mémoires}
-
-\begin{definition}[Bit (Binary Digit)]
-Un bit est un chiffre qui peut prendre deux valeurs 0 ou 1.
-\end{definition}
-
-Électroniquement, seuls les bits sont représentés dans la mémoire de l'ordinateur et les circuits électroniques ne sont capables que de faire des opérations sur les bits~: c'est-à-dire donner des valeurs de bits (0 ou 1) en fonction de la valeur d'autres bits ... Les informations sont représentées, ou encore codées, en mémoire comme une suite de bits. Pour faciliter la conception des circuits électroniques, la suite de bits n'est pas de longueur arbitraire mais plutôt d'une longueur prédéfinie multiple d'une puissance de 2 (pour des raisons d'optimisation des traitements). On parle alors de mots mémoires, ou mots.
-
-\begin{definition}[Mot] Un mot, ou un mot mémoire, est une suite de bits d'une longueur prédéfinie (puissance de 2) pour une architecture électronique.
-\end{definition}
-
-\begin{exemple}
-Pour un processeur dit ``32 bits'', les mots utilisés par les processeurs sont de taille 32, et pour les architectures dites ``64 bits'', les mots sont de taille 64.
-\end{exemple}
-
-
-Si on veut qu'un ordinateur fasse des opérations sur des nombres, il faut arriver à traduire cette opération sous la forme d'opérations sur des bits. La première étape consiste d'abord à être capable de représenter des objets complexes tels que des nombres ou des caractères sous la formes de bits. C'est ce à quoi s'intéresse le codage de l'information.
-
-Un codage n'étant jamais parfait, il faut bien être conscient que cette étape préliminaire du codage de l'information sous forme binaire (discrétisée, et de taille finie) est la source de beaucoup d'incapacités fondamentales des outils informatiques.
-
-Dans la suite de cette section, nous présentons le codage pour les \textbf{types de bases}~: nombres entiers, nombres relatifs, nombre à virgule flottante et chaînes de caractères.
-
-\subsection{Codage des nombres entiers}
-
-Prenons le cas d'un mot mémoire de 16 bits. Pour traduire un mot $m$ sous la forme d'un nombre entier, il faut lire les bits de droite à gauche. Le bit de poids faible (le plus à droite) vaut $2^{0}$, le suivant vaut $2^{1}$, le suivant
-vaut $2^{2}$ ... Pour obtenir la valeur $v$ du nombre entier, il faut sommer les valeurs des bits à 1. On note $m_i$ la valeur (1 ou 0) du ième bit à partir de la droite dans le mot $m$.
-
-\begin{equation*}
-v=\sum_{i=0}^{i=15} {m_{i}.2^{i}}
-\end{equation*}
-
-Se codage du bit donnant le bit de poids faible à droite est dit ``little endian'' et s'oppose au codage des nombres en ``big endian''. Le ``little endian'' est le plus fréquemment rencontré dans les ordinateurs usuels et je me tiendrai à ce codage pour la suite.
-
-%\begin{exemple}
-%coucou
-\begin{figure}[ht]
-\centering
-\includegraphics[width=\defaultfigurewidth]{\Figures/Poly-img002}
-\caption{test}
-\end{figure}
-%\end{exemple}
-
-\begin{exercice}
-\question{Donner le nombre entier correspondant au code binaire suivant~: $1010 1011$}
-\question{Coder sur 8 bits les entiers 205, 27 et 13}
-
-\begin{Solution}
- \question{171}
- \question{11001101, 00011011, 00001101}
-\end{Solution}
-\end{exercice}
-
-Les limites du codage des nombres entiers sur 16 bits sont donc :
-\begin{itemize}
-\item Valeur minimum~: 0
-\item Valeur maximum~: 131072
-\end{itemize}
-
-On pourra remarquer que plus la longueur du mot est importante, plus la limite supérieure des entiers codables dans l'ordinateur est haute. Si vous travaillez avec un ordinateur 16 bits, il pourra bien évidemment compter au delà de 131072, mais cela nécessitera pour lui plus de travail que si vous restez dans cette limite. Ensuite, pour des applications très bas niveau (celle où il est nécessaire de programmer des opérations sur des bits comme par exemple le développement de driver de périphériques), ces limites sont prégnantes.
-
-Lorsqu'un calcul numérique conduit à un résultat théorique qui dépasse la limite de codage d'un nombre on parle de ``débordement''.
-En langage C, rien n'interdit les débordements sur les nombres entiers, en pratique, la suite du programme continuera mais sera erronée.
-Par exemple, rien ne limite la réalisation de l'opération 131072+131072, mais la valeur calculée sera une valeur entre 0 et 131072 (elle dépendra du processeur ...).
-
-\subsection{Codage des nombres entiers relatifs}
-Pour les entiers relatifs, il faut être capable de coder le signe d'un nombre. Pour cela, on se sert du bit de poids fort (le plus à gauche dans un codage de type ``little endian'') pour coder la valeur d'un entier relatif~: \textbf{négatif si il est égal à 1 et positif sinon}.
-
-Pour obtenir la valeur $v$ du nombre entier, il faut sommer les valeurs des bits à 1. On note $m_i$ la valeur (1 ou 0) du ième bit à partir de la droite dans le mot $m$.
-
-\begin{equation*}
-v=(-1)^{m_{15}}\sum_{i=0}^{i=14}{m_{i}.2^{i}}
-\end{equation*}
-
-\begin{figure}[ht]
-\centering
-\includegraphics[width=10.624cm,height=3.332cm]{\Figures/Poly-img003}
-\end{figure}
-
-\begin{exercice}
-\question{Donner le nombre entier relatif correspondant au code binaire suivant~: \texttt{1010 1011}. Remarque par rapport à l'exercice 1 ?}
-\question{Coder sur 8 bits les entiers relatifs suivants~: 205, 27, -13 et -77. Remarques par rapport à l'exercice 2 ?}
-\begin{Solution}
- \question{-43, c'est pas pareil à cause du bit de poid fort qui est utilisé comme bit de signe.}
- \question{impossible de coder 205!, 00011011, 10001101, 11001101}
-\end{Solution}
-
-\end{exercice}
-
-\subsection{Codage des nombres à virgule flottante (simple précision)}
-
-Un nombre à virgule flottante est une représentation d'un nombre à virgule (\eg 1,32). A la fin des années 70 chaque ordinateur avait sa propre représentation interne pour les nombres à virgule flottante. Or, l'arithmétique à virgule flottante possède certaines subtilités que le constructeur moyen ne maîtrisait pas forcément et certaines machines effectuaient certaines opérations de manière incorrecte. Pour remédier à cette situation, l'IEEE proposa un standard non seulement pour permettre les échanges de données en virgule flottante entre ordinateurs, mais aussi pour fournir un modèle rodé aux constructeurs, dont le fonctionnement était correct et maîtrisé. De nos jours, pratiquement tous les constructeurs ont des processeurs ou des coprocesseurs dédiés qui effectuent des calculs en virgule flottante et qui emploient la représentation au standard IEEE 754.
-
-La norme les nombres à virgule flottante à \emph{simple précision} (mot de 32 bits) et à \emph{double précision} (mot de 64 bits).
-
-\subsubsection{Nombres à simple précision ou \textit{float}}
-
-La représentation des nombres à virgule flottante simple précision en utilise une écriture sous la forme exponentielle suivante :
-
-\begin{equation*}
-v=(-1)^{S}.m.2^{E-127}
-\end{equation*}
-Pour les float simple précision, les 32 bits sont organisés de la sorte (de droite à gauche) :
-
-\begin{itemize}
-\item 23 bits de mantisse ($m$) représentant la fraction du nombre. Les 23 bits code un nombre entiers \textit{M} qui permet de réécrire la mantisse en notation décimale sous la forme
-``1,$M$''
-\item 8 bits d'exposant ($E$) dont la valeur entière est entre 0 et 128. Dans la formule, il faut noter la présence du ``-127'' de sorte à ce que l'exposant peut être négatif pour coder de très petits nombres.
-\item 1 bit de signe ($S$) (bit de poids fort)
-\end{itemize}
-
-\begin{exemple}
-\begin{itemize}
- \item $ 1 = 2^{0} \times (1 + 0)$\\
-Le bit de signe sera 0, l'exposant, en code relatif à 127 sera représenté par 127 = 01111111, et le significande vaut 1, ce qui résulte en une mantisse dont tous les bits sont à O. La représentation IEEE simple precision IEEE 754 du nombre 1 est donc :
-
-$$
-\begin{array}{lllll}
-Code(1) = & 0011 & 1111 & 1000 & 0...0 \\
- & seee & eeee & emmm & m...m
-\end{array}
-$$
-
- \item $0.5 = 2^{-1} \times (1 + 0)$\\
-Le bit de signe est 0, l'exposant, en code relatif à 127 est représenté par 127 - 1 = 01111110, et le significande vaut 1, ce qui résulte en une mantisse dont tous les bits sont à 0. La représentation IEEE simple precision IEEE 754 du nombre 0.5 est donc :
-
-$$
-\begin{array}{lllll}
-Code(0.5) = & 0011 & 1111 & 0000 & 0...0 \\
- & seee & eeee & emmm & m...m
-\end{array}
-$$
-
- \item $1.5 = 2^0 \times (1 + 2^{-1})$\\
-Le bit de signe est 0, l'exposant, en code relatif à 127 est représenté par 127 = 01111111, et le significande vaut 1.1, ce qui résulte en une mantisse dont le premier bit est à 1 et les 22
-suivants à 0. La représentation IEEE simple precision IEEE 754 du nombre 1.5 est donc :
-$$
-\begin{array}{lllll}
-Code(1.5) = & 0011 & 1111 & 1100 & 0...0
-\end{array}
-$$
-
-\end{itemize}
-\end{exemple}
-
-
-Certains codes sont conservés pour des valeurs particulières :
-
-\begin{center}
-\tablefirsthead{}
-\tablehead{}
-\tabletail{}
-\tablelasttail{}
-\begin{supertabular}{|m{1.961cm}|m{0.96900004cm}|m{2.599cm}|m{2.71cm}|}
-\hline
-\bfseries Nombre &
-\bfseries signe &
-\bfseries exposant &
-\bfseries mantisse\\\hline
-\bfseries Zéro &
-\centering 0/1 &
-\centering 0 &
- 0 \\ \hline
-\bfseries infini &
-\centering 0/1 &
-\centering FF &
- 0\\\hline
-\bfseries NaN (not a number) &
-\centering 0/1 &
-\centering FF &
- tout sauf 0\\\hline
-\end{supertabular}
-\end{center}
-
-
-En arithmétique à virgule flottante on peut obtenir un résultat valable, ou alors rencontrer un problème de dépassement par valeur supérieure (\textit{overflow}) lorsque le résultat est trop grand pour pouvoir être représenté, ou par valeur inférieure (\textit{underflow}) lorsque le résultat est trop petit. Il peut même advenir une impossibilité de donner une valeur (\textit{NaN}).
-
-\begin{itemize}
-\item \textbf{Dépassement par valeur inférieure}~:
-Cette situation arrive lorsqu'un résultat est trop petit pour pouvoir être représenté. Le standard IEEE 754 résout partiellement le problème en autorisant dans ce cas une représentation dénormalisée. Une représentation dénormalisée est caractérisée par le fait d'avoir un code d'exposant complètement nul, ce qui est interprété comme une indication du fait que le bit de poids fort de la mantisse, implicite, est cette fois à 0 au lieu d'être à 1. De cette façon, le plus petit nombre ``exprimable'' est :
-
-$$2^{-127} \times 2^{-23} = 2^{-150} \approx 10^{-45}$$
-
-Cependant, il faut remarquer que plus le nombre représenté est petit, moins sa mantisse comportera de bits significatifs. Ce schéma permet une approche ``douce'' du phénomène de dépassement par valeur inférieure, en sacrifiant la précision lorsqu'un résultat est trop petit pour admettre une représentation normalisée.
-
-\item \textbf{Dépassement par valeurs supérieures}~: Le dépassement par valeurs supérieures ne peut pas être traité comme le dépassement par valeurs inférieures, et est indiqué par un code d'exposant dont tous les bits sont à 1, suivi par une mantisse dont tous les bits sont à 0. Ceci est interprété comme représentant l'infini. L'infini peut être positif ou négatif, en fonction de la valeur du bit de signe. L'infini peut être utilisé dans les calculs et les résultats correspondent au sens commun :
-\begin{eqnarray*}
-inf + inf = inf\\
-\forall x,\;x / inf = 0\\
-\forall x,\;x / 0 = inf
-\end{eqnarray*}
-
-\item \textbf{NaN~: Not a Number}~: Cependant, certaines opérations peuvent ne conduire à aucun résultat exprimable, comme
-
-\begin{eqnarray*}
-inf / inf = ?\\
-0 \times inf = ?
-\end{eqnarray*}
-\end{itemize}
-
-Le résultat de telles opération est alors indiqué par un autre
-code spécial~: le code d'exposant a tous les bits à 1, suivi par
-une mantisse non nulle. Le ``nombre''
-correspondant est appelé \textbf{NaN} (Not a Number)~: c'est un
-non-nombre. \textbf{NaN} doit être différencié de \textbf{NULL} dont il sera question de pointeurs.
-
-\espace
-
-Les caractéristiques des nombres à virgules flottantes simple précision sont les suivantes :
-\begin{itemize}
-\item Plus petit nombre normalisé~: $2^{-126}$
-\item Plus grand nombre normalisé~: presque $2^{128}$
-\item Intervalle utile~: approximativement $10^{-38}$ à $10^{38}$
-\item La précision des nombres flottants n'est pas uniforme (\cf Figure \ref{fig:DistribFlottants})~: pour les nombres proches de zéro, il y a beaucoup de précision, et plus on s'éloigne de zéro plus on perd en précision moyenne.
-\end{itemize}
-
-
-\begin{figure}[ht]
-\centering
-\includegraphics[width=\defaultfigurewidth]{\Figures/Poly-img004}
-\caption{Illustration de densité des nombres à virgule flottante (barres verticales en haut) dans IR (graduation continue en bas) (Source \url{http://www.macaulay.ac.uk/fearlus/floating-point/fpreal.gif})}
-\label{fig:DistribFlottants}
-\end{figure}
-
-
-\begin{exemple}
-Supposons que l'on cherche la valeur du float suivant exprimé en binaire~: $$1100 0010 1101 0101 1010 0000 0000 0000$$
-
-On procède ainsi~:
-
- \begin{itemize}
- \item Le bit de signe est positionné~: c'est un négatif.
- \item On a 10000101 = 133 qui est la valeur de l'exposant biaisé. 133 - 127 = 6 est la valeur de l'exposant vrai.
- \item La lecture de la mantisse donne (avec le bit sous-entendu égal à 1 en tête, puisqu'il s'agit bien d'un nombre normalisé)~: 1,10101011010000000000000.
-\end{itemize}
-
-L'exposant est 6, il faut donc décaler la mantisse de 6 colonnes vers la gauche.
-
-Le nombre est donc égal à~:
-$$-1,1010101101 \times 2^6 = -1101010,1101 = -(2 + 8 + 32 + 64 + 0,5 + 0,25 + 0,0625)$$
-$$= -106,8125$$
-
-\end{exemple}
-
-
-
-\subsubsection{IEEE 754 double précision}
-Le principe de codage des nombres à virgule en double précision est exactement le même, mais on dispose cette fois de 64 bits pour coder le signe, l'exposant (sur 11 bits avec un codage relatif à 1023) et la mantisse (sur 52 bits). En accroissant fortement la taille de la mantisse, on gagne surtout en précision de calcul (et peu en plage de nombres).
-
-Les caractéristiques des nombres à virgules flottantes double précision sont les suivantes :
-
-\begin{itemize}
-\item Plus petit nombre normalisé~: 2\textsuperscript{{}-1022}
-\item Plus grand nombre normalisé~: presque 2\textsuperscript{1024}
-\item Intervalle utile~: approximativement 10\textsuperscript{{}-308} à
-10\textsuperscript{308}
-\end{itemize}
-
-
-\begin{definition}[Précision] La notion de précision renvoie à la capacité de différencier finement deux nombres. Plus un
-ordinateur est précis, plus les nombres qu'il sera capable de distinguer seront proches de 0, et moins il fera d'arrondies dans les calculs.
-\end{definition}
-
-Avec un codage en simple précision, un ordinateur ne peut pas faire la différence entre 0 et $2^{-126}$. Tous les nombres entre ces deux valeurs, par exemple $2^{-200}$ seront donc arrondies à l'une de ces valeurs. Par contre, en passant dans un codage double, les trois valeurs, 0, $2^{-126}$ et $2^{-200}$ seront bien distinguées. En passant en double, il y a un gain de précision.
-
-Cette notion de précision est fondamentale dans les problèmes de calcul numérique où les arrondies dans les calculs s'accumulent. C'est le cas par exemple des calculs pour les prévisions météo ou bien les simulations numérique d'écoulement, de rayonnement, ... pour les quelques de nombreuses opérations numériques sont réalisées.
-
-\subsection{Représentation des textes}
-
-En informatique, un texte doit être vu comme une simple suite de caractères pour lequel il n'y a aucune mise en forme. Nous voyons donc d'abord la représentation des caractères, puis celle des textes.
-
-\subsubsection{Représentation des caractères}
-Le codage des caractères associe un nombre entier à un caractère contenu dans un alphabet. Le problème informatique du codage en mémoire des caractères est donc très simplifié puisqu'il va utiliser le codage des nombres entiers.
-La représentation de base pour un caractère est l'octet (8 bits).
-
-Il reste néanmoins à faire la correspondance entre un nombre entier, codé en mémoire, et un caractère alphabétique. Ceci est possible grâce à des \textbf{tables de caractères}.
-
-La table de correspondance la plus connue est la table ASCII. Cette table n'utilise que 127 valeurs numériques codées sur 7 bits. Le 8ème bit est nul.
-Schématiquement, la table ASCII est organisée comme suit~:
-\begin{itemize}
-\item 0 à 31~: caractères non imprimables (saut de ligne, son de
-cloche, ...)
-\item 32~: espace
-\item puis, les chiffres arabes, les lettres latines majuscules puis les
-minuscules
-\item et enfin, les signes de ponctuation sont répartis dans la table
-\end{itemize}
-
-Autres tables usuelles :
-
-\begin{itemize}
-\item Latin-1~: basée sur la table ASCII, elle utilise les 127 caractères restant pour coder les caractères accentués et les caractères allemands.
-\item UTF-8~: ce codage permet de représenter les milliers de caractères du répertoire universel, il est compatible ASCII, et conçu pour son interopérabilité (communications facilité entre systèmes). Dans ce codage, la taille en mémoire d'un caractère varie entre 1 à 4 octets.
-\item Windows-1225~: une des nombreuses tables de caractères Windows (à éviter ...)
-\item tables pour les caractères mandarins, arabes, cyriliques, ...
-\end{itemize}
-
-\begin{exercice} [Codage des caractères]
-En consultant sur internet une table ASCII, répondre aux questions suivantes :
-\question{à quels caractères ASCII correspondent les codes suivants}
-\begin{itemize}
-\item $0111 0010$
-\item $1001 0110$
-\item $0011 0110$
-\end{itemize}
-\question{Pour les codes précédents, quelle(s) différence(s) y aurait-il avec un table ``Latin-1'' ? avec une table ``cyrilique'' ?}
-\question{Représenter en binaire les caractères suivants~: ``f'', ``EOF'' (ou ``EOT'') et ``?''}
-
-
-\begin{Solution}
- \question{Traduire les valeurs binaire en nombre et regarder la table ASCII pour faire la correspondance :}
-
-\begin{itemize}
-\item $0111 0010$ -> $114$ -> 'r'
-\item $1001 0110$ -> $150$ -> hors table ascii !
-\item $0011 0110$ -> $54$ -> '6' (caractère '6' !!)
-\end{itemize}
-\question{Pas de changement pour le premier et le troisième, par contre le second s'interprète différement dans une table Latin-1 ou Cyrilique ... voir les tables !}
-\question{Démarche inverse ...}
-\begin{itemize}
-\item 'f' -> $102$ -> $01100110$
-\item 'EOF' -> $4$ -> $00000100$
-\item '?' -> $63$ -> $00111111$
-\end{itemize}
-\end{Solution}
-\end{exercice}
-
-
-\subsubsection{Représentation des chaînes de caractères, les textes}
-
-Lorsqu'on pense à un texte, un informaticien parle de chaîne de caractères.
-
-\begin{definition}[Chaîne de caractères]
-Une chaîne de caractères est une suite ordonnée de caractères se terminant par un caractère \texttt{nul}. En anglais, on emploie le terme \textit{string}.
-\end{definition}
-
-Dans la mémoire de l'ordinateurs, une chaîne de caractères est un espace contigüe de mots mémoires qui est organisé dans l'ordre des caractères dans la chaîne.
-À partir du moment où vous savez qu'un caractère ASCII est codé sur un mot de 8 bits, le texte en mémoire est simplement une suite de mots de 8 bits. Et lorsque vous tombez sur un mot contenant 8 zéros (le caractère \texttt{nul}), alors vous
-arrêter le lire la chaîne de bits.
-
-On peut alors représenter une chaîne de caractères comme une suite de bits, mais qui s'étend beaucoup plus largement en mémoire. En pratique, cette représentation est sans intérêt, nous n'y reviendrons jamais.
-
-
-\begin{exemple}
-En pratique, la chaîne de caractères ``toto'' est codée par 5 mots ~: 4 pour le texte et 1 pour le caractères \texttt{nul}.
-Avec des mots de 8 bits, une telle chaîne de caractère prendra donc $5\times 8 = 40$ bits.
-%illustration d'un problème d'alignement !
-
-En consultant la table ASCII, on sait que 'o' se code $01101111$ et que 't' se code $01110100$, on a alors en mémoire :
-$$01110100 01101111 01110100 01101111 00000000$$
-\end{exemple}
-
-
-Pour un fichier texte simple (c'est-à-dire non mis en forme avec word ou autre logiciel de traitement de texte), c'est la même chose. Le fichier est enregistré comme une suite de caractères codés sur des mots de 8 bits. En revanche, le caractère de fin du fichier n'est pas le caractère \texttt{nul}, mais le caractères \texttt{EOF} (ou \texttt{EOT}).
-
-\begin{exercice}Extraite le texte de la chaîne de caractères ASCII suivante :
-$$01101011011000010110011101101110001000010000000000101001$$
-\begin{Solution}
- On segmente cette chaîne binaire en mot de 8 bits, et on traduit un à un:
-\begin{enumerate}
- \item 01101011 -> 107 -> 'G'
- \item 01100001 -> 97 -> 'a'
- \item 01100111 -> 103 -> 'g'
- \item 01101110 -> 110 -> 'n'
- \item 01100101 -> 101 -> 'e'
- \item 00100001 -> 33 -> '!'
- \item 00000000 -> caractère \texttt{nul}~: fin de la chaîne
- \item 00101001 -> peu importe !!!
-\end{enumerate}
-
-La solution est donc ``Gagne!''.
-
-\end{Solution}
-\end{exercice}
-
-\subsection{Remarque sur la sémantique du binaire}
-Le binaire n'est qu'un codage d'une information structurée. Si vous ne connaissez pas à l'avance la structure de l'information, il est très difficile d'extraire du sens d'une suite de bits.
-
-C'est le sens d'un format de fichier~: il définit la façon dont est codé l'information dans un fichier. Si vous connaissez le type de fichier auquel vous avez à faire, il vous sera possible d'en extraire l'information.
-
-\section{Architecture de von Neumann}
-L'architecture de von Neumann désigne un modèle de fonctionnement d'un micro-processeur (et \textit{a fortiori} d'un ordinateur). Cette architecture a été proposée en 1936. Elle était très innovante par son principe de représenter en mémoire à la fois les données traitées par l'ordinateur et les programmes, c'est à dire la description des traitements. Jusque là, programmes et données étaient des objets différents. Les travaux théoriques de A. Turing ont permis cette avancée conceptuelle et les travaux de von Neumann (et d'autres également) ont permis une concrétisation de ces idées.
-
-Tout d'abord, il va nous falloir poser quelques définitions.
-
-\begin{definition}[Programme]
-Un programme est une \textit{suite d'instructions} qui traite des données en entrée et produit des données en sortie.
-\end{definition}
-\begin{definition}[Instruction]
-Une instruction est une \textit{action élémentaire} que peut réaliser un processeur.
-\end{definition}
-\begin{definition}[Processus]
-C'est \textit{une} exécution d'un programme sur un processeur.
-\end{definition}
-
-Pour faire une image culinaire, un processus est à un programme ce que la préparation d'un plat est à une recette.
-
-Tout le travail d'un programmeur est de bien connaître les instructions qui peuvent être faites par une machine pour construire une suite d'instructions qui vont faire réaliser au processeur la tâche qu'il s'est fixée.
-
-On dépeind ici l'architecture d'un ordinateur de manière très simplifiée. Les principes sont présentés en laissant
-volontairement de côté bon nombre de détails et en sous-entendant que tous les processeurs suivent ces fonctionnements. Des variantes importantes peuvent être rencontrées en pratique. Pour plus d'information, il faudra se référer aux cours de systèmes et réseaux.
-
-\subsection{Présentation de l'architecture de von Neumann}
-
-\begin{figure}[ht]
-\centering
-\includegraphics[width=\defaultfigurewidth]{\Figures/Poly-img005}
-\caption{Illustration de l'architecture de von Neumann}
-\label{fig:VonNeumann}
-\end{figure}
-L'architecture de von Neumann décompose l'ordinateur en 4 parties distinctes :
-
-\begin{itemize}
-\item l'\textbf{unité arithmétique et logique} (UAL ou ALU en anglais) ou unité de traitement~: son rôle est d'effectuer les opérations de base~: addition, soustraction, ... ;
-\item l'\textbf{unité de contrôle}, chargée du séquençage des opérations ;
-\item la \textbf{mémoire} qui contient à la fois les données et le programme qui dira à l'unité de contrôle quels calculs faire sur ces données ;
-\item les \textbf{dispositifs d'entrée-sortie}, qui permettent de communiquer avec le monde extérieur.
-\end{itemize}
-
-Les registres sont des petites mémoires sur lesquelles l'ALU applique ses opérations de base. Lorsque l'ALU fait une addition, il fait l'addition des nombres (codés en binaire) contenus dans le registre 1 et le registre 2. Le résultat de l'addition est retourné dans l'un de ces deux registres.
-
-\subsection{Image de l'organisation de la mémoire}
-
-\begin{figure}[ht]
- \centering
- \includegraphics{\Figures/ImageMemoire}
- % ImageMemoire.eps: 0x0 pixel, 300dpi, 0.00x0.00 cm, bb=0 0 69 118
- \label{fig:ImageMemoire}
-\end{figure}
-
-Je commence par préciser que la mémoire dont il est question dans l'architecture de Von Neumann est la mémoire RAM. Il ne s'agit pas du disque dur dont il n'est pas question ici.
-
-La mémoire peut être représentée comme une longue bande orientée d'emplacements mémoire. À une granularité fine, on peut voir la mémoire comme une longue bande d'emplacement pouvant contenir des bits (0 ou 1), à une granularité plus importante, on peut la voir comme une langue bande d'emplacement de mots mémoires. La taille des mots mémoires utilisé est une caractéristique du processeur utilisé~: c'est la taille des registres qui définit la taille des mots d'un processeur.
-
-Cette bande est orientée. L'orientation impose un sens de lecture par le processeur. Par conséquent, chaque emplacement mémoire peut être identifié par sa position dans la bande. On parle d'adresse mémoire.
-
-\begin{definition}[Adresse mémoire]
-C'est un nombre qui localise un mot dans la bande mémoire.
-\end{definition}
-Prenons l'exemple d'un processeur 8 bits. On représente sa mémoire comme une grande bande de largeur 8 bits. Chaque emplacement peut contenir :
-\begin{itemize}
-\item une donnée codée sur 8 bits parmi les types de base~: un nombre entier, un nombre en virgule flottante ou un caractère.
-\item la description d'une instruction
-\end{itemize}
-
-Les instructions et les données ne sont pas mélangées de manière anarchique. Les données sont regroupées ensembles (par exemple, pour les chaînes de caractères on a vu qu'un texte était une suite contigüe de mots de 8 bits). De même, dans la mesure où les programmes sont des suites d'instructions, la séquence des instructions est traduite par la suite des instructions dans la bande.
-
-\subsection{Image du fonctionnement d'un processeur}
-
-\subsubsection{Descriptif général du fonctionnement d'un processeur}
-Décrire le fonctionnement d'un processeur, c'est décrire comment le processeur fait pour exécuter un processus à partir de la description d'un programme en mémoire.
-
-L'unité de contrôle est au centre de l'exécution d'un processus par le processeur. il nous faut donc donner quelques détails sur sa constitution. L'unité de contrôle contient 2 registres :
-
-\begin{figure}[ht]
-\centering
-\includegraphics[width=3cm,height=4.47cm]{\Figures/Poly-img006}
-\end{figure}
-
-\begin{itemize}
-\item le registre PC (program counter)~: il contient l'adresse de l'instruction courante
-\item le registre RI (registre d'instruction)~: il contient le code binaire de l'instruction à faire réaliser par l'ALU
-\end{itemize}
-
-À un instant donné de l'exécution du processus, PC pointe sur un emplacement mémoire. Pour réaliser l'instruction suivante, les opérations suivantes sont effectuées par le processeur :
-\begin{enumerate}
-\item PC est incrémenté (\ie qu'il passe à l'emplacement suivant dans la bande mémoire)
-\item Le contenu de l'emplacement pointé par PC est recopié dans RI
-\item L'instruction est décodée par l'unité de contrôle et ce dernier prépare l'ALU
-\item L'ALU effectue l'instruction, par exemple :
-\begin{itemize}
-\item Les registres R1 et R2 sont chargés à partir de mots en mémoires
-\item Une opération arithmétique ou logique traite les registres
-\item Le contenu d'un registre est copié dans un emplacement mémoire
-\item L'ALU effectue l'instruction, par exemple :
-\end{itemize}
-\item Retour à 1.
-\end{enumerate}
-
-L'ensemble de ces 5 étapes constitue un cycle du processeur. Un processeur cadencé à 1GHz réalisera 1 million de cycle de la sorte par seconde.
-
-\subsubsection{Codage du jeu d'instructions}
-
-\begin{definition}[Jeu d'instructions]
-Le jeu d'instructions est le descriptif de toutes les instructions élémentaires que peut réaliser un processeur et le codage binaire de ces instructions.
-\end{definition}
-
-Concrètement, chaque instruction est câblée électroniquement sur la puce électronique. Le jeu d'instructions est donc spécifique d'un processeur. Lorsqu'une instruction est câblée électroniquement elle sera réalisée très rapidement. Ceci explique pourquoi il y a des processeurs spécifiques pour certaines tâches. Par exemple, si les processeurs des cartes graphiques sont réputées pour leur efficacité sur les opérations sur des matrices, c'est que les opérations usuelles sur les matrices sont câblées électroniquement. Alors que sur un processeur généraliste (sans opération matricielle dans le jeu d'instructions) il faudra tout coder à partir d'opérations sur des scalaires. Les résultats seront médiocres par rapport à la puce électronique spécialisée.
-
-En général, un processeur sait faire les opérations suivantes :
-
-\begin{itemize}
-\item Consulter ou modifier un état de la mémoire ou des registres
-\item Déclencher une opération entrée-sortie (communication avec l'extérieur, en particulier l'utilisateur humain)
-\item Modifier la séquence d'instructions, par exemple en sautant à différents endroits du programme~: en avant (pour les conditions), en arrière (pour les boucles)
-\item Faire des opérations arithmétiques et logiques~: additions, soustraction, incrémentation, ...
-\end{itemize}
-
-
-Le jeu d'instructions est donc un catalogue d'opérations élémentaires. Mais en plus, c'est un codage des instructions. Par exemple, pour le code instruction binaire $1001 1101$, le processeur réalise l'addition des deux registres. Pour certaines instructions, une partie du mot de l'instruction est réservée à un paramètre (par exemple une adresse mémoire).
-
-Lorsqu'un programme est écrit en utilisant des codes instructions spécifique à un processeur, on dit qu'il s'agit d'un programme en langage assembleur.
-
-\begin{definition}[Langage assembleur] \label{def:assembleur}
-Le langage assembleur est la ``langue maternelle'' d'un processeur. Un programme écrit en langage assembleur est spécifique à un processeur. On parle parfois de ``code machine''.
-
-On parle également de ``langage machine''\index{langage machine}.
-
-Un fichier écris en assembleur est un \textbf{programme exécutable} par un processeur.
-\end{definition}
-
-\subsubsection{Exemple de jeu d'instructions et de programme assembleur}
-Voici une liste réduite d'instructions élémentaires pour un processeur 16 bits (inspirée d'un processeur Intel8080)
-
-Chaque instruction est codée sur 16 bits. Les 5 premiers bits codent l'opération, le 6eme et 7eme bit désigne l'utilisation du registre 1 ou 2, et les 9 bits restant servent à coder une adresse mémoire pouvant être utilisé dans une opération.
-
-Le jeu d'instructions comporte 6 opérations :
-
-\begin{center}
-\tablefirsthead{}
-\tablehead{}
-\tabletail{}
-\tablelasttail{}
-\begin{supertabular}{|m{7cm}|m{3.5cm}|m{4cm}|}
-\hline
-\bfseries Instruction &
-\bfseries Code opération &
-\bfseries Nom mnémonique\\ \hline
-Chargement Registre->Mémoire &
-$00001$ &
-\texttt{LOAD} \\ \hline
-Copie Registre->Mémoire &
-$00010$ &
-\texttt{STORE}\\ \hline
-Addition mémoire/registre à registre &
-$00011$ &
-\texttt{ADD}\\ \hline
-Afficher le contenu de la mémoire &
-$00100$ &
-\texttt{PRINT}\\ \hline
-Test le registre et branchement &
-$00101$ &
-\texttt{ADD}\\ \hline
-Fin &
-$00101$ &
-\texttt{END}\\ \hline
-\end{supertabular}
-\end{center}
-
-Exemple de mot mémoire codant une instruction :
-\begin{itemize}
-\item $00001 1 0 000010100$~: \texttt{LOAD R1, @(0 0001 0100)} Chargement dans le registre 1 (\texttt{R1} du contenu de l'emplacement mémoire 20, écrit en mnémonic
-\item $00011 0 1 000010100$~: \texttt{ADD R2, @(0 0001 0100)} Additionne \texttt{R2} et le contenu de l'adresse 20 (place le résultat dans le registre \texttt{R2})
-\item $00011 1 1 000010100$~: \texttt{ADD R1,R2} Additionne \texttt{R1} et \texttt{R2} (place le résultat dans \texttt{R1}). L'adresse ne sert ici à rien !
-\item $00101 1 0 00000110$~: \texttt{BZ R1, @(0 0001 0100)} Test si \texttt{R1} est nul, si oui, mettre \texttt{PC} à 6.
-\end{itemize}
-
-
-\begin{exemple}[Exemple de programme (assembleur)]
-\begin{verbatim}
- LOAD R1, @20
- BZ R1, FIN
- ADD R1, @(21)
- STORE R1, @(22)
- PRINT @(22)
-FIN END
-\end{verbatim}
-\end{exemple}
-
-Les explications précédentes ne permettent certainement pas de comprendre entièrement le programme. Il s'agit juste d'une illustration d'un programme assembleur. En particulier, les expressions entre parenthèses désigne des adressages indirectes (notion non-présentée, mais indispensable pour compléter correctement un jeux d'instructions). Voici néanmoins une description de ce que fait ce programme~:
-
-La première instruction charge le contenu de l'adresse mémoire dans le registre R1. À la ligne suivante, il s'agit d'un branchement conditionnel, si R1 est non nul, alors le programme passe directement à la la dernière ligne signalant la fin du programme. Dans le cas contraire, le processeur exécute les trois dernières instructions. D'abord, on demande au processeur d'ajouter le contenu du registre R1 avec le contenu de l'adresse 21 de la mémoire. La description des instructions devrait préciser où est mis le résultat de cette opération, par exemple dans le registre R1. Le contenu du registre est ensuite sauvegardé dans l'emplacement 22 de la mémoire. Finalement, le contenu de cette adresse est affiché.
-
-\section{Compilation}
-Il n'est pas raisonnable de programmer ses programmes en assembleur :
-\begin{itemize}
-\item Un programme en assembleur n'est pas tendre avec le cerveau du programmeur, même chevronné, puisqu'il nécessite d'avoir en permanence une vision de l'ensemble du code ;
-\item Programmer en assembleur est dangereux ... personne n'est à l'abri d'erreurs, et les erreurs en assembleurs sont difficiles à corriger et aux conséquences souvent inattendues ;
-\item Le temps nécessaire pour programmer une application, même simple serait démentiel ;
-\item Tout les efforts de programmation devraient être démultipliés pour porter les applications sur tous les processeurs du marché !
-\end{itemize}
-
-Il est donc nécessaire d'utiliser un langage de programmation plus évolué qui permette de résoudre tous ces problèmes. On parle alors de langage de ``haut niveau''. Plus le langage sera proche de la pensée du programmeur et s'éloignera des couches matérielles, plus il sera de haut niveau. Par exemple, des langages comme Java, python ou R sont de très haut niveau~: les instructions qui sont programmées sont très loin de la réalité matérielle du processeur. Le langage C est un langage intermédiaire~: il résout tous les problèmes sus mentionnés, mais reste un langage de programmation basique (ne compter pas trouver une fonction qui calcule une ACP ! Si vous voulez calculer une ACP, il faudra programmer l'algorithme où utiliser l'implémentation d'un collègue).
-
-Parmi les langages de programmation, on distingue trois types de langage~: les langages machine, \ie l'assembleur, \cf définition \ref{def:assembleur} (le seul que la machine comprend), les langages compilés et les langages interprétés.
-
-
-\begin{definition}[Langage compilé]
- Un langage compilé est un langage de programmation pour lequel une architecture matérielle dispose d'un \textbf{compilateur}\index{compilateur} qui peut traduire un programme du langage compilé dans le langage machine. Le programme traduit par le compilateur peut alors être exécuté sur la machine.
-
- Le résultat de la compilation est un programme
-\end{definition}
-
-\begin{definition}[Langage interprété]
- Un langage interprété est un langage de programmation pour lequel une architecture matérielle dispose d'un programme capable d'interpréter ``en direct'' le programme écrit en langage interprété. L'interpréteur agit comme une couche intermédiaire entre le langage machine et le langage interprété.
-\end{definition}
-
-Le langage C est un langage compilé (\cf Figure \ref{fig:CompilationC}).
-
-\begin{figure}[ht]
- \centering
- \includegraphics[width=\defaultfigurewidth]{\Figures/CompilationC}
- % CompilationC.eps: 0x0 pixel, 300dpi, 0.00x0.00 cm, bb=0 0 425 113
- \label{fig:CompilationC}
-\end{figure}
-
-La compilation va bientôt devenir votre quotidien ... vous programmez, vous compilez et vous exécutez ! Voilà ce qui vous attend ... Alors autant bien s'entendre avec son compilateur si on veut éviter la crise de nerfs. Et pour bien s'entendre avec lui, il est intéressant de mieux comprendre comment il fonctionne.
-
-Il existe de très nombreux compilateurs~: sous Windows, on peut citer par exemple \textbf{Visual C++} (Microsoft), \textbf{C++ Builder} (Borland), et sous Linux vous disposez des compilateurs \texttt{gcc} ou \texttt{g++} qui sont d'excellents compilateurs libres. Dans le cadre de ce cours, on n'utilisera que de \texttt{g++} (qui peut également être utilisé sous Windows). Tous fonctionnent sur les mêmes principes.
-
-\espace
-
-Pour plus d'informations sur la compilation d'un programme en C, voir le chapitre \ref{chp:Compilation}.
-
-\section{Correction des exercices}
-\Closesolutionfile{solutions}
-\Readsolutionfile{solutions}
\ No newline at end of file
diff --git a/Polyc/Compilation.tex~ b/Polyc/Compilation.tex~
deleted file mode 100644
index 5f4a515e429bb8c9ba283887d6e50aa9a20bb4cb..0000000000000000000000000000000000000000
--- a/Polyc/Compilation.tex~
+++ /dev/null
@@ -1,393 +0,0 @@
-\chapter{Complément de compilation en C} \label{chp:Compilation}
-Dans cette partie, on apporte quelques précisions sur les étapes de compilation spécifiques au langage C. La Figure \ref{fig:compilationC_full} illustre le schéma général de la compilation d'un programme C utilisant plusieurs fichiers \texttt{.c} et \texttt{.h}.
-
-On présente également l'utilisation approfondie du compilateur \texttt{gcc} en ligne de commande ainsi que l'usage des \texttt{Makefile}.
-
-\begin{figure}[ht]
-\centering
-\includegraphics[width=\defaultfigurewidth]{\Figures/CompilationC_full}
-\caption{Schéma général de la compilation d'un programme C}
-\label{fig:compilationC_full}
-\end{figure}
-
-Un programme en C est un ensemble de fichiers texte contenant les programmes. On distinguera par la suite deux types de fichiers :
-\begin{itemize}
-\item les fichiers \texttt{.c} : ils contiennent les implémentations des fonctions,
-\item les fichiers \texttt{.h} : ils contiennent uniquement les déclarations de fonctions et de variables qui peuvent être utilisé par plusieurs fichiers \texttt{.c}. \textbf{Ces fichiers ne doivent pas être compilés}.
-\end{itemize}
-
-
-\section{Introduction à la compilation}
-Lors de la compilation, il y a quatre tâches distinctes :
-
-\begin{itemize}
-\item La \textbf{vérification syntaxique} regarde si le programme est syntaxiquement correct,
-\item La \textbf{compilation} construit des bouts de code assembleurs à partir de vos programmes,
-\item L'\textbf{assemblage} construit du code machine à partir du code assembleur (je néglige cette étape par la suite),
-\item L'\textbf{édition de liens} lie vos bouts de code ensemble, avec éventuellement d'autres bouts de codes extérieurs que vous auriez importé (sous la forme de librairies).
-\end{itemize}
-
-Des erreurs spécifiques peuvent apparaître à chacune de ces étapes.
-
-\subsection{Notions d'analyse syntaxique}
-Lorsque vous écrivez un programme, il y a tout un tas de \textit{règles syntaxiques} auxquelles le programmeur doit se contraindre. Ces règles permettent aux compilateurs de comprendre sans ambigu\"ité ce que le programmeur souhaitait que le programme fasse. Ces conventions sont donc indispensables à l'inter-compréhension de la machine et du programmeur. Avant de pouvoir passer à l'étape de compilation proprement dite, le compilateur vérifie donc que la syntaxe élémentaire est correcte.
-
-En langage C, il vérifie, par exemple :
-\begin{itemize}
-\item que toutes les instructions finissent par un point virgule,
-\item que toutes les fonctions auxquels il est fait référence ont été déclarées (existent),
-\item que les accolades, les parenthèses, les guillemets ouverts sont bien fermées,
-\item que les structures de contrôle sont bien utilisées,
-\item ...
-\end{itemize}
-
-Pour comprendre le programme, le compilateur découpe votre fichier en lexème, c'est-à-dire en unité syntaxique et représente votre programme sous la forme d'un arbre (\cf Figure \ref{seq:refFigure2}). Pour cela, il s'appuie sur les séparateurs : l'espace, les parenthèses, les accolades, les guillemets, les virgules, les points virgules.
-
-Ensuite, il vérifie que chacun des lexèmes correspond à un mot qu'il connaît soit parce que c'est un mot clé du langage C, soit parce que c'est un mot que vous avez défini (\textit{table des symboles}), soit parce que c'est un mot qui fait partie d'une librairie que vous avez explicitement importé (avec la directive de préprocessing \lstinline!include!, \cf section \ref{sec:preprocesseur}).
-
-Plus finement, il vérifie que ces lexèmes vont bien ensemble (on parle un peu à tort d'\textit{analyse sémantique}, il s'agit plutôt d'une analyse grammaticale). Par exemple, il faut vérifier que après le mot clé \lstinline!if! il y a bien une parenthèse pour contenir le test.
-%que si une fonction avait pour paramètre un nombre, la variable qui est utilisée est bien un nombre et pas une chaîne de caractères.
-
-Finalement, les dernières vérification, mais pas moins les moins importantes, sont les vérifications de type. Le langage C est un langage ``fortement typé'', c'est à dire que toutes les variables, toutes les fonctions, tous les paramètres ont un type et que le compilateur fait la vérification de la bonne correspondance des types. Par exemple, une fois qu'on sait qu'il y a un élément entre les parenthèse du \lstinline!if!, il faut faire la vérification qu'il s'agit bien d'un résultat booléen et pas du texte ou autre chose.
-
-\begin{figure}[ht]
- \centering
- \includegraphics{\Figures/Compilation_ArbreLexeme}
-\begin{lstlisting}
-if( nom != NULL ) {
- // Commentaire
- printf("Coucou %s\n", nom);
-} else {
- printf("Bye bye\n");
-}
-\end{lstlisting}
-\caption{Exemple d'analyse syntaxique. En bas : le programme C, en haut : représentation du programme sous la forme d'un arbre par analyse syntaxique.}
-\label{seq:refFigure2}
-\end{figure}
-
-
-Si une erreur de syntaxe est trouvée, alors la compilation est arrêtée et des messages d'erreur vous invite de manière assez \texttt{explicite} à corriger celles-ci. Le compilateur peut même vous suggérer des modifications.
-
-\begin{remarque}[Lisez les messages d'erreur]
- Les messages d'erreurs sont explicites !! Au début, il peut être difficile de les lire, mais à force de les voir vous devriez apprendre à les reconnaître et à corriger vous même vos erreurs !
-\end{remarque}
-
-\begin{remarque}[Utiliser le compilateur régulièrement pour la syntaxe !]
- Le compilateur peut également vous aider à écrire votre programme au fur et à mesure. Dans la mesure où il vous informe de la correction de votre syntaxe, n'hésitez pas à faire appel à lui (plutôt qu'à l'enseignant) pour vous donner un coup de main ...
-\end{remarque}
-
-
-Même en cas d'erreur, l'analyse syntaxique peut continuer afin d'identifier toutes les erreurs syntaxiques en une seule lecture du fichier. Vous pouvez ainsi vous retrouver avec des centaines d'erreur assez rapidement ! Il ne faut pas paniquer ... En règle général, il vaut mieux commencer par traiter les premières erreurs qui ont été identifiées, il y a des chances que si le début a été mal lu, le compilateur n'a plus rien compris à la suite et qu'il a trouvé plein de fautes ``imaginaires''.
-
-D'autres messages d'information peuvent indiquer des ``\textit{Warning}''. Ceci ne bloque pas la compilation, mais il est conseillé de les corriger également. Même si ils ne gênent pas la compilation, les \textit{warnings} peuvent avoir des conséquences sur le bon déroulement de l'exécution du programme. Rien ne vaut un programme nickel d'un point de vue du
-compilateur.
-
-\begin{warning}
-Ce n'est pas parce qu'un programme est syntaxiquement correct qu'il est ``bon'' ! En effet, généralement, un programme doit faire quelque chose, une syntaxe correcte ne garantis en rien que ce que fait le programme est conforme aux spécifications.
-\end{warning}
-
-Je ne préfère pas aborder ici les autres types d'erreur qui peuvent être rencontrées et qui sont plus complexes à généraliser :
-
-\begin{itemize}
-\item erreur d'édition de liens ;
-\item erreurs d'exécution.
-\end{itemize}
-
-\subsection{Notion d'optimisation du code}
-Un compilateur est un programme très complexe qui est capable de ``comprendre'' votre code et parfois de le remplacer en utilisant des astuces qui exploitent les spécificités de votre architecture matérielle. On parle alors d'optimisation.
-
-Exemple d'optimisation qui pourra être faite de manière transparente pour le programmeur :
-
-Voici une version non-optimisée qui nécessite de faire autant d'appel à la fonction \lstinline!getLimite()! que de tour de boucle :
-
-\begin{lstlisting}
-for(int i=0; i<getLimite(); i++) {
- //...
-}
-\end{lstlisting}
-Et voici, une version optimisée, avec un seul appel à la fonction \lstinline!getLimite()! :
-
-\begin{lstlisting}
-int l=getLimite();
-for(int i=0; i<l; i++) {
- //...
-}
-\end{lstlisting}
-
-Il ne s'agit là que d'un exemple simple, mais c'est avec de petites modifications que le compilateurs est capable d'obtenir des améliorations impressionnantes.
-
-Très souvent, il est même recommandé de laisser le compilateur faire les optimisations plutôt que de les faire soit même. Le compilateur est généralement plus efficace que l'humain (programmeur moyen) pour trouver des optimisations, et les programmes restent ainsi lisibles, plus facilement compréhensibles.
-
-\section{Le pré-processeur} \label{sec:preprocesseur}
-La compilation d'un fichier \texttt{.c} se fait en deux étapes (\cf Figure \ref{seq:refFigure4}) :
-\begin{itemize}
-\item le pré-processeur apporte quelques modifications à votre fichier pour le préparer à la compilation,
-\item la compilation construit un fichier binaire (objet ou programme).
-\end{itemize}
-
-\begin{figure}[ht]
-\centering
-\includegraphics{\Figures/CompilationC_fichier}
-\caption{Compilation d'un fichier C}
-\label{seq:refFigure4}
-\end{figure}
-
-
-Le pré-processeur traite toutes instructions qui commencent par le caractère \texttt{\#} dans un programme C. Les instructions qui peuvent être données au pré-processeur sont les suivantes :
-\begin{itemize}
-\item \lstinline!#include "fichier.h"!~: demande au préprocesseur de copier le contenu du fichier fichier.h à cet emplacement. Cette instruction au pré-processeur est très fréquemment utilisé pour importer des fonctions décrites dans un autre fichier.
-\item \lstinline!#define TOTO!~: déclare la variable \texttt{TOTO} (les variables du préprocesseur sont très souvent en majuscule)
-\item \lstinline!#define FNCT(x) ...!~: déclare une macro \texttt{FNCT} avec une variable \texttt{x}
-\item \lstinline!#ifndef TOTO ... #endif! : si la variable \texttt{TOTO} n'est pas définie, alors le code contenu jusqu'au \lstinline!#endif! sera compilé (sinon, il sera totalement ignoré)
-\item \lstinline!#define TOTO 10! : déclare la variable \texttt{TOTO} avec la chaîne de caractères 10. à chaque fois que le préprocesseur rencontrera cette variable, il la remplacera par 10 \textit{avant la compilation} (il effectue simplement un remplacement du texte). Ceci est un moyen efficace de définir des constantes utiles dans un programme (par exemple la valeur de \texttt{Pi}).
-\end{itemize}
-
-\subsection{Exemple de l'effet du pré-processeur lors de la compilation}
-
-Le petit programme \ref{code:compilationpp} utilise des commandes spécifiques au pré-processeur. En utilisant la commande de compilation suivante (avec l'option \texttt{-E}, on ne fait fonctionner que le pré-processeur~:
- \begin{center}
- \texttt{\$ gcc -E -o} \textit{exemple\_compilation\_pp.i} \textit{exemple\_compilation\_pp.c}
- \end{center}
-
-Le résultat est de cette commande est illustré par le programme \ref{code:compilationpp_res}, pour lequel certains remplacements ont été réalisés. On constate, d'une part, que la variable de préprocesseur \lstinline!LIMITE! a été remplacée par sa valeur 10 dans le \lstinline!for! et, d'autre part, que la macro \lstinline!VALEUR_ABSOLUE! a été remplacée ``intelligemment'' (\ie toutes les valeurs de \lstinline!x! ont été remplacée par la valeur du paramètre effectif).
-
-\lstinputlisting[label=code:compilationpp]{\Sources/exemple_compilation_pp.c}
-\lstinputlisting[label=code:compilationpp_res]{\Sources/exemple_compilation_pp.i}
-
-En pratique, le programme contient beaucoup de nouvelles lignes au début de fichier que je ne fais pas apparaître, vous pourrez menez l'expérience par vous même pour les voir, mais elles ont peu d'intérêt.
-
-\subsection{Utilisation des \texttt{define} dans les \texttt{.h}}
-Voici maintenant un exemple d'illustration du fonctionnement du préprocesseur qui est très utilisé dans l'écriture de fichiers \texttt{.h} propres. Je recommande donc de faire de même dans tout vos \texttt{.h}.
-
-\begin{lstlisting}
-/***
-* Exemple de fichier .h
-***/
-#ifndef FICHIER_H
-#define FICHIER_H
-...
-#endif
-\end{lstlisting}
-
-
-Dans cet exemple, on indique que si la variable \lstinline!FICHIER_H! n'est pas définit, on la définie et on ajoute (à la place des ...) les instructions en C spécifique à ce fichier. Cette façon de procéder permet de s'assurer que le préprocesseur n'insérera qu'une seule fois le contenu de ce fichier \texttt{.h} avant la compilation d'un \texttt{.c}. Lorsque le nombre de fichiers croît, il est facile de se retrouver avec des dépendances cycliques entre les fichiers \texttt{.c} et \texttt{.h} de sorte que le préprocesseur insère deux fois un même \texttt{.h}. Cela pose des problèmes de compilation par la suite. Ici, si le fichier est appelé une seconde fois, par le préprocesseur, le fait que la variable \lstinline!FICHIER_H! soit déjà définie va bloquer l'insertion du contenu du fichier.
-
-Pour chaque fichier \texttt{.h}, il faut un nom de variable différent.
-
-Le préprocesseur supprime également tous les commentaires (\lstinline!//! et \lstinline!/*~~~*/!) qui sont utiles au programmeur, mais inutiles pour l'ordinateur.
-
-
-\section{Compilation séparée}
-
-Jusque là, nous nous sommes principalement intéressé à des programmes ne contenant qu'un unique fichier. Pour de gros programmes, il n'est pas raisonnable d'imaginer que tout ce passe dans un seul fichier. Si les programmes sont réparties dans plusieurs fichiers, il faut avoir recours à la compilation séparée.
-Le problème de la décomposition d'un programme en plusieurs fichiers sera abordé dans la partie sur la ``décomposition'' des programmes. Je présente ici le problème de la compilation séparée.
-
-\begin{remarque}
- Je commence par faire remarquer que la gestion de la compilation avec plusieurs fichiers est généralement transparente avec l'utilisation d'un IDE comme \texttt{Code::Blocks}.
-\end{remarque}
-
-Commençons par donner les deux grandes étapes nécessaires à la compilation séparée (\cf Figures \ref{fig:compilationC_full})~:
-\begin{enumerate}
- \item tous les fichiers \texttt{.c} sont \textbf{compilés} indépendamment sous la forme de fichiers objets (\texttt{.o}),
- \item tous les fichiers objets (\texttt{.o}) sont assemblés par une étape d'\textbf{édition de liens}\index{édition de liens}. Dans cette étape, les liens sont également effectué avec des librairies de fonctions extérieures à votre code mais que vous utilisez.
-\end{enumerate}
-
-
-
-\subsection{Compilation d'un fichier \texttt{.c} en fichier objet avec \texttt{gcc}}
-Pour compiler un fichier \texttt{.c} contenant un programme écrit en langage C sous la forme d'un fichier objet, il faut utiliser l'option \texttt{-c} de \texttt{gcc}. \texttt{gcc} est un compilateur qui s'exécute en ligne de commande sous Linux. Consulter la partie du cours sur l'utilisation de l'environnement de programmation Linux pour bien comprendre les explications suivantes.
-
-Un fichier objet, extension \texttt{.o}, est un bout de programme compilé. Il ne peut pas être directement exécuté par le processeur, mais contient la traduction des programmes dans le langage machine. L'édition de liens se chargera \textit{simplement} de mettre ensemble tous les fichiers \texttt{.o} et à indiquer par où il faut commencer l'exécution du programme.
-
-Commande permettant de compiler un fichier C à la suivante :
-
-\begin{verbatim}
-$ gcc -c -o fichier.o fichier.c
-\end{verbatim}
-ou
-\begin{verbatim}
-$ gcc -c fichier.c
-\end{verbatim}
-
-La ligne de commande se comprend ainsi :
-\begin{itemize}
-\item \texttt{-c} : option qui indique de ne faire que compiler le programme (pas d'édition de lien)
-\item \texttt{-o fichier.o} : option pour imposer le nom du fichier binaire qui est construit (par défaut, il prend le même nom que le fichier \texttt{.c} et remplace juste l'extension en \texttt{.o})
-\item \texttt{fichier.c} : nom du fichier à compiler (toujours à la fin de la ligne de commande)
-\end{itemize}
-
-Vous noterez qu'il n'est fait référence à aucun fichier \texttt{.h}. En effet, le compilateur ira chercher ces fichiers si le préprocesseur en a trouvé. Mais où va-t-il chercher les fichiers \texttt{.h} dans l'arborescence de fichier ? Par défaut, le compilateur les cherche dans le répertoire courant, et dans un certain nombre de répertoires usuels (définie lors de la configuration du système), par exemple \texttt{/usr/include}. Si vous souhaitez ajouter des répertoires dans lesquels le compilateur aura besoin d'aller identifier des \texttt{.h}, alors, il est nécessaire de lui indiquer explicitement à l'aide de l'option \texttt{-I}.
-
-Par exemple :
-\begin{verbatim}
-$ gcc -c -o fichier.o -I ./monrepertoire/ fichier.c
-\end{verbatim}
-
-Le résultat de la compilation est un fichier binaire qui est la traduction dans le langage machine du programme écrit en C. Pour visualiser le résultat, vous pouvez essayer d'ouvrir le fichier sous un éditeur de texte ... comme c'est du binaire, ça ne marche pas, ou bien avec une visualisation du contenu binaire :
-
-\begin{verbatim}
-$ od -a fichier.o
-$ od -x fichier.o
-\end{verbatim}
-
-
-\subsection{Édition de liens entre plusieurs fichiers \texttt{.o}}\index{édition de liens}
-Une fois que tous vos fichiers \texttt{.c} ont été compilés en fichier \texttt{.o}, vous pouvez passer à l'édition de liens. La commande pour faire l'édition de liens entre trois fichiers \texttt{.o} est la suivante :
-
-\begin{verbatim}
-$ gcc -o monprogramme fichier1.o fichier2.o fichier3.o
-\end{verbatim}
-
-La ligne de commande se comprend ainsi :
-
-\begin{itemize}
-\item \texttt{-c} : contrairement à la compilation, \textbf{il n'y a pas d'option -c ici.}
-\item \texttt{-o monprogramme} : le fichier binaire généré s'appellera monprogramme, en l'absence de cette fonction, le fichier généré s'appellera \texttt{a.out}.
-\item \texttt{fichier1.o ...}~: à la fin de la ligne de commande, il faut préciser tous les fichiers \texttt{.o} que vous souhaitez lier entre eux.
-\end{itemize}
-
-De même que pour l'importation de fichier \texttt{.h} lors de la compilation, vous pourriez avoir besoin de préciser explicitement l'utilisation de librairies et où trouver ces libraires. Il faut alors utiliser les options \texttt{-L} et \texttt{-l}. Je ne détaille pas ce point ici, vous pouvez consulter la documentation de gcc pour plus d'informations.
-
-Exemple d'utilisation de la librairie de fonctionnalités mathématiques :
-\begin{verbatim}
-$ gcc -o monprogramme -lm fichier1.o fichier2.o fichier3.o
-\end{verbatim}
-
-\section{Compilation rapide d'un fichier unique}
-Dans le cadre de ce cours, il est possible que vos programmes tiennent dans un seul et même fichier. Il n'est alors pas nécessaire de faire deux commandes pour compiler le programme. La commande suivante réalise d'un coup les deux étapes (compilation + édition de liens) :
-\begin{verbatim}
-$ gcc -o monprogramme fichier.c
-\end{verbatim}
-
-\section{Utilisation d'un Makefile}\label{sec:Makefile}
-Un \texttt{Makefile} est un fichier, nommé \texttt{Makefile} (sans extension), qui décrit la proédure de compilation qui doit être automatisée. Ce fichier est utilisé par la commande \texttt{make}.
-
-\subsection{Un exemple simple}
-
-Prenons l'exemple de trois fichiers :
-\begin{itemize}
- \item \texttt{fonctions.h} : un fichier contenant les descriptions de quelques fonctions utilent au programme,
- \item \texttt{fonctions.c} : il contient les implémentations des fonctions de \texttt{fonctions.h}. Ce fichier fait appel à \texttt{fonctions.h},
- \item \texttt{main.c} : contient la fonction \lstinline!main()!, c'est le programme principal. Nous supposons qu'il fait appel à \texttt{fonctions.h}.
-\end{itemize}
-
-La Figure \ref{fig:Makefile1} illustre les dépendances entre les fichiers et les étapes de compilation à effectuer.
-
-\begin{figure}[ht]
- \centering
- \includegraphics[height=4cm]{./Figures/CompilationC_Makefile1}
- % CompilationC_Makefile1.eps: 0x0 pixel, 300dpi, 0.00x0.00 cm, bb=0 0 196 226
- \caption{Ordre de compilation et dépendances}
- \label{fig:Makefile1}
-\end{figure}
-
-Supposons que nous fassions une modification du fichier \texttt{main.c}, alors, il suffit de compiler de nouveau le fichier \texttt{main.c} et de refaire l'édition en lien. En revanche, si vous modifier le fichier \texttt{fonctions.h}, alors tous les fichiers doivent être compilés. En utilisant les dates des fichiers, la commande \texttt{make} est capable de déterminer les bons fichiers à compiler à partir des dépendances entre fichiers décrites dans le \texttt{Makefile}.
-
-Pour cet exemple, le \texttt{Makefile} (assez simple) aura l'allure suivante :
-
-\lstinputlisting[language=make,keywordstyle=\color{red}]{\Sources/exMakefile}
-
-Ce fichier s'interprète à partir de motifs de règles qui ont l'allure suivante :
-\begin{verbatim}
-cible: dependance1 dependance2 ...
- commande
- commande
-\end{verbatim}
-
-Dans cette règle, \texttt{cible} indique le nom fichier qui sera produit par l'exécution de règle. Sur la même ligne, et séparé de ``:'' avec la cible, on donne toutes les dépendances nécessaire à la production de la cible. Sur les lignes en-dessous, décalées par une tabulation\footnote{Attention, il faut impérativement utiliser une tabulation. Les espaces ne vont pas fonctionner.}, on donne la (ou les) commande qu'il faut exécuter (typiquement un gcc).
-
-Dans le \texttt{Makefile} exemple, la première règle \texttt{all} désigne ce qui doit être réalisé par défaut. On retrouve ensuite la règle de \texttt{main} qui réalise l'édition de liens et les deux règles pour les compilations de \texttt{main.c} et \texttt{fonctions.c}. Finalement on donne également une règle nommée \texttt{clean} pour faciliter la suppression de tous les fichiers compilés.
-Pour la règle de \texttt{fonctions.o}, on a comme dépendance le fichier \texttt{fonctions.c} et également \texttt{fonctions.h} qui permettra de savoir qu'il faut réappliquer cette règle si l'un de ces fichiers a été modifié. La commande réalisé lors du déclenchement de cette règle est simplement un appel à \texttt{gcc}.
-Pour la règle \texttt{clean}, il n'y a pas de dépendance et la commande exécuté sera la commande système \texttt{rm} (suppression de fichier).
-
-\espace
-
-Une fois ce fichier enregistré (dans le même répertoire que les fichiers sources), il s'utilise ainsi :
-\begin{itemize}
- \item pour compiler ou recompiler votre programme \texttt{main}, tapez dans la console :
-\begin{verbatim}
- ...$ make
-\end{verbatim}
- \item pour déclencher la règle \texttt{clean}, faire :
-\begin{verbatim}
- ...$ make clean
-\end{verbatim}
-\end{itemize}
-
-Une fois le \texttt{Makefile} en place, on ne se pose plus de question sur la compilation !! C'est très pratique !
-
-\subsection{Utilisation de variables dans le Makefile}
-L'intérêt de \texttt{make} ne s'arrête pas là. Il est possible d'utiliser des variables dans le \texttt{Makefile} qui vont vous faciliter la vie. L'intérêt principal est de pouvoir facilement changer toutes les options de compilation sans avoir à modifier toutes les règles.
-
-Le cas le plus usuel est le suivant. On retrouve exactement les mêmes règles que précédemment, mais, on a ajouté aux commandes de compilation une variable \texttt{\$(FLAGS)}. Cette variable sera remplacée par la valeur \texttt{-O2 -Wall}, définie en haut du fichier. On peut modifier facilement la valeur de cette variable (en \texttt{-g} par exemple). Dans ce cas, la modification s'appliquera aux deux commandes de compilation.
-
-\lstinputlisting[language=make,keywordstyle=\color{red}]{\Sources/exMakefileVar}
-
-Il restera alors à enregistrer le \texttt{Makefile}, puis à faire un \texttt{make clean} pour supprimer les anciennes versions compilées avec en \texttt{-O2} et à recompiler l'ensemble avec un \texttt{make}.
-On peut ainsi facilement passer d'une compilation pour le débuggage (option \texttt{-g}) à une compilation finale (option \texttt{-O2}).
-
-\espace
-
-Beaucoup plus de fonctionnalité existent pour les \texttt{Makefile}, mais leur maîtrise n'est pas justifié dans le cadre de ce cours.
-
-\section{Options avancées de compilation}
-Lors de la compilation vous pouvez ajouter des options qui vont modifier le comportement du compilateur.
-
-\texttt{-Wall} (\textit{Warning all}) : L'ajout de cette option indique au compilateur qu'on veut qu'il nous informe de tous les \textit{warnings} qu'il a pu trouver. Cette option assure que votre code est nickel pour la compilation.
-
-Un autre grande classe d'option concerne le choix de l'optimisation à faire sur le code :
-
-\begin{itemize}
-\item options \texttt{-g}, \texttt{-g3}, \texttt{-pg} : correspond à la compilation en mode ``debug'' et de ``profiling''
-\item option \texttt{-O1}, \texttt{-O2}, \texttt{-O3} : correspond au niveau global d'optimisation. Plus vous augmenterez le niveau d'optimisation, plus la compilation du code prendra du temps et utilisera de la mémoire. (l'option \texttt{-O3} utilise des fonctionnalités d'optimisation de code plus poussées, mais elles peuvent avec des conséquences importantes sur la traduction des programmes, et mieux vaut ne pas les utiliser sans en maîtriser les finesses.
-\end{itemize}
-
-
-%L'étape de débuggage consiste à trouver un problème (un bug) dans votre programme. Bien que celui-ci compile, il ne donne pas les résultats attendu, voire il plante totalement. Il peut être assez difficile de trouver l'origine du problème. Les outils de débuggage sont là pour vous aider (\texttt{gdb} et \texttt{valgrind}). L'option \texttt{-g} peut également être graduée entre 1 et 3 (par défaut \texttt{-g} signifie \texttt{-g2}).
-
-Pour que les outils de débuggage (\texttt{gdb} et \texttt{valgrind}) fonctionnent, il faut impérativement que les programmes soient compilées avec l'option \texttt{-g}. En utilisant cette option, le compilateur va insérer tout un tas de code qui va permettre aux outils de bien comprendre ce qui se passe et ainsi vous aider à trouver les erreurs. Bien évidemment, toutes ces insertions nuisent aux performances de votre code, mais peu importe, vous l'utiliser dans une phase préliminaire.
-L'option \texttt{-pg} permet d'ajouter de nouvelles informations dans le code qui vont permettre d'utiliser l'outil \texttt{gprof}.
-
-Quand le code fonctionne bien, il est temps de compiler une vraie version (version ``Release''). Et même pourquoi pas une version optimisée en recompilant tout le code avec une option du type \texttt{-O}.% ou une option \texttt{-march}.
-Le niveau \texttt{-O2} est le niveau généralement requis pour l'optimisation d'un code finalisé.
-
-%Option \texttt{-march} : cette option indique au compilateur quel code il doit produire pour l'architecture (ou arch) de votre processeur : elle indique qu'il doit fournir un code pour un certain type de processeur. Les différents processeurs ont des capacités différentes, supportent des jeux d'instructions différents et exécutent le code de façon différente. L'option \texttt{-march} va signaler au compilateur quel code créer spécifiquement pour votre processeur, avec toutes ses capacités.
-
-% Quel type de processeur avez-vous ? Pour le savoir, tapez ceci :
-%
-% \begin{verbatim}
-% $ cat /proc/cpuinfo
-% \end{verbatim}
-%
-% à présent, voyons l'option \texttt{-march} en action :
-% \begin{itemize}
-% \item Pour un vieux processeur Pentium III : \texttt{-march=pentium3},
-% \item Pour un processeur AMD 64~bits : \texttt{-march=athlon64}
-% \end{itemize}
-% Si vous n'êtes pas s\^ur de votre type de processeur, utilisez juste \texttt{-march=native}. Quand cette option est utilisée, GCC détecte votre processeur et ajoute automatiquement les options appropriées.
-
-
-
-% Il y a cinq paramètres \texttt{-O} : \texttt{-O0}, \texttt{-O1}, \texttt{-O2}, \texttt{-O3}, et \texttt{-Os}. Vous ne devrez utiliser qu'un seul d'entre eux. à l'exception de \texttt{-O0}, les paramètres \texttt{-O} activent chacun plusieurs options supplémentaires, donc assurez-vous de bien lire le chapitre sur les options d'optimisation\footnote{http://gcc.gnu.org/onlinedocs/gcc-4.3.3/gcc/Optimize-Options.html\#Optimize-Options}
-% du manuel de \texttt{gcc} pour savoir quelles options sont activées à chaque niveau \texttt{-O}, ainsi que pour obtenir quelques explications sur ce qu'elles font.
-%
-% Examinons chaque niveau d'optimisation :
-%
-% \begin{itemize}
-% \item \texttt{-O0}: Ce niveau (la lettre {\textquotedbl}O{\textquotedbl} suivie d'un zéro) désactive entièrement l'optimisation, c'est le niveau par défaut si aucun niveau -O n'est spécifié. Votre code ne sera pas optimisé : ce n'est généralement pas ce qui est voulu.
-% \item \texttt{-O1}: C'est le niveau le plus classique d'optimisation. Le compilateur va essayer de générer un code plus rapide et plus léger sans prendre plus de temps à compiler. C'est relativement classique, mais cela devrait fonctionner dans tous les cas.
-% \item \texttt{-O2}: Un étape au-dessus du \texttt{-O1}. C'est le niveau recommandé d'optimisation sauf si vous avez des besoins spécifiques. Le niveau \texttt{-O2} va activer quelques options en plus de celles du \texttt{-O1}. Avec le
-% niveau \texttt{-O2}, le compilateur va tenter d'augmenter les performances du code sans faire de compromis sur la taille et sans prendre trop de temps à compiler.
-% \item \texttt{-O3}: Il s'agit du plus haut niveau d'optimisation possible mais aussi du plus risqué. Le temps de compilation sera plus long avec cette option qui en fait ne devrait pas être utilisée de façon globale avec GCC 4.x. Le comportement de \texttt{gcc} a changé de façon significative depuis la version 3.x. Dans la version 3.x, \texttt{-O3} a
-% montré que son utilisation conduisait à des temps d'exécution marginaux plus rapides qu'avec \texttt{-O2}, mais ce n'est plus le cas avec \texttt{gcc} 4.x. Compiler tous vos paquets avec \texttt{-O3} produira des plus gros binaires qui demanderont plus de mémoire et va augmenter de façon significative les étranges erreurs de compilation ou provoquer des
-% comportements inattendus pour les programmes (y compris des erreurs). Les inconvénients sont plus nombreux que les avantages ;
-% \textbf{L'utilisation du niveau \texttt{-O3} n'est pas recommandé pour GCC 4.x.}
-% \item \texttt{-Os}: Ce niveau va optimiser votre code en taille. Il active toutes les options du niveau \texttt{-O2} qui n'influent pas sur la taille du code généré. Il peut être utile pour les machines qui ont une taille très limitée d'espace libre sur le disque dur et/ou qui ont des processeurs avec une petite taille de cache. Toutefois, ce niveau
-% peut tout à fait causer d'autres problèmes, c'est pourquoi l'utilisation de -Os n'est pas recommandé.
-% \end{itemize}
-
-
-
-
-%Option \texttt{-pipe} : \texttt{-pipe} est une option assez répandue. Elle n'a, en fait, pas d'effet sur le code généré, mais va accélérer le processus de compilation. Elle dit au compilateur d'utiliser des tubes à la place des fichiers temporaires pendant les différentes étapes de la compilation. L'utilisation de tubes va utiliser plus de mémoire.
-%Cette option est donc déconseillée sur les machines avec peu de mémoire, car \texttt{gcc} pourrait en manquer et se faire tuer par le système.
\ No newline at end of file
diff --git a/Polyc/Decomposition.tex~ b/Polyc/Decomposition.tex~
deleted file mode 100644
index 98cf04e47cdbc5f9008cbd1121dd4eb4ab2fff3e..0000000000000000000000000000000000000000
--- a/Polyc/Decomposition.tex~
+++ /dev/null
@@ -1,1010 +0,0 @@
-
-\chapter{Décomposition d'un programme C -- récursivité}
-\Opensolutionfile{solutions}{}
-
-\section{Approche descendante}
-On se replace ici sur le problème de conception algorithmique d'un programme qui doit réaliser une tâche complexe. Pour trouver une solution algorithmique à ce problème, l'approche descendante invite à décomposer cette tâche, qu'on va dire de premier niveau, en tâches de second niveau. Cette première étape permet d'avoir un algorithme abstrait (dans le sens o\`u il ne peut être exécuté par la machine). Dans un second temps, l'analyste programmeur s'intéresse aux tâches de second niveau pour en donner des algorithmes utilisant des tâches de troisième niveau etc. jusqu'à décrire les tâches à partir d'instructions élémentaires.
-
-La devise de l'approche descendante est ``diviser pour régner''~: le problème est divisé est sous-partie qu'on sait bien faire (\textit{régner}), et qu'on sait combiner en utilisant les structures de contrôle usuelles.
-
-L'approche descendante est une démarche intellectuelle pour aider à construire des algorithmes. Il est intéressant de conserver des traces de cette démarche conservant une trace des tâches de second niveau, troisième niveau ...
-
-\begin{itemize}
-\item ceci va rendre le programme beaucoup plus lisible que si il était entièrement écris dans une unique fonction \lstinline!main()!, et donc ce sera beaucoup plus facile d'y trouver des erreurs ou, pour autre programmeur, de comprendre ce programme.
-\item les briques intermédiaires sont réutilisables pour d'autres programmes. Si ces briques sont bien con\c{c}ues, elles sont suffisamment génériques pour pouvoir être utilisées à plusieurs endroits dans vos programmes. Plutôt que de refaire à chaque fois le même bout de programme, mieux vaut le faire une fois bien, et le réutiliser ensuite\footnote{Il semble ici opportun de rappeler que les fainéants ont bonne presse chez les informaticiens. En effet, mieux vaut utiliser quelque chose qui est déjà fait et qui marche que de le refaire moins bien soit même !}
-!
-\item le travail est plus facilement partageable entre plusieurs programmeurs. Si deux programmeurs se sont bien mis d'accord sur les \textbf{spécifications} des fonctions, peut importe lequel des programmeurs a effectivement réalisé la fonction, ils pourront utiliser le travail de l'autre sans se soucier de comment c'est fait.
-\end{itemize}
-
-
-En programmation, les sous-tâches peuvent s'écrire sous la forme de fonctions. Chaque fonction réalise une sous-tâche. Les fichiers \texttt{.h} et \texttt{.c} permettent ensuite de regrouper des ensembles de fonctions qui sont cohérentes entre elles de sorte à constituer des sortes de modules (on parle de programmation modulaire).
-
-Un programme sera désormais composé comme un ensemble de fonctions\footnote{En programmation, on distingue parfois les
-fonctions, des procédures. En C, tout est fonction. Je n'insisterai pas sur la différence.} qui peuvent s'appeler les unes les autres. La fonction \lstinline!main()! est une fonction particulière, puisque le compilateur va savoir que c'est par cette fonction que le programme doit commencer~! Pour le \lstinline!main()!, on parle parfois de \textit{programme principal}. Il serait plus judicieux de parler de \textit{fonction principale}.
-
-\section{Fonctions}
-Une fonction est une sorte de boîte noire~:
-
-\begin{itemize}
-\item \textbf{à l'extérieure}, elle est vue \textbf{comme une instruction} qui réalise une tâche de traitement de données (peu importe comment !),
-\item \textbf{à l'intérieur}, c'est \textbf{un (mini-)programme} qui implémente la sous-tâche de traitement de l'information.
-\end{itemize}
-
-\begin{exemple}[Fonction Somme]\label{ex:fonction_somme}
-
-Le programme ci-dessous illustre la définition et l'utilisation d'une fonction.
-\begin{lstlisting}
-#include <stdio.h>
-/*
-* int somme(int a, int b)
-* @brief Calcul de la somme de deux entiers a et b
-* @param a, b~: entiers operandes de la somme
-* @return la somme des deux entiers a et b.
-*/
-int somme(int a, int b) {
- int s=0;
- printf("a: %d, b: %d\n",a,b);
- s=a+b;
- return a+b;
-}
-
-int main(void) {
- int x =2, y =3, z =0;
- z=somme(x,y);
- printf("%d\n", z);
-}
-\end{lstlisting}
-
-Le résultat de l'exécution de ce programme est le suivant~:
-
-\begin{verbatim}
-...> ./fonctions
-a: 2, b: 3
-5
-\end{verbatim}
-
-À la ligne 17, \lstinline!somme! est utilisé comme une instruction dans le programme principal. Et les lignes 9 à 12 décrivent ce que fait cette sous-tâche à partir d'instructions plus élémentaires. Les lignes 2 à 7 sont des commentaires qui décrivent ce que fait la fonction. Ce doit être ici des informations précises et concises qui vont permettre à l'utilisateur de la fonction de savoir exactement ce qui va se passer lors de l'\textbf{appel de la fonction} (par exemple, à la ligne 17) sans avoir à lire le contenu de la fonction. On parle de \textbf{cartouche}. Il contient les \textbf{spécifications
-de la fonction}.
-\end{exemple}
-
-\subsection{Déclaration d'une fonction}
-Une fonction est un (sous-)programme qui prend des paramètres et \textbf{retourne} une valeur. Une fonction est caractérisée par~:
-\begin{itemize}
-\item son \textbf{profil~}: une sorte de nom de la fonction
-\item son \textbf{corps}~: c'est l'implémentation de ce que fait la fonction
-\end{itemize}
-
-En C, une fonction se définie de la sorte~:
-\begin{lstlisting}
-type_retour nom_fonction(type1 parametre1, type2 parametre2, ...)
-{
- //Corps de la fonction
- ...
-}
-\end{lstlisting}
-
-
-\begin{exemple} [Exemple d'une fonction somme]\label{ex:fonction_somme_2}
-
-On reprend ici la même fonction que l'exemple \ref{ex:fonction_somme}.
-
-\begin{lstlisting}
-int somme(int a, int b) // profil de la fonction
-{
- //Corps de la fonction
- int s=0;
- printf("a: %d, b: %d\n",a,b);
- s=a+b;
- return a+b;
-}
-\end{lstlisting}
-\end{exemple}
-
-Il faut faire le rapprochement entre la définition d'une fonction telle que présentée ci-dessus et une fonction mathématique. Voici la déclaration usuelle d'une fonction mathématique~:
-$$\begin{gathered}f:\mathbb{N}\times \mathbb{R}\rightarrow
-\mathbb{R}\\\ \ \ \ \ \ n,x\ \mapsto
-2.\mathit{x.e}^{n}\end{gathered}$$
-
-La première ligne donne, en quelque sorte, le profil de la fonction $f$~: la fonction a deux paramètres (un entier $n$ et un réel $x$), et que la fonction ``retourne'' une valeur réelle (à droite de la flèche).
-
-Sur la seconde ligne, vous avez l'implémentation de la fonction~: c'est-à-dire la description de ce quelle fait. Ici, cette fonction calcule la valeur $2.\mathit{x.e}^{n}$.
-
-
-\begin{remarque} [Effet de bord]
- La fonction de l'exemple \ref{ex:fonction_somme_2} réalise un calcul qui permet de retourner une \textit{valeur utile}. On peut dire que c'est l'attente principale qu'à le programmeur lorsqu'il utilise cette fonction.
-
- Tout ce qui se réalise en plus peut être vu comme un \textbf{effet de bord}.
- L'utilisation de la fonction de l'exemple aura aussi pour conséquence de faire un affichage à l'écran. C'est un effet de bord.
-
- Ces effets doivent être décris dans le cartouche de la fonction, car il ne sont généralement pas attendus par l'utilisateur.
-\end{remarque}
-
-
-\subsubsection{Profil de la fonction}
-Dans un profil de fonction~:
-
-\begin{itemize}
-\item le contenu des parenthèses indique les \textbf{paramètres} de la fonction ; L'\textbf{ordre des paramètres }est très important. Ce qui compte pour la liste des paramètres d'une fonction, c'est uniquement la liste des types du paramètre (le nom servira pour le corps de la fonction).
-\item le type à gauche indique le \textbf{type de retour} de la fonction.
-\end{itemize}
-
-\begin{exemple}[Exemple d'une fonction somme (suite)]
-Dans l'exemple de la fonction \textup{somme}, le profil indique que la fonction a deux paramètres (un premier paramètre de type entier et un second paramètre de type entier) et retourne une valeur entière.
-\end{exemple}
-
-\begin{remarque}
-Lorsqu'une fonction n'a pas de paramètre, on peut soit ne rien mettre entre les parenthèses (mais avec des parenthèses tout de même), soit indiquer explicitement qu'il n'a pas de paramètre en indiquant \lstinline!void!.
-\end{remarque}
-
-\begin{exemple} [Fonction et procédure sans paramètres]
-
-Profil d'une fonction sans paramètre~:
-\lstinline!int fonction(void)! ou \lstinline!int fonction()!
-
-Profil d'une procédure sans paramètres (il est nécessaire de mettre le \lstinline!void! de type de retour dans tous les cas)~:
-\lstinline!void proc(void)! ou \lstinline!void proc()!
-\end{exemple}
-
-\begin{remarque}
-En C, deux fonctions ne peuvent avoir les mêmes noms ET les mêmes paramètres ! Il faut comprendre par ``mêmes paramètres'' que l'ordre et les \textit{types} des paramètres sont les mêmes (les noms de paramètres n'interviennent pas). Ceci signifie que deux fonctions peuvent avoir le même nom à condition qu'elles n'est pas les mêmes paramètres.
-\end{remarque}
-
-\begin{exemple}
-Exemple de fonctions compatibles~:
-\begin{itemize}
-\item \lstinline!void division( int a, float b);!
-\item \lstinline!void division( int a);!
-\item \lstinline!void division( float a, int b);!
-\item \lstinline!void division( double a, double b);!
-\end{itemize}
-
-
-Exemple de fonctions qui ne peuvent pas coexister~:
-\begin{itemize}
-\item \lstinline!void division(int a, int b);!
-\item \lstinline!int division(int c, int d);!
-\end{itemize}
-\end{exemple}
-
-\subsubsection{Corps de la fonction}
-Le corps de la fonction qui comporte la description de la tâche réalisée par la fonction est délimité par les accolades
-``\{...\}'' succédant le profil de la fonction.
-
-Pour le sous-programme qu'est une fonction les paramètres de la fonction correspondent à des \textbf{variables locales} qui sont initialisées par les valeurs données par l'appel de la fonction.
-Ces variables peuvent être utilisées sans être initialisées.
-
-Une fonction doit obligatoirement retourner une valeur dont le type correspond au type de retour de la fonction. Pour indiquer quelle valeur retourner, il faut utiliser l'instruction \lstinline!return!.
-
-L'instruction \lstinline!return!~:
-
-\begin{itemize}
-\item finalise l'exécution de la fonction (les instructions suivantes ne seront pas traitées),
-\item indique la valeur qui sera retournée par la fonction.
-\end{itemize}
-
-
-\begin{exemple}
-La fonction suivante retournera toujours 0~:
-\begin{lstlisting}
-int fonction()
-{
- int x;
- x=0;
- return x;
- //Partie du code inatteignable
- x=x+1;
- return x;
-}
-\end{lstlisting}
-\end{exemple}
-
-L'instruction \lstinline!return! peut également s'utiliser avec des parenthèses, par exemple~:
-\begin{lstlisting}
-int fonction()
-{
- int x;
- x=0;
- return(x);
-}
-\end{lstlisting}
-
-\subsubsection{Procédure : une fonction sans type de retour}
-En C, une \textbf{procédure} est une sorte de fonction qui ne retourne aucune valeur (par exemple la fonction \lstinline!printf! fait quelque chose, mais elle ne retourne aucune valeur.). Dans la déclaration de la fonction cela se traduit en disant que le type de retour est \lstinline!void!.
-
-L'instruction \lstinline!return! (sans paramètres) peut également être utilisée dans une procédure pour mettre fin à l'exécution de celle-ci.
-
-\begin{exemple}[Procédure]
-\begin{lstlisting}
-void maProcedure(int i, float f)
-{
- if(i<0) {
- return; //on sort de la fonction
- }
- printf("%d , %f\n", i,f);
-}
-\end{lstlisting}
-\end{exemple}
-
-\subsubsection{Le cartouche}
-Un cartouche correspond à la documentation d'une fonction pour des utilisateurs de celle-ci. Il doit être~:
-\begin{itemize}
-\item précis
-\item exhaustif
-\item concis
-\end{itemize}
-
-Il est très important de faire l'effort de mettre un cartouche sur \textbf{toutes} vos fonctions. C'est un effort qui paye à long terme (pour la qualité du code et également pour la formation des programmeurs débutants). Rédiger un cartouche est une étape difficile, mais cela vous amènera à vous poser tout un tas de bonnes questions sur votre implémentation (avez vous bien pensez à tous les cas possibles, quels valeurs de paramètres faut-il interdire, ...). Pour vous aider à la rédaction, \textit{mettez vous à la place d'un programmeur qui veut utiliser votre fonction}, mais sans lire le code. Vous devez alors savoir
-comment utiliser la fonction et savoir exactement ce qu'elle fait !
-
-Le format plutôt simple que je propose comporte trois champs à décrire dans un bloc de commentaire avant la fonction (format Doxygen\footnote{Doxygen est un générateur automatique de documentation à partir des annotations du code par le programmeur. \cf \href{www.doxygen.org}{www.doxygen.org} })~:
-
-\begin{itemize}
-\item \lstinline!@brief!~: vous y mettrez la description détaillée\footnote{Pour Doxygen, le champs \lstinline!@brief! correspond à la description \textit{courte}, mais peu importe ici ... ce n'est pas le but premier de ce cours !} de ce que fait la fonction, avec également la description des limitations (cas qui ne sont pas pris en compte, ...) et des traitements particuliers.
-\item \lstinline!@param!~: description d'un paramètre de fonction (quels sont les contraintes pré-supposées dans l'implémentation de la fonction ...)
-\item \lstinline!@return!~: description de la valeur retournée (en fonction des entrées)
-\end{itemize}
-
-\subsection{Utilisation d'une fonction}
-\subsubsection{Appel de fonction}
-Tout l'intérêt d'avoir déclaré une fonction, c'est de l'utiliser dans un programme de niveau de décomposition supérieur. Dans une fonction on peut \textbf{faire appel} à d'autres fonctions en passant des valeurs qui servent d'arguments à la fonction.
-
-\begin{remarque}
-Lorsque je désigne ce qu'il y a entre parenthèses pour une fonction, je parle d'``arguments'' (\textit{arguments effectifs}) pour l'utilisation d'une fonction, alors que je parle de ``paramètres'' lorsqu'il s'agit des variables décrites dans le profil d'une fonction (\textit{arguments formels}).
-\end{remarque}
-
-\begin{exemple}
-Dans l'exemple suivant, les arguments de la fonction somme sont 12 et 23, et le résultat de la fonction somme est affecté à la variable \lstinline!d!.
-\begin{lstlisting}
-int d;
-d=somme(12, 23);
-printf("%d",d);
-\end{lstlisting}
-
-Lors de cet appel de la fonction somme, voilà ce qui se passe en interne dans la fonction~:
-\begin{itemize}
-\item le paramètre \lstinline!a! prend la valeur 12 (\cf Exemple \ref{ex:fonction_somme})
-\item le paramètre \lstinline!a! prend la valeur 23
-\item les instructions de la fonction sont ensuite réalisées (\lstinline!printf! et addition dans la variable \lstinline!s!)
-\item au \lstinline!return!, c'est la fin de la fonction
-\end{itemize}
-
-Le résultat de ce programme sera l'affichage suivant~:
-\begin{verbatim}
-35
-\end{verbatim}
-\end{exemple}
-
-À la place des valeurs 12 et 23, on peut avoir envie de mettre directement des variables comme argument de la fonction~:
-
-\begin{lstlisting}
-int d, x=12, y=23;
-d=somme(x, y);
-printf("%d",d);
-\end{lstlisting}
-Le résultat de ce programme est strictement le même que précédemment. Pour bien comprendre cela, il faut comprendre comment les arguments sont transmis à la fonction.
-
-\subsubsection{Transmission des arguments ``par valeurs''}
-En C, la transmission d'un argument à une fonction a toujours lieu \textbf{par valeur}. Ceci signifie que \textbf{lors d'un appel de fonction par un programme, les valeurs des arguments sont recopiés dans les emplacements mémoire des paramètres de la fonction}.
-
-De même, pour le retour de la fonction, c'est \textit{une valeur} qui est retournée et qui peut être affectée à une variable (du type correspondant au type de retour de la fonction).
-
-Pour bien comprendre ce qui se passe, il faut \textit{imaginer} qu'il y a une étape, avant de rentrer dans la fonction appelée, qui consiste à remplacer le contenu des arguments de la fonction appelée par la \textit{valeur} de ces arguments de sorte qu'on se retrouve dans le cas de l'exemple précédent (\lstinline!d=somme(12, 23)!). Sur l'exemple de programme \ref{ex:passageparam}, on peut imaginer les étapes suivantes lors de l'appel de la fonction à la ligne 9~:
-
-\begin{figure}[ht]
-\includegraphics[width=.8\textwidth]{\Figures/Decomposition_fig1}
-\caption{Illustration du passage de paramètres par valeurs et du retour de la fonction (appel de fonction~: \lstinline!f=division(j,i+j)! avec \lstinline!i=3! et \lstinline!j=34!)}
-\end{figure}
-
-\begin{exemple} [Illustration des passages de paramètres] \label{ex:passageparam}
-\begin{lstlisting}
-#include <stdio.h>
-float division(int a, int b) {
- return (float)a/(float)b;
-}
-
-void main() {
- int i=3, j=34;
- float f;
- f=division(j, i+j);
- printf("result: %f\n",f);
-}
-\end{lstlisting}
-\end{exemple}
-
-La conséquence du passage par valeur est la suivante~: \textbf{une fonction ne peut pas modifier la }\textbf{valeur d'un argument}. L'argument n'est pas visible à l'intérieur de la fonction. Toute modification de la valeur d'un paramètre d'une fonction ne sera effectuée que sur la copie, et n'aura aucune incidence sur la valeur de l'argument effectif.
-
-
-\begin{exemple}
-Dans l'exemple ci-dessous, la fonction n'a aucun effet et l'affichage sera~: \lstinline!n=2 p=5!
-\begin{lstlisting}
-#include <stdio.h>
-void Echange(int a, int b)
-{
- int temp;
- temp = a; a = b; b = temp;
-}
-
-int main(void)
-{
- int n=2, p=5;
- Echange(n, p);
- printf("\n=%d \t p=%d \n",n,p);
- return 0;
-}
-\end{lstlisting}
-\end{exemple}
-
-\begin{exercice}[Définition d'une fonction]
-Pour chacune des questions suivantes, il est demandé d'écrire la fonction et d'écrire une fonction \lstinline!main()! qui fera appel à cette fonction.
-\question{Écrire une fonction qui calcule l'IMC à partir du poids et de la taille d'une personne~:}
-$$\mathit{IMC}=\frac{\mathit{poids}}{\mathit{taille}^{2}}$$
-\question{Écrire une fonction qui calcule la longueur $L$ d'un câble entre deux pylônes, grâce à la formule~:}
-$$L=a\left(1+\frac{2}{3}\left(\frac{2f}{a}\right)^{2}\right)$$
-o\`u a est la distance entre les pylônes et \lstinline!f! la flèche mesurée perpendiculairement au milieu du câble. Ces deux paramètres seront passés en paramètres de la fonction.
-\question{Dans le même esprit, écrire une fonction qui calcule le capital $A$ produit par $x$ euros, placés au taux $r$ au bout de $n$ années, avec~:}
-$$A=x\left(1+r\right)^{n}$$
-\end{exercice}
-
-\begin{exercice}[Appel de fonction]
-\question{Saisie utilisateur} Modifier le \lstinline!main()! de la fonction pour faire en sorte que la valeur d'une des fonctions (au choix) soit saisie par l'utilisateur et que le programme affiche le résultat.
-
-\question{Choix de la fonction à utiliser}
-En réutilisant les fonctions de l'exercice précédent, écrire un programme qui demande si l'utilisateur veut calculer son IMC, la longueur de son fil à linge ou son capital financier. Ensuite, il sera proposé à un utilisateur de donner les valeurs nécessaire au calcul pour finalement afficher le résultat
-\end{exercice}
-
-\subsection{Visibilité et durée de vie des variables}
-\subsubsection{Visibilité des variables dans un bloc d'instructions}
-\begin{definition}[Visibilité/Portée] La \textbf{visibilité} (ou la \textbf{portée}) d'une variable déclarée désigne les endroits du programme o\`u cette variable peut être utilisée.
-\end{definition}
-
-On voit dans l'exemple \ref{ex:visibilite} que les variables \lstinline!i!, \lstinline!r! et \lstinline!d! ont été définies et utilisées à plusieurs endroits. Dans le principe, c'est tout à fait possible. Le problème est alors de
-savoir si, lors de leur invocation, les variables sont bien définies, et de savoir de quelle ``version'' il s'agit.
-
-Pour cela, il y a un ensemble de règles qui régissent la visibilité des variables. Ces règles sont bâties sur la notion de bloc d'instructions. On retrouve cette notion de bloc pour les fonctions et les structures de contrôles.
-
-\begin{definition}[Bloc d'instructions] Un \textbf{bloc d'instructions} est un ensemble d'instructions délimitées par des accolades (une ouvrante et une fermante).
-\end{definition}
-
-Et maintenant, voici les règles en question~:
-\begin{itemize}
-\item Une variable est définie dans un bloc \textit{après sa déclaration},
-\item Elle est visible dans le bloc et tout les sous-blocs succédant la déclaration mais pas dans son sur-bloc,
-\item Une variable peut être redéfinie dans un sous-bloc mais pas dans un même bloc,
-\item La variable redéfinie dans un sous-bloc \textit{masque} l'autre variable dans tous les sous-blocs (règle de proximité supérieure).
-\end{itemize}
-
-\begin{exemple}[Visibilité des variables ]\label{ex:visibilite}
-\begin{lstlisting}
-#include <stdio.h>
-int i=4;
-
-int fonction(int d)
-{
- int r=4;
- printf("dans la fonction %d %d\n", d, r);
-}
-
-int main(void)
-{
- fonction(i);
- printf("avant dcl %d\n", i);
- int i=3;
- fonction(i);
- {
- int i=2;
- printf("dans le sous-bloc du main %d\n", i);
- }
- printf("dans le main: %d %d\n", i, r);
- return 0;
-}
-\end{lstlisting}
-
-Tout d'abord, il y aura une erreur à la ligne 20 puisque \lstinline!r! n'est pas défini à cet endroit. Sinon, le résultat de l'exécution de ce programme sera l'affichage suivant~:
-\begin{verbatim}
-dans la fonction 4 4
-avant dcl 4
-dans la fonction 3 4
-dans le sous-bloc du main 2
-dans le main 3
-\end{verbatim}
-\end{exemple}
-
-\begin{definition}[Variable globale] Une variable globale est une variable définie pour tout le programme. Elle est déclarée en dehors de toute fonction et est accessible depuis toutes les fonctions.
-\end{definition}
-
-La ligne 2 du code ci-dessus illustre la déclaration de la variable \lstinline!i! comme variable globale.
-
-\subsubsection{Durée de vie d'une variable}
-La visibilité des variables à des conséquences sur l'utilisation de la mémoire par le programme. Ce qu'il faut retenir en simplifiant les choses c'est que \textbf{les variables qui ne sont pas visibles sont supprimées de la mémoire} (leur emplacement mémoire est rendu disponible pour une autre variable).
-
-Les variables globales sont toujours statiques, c'est-à-dire permanentes~: elles existent pendant toute la durée de l'exécution.
-Le système d'exploitation se charge, immédiatement avant l'activation du programme, de les allouer dans un espace mémoire de taille adéquate, éventuellement garni de valeurs initiales.
-
-À l'opposé, les variables locales et les arguments des fonctions sont ``automatiques''~: l'espace correspondant est alloué lors de l'activation de la fonction ou du bloc d'instructions en question et il est rendu au système lorsque le
-contrôle quitte cette fonction ou ce bloc.
-
-\begin{exercice}[Jouons avec la visibilité des variables (\hard)]
-\question{Écrire une fonction qui se contente de comptabiliser le nombre de fois o\`u elle a été appelée en affichant seulement un message ``de temps en temps'', à savoir~:}
-\begin{itemize}
-\item au premier appel~: *** appel 1 fois ***
-\item au dixième appel~: *** appel 10 fois ***
-\item au vingtième appel~: *** appel 20 fois ***
-\end{itemize}
-et ainsi de suite ...
-
-C'est dans la fonction qu'il faut compter le nombre de fois o\`u elle est appelée ! Sinon, c'est triché ! On supposera que le nombre maximal d'appels ne peut dépasser la capacité d'un \lstinline!long!.
-
-\question{Écrire le programme qui teste la fonction}
-
-Aide~: Il faut une variable qui soit capable de se souvenir, en dehors de la fonction, le nombre de fois où le programme est passé dans la fonction.
-
-\begin{Solution}
-Solution aux deux questions :
-
-\begin{lstlisting}
-int nbappel; ///Déclaration d'une variable globale
-
-void mafonction() {
- nbappel++;
- printf("*** appel %d fois ***\n", nbappel);
-}
-
-void main() {
- nbappel = 0; //Initialisation de la variable globale !
- for(int i=2; i<14; i++) {
- mafonction();
- }
-}
-\end{lstlisting}
-
-Deux remarques supplémentaires pour la correction :
-\begin{itemize}
- \item Attention de ne pas oublier d'initialiser les variables globales au début du programme. Ceci étant une instruction, elle doit être réalisée dans une fonction. La place qui lui convient donc est au début du main.
- \item On parle ici d'\textbf{effet de bord}: la fonction \lstinline!mafonction! a un effet de bord sur la variable \lstinline!nbappel!. L'appel de cette fonction modifie une variable qui n'est pas directement dans son contexte.
-\end{itemize}
-
-
-\end{Solution}
-
-\end{exercice}
-
-\subsection{Séparer la déclaration de l'implémentation}\label{sec:sep_decl_impl}
-Il est parfois nécessaire de séparer la déclaration de la fonction (c'est-à-dire annoncer au compilateur d'une fonction existe en donnant son profil complet) et son implémentation (c'est-à-dire décrire au compilateur ce qui compose cette fonction).
-
-\begin{exemple} [Dépendances circulaires entre fonctions]
-Dans l'exemple ci-dessous, la fonction \lstinline!A()! fait appel à \lstinline!B()! et la fonction \lstinline!B()! fait appel à \lstinline!A()!, si bien que le programmeur ne saurait quelle fonction déclarer en premier (\lstinline!A! ou \lstinline!B! ??) de sorte que le compilateur, qui lit linéairement le fichier, le comprenne. Si \lstinline!A! était
-déclaré avant \lstinline!B!, alors \lstinline!B! ne serait pas connus au moment de son invocation, et réciproquement.
-
-La solution ci-dessous indique au début du fichier qu'une fonction \lstinline!A! existe (et donc que le compilo peut l'utiliser) et ensuite \lstinline!B! peut être déclaré en utilisant un appel à la fonction \lstinline!A!. Ensuite, à la fin du fichier, on finit par décrire la fonction \lstinline!A!. Du fait que les profils soient les mêmes, le compilateur va faire la correspondance entre la ligne 1 et la ligne 14.
-
-\begin{lstlisting}
-float A(int a, int b); //Declaration de la fonction
-void B() {
- ...
- textbf{A(x,y);}
- ...
-}
-
-void main() {
- B();
- printf("Ok\n");
-}
-
-//Definition de la fonction A !!
-float A(int a, int b) {
- B();
- return ...;
-}
-\end{lstlisting}
-\end{exemple}
-
-\begin{remarque}
-Le compilateur vérifie l'existence des fonctions dont on a déclaré le profil lors de l'étape d'édition de liens.
-\end{remarque}
-
-\subsection{Exercices}
-
-\begin{exercice}[Fonction simple]
-
-Quel sera l'affichage du programme ci-dessous ?
-\begin{lstlisting}
-int mafontion(double a, double b) {
- return (int)(a-b);
-}
-
-int main() {
- double x=2.3, y=4.7;
- int r=1;
-
- r=mafontion(x,y);
- printf("%d\n", r);
-}
-\end{lstlisting}
-
-
-\begin{Solution}
- Le programme affiche \texttt{-2}. Dans la fonction, la différence entre $a$ et $b$ donne $2,3-4,7=-2,4$. Le transtypage du \lstinline!double! en \lstinline!int! réalise une troncature, d'où le résultat.
-\end{Solution}
-\end{exercice}
-
-\begin{exercice}[Passage de paramètres]
-
-Quel sera l'affichage de ce programme ?
-
-{\it \underline{Aide :} rappelez vous des mécanismes de passage de paramètres à une fonction en C.}
-
-\begin{lstlisting}
-int mafonction(int a) {
- printf("a:%d, ", a);
- a=1;
- return a;
-}
-
-int main() {
- int x=0, y=0;
- y = mafonction(x);
- printf("x:%d, y:%d\n", x, y);
- return 0;
-}
-\end{lstlisting}
-\begin{Solution}
- Le programme affiche \texttt{a:0, x:0, y:0}.
-\end{Solution}
-\end{exercice}
-
-\begin{exercice}[Effet du \texttt{return} dans une fonction]
-
-Indiquer ce que le programme ci-dessous affichera ?
-
-\begin{lstlisting}
-int mafonction(int a) {
- int i;
- for(i=0; i<100; i++) {
- if( i>a ) {
- return 0;
- }
- printf("%d\n", i);
- }
- return 1;
-}
-
-int main() {
- int ret=mafonction(5);
- printf("%d\n",ret);
- int ret=mafonction(105);
- printf("%d\n",ret);
- return 0;
-}
-\end{lstlisting}
-\begin{Solution}
- Le programme affiche :
-\begin{verbatim}
-1
-2
-3
-4
-5
-0
-1
-2
-3
-(...)
-98
-99
-1
-\end{verbatim}
-\end{Solution}
-\end{exercice}
-
-\section{Récursivité}
-\begin{definition} [Fonction récursive]
-Une \textbf{fonction récursive} est une fonction qui s'appelle elle-même soit directement, soit indirectement.
-\end{definition}
-
-\subsection{Récursivité simple}
-
-\begin{exemple}
-Prenons un exemple de calcul d'une factorielle. Pour rappel, la factorielle de $n$ (notée $n!$) correspond à la formule suivante~:
-\begin{equation*}
-n!=\mathit{n.}(n-1).(n-2)...3.2.1
-\end{equation*}
-
-Récursivement, la factorielle peut s'écrire très simplement ainsi~:
-\begin{equation*}
-n!=\left\{\begin{matrix}1&\mathit{si}\;n=1\\\mathit{n.}(n-1)!&\mathit{sinon}\end{matrix}\right.
-\end{equation*}
-
-La fonction correspondante peut alors s'écrire ainsi~:
-\begin{lstlisting}
-#include <stdio.h>
-int Factorielle(int n) {
- int Fact;
- if(n>1) {
- Fact = n * Factorielle(n-1);
- } else {
- Fact=1;
- }
- return Fact;
-}
-
-int main(void) {
- int n, fn;
- printf("Donnez un entier positif: ");
- scanf("%d",\&n);
- fn = Factorielle(n);
- printf("La factorielle de %d est %d\n",n,fn);
- return 0;
-}
-\end{lstlisting}
-\end{exemple}
-
-\begin{definition} [Cas d'arrêt]
-Dans une fonction récursive, il doit exister une condition pour laquelle on arrête la récursion (sinon la récursion serait infinie). Cette condition définit le \textbf{cas terminal} ou \textbf{cas d'arrêt}.
-\end{definition}
-
-Dans l'exemple, le cas $n=1$ est appelé le \textbf{cas terminal}.
-
-Le tableau suivant représente la séquences des appels de fonctions lorsque l'utilisateur a rentré le chiffre 4~:
-
-\begin{center}
-\small
-\tablefirsthead{}
-\tablehead{}
-\tabletail{}
-\tablelasttail{}
-\begin{supertabular}{|m{2.816cm}|m{2.843cm}|m{1.282cm}|m{1.8899999cm}|m{1.668cm}|}
-\hline
-\bfseries Fonction & \centering \bfseries Ligne de code & \centering \bfseries n & \centering \bfseries Fact & \bfseries fn\\\hline
-main & \centering 17 (avant affectation) & \centering 4 & & ???\\\hline
-Factorielle(4) & \centering 5 & \centering 4 & \centering ??? & \\\hline
-Factorielle(4) & \centering 6 (avant affectation) & \centering 4 & \centering ??? & \\\hline
-Factorielle(3) & \centering 5 & \centering 3 & \centering ??? & \\\hline
-Factorielle(3) & \centering 6 (avant affectation) & \centering 3 & \centering ??? & \\\hline
-Factorielle(2) & \centering 5 & \centering 2 & \centering ??? & \\\hline
-Factorielle(2) & \centering 6 (avant affectation) & \centering 2 & \centering ??? & \\\hline
-Factorielle(1) & \centering 5 & \centering 1 & \centering ??? & \\\hline
-Factorielle(1) & \centering 8 & \centering 1 & \centering 1 & \\\hline
-Factorielle(1) & \centering 9 & \centering 1 & \centering 1 & \\\hline
-Factorielle(2) & \centering 6 (après affectation) & \centering 2 & \centering 2 & \\\hline
-Factorielle(2) & \centering 9 & \centering 2 & \centering 2 & \\\hline
-Factorielle(3) & \centering 6 (après affectation) & \centering 3 & \centering 6 & \\\hline
-Factorielle(3) & \centering 9 & \centering 3 & \centering 6 & \\\hline
-Factorielle(4) & \centering 6 (après affectation) & \centering 4 & \centering 24 & \\\hline
-Factorielle(4) & \centering 9 & \centering 4 & \centering 24 & \\\hline
-main & \centering 17 (après affectation) & \centering 4 & & 24\\\hline
-\end{supertabular}
-\end{center}
-
-Prenons un second exemple avec la fonction puissance $r:x\rightarrow x^{n}$. Cette fonction peut être définie récursivement~:
-\begin{equation*}
-x^{n-1}:\left\{\begin{matrix}1&\mathit{si}\;n=0\\\mathit{x.x}^{n-1}&\mathit{sinon}\end{matrix}\right.
-\end{equation*}
-
-La fonction correspondant s'écrit ainsi\footnote{J'utilise ici une notation très condensée. Ceci rend parfois le C assez illisible pour les novices, mais c'est très pratique, car rapide à écrire !}~:
-
-\begin{lstlisting}
-double xn(double x, int n)
-{
- if(n==1) return 1;
- else return x * xn(x, n-1);
-}
-\end{lstlisting}
-
-\subsection{Autres formes de récursivité}
-
-\subsubsection{Récursivité multiple}
-Une définition récursive peut contenir plus d'un appel récursif. Nous voulons calculer ici les combinaisons $C_{n}^{p}$ en se servant de la relation de Pascal~:
-\begin{equation*}
-C_{n}^{p}=\left\{\begin{matrix}1&\mathit{si}\;p=0\;\mathit{ou}\;p=n,\\C_{n-1}^{p}+C_{n-1}^{p-1}&\mathit{sinon.}\end{matrix}\right.
-\end{equation*}
-
-
-La fonction s'écrit alors ainsi~:
-\begin{lstlisting}
-int combinaison(int n, int p)
-{
- if( p==0 || p==n ) {
- return 1;
- } else {
- return combinaison(n-1, p) + combinaison(n-1, p-1);
- }
-}
-\end{lstlisting}
-
-Les appels récursifs des fonctions devient alors assez complexe. Ici, tout ce passe bien parce qu'on sait qu'on ne tombera jamais deux fois sur le même calcul de combinaison, mais parfois ce peut être le cas. Auquel cas, les mêmes calculs sont répétés plusieurs fois.
-
-\subsubsection{Récursivité mutuelle}
-Des définitions sont dites mutuellement récursives si elles dépendent les unes des autres. \c{C}a peut être le cas pour la définition de la parité~:
-
-$$pair(n)=\left\{\begin{matrix}\text{vrai}&\text{si}\;n=0\\
-impair(n-1)&\text{ sinon}\end{matrix}\right.$$
-et
-$$impair(n)=\left\{\begin{matrix}\text{vrai}&\text{si}\;n=1\\
-pair(n-1)&\text{ sinon}\end{matrix}\right.$$
-
-Les fonctions vont alors de soit ...
-
-\begin{exercice}[Qui pair gagne ...]
-Écrire en C les fonctions qui permettent de déterminer récursivement si un nombre est pair ou impair.
-
-\begin{Solution}
-
-Voici la solution. Les deux fonctions étant croisées, il est nécessaire d'en déclarer une avant de l'implémenter.
-
-\begin{lstlisting}
-int impair(int n); //declaration de la fonction impair en attendant sa definition
-
-int pair(int n) {
- if( n==0 ) {
- return 1;
- } else {
- return impair(n-1);
- }
-}
-
-int impair(int n) {
- if( n==1 ) {
- return 1;
- } else {
- return pair(n-1);
- }
-}
-\end{lstlisting}
-\end{Solution}
-
-
-\end{exercice}
-
-\subsubsection{Récursivité imbriquée}
-La fonction d'\textit{Akermann} est définie comme suit~:
-
-\begin{equation*}
-A(m,n)=\left\{\begin{matrix}n+1&\mathit{si}\;m=0\\A(m-1,1)&\mathit{si}\;m>0\;\mathit{et}\;n=0\\A(m-1,A(m,n-1))&\mathit{sinon}\end{matrix}\right.
-\end{equation*}
-
-Dans ce cas, selon les mêmes principes de traduction que précédemment, on peut définir une fonction avec une récursion
-imbriquée ... c'est presque sans intérêt ! Mais ça a le mérite de montrer que la récursion peut se définir à toutes les sauces et que \c{c}a fonctionne très bien en informatique !
-
-\subsection{Principes et dangers de la récursivité}
-\underline{Principe et intérêt~:} ce sont les mêmes que ceux de la démonstration par récurrence en mathématiques. On doit avoir~:
-\begin{itemize}
-\item un certain nombre de cas dont la résolution est connue, ces ``cas simples'' formeront les cas d'arrêt de la récursion ;
-\item un moyen de se ramener d'un cas ``compliqué'' à un cas ``plus simple''.
-\end{itemize}
-
-
-La récursivité permet d'écrire des algorithmes concis et élégants. Il faut noter que tout programme itératif peut être traduit sous une forme récursive.
-
-\underline{Difficultés~:}
-\begin{itemize}
-\item la définition peut être dénuée de sens
-\item il faut être s\^ur que l'on retombera toujours sur un cas connu, c'est-à-dire sur un cas d'arrêt; il nous faut nous assurer que la fonction est complètement définie, c'est-à-dire, qu'elle est définie sur tout son domaine d'applications.
-\end{itemize}
-
-Moyen~: existence d'un ordre strict tel que la suite des valeurs successives des arguments invoqués par la définition soit strictement monotone et finit toujours par atteindre une valeur pour laquelle la solution est explicitement définie.
-
-L'algorithme ci-dessous teste si $a$ est un diviseur de $b$.
-
-\begin{lstlisting}
-int diviseur(int a, int b)
-{
- if(a<=0) {
- return -1; //erreur
- } else {
- if( a>=b ) return a==b;
- else return diviseur(a, b-a);
- }
-}
-\end{lstlisting}
-
-La suite des valeurs $b$, $b-a$, $b-2a$, ... est strictement décroissante, car $a$ est strictement positif, et on finit toujours par aboutir à un couple d'arguments $(a,b)$ tel que $b-a$ soit négatif, car défini explicitement (cas d'arrêt). Cette méthode ne permet pas de traiter tous les cas~:
-\begin{lstlisting}
-int syracuse(int n)
-{
- if( n==0 || n==1 )
- return 1
- else {
- if( (n%2) == 0) {
- syracuse(n/2);
- } else {
- syracuse(3*n+1);
- }
- }
-}
-\end{lstlisting}
-
-\begin{remarque}
-Le résultat de cette fonction est toujours 1 pour tous les entiers (problème ouvert...)
-\end{remarque}
-
-\subsection{Non-décidabilité de la terminaison}
-Cette section commence à être un peu plus poussée en terme d'algorithmique, puisqu'on se demande ici si il existe des moyens de déterminer automatiquement si un programme donné termine quand il est exécuté sur un jeu de données.
-
-Et bien, la réponse est ... NON !
-
-Qu'est ce que ça veut dire ?? \c{C}a veut dire que vous ne pouvez pas démontrer (pour tous les algorithmes) si le programme s'arrête ou pas~: vous ne pouvez pas montrer qu'il va s'arrêter, mais vous ne pouvez pas non plus démonter qu'il va tourner à l'infini ! Vous n'en saurez rien ... c'est indécidable\footnote{Notez que la classe des problèmes indécidables est ``majoritaire'' dans l'ensemble des problèmes ``informatisables'' !} !
-
-La démonstration de ce résultat étonnant, est une démonstration par l'absurde utilisant un raisonnement dit diagonal (proposé par God\"el).
-
-Supposons que la terminaison soit décidable, alors il existe un programme, nommé \texttt{termine}, qui vérifie la terminaison d'un programme, sur des données.
-
-À partir de ce programme on con\c{c}oit le programme Q suivant (en pseudo-code)~:
-\begin{verbatim}
-bool Q()
-{
- resultat = termine(Q, {})
- while( résultat==vrai ) {
- attendre 1 seconde
- }
- return(resultat);
-}
-\end{verbatim}
-
-Supposons que le programme \texttt{Q}, qui ne prend pas d'arguments, termine. Donc \texttt{termine(Q, \{\})} renvoie vrai, la deuxième instruction de \texttt{Q} boucle indéfiniment et \texttt{Q} ne termine pas. Il y a donc contradiction et le programme \texttt{Q} ne termine pas.
-
-Donc, \texttt{termine(Q, \{\})} renvoie faux, la deuxième instruction de \texttt{Q} ne boucle pas, et le programme \texttt{Q} termine normalement. Il y a une nouvelle contradiction~: par conséquent, il n'existe pas de programme tel que termine, et donc le problème de la terminaison n'est pas décidable.
-
-\subsection{Exercices}
-
-
-\begin{exercice}[Nombre d'or]
-
-Pour $v_1=2$, la suite récurrence suivante converge vers le nombre d'or~: $$v_n=1+\frac{1}{v_{n-1}}.$$
-
-Pour rappel, le nombre d'or vaut $\Phi = \frac{1+\sqrt{5}}{2}$. Il est censé être le rapport de distance ``le plus esthétique'' pour un cadre rectangulaire (en autres rapport de distances) ...
-
-Construire une fonction qui calcule récursivement les valeurs successives de la suite et qui s'arrête lorsque la distance entre deux valeurs successives est inférieure à $\epsilon$ ($|v_{n+1}-v_n|<\epsilon$).
-
-\begin{Solution}
- On déduit directement de la relation de récursion établies dans l'énoncé la fonction suivante :
-
-\begin{lstlisting}
-double nbor(int n) {
- if(n==1) {
- return 2.0;
- } else {
- return 1+1/nbor(n-1);
- }
-}
-\end{lstlisting}
-\end{Solution}
-\end{exercice}
-
-\begin{exercice}[Suite de Fibonacci]
-Possédant au départ un couple de lapins, combien de couples de lapins obtient-on en douze mois si chaque couple engendre tous les mois un nouveau couple à compter du second mois de son existence ?
-
-La suite de Fibonacci répond à cette question :
-$$
-\begin{array}{l}
- u_0 = u_1 = 1\\
-\forall n \in \mathbb{N}, u_{n+2} = u_{n} + u_{n+1}
-\end{array}
-$$
-
-Écrire une fonction récursive en C qui calcule la suite de Fibonacci jusqu'à rang $k$ et qui enregistre les valeurs de $(u_n)_{ n \in [0,k]}$ dans un fichier pour être affiché avec \texttt{gnuplot}.
-
-\begin{Solution}
-Pour obtenir la solution, il faut renverser la formule de récursion et en déduire le code ci-dessous :
-\begin{lstlisting}
-uint fibonacci(uint m)
-{
- if (m <= 1)
- return 1;
- return fibonacci(m-2) + fibonacci(m-1) ;
-}
-
-void main() {
- uint val=30;
- uint f = fibonacci(val);
- printf("fibo(%d)=%d\n", val, f);
-}
-\end{lstlisting}
-
-
-Voici une version non-récursive du calcul (c'est à dire iteratif!) de la suite de fibonnacci :
-
-\begin{lstlisting}
-int fibonacci(int n) {
- int a = 0;
- int b = 1;
- int sum;
- int i;
-
- for (i=0;i<n;i++) {
- printf("%d\n",a);
- sum = a + b;
- a = b;
- b = sum;
- }
- return b;
-}
-\end{lstlisting}
-\end{Solution}
-\end{exercice}
-
-\section{Travailler avec plusieurs fichiers \texttt{.h} et \texttt{.c}}
-Revenons dans un peu plus de cambouis du langage C ... après avoir réfléchis, \c{c}a va détendre !
-
-\subsection{Séparer les déclarations des fonctions de leurs implémentations}
-La déclaration et l'implémentation des fonctions peuvent être séparées dans deux types de fichiers~:
-\begin{itemize}
-\item fichiers \textbf{.h}~: il contient uniquement les profils des fonctions (les entêtes ou \textit{headers}), c'est-à-dire la déclaration d'une fonction.
-\item fichiers \textbf{.c}~: il contient les corps des fonctions, c'est-à-dire leurs implémentations.
-\end{itemize}
-
-La primitive du préprocesseur \lstinline!#include! permet d'inclure des fichiers \texttt{.h} dans un fichier \texttt{.c}. Tout ce passe alors comme le cas de la déclaration préalable d'un profil de fonction (\cf section \ref{sec:sep_decl_impl})~: les fonctions peuvent être utilisées, et le compilateur fera le lien entre la déclaration et l'implémentation uniquement lors de l'édition de liens.
-
-\begin{exemple}[Séparation des fichiers]
-\texttt{fonctions.h}~:
-\begin{lstlisting}
-#ifndef FONCTIONS_H
-#define FONCTIONS_H
-
-int somme(int a, int b);
-int soustraction(int a, int b);
-
-#endif
-\end{lstlisting}
-
-\texttt{main.c}~:
-\begin{lstlisting}
-#include "fonctions.h"
-#include <stdio.h>
-void main() {
- int a;
- int b;
- int sum = somme(a,b);
- int sub = soustraction(b,a);
- printf("%d %d\n", sum, sub);
-}
-\end{lstlisting}
-
-\texttt{fonctions.c}~:
-\begin{lstlisting}
-#include "fonction.h"
-int somme(int a, int b) {
- return a+b;
-}
-
-int soustraction(int a, int b) {
- return a-b;
-}
-\end{lstlisting}
-\end{exemple}
-
-
-% \begin{figure}[ht]
-% \centering
-% \includegraphics{\Figures/Decomposition_fig2}
-% % Decomposition_fig2.eps: 0x0 pixel, 300dpi, 0.00x0.00 cm, bb=0 0 230 225
-% \caption{Compilation séparée}
-% \label{fig:DecompositionFig2}
-% \end{figure}
-
-
-\begin{remarque}
-Consulter le chapitre sur la compilation pour savoir comment utiliser la compilation séparée avec \texttt{gcc}, et des outils de compilations tels que \texttt{make} pour vous aider à enchaîner correctement les compilations.
-\end{remarque}
-
-\subsection{Programmation modulaire}
-Maintenant que vous êtes capables de regrouper des fonctions dans des fichiers, il est intéressant de les regrouper intelligemment. Ce qui est intéressant, c'est de prévoir des regroupements qui vont permettre une réutilisation des fichiers dans d'autres développements.
-
-Ces regroupements portent le nom de ``module'' ... d'o\`u le nom de programmation modulaire !
-
-Pour chaque module, il y a~:
-\begin{itemize}
-\item des objets globaux (constantes et définitions de types) et des interfaces de fonctions dans un fichier d'en tête (\texttt{.h}) ;
-\item des objets locaux (variables) et des implémentations de fonctions dans un fichier source (\texttt{.c}) ou mieux dans un fichier compilé (\texttt{.o}).
-\end{itemize}
-
-
-Si vous fournissez uniquement le fichier \texttt{fonctions.h} et le fichier \texttt{fonctions.o}, alors vous permettez aux autres programmeurs d'utiliser votre module tout en conservant le secret sur l'implémentation des fonctions que vous proposez. C'est exactement ce que permettent les librairies usuelles (\eg \texttt{libXML} qui offre des fonctions pour manipuler des fichiers \texttt{xml}) puisque vous disposez des fichiers d'entêtes (\eg \texttt{SAX.h}, \texttt{xmlIO.h}, ...) et des librairies qui sont compilées comme des librairies partagées avec des extensions \texttt{.so} (\eg \texttt{libxml2.so}).
-
-Notez que pour les librairies standard, c'est un peu différent puisqu'elle font maintenant quasiment partie intégrante du C.
-
-On comprend alors maintenant mieux l'importance de bien documenter les fonctions qui ont été écrites. Car dans le cas de modules, on n'a pas l'implémentation pour comprendre ce qui se fait dans une fonction.
-
-
-\section{Correction des exercices}
-\Closesolutionfile{solutions}
-\Readsolutionfile{solutions}
\ No newline at end of file
diff --git a/Polyc/Environnement.tex~ b/Polyc/Environnement.tex~
deleted file mode 100644
index 967537a7cdd80532a893a1cea287d7e32f4a62db..0000000000000000000000000000000000000000
--- a/Polyc/Environnement.tex~
+++ /dev/null
@@ -1,738 +0,0 @@
-\chapter{Environnement de programmation} \label{chp:environnement}
-
-L'environnement de programmation désigne l'ensemble des outils qui sont à disposition pour permettre à un développeur de mener à bien sa tâche. Je distingue quatre types d'outils~:
-\begin{itemize}
- \item le compilateur~: c'est-à-dire l'outil fournit par le système d'exploitation pour compiler vos programmes C en programmes exécutables sur votre ordinateur (\cf chapitre \ref{chp:Compilation}),
- \item les éditeurs~: c'est-à-dire les outils dans lesquels écrire vos programmes en C. Il est existe des très basiques jusqu'à des très avancés (appelé IDE pour \textit{Interactive Development Environment}),
- \item les outils de débuggage/profilage~: c'est-à-dire des outils qui vont vous permettre d'analyser votre code soit pour le corriger soit pour l'améliorer,
- \item les outils annexes~: ceux qui n'ont pas de lien direct avec la programmation mais qui peuvent être utiles ...
-\end{itemize}
-
-Il se trouve que le langage C est le langage utilisé pour le développement du système d'exploitation Linux. Il est par conséquent plus facile de développer dans ce langage dans cet environnement. Je commencerai donc par présenter les outils du système Linux. Ensuite, je reviens sur les environnements de programmation que vous pourrez installer sur les autres systèmes d'exploitation usuels (Windows ou Mac). N'étant pas pas familier de ces derniers, les informations seront moins fournies.
-
-\section{Programmer en environnement Linux (sans IDE)}
-
-Avant de vous aventurer dans le développement sous Linux, il est plus pratique de savoir se servir d'un terminal de commandes.
-
-\subsection{Éditeurs}\label{sec:editeur}
-
-Tout éditeur de texte peut servir à écrire un programme C puisqu'un programme ce n'est qu'un texte brut (avec un syntaxe bien particulière). Néanmoins, rien ne sert de se compliquer la vie à utiliser des éditeurs tels que \texttt{vi}\footnote{\texttt{vi} est l'éditeur de texte le plus basique que je connaisse mais vraiment trop peu intuitif pour être utilisé ...}.
-
-Les propriétés attendues d'un éditeur de texte pour la programmation sont les suivantes~:
-\begin{itemize}
- \item la \textbf{coloration syntaxique}~: INDISPENSABLE ! elle permet de mettre en valeur par des couleurs spécifiques, à la fois, les mots clés et syntaxes particulières. Certaines colorations permettent également de mettre en valeurs des erreurs de grammaire (oublis d'un \texttt{\{} par exemple). La coloration syntaxique permet au programmeur de faciliter la lecture d'un programme et souvent de repérer des erreurs de frappes etc.
- \item l'\textbf{auto-indentation}~: cette propriété permet de demander à l'éditeur d'indenter son programme. Cette fonctionnalité est pratique pour faciliter la vie des jeunes programmeurs (car rien ne vaut une bonne indentation dès la programmation). Certaines auto-identation se font à la frappe (le curseur se place à la bonne position lors d'une nouvelle ligne) et d'autres se font à posteriori.
- \item la \textbf{complétion}~: cette propriété offre la possibilité au programmeur de faire afficher toutes la variables ou fonctions disponibles qui commence par les premières lettres d'un mot déjà tapées. Cette fonctionnalité s'adresse soit aux bons programmeurs qui ont appris à se servir de cette fonctionnalité pour être plus efficaces, soit aux débutants qui s'en servent comme d'un aide mémoire.
-\end{itemize}
-
-Quelques éditeurs intéressants disponibles sur la plupart des systèmes d'exploitation Linux~:
-\begin{itemize}
- \item \texttt{scite}
- \item \texttt{gedit}
- \item \texttt{kile}
- \item \texttt{emacs} (usage un peu particulier pour un débutant)
-\end{itemize}
-
-Tous ces éditeurs sont en fait des éditeurs généralistes~: ils sont capables de colorer syntaxiquement différents langages de programmation. Ils ``savent'' quel langage utiliser à partir de l'extension du fichier que vous ouvrez.
-
-\subsection{Compilateurs \texttt{gcc}, \texttt{g++}}
-Les compilateurs sous Linux se fait au travers de la console de commande (ou terminal de commande).
-
-Vous pouvez lancer un terminal à l'aide du menu \texttt{Applications>Outils Systèmes>Terminal}. Dans la mesure où vous aurez souvent besoin des terminaux, il est intéressant de vous faire un raccourcis sur le bureau pour les lancer plus rapidement. Pour cela, glissez l'icone du menu sur le bureau. Au lancement, le répertoire courant du terminal correspond à la racine de votre espace personnel. Vous pouvez vous en rendre compte en listant le contenu de ce répertoire (commande \texttt{ls}). Vous devriez y trouver les documents accessibles sous Windows par le volume \texttt{Z:}.
-
-Pour vous déplacer dans vos répertoires, il faut utiliser la commande \texttt{cd}. Rendez-vous alors dans le répertoire où se trouve le fichier que vous voulez compiler.
-
-\subsubsection{Compilation avec \texttt{gcc}}
-La commande de compilation la plus simple pour un fichier \texttt{source.c} (sans dépendance et contenant un \lstinline!main!) est de la forme~:
-
-\begin{verbatim}
-$ gcc -o source source.c
-\end{verbatim}
-ou
-\begin{verbatim}
-$ gcc source.c -o source
-\end{verbatim}
-
-
-Cette commande va ``construire'' un nouveau fichier \texttt{source} (le nom du fichier généré par le compilateur est donné après l'argument \texttt{-o}) que vous pourrez exécuter ainsi pour tester votre programme~:
-
-
-\begin{verbatim}
-$ ./source
-\end{verbatim}
-
-\espace
-
-Pour plus d'informations sur la commande \texttt{gcc} ou \texttt{g++}, voir le chapitre \ref{chp:Compilation} sur les détails de la procédure de compilation.
-
-Le compilateur \texttt{g++} est un compilateur pour \texttt{C++}. Il permet la compilation également des programmes \texttt{C} mais parfois avec de légère différence sur l'acceptation des syntaxes.
-
-%\subsubsection{Les erreurs de compilation}
-
-%TODO
-
-\subsubsection{Automatiser la compilation avec \texttt{make}}
-Lorsque les programmes comprennent un grand nombre de fichier, l'étape de compilation est assez délicate. On ne peut pas prendre son temps à compiler tous les fichiers à chaque fois qu'une petite modification est réalisée, mais il faut néanmoins tenir compte des dépendances existantes entre les sources pour que les fichiers qui sont influencés par la modification soient recompilés.
-Bref, c'est un casse tête et tout cela peut s'automatiser avec un outil magique qui s'appelle \texttt{make}.
-
-Un \texttt{Makefile} est un fichier qui va contenir un descritif des instructions de compilation des fichiers d'un programme et des dépendances entre ces fichiers. Ainsi, en se référant aux dates de dernière modification d'un fichier source, la commande \texttt{make} qui utilise le \texttt{Makefile}, va savoir quels sont les fichiers à recompiler, et comment le faire.
-
-L'étape de création d'un \texttt{Makefile} prend quelques minutes, mais ensuite le gain de temps pour chaque compilation est considérable.
-
-\espace
-
-Les détails sur la création d'un \texttt{Makefile} sont donnés dans la section \ref{sec:Makefile} de ce poly.
-
-\subsection{Débuggage avec \texttt{gdb}}\label{sec:gdb}
-
-%\textit{la lecture de cette section reste difficile ...}
-%\espace
-
-L'une des difficultés de la programmation est que la conception du code est faite en amont de son exécution. Une fois que vous avez créer votre code, vous compilez puis lancez votre programme sans ``voir'' les détails de ce qu'il a fait.
-
-Le débuggage ou débogage est la tâche qui consiste à diagnostiquer et réparer une erreur dans un programme, un ``bug'' !
-Un bug (de l'anglais bug, ``insecte''\footnote{Pour l'histoire, il semble que ce terme est apparue à cause d'un problème survenu dans un programme à cause d'un insecte collé sur une carte perforée}) est, en informatique, un défaut de logique dans un programme informatique qui provoque un calcul ou un traitement incorrect à l'origine de dysfonctionnements et de pannes.
-
-L'erreur peut provenir d'une erreur de conception du programme ou d'une erreur dans la traduction du programme dans le langage choisi (typiquement, une erreur de frappe).
-
-Pour identifier un bug, il est plus facile de faire \textbf{exécuter le programme pas-à-pas}. C'est à dire qu'on veut pouvoir maîtriser la succession des instructions pour s'attarder sur chaque instruction de votre code. On fait exécuter une ligne de code, puis on regarde ce qu'il s'est passé, puis une autre ligne de code, etc.
-
-Il est possible de faire cela grâce à des outils de débuggage.
-
-\subsubsection{Présentation succincte de \texttt{gdb}}
-L'outil \texttt{gdb}\footnote{\texttt{gdb} est l'acronyme de Gnu DeBugger} est un programme de débuggage pour les programmes en C. Il est puissant, mais l'interface est totalement en ligne de commande, c'est-à-dire avec une invite en texte et toujours au travers du terminal de commande. Dans certains IDE, \texttt{gdb} est interfacé pour faciliter son utilisation.
-
-\espace
-
-Si votre programme fait une erreur à l'exécution et affiche un très peu explicite \texttt{segmentation fault}, vous devez trouver d'où vient l'erreur. Pour cela, il faut :
-\begin{enumerate}
- \item Recompiler votre programme avec l'option \texttt{-g},
- \item Exécuter de nouveau votre programme avec \texttt{gdb}.
-\end{enumerate}
-
- Pour obtenir des informations de trace sur votre programme \texttt{titi.c} avec le debugger, vous devez le compiler avec l'option \texttt{-g} ainsi~:
-\begin{verbatim}
-$ gcc -g titi.c -o titi
-\end{verbatim}
-
-L'utilisation de cette option \texttt{-g} va demander au compilateur d'ajouter des informations dans le code qui sont utilisées pour tracer le déroulement du programme.
-
-Vous pouvez alors utiliser le debugger de la manière suivante~:
-\begin{verbatim}
-$ gdb titi
-\end{verbatim}
-
-\texttt{gdb} charge tout ce dont il a besoin... et présente une invite \texttt{(gdb)}.
-
-Une nouvelle invite de commande se présente à vous :
-
-\begin{verbatim}
-(gdb)
-\end{verbatim}
-
-Pour exécuter le programme, taper \texttt{run} puis valider votre commande avec la touche Entrer. Le programme devrait se lancer et s'arrêter exactement à l'endroit de votre erreur. La ligne de votre programme sur laquelle s'est arrêter l'exécution est affiché par \texttt{gdb}.
-
-\subsubsection{Une situation pratique}
-Je peux mettre un ``breakpoint'' (un point d'arrêt dans le programme) dans la fonction critique de mon programme. Disons que cette fonction s'appelle \texttt{tutu}. je tape sous \texttt{gdb}~:
-\begin{verbatim}
-(gdb) b tutu
-\end{verbatim}
-
-\texttt{b} veut dire \texttt{breakpoint}. \texttt{gdb} me répond~:
-\begin{verbatim}
-Breakpoint 1 at 0x80de41c: file titi.c, line 1309.
-\end{verbatim}
-
-Je peux spécifier plutôt un arrêt à une ligne (ex: 134) de mon programme~:
-\begin{verbatim}
-(gdb) b titi.c:134
-\end{verbatim}
-
-Maintenent je lance mon programme sous \texttt{gdb}~:
-
-\begin{verbatim}
-(gdb) run
-\end{verbatim}
-
-On peut aussi taper \texttt{run bibi} pour donner en argument à \texttt{titi} la chaine `\texttt{bibi}' (ex~: nom de fichier). \texttt{gdb} me répond~:
-\begin{verbatim}
-Starting program: /home/benoit/src/titi bibi
-\end{verbatim}
-
-Pouf, le programme stoppe sur le \texttt{breakpoint}. On peut alors maîtriser l'exécution du programme pas-à-pas.
-
-Par exemple, on avance d'une ligne dans le programme avec la commande \texttt{n} ou \texttt{next} et pour entrer dans les sous-fonctions, on fait un \texttt{step} ou \texttt{s}. Notez qu'il n'est pas possible d'allez en arrière dans l'exécution du programme. Si finalement, vous vouliez regarder ce qui c'est passé un peu avant, alors il faut arrêter l'exécution en cours (avec, par exemple, un \texttt{Ctrl+C}) et placer un \texttt{breakpoint} un peu plus haut dans le programme et relancer le débuggage.
-
-\begin{verbatim}
-(gdb) n
-\end{verbatim}
-
-\texttt{gdb} me répond en m'affichant la ligne du programme en cours\footnote{Attention, il faut que votre fichier de programme soit effectivement celui du programme compilé que vous débugger, sinon il risque que les lignes ne vont correspondre autre chose que ce qui se passe}~:
-\begin{verbatim}
-1350 if (Array1[i]!=i)
-\end{verbatim}
-
-Et en plus, il est possible de connaître les valeurs des variables en cours d'utilisation. Disons que je veux vérifier la valeur de \texttt{i}, je fais alors~:
-
-\begin{verbatim}
-(gdb) print i
-\end{verbatim}
-
-\texttt{gdb} me répond~: \texttt{\$1 = 6}.
-Le 1 veut dire que c'est la première fois que j'invoque \texttt{i} ...qui est égal à 6. Il est également possible d'utiliser la commande \texttt{disp}, qui permet d'afficher la valeur de la variable à chaque pas (sans qu'on en demande l'affichage explicite).
-
-Bon, continuons l'exécution avec la commande \texttt{continue} ou \texttt{c}.
-\begin{verbatim}
-(gdb) c
-Continuing.
-\end{verbatim}
-
-On peut interrompre l'exécution pour retrouver l'invite en tapant \texttt{Ctrl-c}. Sinon le programme continue son exécution jusqu'à la fin de celui-ci, ou jusqu'à tomber sur un nouveau \texttt{breakpoint} ou bien ...
-
-Et hop! plaf! boum!, alors que tout ce passait bien l'erreur apparaît~! \texttt{gdb} s'arrête et nous invite à réfléchir...
-Tout d'abord, il faut localiser l'endroit du programme où l'exécution s'est interrompue. Pour cela, On peut taper \texttt{where} c'est-à-dire ``où suis-je dans le programme ?''. Le plus efficace est d'afficher la pile des appels des fonctions pour mieux zoomer sur l'endroit de l'erreur. On peut ainsi savoir comment on est arrivé à l'endroit actuel du programme~:
-\begin{verbatim}
-(gdb) bt
-\end{verbatim}
-
-\texttt{bt} veut dire \texttt{backtrace}. De là, on peut monter ou descendre dans les appels de fonctions~:
-\begin{itemize}
- \item \texttt{up} permet de monter dans le contexte de la fonction appelante.
- \item \texttt{down} permet de descendre dans vers la fonction appelée.
-\end{itemize}
-Cela nous permet donc de se trouver dans le contexte de n'importe quelle fonction liée à l'erreur. On peut imprimer les variables que l'on veut dans le contexte courant avec la commande \texttt{print} ou \texttt{disp}. En comparant les valeurs contenues dans les variables et les valeurs théoriquement attendues, vous pouvez ainsi trouver l'erreur.
-
-
-Pour quitter \texttt{gdb}, il suffit de taper \texttt{q}, et valider par Enter. \texttt{gdb} a de nombreuses commandes. pour en savoir plus, il suffit de taper \texttt{h} ou \texttt{help} et il vous propose une liste de thèmes. Tapez alors~:
-
-\begin{verbatim}
-(gdb) h `le thème voulu'
-\end{verbatim}
-
-
-\begin{remarque}[De l'art du débuggage]
- Le débuggage est un art, il nécessite de l'intuition et une très bonne connaissance de la programmation et du langage. Seule l'expérience de la programmation vous rendra efficace dans cette tâche.
-
-Il est beaucoup plus facile d'apprendre à programmer qu'à débugger ... alors essayer de faire le moins d'erreur de programmation~!
-\end{remarque}
-
-Pour devenir un pro de \texttt{gdb}, visitez le site web de référence de \href{http://www.cs.utah.edu/dept/old/texinfo/gdb/gdb_toc.html}{gdb} . Là vous saurez tout sur \texttt{gdb} ! Voilà... Mais surtout n'oubliez jamais de compiler avec l'option de debuggage... \texttt{-g} pour \texttt{gcc}.
-
-\subsection{Debuggage avec \texttt{valgrind}}\label{sec:valgrind}
-\texttt{\texttt{valgrind}} est un outil de profilage et de débuggage mémoire. Il permet de détecter des problèmes de gestion mémoire dans des programmes écrits en \texttt{C}/\texttt{C++}.
-
-Une des premiers problèmes est la fuite de mémoire ... Une fuite mémoire est un problème qui survient lorsque le programme alloue de la mémoire et oublie de la libérer quand on n'en n'a plus besoin, voire se retrouver à ne plus être en mesure de la libérer (voir la partie du cours sur l'allocation mémoire pour comprendre le problème).
-
-\espace
-
-Vous pouvez consulter la page suivante pour en savoir plus~: \href{http://www.unixgarden.com/index.php/administration-systeme/corriger-votre-utilisation-memoire-avec-valgrind}{http://www.unixgarden.com}.
-
-% \subsection{Debuggage avec \texttt{valgrind}}\label{sec:valgrind}
-% \textit{Cette section est largement extraite de \href{http://www.unixgarden.com/index.php/administration-systeme/corriger-votre-utilisation-memoire-avec-valgrind}{http://www.unixgarden.com}.}
-%
-% \espace
-%
-% \texttt{\texttt{valgrind}} est un outil de profilage et de débuggage mémoire. Il permet de détecter des problèmes de gestion mémoire dans des programmes écrits en \texttt{C}/\texttt{C++}.
-%
-% \subsubsection{Préparer votre programme}
-% Afin que \texttt{valgrind} soit vraiment utilisable, il est nécessaire d'avoir les informations de debug pour votre binaire. Si vous le compilez vous-même, il faut donc ajouter l'option \texttt{-g} à votre appel de \texttt{gcc}.
-%
-% \subsubsection{Lancer votre programme avec \texttt{valgrind}}
-% Si votre programme se lance habituellement par la commande \texttt{plop coin coin}, il vous suffit d'utiliser à la place~:
-% \begin{verbatim}
-% $ valgrind plop coin coin
-% \end{verbatim}
-%
-% Vous pouvez aussi ajouter des options à \texttt{valgrind}. Ces options sont à ajouter avant votre commande (sinon, elles seraient transmises à votre programme au lieu d'être interprétées par \texttt{valgrind}). Nous en rencontrerons en particulier dans la section traitant de la recherche de fuites mémoire.
-%
-% \texttt{valgrind} affichera alors un message indiquant qu'il charge \texttt{memcheck} et listant les \textit{copyrights}, puis des erreurs au fur et à mesure qu'elles sont rencontrées.
-%
-% Les erreurs sont affichées sous la forme suivante~:
-%
-% \begin{verbatim}
-% ==21031== Invalid read of size 1
-% ==21031== at 0x804839A: main (read.c:5)
-% ==21031== Address 0x4180032 is 0 bytes after a block of size 10 alloc'd
-% ==21031== at 0x40204E5: malloc (in /usr/lib/...)
-% ==21031== by 0x8048390: main (read.c:3)
-% \end{verbatim}
-%
-% 21031 est le numéro du processus. Cela permet surtout de voir quand le problème est en fait dans l'un des fils du vôtre et pas directement dans votre code.
-%
-% La première ligne indique l'erreur, ici la lecture d'un octet à un endroit où l'on n'aurait pas dû accéder. Les lignes suivantes indiquent la pile d'appel, une seule ligne ici car l'erreur se situe dans \lstinline!main(),! ligne 5 de \texttt{read.c}.
-%
-% Dans le cas où \texttt{valgrind} parvient à identifier le bloc mémoire auquel vous vouliez accéder, il indique également où il avait été alloué ou libéré. Dans notre cas, on avait alloué un bloc de taille 10 à la ligne 3 de \texttt{read.c}, et on essaye d'accéder en lecture 0 octet après celui-ci, donc au 11ème octet.
-%
-% Lorsque la même erreur se produit plusieurs fois lors de la même exécution de votre programme, \texttt{valgrind} ne l'affiche qu'une fois. L'option -v permet de lui demander d'afficher à la fin le nombre de fois que chaque erreur s'est produite.
-%
-% Si votre programme génère trop d'erreurs (1000 différentes ou 1000000 au total), \texttt{valgrind} finit par abandonner avec un message sympathique~:
-%
-% \begin{verbatim}
-% ==31573== More than 1000 different errors detected. I'm not reporting any more.
-% ==31573== Final error counts will be inaccurate. Go fix your program!
-% ==31573== Rerun with --error-limit=no to disable this cutoff. Note
-% ==31573== that errors may occur in your program without prior warning from
-% ==31573== \texttt{valgrind}, because errors are no longer being displayed.
-% \end{verbatim}
-%
-% Vous pouvez supprimer cette limite avec l'option \texttt{--error-limit=no}, mais cela risque de provoquer une consommation mémoire très élevée et des performances fortement dégradées.
-%
-% \subsubsection{Les différentes erreurs signalées}
-%
-% \paragraph{Lecture ou écriture invalide}
-% Cette erreur indique que votre programme lit ou écrit hors des zones mémoire auxquelles il devrait avoir accès. Cela permet notamment de repérer les accès au-delà de la fin d'un tableau ou d'une chaîne et les accès à des adresses invalides comme \lstinline!NULL! (ou \lstinline!NULL+42!).
-%
-% L'exemple suivant montre les messages d'erreur pour une lecture après la fin de la zone allouée et une lecture dans une zone précédemment libérée. Comme vous pouvez le constater, les messages indiquent exactement comment se situe l'accès par rapport à la zone mémoire la plus proche (respectivement 0 octet après la fin, donc l'octet suivant la fin de la zone, et 0 octet à l'intérieur, donc le premier octet de la zone).
-%
-% \begin{lstlisting}
-% #include <stdlib.h>
-% #include <string.h>
-% int main() {
-% char *a = (char *)malloc(10);
-% char b;
-% /* Lecture apres la fin de la zone allouee */
-% b = a[10];
-% free(a);
-% /* Lecture dans une zone liberee */
-% b = a[0];
-% return 0;
-% }
-% \end{lstlisting}
-%
-% \begin{verbatim}
-% ==21281== Invalid read of size 1
-% ==21281== at 0x804839A: main (read.c:8)
-% ==21281== Address 0x4180032 is 0 bytes after a block of size 10 alloc'd
-% ==21281== at 0x40204E5: malloc (in /usr/lib/...)
-% ==21281== by 0x8048390: main (read.c:4)
-% ==21281==
-% ==21281== Invalid read of size 1
-% ==21281== at 0x80483AE: main (read.c:13)
-% ==21281== Address 0x4180028 is 0 bytes inside a block of size 10 free'd
-% ==21281== at 0x40200FF: free (in /usr/lib/...)
-% ==21281== by 0x80483AA: main (read.c:10)
-% \end{verbatim}
-%
-% Cet exemple montre une lecture, mais une écriture serait beaucoup plus dangereuse.
-%
-% \paragraph{Utilisation d'une zone mémoire non initialisée}
-% Lorsque vous n'initialisez pas une variable, sa valeur initiale est inconnue. Faire un test sur cette variable ou la passer à une autre fonction ou un appel système entraîne donc un comportement aléatoire.
-%
-% En général, lorsque \texttt{valgrind} vous signale cette erreur, cela vous permet de repérer un chemin d'exécution que vous n'aviez pas prévu et où, par exemple, un pointeur n'est jamais affecté avant son utilisation. La correction de cette erreur est souvent triviale, et peut par exemple consister à initialiser le pointeur à \lstinline!NULL!, et vérifier avant son utilisation qu'il n'est plus \lstinline!NULL!.
-%
-% L'exemple suivant indique les messages lorsqu'un test dépend d'une valeur non initialisée et lorsque qu'un paramètre d'un appel système n'est pas entièrement initialisé (dans notre cas, il s'agit d'un entier qui ne l'est donc pas du tout, mais, pour un buffer, cela peut être intéressant à savoir).
-%
-% \begin{lstlisting}
-% #include <stdlib.h>
-% int main() {
-% int n;
-% /* Test d'une variable non initialisee */
-% if(n > 1) {
-% /* Passage d'une variable non initialisee a un appel systeme */
-% return n;
-% }
-% return 0;
-% }
-% \end{lstlisting}
-%
-% \begin{verbatim}
-% ==21397== Conditional jump or move depends on uninitialised value(s)
-% ==21397== at 0x8048329: main (init.c:6)
-% ==21397==
-% ==21397== Syscall param exit_group(exit_code) contains uninitialised byte(s)
-% ==21397== at 0x40CF158: _Exit (in /lib/i686/libc-2.6.1.so)
-% ==21397== by 0x4054F97: (below main) (libc-start.c:254)
-% \end{verbatim}
-%
-% \paragraph{Libération invalide}
-% Le pointeur passé à \lstinline!free! doit forcément être celui vers le début d'une zone allouée précédemment et non encore libérée. Les problèmes de libération les plus courants sont donc de libérer 2 fois la même zone mémoire ou d'avoir modifié le pointeur accidentellement et demander à libérer une adresse au milieu (voire en dehors) de la zone voulue.
-%
-% \begin{lstlisting}
-% #include <stdlib.h>
-% int main() {
-% char *a = (char *)malloc(10);
-% free(a);
-% /* Double liberation */
-% free(a);
-% /* Liberation d'une adresse n'etant pas le debut d'une zone allouee */
-% free((void*)42);
-% return 0;
-% }
-% \end{lstlisting}
-%
-% \begin{verbatim}
-% ==21334== Invalid free() / delete / delete[]
-% ==21334== at 0x40200FF: free (in /usr/lib/...)
-% ==21334== by 0x80483A9: main (free.c:9)
-% ==21334== Address 0x4180028 is 0 bytes inside a block of size 10 free'd
-% ==21334== at 0x40200FF: free (in /usr/lib/...)
-% ==21334== by 0x804839E: main (free.c:6)
-% ==21334==
-% ==21334== Invalid free() / delete / delete[]
-% ==21334== at 0x40200FF: free (in /usr/lib/...)
-% ==21334== by 0x80483B5: main (free.c:14)
-% ==21334== Address 0x2A is not stack'd, malloc'd or (recently) free'd
-% \end{verbatim}
-%
-% \paragraph{Libération avec une fonction incorrecte}
-% Lorsque vous faites du \texttt{C++}, vous libérez un objet créé par \lstinline!new! à l'aide de \lstinline!delete!, et une zone allouée par \lstinline!malloc!/\lstinline!calloc!/\lstinline!realloc!/... avec \lstinline!free!. Il arrive parfois que des gens se mélangent les pinceaux et libèrent avec \lstinline!free! un objet alloué par \lstinline!new!.
-%
-% \begin{lstlisting}
-% #include <string>
-% int main() {
-% std::string *s = new std::string("plop");
-% free(s);
-% return 0;
-% }
-% \end{lstlisting}
-%
-% \begin{verbatim}
-% ==16330== Mismatched free() / delete / delete []
-% ==16330== at 0x40200FF: free (in /usr/lib/...)
-% ==16330== by 0x804860B: main (free.cpp:5)
-% ==16330== Address 0x42A4028 is 0 bytes inside a block of size 4 alloc'd
-% ==16330== at 0x4020C8C: operator new(unsigned) (in /usr/lib/...)
-% ==16330== by 0x80485D2: main (free.cpp:4)
-% \end{verbatim}
-%
-% \paragraph{Recouvrement de la source et de la destination}
-% Certaines fonctions C (\lstinline!memcpy!, \lstinline!strcpy!, \lstinline!strncpy!, \lstinline!strcat!, \lstinline!strncat!) copient une zone mémoire vers une autre. Si une partie de la source et de la destination se superposent il y a un risque de corruption lors de la copie. \texttt{memcheck} le signale donc par l'erreur \textit{Source and destination overlap}.
-%
-% Dans le fichier \texttt{C} suivant, par exemple, la source et la destination se superposent de 2 octets et \texttt{valgrind} le détecte bien.
-%
-% \begin{lstlisting}
-% #include <string.h>
-% int main() {
-% char a[10] = "azertyuio";
-% /* Copie d'une chaine par dessus une partie d'elle meme */
-% strncpy(a, a+2, 8);
-% return 0;
-% }
-% \end{lstlisting}
-%
-% \begin{verbatim}
-% ==19188== Source and destination overlap in strncpy(0xBEDBFF41, 0xBEDBFF43, 8)
-% ==19188== at 0x40219A8: strncpy (in ....)
-% ==19188== by 0x80483BC: main (overlap.c:6)
-% \end{verbatim}
-%
-% \paragraph{Avertissements}
-% \texttt{valgrind} peut aussi émettre de simples avertissements. Par exemple, si vous utilisez un descripteur de fichier invalide, \texttt{valgrind} vous le signalera, mais ce n'est pas forcément un problème dans la mesure où l'appel système renverra une erreur et que vous êtes censé vérifier le résultat d'un write !
-%
-% \begin{lstlisting}
-% #include <unistd.h>
-% int main() {
-% write(424242, "42", 2);
-% return 0;
-% }
-% \end{lstlisting}
-%
-% \begin{verbatim}
-% ==17498== Warning: invalid file descriptor 424242 in syscall write()
-% \end{verbatim}
-%
-%
-% \subsubsection{Erreurs non détectées}
-% Je ne vais bien sûr pas vous lister ici toutes les erreurs non détectées par \texttt{valgrind}. J'en oublierais forcément. Il est toutefois important de savoir que certaines erreurs courantes de gestion mémoire, pouvant avoir de graves conséquences sur la sécurité de votre application, ne sont pas détectées par \texttt{valgrind}. Je parle des débordements sur la pile.
-%
-% Il s'agit d'accès en écriture à des données qui n'ont pas été allouées par un malloc, mais placées sur la pile (variables locales d'une fonction ou allocation avec \lstinline!alloca!). Lorsque vous dépassez d'un tel tableau, vous risquez de modifier des données importantes comme l'adresse de retour de la fonction ! Il s'agit donc d'une source très commune de failles de sécurité.
-%
-% Pour détecter ce genre de problèmes et éviter par exemple l'exécution de code par ce biais, l'approche la plus commune consiste à utiliser des mécanismes de protection de pile (\textit{stack smashing protection}) à base de canaris. Il s'agit de marqueurs qui s'ils sont modifiés indiquent que vous avez débordé, et votre programme est alors immédiatement interrompu pour éviter tout risque. \texttt{gcc} inclut depuis sa version 4.1 un tel mécanisme, utilisable avec les options de compilation \texttt{-fstack-protector} et \texttt{-fstack-protector-all}. Ces options sont utilisées par défaut dans la plupart des distributions GNU/Linux modernes.
-%
-% Je ne m'attarderai pas plus sur ce sujet qui n'est pas le c\oe ur de cet article, mais, dans la mesure où c'est la principale source de failles de sécurités dans le code \texttt{C}, il m'a semblé utile de le mentionner.
-%
-% Abordons maintenant un autre domaine, moins critique pour la sécurité, dans lequel \texttt{valgrind} peut également vous aider.
-
-% \subsubsection{Recherche des fuites mémoire}
-% Pour éviter que votre programme ne devienne aussi gourmand que XXX (remplacer XXX par celui que vous avez besoin de redémarrer au moins une fois par jour pour que votre machine reste utilisable), il est très fortement suggéré de veiller à corriger toutes les fuites mémoire avant de le distribuer.
-%
-% Pour rappel, une fuite mémoire ça consiste à allouer de la mémoire et oublier de la libérer quand on n'en n'a plus besoin, voire se retrouver à ne plus être en mesure de la libérer.
-%
-% Il existe plusieurs sortes de fuites mémoire, la plus simple à détecter étant celle où vous affectez une nouvelle valeur à un pointeur sans avoir libéré la mémoire vers laquelle il pointait, et n'avez donc plus aucun moyen de libérer cette mémoire. \texttt{valgrind} détecte de telles fuites à la fin de l'exécution en parcourant l'intégralité de la mémoire non libérée par votre programme à la recherche d'un pointeur vers les différentes zones non libérées. Si certaines zones de mémoire non libérée ne sont plus référencées par aucun pointeur, il vous listera les zones perdues et là où elles avaient été allouées.
-%
-% Vous pouvez aussi demander à \texttt{valgrind} de vous indiquer celles pour lesquelles il restait des pointeurs, mais qui n'ont quand même pas été libérées avant de sortir de votre programme. Cela indique généralement que vous avez oublié de libérer ces zones et qu'elles consomment donc inutilement de la mémoire, mais cela peut aussi être un choix de ne pas les libérer lorsque vous quittez dans la mesure ou l'OS s'en chargera de toute façon. Pour que \texttt{valgrind} vous les indique également, il faut ajouter l'option \texttt{--show-reachable}.
-%
-% Prenons l'exemple du fichier C suivant, contenant 2 fuites mémoire.
-%
-% \begin{lstlisting}
-% #include <stdlib.h>
-% int main() {
-% void **a = (void **) malloc(42*sizeof(void *));
-% void *b = malloc(1);
-% a[0] = b;
-% a = NULL;
-% b = NULL;
-% return 0;
-% }
-% \end{lstlisting}
-%
-% \begin{verbatim}
-% ==17686== malloc/free: in use at exit: 169 bytes in 2 blocks.
-% \end{verbatim}
-%
-% \texttt{valgrind} va détecter les 2, le pointeur sur la zone de 168 octets (4*42) est clairement perdu dans la mesure où l'on stocke \lstinline!NULL! dans a sans avoir copié le pointeur avant. Dans le cas de \lstinline!b!, il reste un pointeur vers la zone de 1 octet, mais ce pointeur est situé dans une zone à laquelle on n'a plus accès~: c'est donc une fuite indirecte.
-%
-% \begin{verbatim}
-% ==17686== malloc/free: 2 allocs, 0 frees, 169 bytes allocated.
-% ==17686== For counts of detected errors, rerun with: -v
-% ==17686== searching for pointers to 2 not-freed blocks.
-% ==17686== checked 49,500 bytes.
-% ==17686==
-% ==17686== 169 (168 direct, 1 indirect) bytes in 1 blocks are definitely lost in loss record 2 of 2
-% ==17686== at 0x4021828: malloc (in /usr/lib/valgrind/x86-linux/vgpreload_memcheck.so)
-% ==17686== by 0x8048360: main (leak.c:3)
-% ==17686==
-% ==17686== LEAK SUMMARY:
-% ==17686== definitely lost: 168 bytes in 1 blocks.
-% ==17686== indirectly lost: 1 bytes in 1 blocks.
-% ==17686== possibly lost: 0 bytes in 0 blocks.
-% ==17686== still reachable: 0 bytes in 0 blocks.
-% ==17686== suppressed: 0 bytes in 0 blocks.
-% \end{verbatim}
-%
-% Après avoir indiqué quelques statistiques sur les allocations et les libérations, \texttt{valgrind} détaille chaque fuite trouvée, puis indique un résumé des fuites, classées par type.
-% \begin{itemize}
-% \item \texttt{definitely lost} indique les zones vers lesquelles il ne reste plus le moindre pointeur (ici 1 zone de 168 octets).
-% \item \texttt{indirectly lost} indique les zones vers lesquelles il reste un pointeur, mais celui-ci n'est plus accessible(ici 1 zone de 1 octets).
-% \item \texttt{possibly lost} indique les zones vers lesquelles il reste un pointeur, mais le pointeur ne pointe pas vers le début du bloc. Il est fort probable que soit le pointeur ait été modifié, soit l'adresse apparaisse juste par hasard (mais rien ne vous empêche de décider de stocker l'adresse des zones allouées +1, et de faire -1 avant de libérer).
-% \item \texttt{still reachable} indique les zones vers lesquelles il reste un pointeur, mais il n'est pas libéré avant de sortir. Ce n'est pas forcément un problème.
-% \item \texttt{suppressed} indique les erreurs masquées.
-% \end{itemize}
-%
-% Les fuites où vous oubliez de libérer la mémoire au moment où elle n'est plus nécessaire, mais conservez un pointeur et les libérez avant de sortir ne peuvent pas être détectées par \texttt{memcheck}, mais un autre outil de la suite \texttt{valgrind} vous y aidera~: massif, qui fait des statistiques sur l'accès aux différentes zones allouées et vous permettra de trouver celles qui restent longtemps alloués alors qu'elles ne servent plus. Ce type de fuite peut par exemple avoir lieu lorsque vous avez votre propre système d'allocation mémoire (avec la fonction d'allocation qui ajoute le pointeur à une liste, donc il sera bien libéré en sortie même si vous-même le perdez dans le reste de l'application) ou, par exemple, un tableau que vous faites grossir quand il est plein, mais que vous ne réduisez jamais.
-
-\subsection{Profilage avec \texttt{gprof}}
-La commande \texttt{gprof} produit un compte-rendu d'exécution pour les programmes \texttt{C}.
-Pour utiliser la commande \texttt{gprof} il faut compiler le programme avec l'option de profilage \texttt{-pg}.
-\begin{itemize}
- \item À la fin de l'exécution, on obtient un fichier de données, \texttt{gmon.out}, que \texttt{gprof} peut analyser. On obtient alors deux compte-rendus~: l'arbre d'appels (\textit{call-graph profile})~: il contient la liste des routines en ordre décroissant du temps cpu consommé ainsi que les routines qui sont appeleées à partir d'elles. On peut ainsi connaitre quelles sont les routines mères qui appellent le plus souvent une routine donnée et quelles sont les routines filles qui sont appelées le plus fréquemment par une routine particulière.
- \item le profil plat (\textit{flat profile}) de l'usage CPU~: la liste des routines avec le nombre d'appels.
-\end{itemize}
-
-Les options pratiques de \texttt{gprof} sont~:
-\begin{itemize}
-\item \texttt{-b}~: supprime l'en-tête en cas de traitement ultérieur des sorties ;
-\item \texttt{-s}~: génère un fichier résumé, appelé \texttt{gmon.sum};
-\item \texttt{-z}~: affiche tous les symboles, même ceux qui n'ont eu aucun appel ou bien un temps total nul.
-\end{itemize}
-
-Procédure pour profiler votre code~:
-\begin{enumerate}
- \item compilation et édition des liens avec l'option de profilage \texttt{-pg} ;
- \item exécution classique;
- \item analyse du fichier de profilage en utilisation la commande \texttt{gprof}.
-\end{enumerate}
-
-La première sortie de \texttt{gprof} est un classement décroissant (du temps cpu consommé) des fonctions appelées dans le programme~: fonctions appartenant au programme et fonctions provenant de librairies du système. Par exemple l'extrait suivant~:
-
-{\small
-\begin{verbatim}
-% time cumulative self calls self total name
- seconds seconds ms/call ms/call
-36.9 92.23 92.23 87253 1.06 1.06 .saxpy [4]
-29.9 167.06 74.83 45751 1.64 1.64 .pmv [5]
-22.0 222.15 55.09 61502 0.90 0.90 .prodscal [6]
-6.1 237.48 15.33 10000 1.53 3.17 .scdmb [7]
-5.1 250.19 12.71 10000 1.27 21.85 .gradconj [3]
-0.0 250.22 0.03 .__mcount [8]
-0.0 250.25 0.03 .qincrement [9]
-0.0 250.27 0.02 1 20.00 20.00 .fctfx [10]
-0.0 250.28 0.01 6 1.67 1.67 .nrmerr [11]
-0.0 250.28 0.00 20000 0.00 0.00 .fctft [12]
-0.0 250.28 0.00 252 0.00 0.00 ._sigsetmask [13]
-0.0 250.28 0.00 170 0.00 0.00 .pthread_mutex_lock [14]
-\end{verbatim}
-}
-
-\begin{itemize}
- \item La colonne \texttt{\% time} indique le pourcentage du temps cpu total consommé par la routine courante.
- \item La colonne \texttt{cumulative seconds} représente la somme partielle des temps cpu du haut de la liste jusqu'à la routine courante.
-\item La colonne \texttt{self seconds} représente le temps cpu de la routine courante.
-\item La colonne \texttt{calls} indique le nombre d'appels de la routine courante.
-\item La colonne \texttt{self ms/call} indique le temps cpu moyen (en milisecondes) consommé par appel à la routine courante, temps exclusif (ne contient pas la consommation des routines qu'elle appelle) uniquement.
-\item La colonne \texttt{total ms/call} indique le temps total (inclusif + exclusif) consommé par appel à la routine courante.
-\end{itemize}
-
-Dans le cas de la fonction \texttt{pmv}, il y a 45751 appels à cette fonction pour un total de 74.83 secondes d'utilisation du cpu, soit 1.64ms par appel de fonction.
-
-\section{Programmer avec \texttt{Code::Blocks}}\label{sec:devcpp}
-
-\subsection{Les IDE pour le développement en C}
-
-Il existe plusieurs IDE pour la programmation en C/C++. Généralement, ces outils ne sont pas spécifiques à C, mais plutôt à C++. Néanmoins, ils nous conviennent parfaitement. Les plus connus sont:
-\begin{itemize}
- \item \texttt{VisualC++}~: l'environnement de développement en C/C++ de Microsoft et totalement dédié à Windows. Il embarque un compilateur spécifique à Windows. C'est un outil très complet, richement documenté mais très cher.
- \item \texttt{BorlandC++}~: concurrent de \texttt{VisualC++} pendant longtemps, il est maintenant en perte de vitesse. Il fut également payant et cher pendant longtemps. Actuellement ??
- \item \texttt{DevCpp}~: environnement de développement intégré utilisant le compilateur g++ de MINGW (une console linux sous Windows). C'est un outil gratuit. \\(\url{http://www.bloodshed.net/devcpp.html})
- \item \texttt{Code::Blocks}~: idem \texttt{DevCpp} (\url{http://www.codeblocks.org}).
- \item \texttt{Eclipse-CDT}~: environnement de développement totalement paramétrable à ses besoins. Il est aussi riche qu'il est difficile à utiliser. Je ne le conseille pas aux débutants. Totalement en Java, il nécessite également d'avoir un ordinateur performant. C'est un outil gratuit.
-\end{itemize}
-
-Le point négatif de ces outils est leur complexité. S'il semble pratique de les utiliser, ils ne sont pas nécessairement intuitifs ni même faciles à utiliser. Ceci est d'autant plus vrai que les développements que nous sommes amener à réaliser sont légers.
-
-Dans mon usage personnel, je n'utilise pas d'IDE pour développer en C. Je m'en sers uniquement en C++ lorsque les projets commencent à être importants (>10000 lignes de code). Depuis que je m'y suis familiarisé, j'utilise principalement \texttt{Eclipse-CDT}. Mais je continue à faire beaucoup de débuggage en ligne de commandes.
-
-\espace
-
-Mon choix de \texttt{Code::Blocks} est motivé par~:
-\begin{itemize}
- \item c'est un outil ``Cross-Plateform''~: vous pouvez aussi bien l'installer sous Windows, sous Linux et également sous Mac (!). En particulier, vous pouvez continuer à travailler chez vous sans avoir à installer Linux,
- \item la possibilité de faire simplement les opérations nécessaires à ce cours, en particulier toute la partie de compilation,
- \item la richesse suffisante de cet outil,
- \item l'intégration du débugger.
-\end{itemize}
-
-\subsection{Premier projet de \texttt{Code::Blocks}}
-
-Lors du premier lancement de \texttt{Code::Blocks}, il se peut qu'il vous demande des informations sur le compilateur. Avec une installation par défaut (avec MINGW) vous ne devez disposer que d'un seul compilateur (celui de MINGW), vous avez donc juste à dire OK !
-
-\subsubsection{Création du projet}
-
-\begin{figure}[ht]
- \centering
- \includegraphics[width=\defaultfigurewidth]{\Figures/CB_1}
- \caption{Interface d'accueil de \texttt{Code::Blocks}}
- \label{fig:codeblock1}
-\end{figure}
-
-
-Lorsque vous lancer \texttt{Code::Blocks}, vous arrivez sur la fenêtre d'accueil illutrée dans la Figure \ref{fig:codeblock1}. Commencez peut être par faire un peu de ménage dans les fenêtres qui sont affichées : fermer l'onglet ``start here'' et la console de scripts.
-
-Pour commencer à travailler, créer un nouveau projet~:
-\begin{enumerate}
- \item cliquer sur ``nouveau projet'' au centre de l'interface,
- \item sélectionner ensuite ``Empty project'' pour créer un projet vide,
- \item répondez aux questions relatives à l'emplacement du projet
- \begin{itemize}
- \item nom du projet (par ex. ``Test\_LangageC'')
- \item ``folder to create project in''~: donner un répertoire où enregistrer votre projet
- \end{itemize}
- \item répondez aux questions relatives au compilateur (doit être ``GNU GCC'', ne rien modifier)
-\end{enumerate}
-
-Ensuite, il vous faut créer des fichiers de programme. Pour cela~:
-\begin{enumerate}
- \item aller dans le menu \texttt{File>New empty file}
- \item répondre ``Oui'' à l'insertion du fichier au projet
- \item donner un nom à votre fichier (par exemple ``\texttt{test.c}'') et valider
- \item sélectionner seulement ``Debug'' (et pas ``Release'') dans la fenêtre suivante et valider. La configuration ``Debug'' correspond à la compilation d'un programme qui vous permettra de débugger plus facilement. C'est la version de compilation utilisé pendant la réalisation d'un projet. Lorsque votre programme est finalisé, vous pourriez passer à un mode de compilation ``Release'' dans lequel le programme sera plus efficace. Dans ce cours, il n'est pas nécessaire de travailler sur deux versions ...
-\end{enumerate}
-
-\espace
-
-Et voilà tout est prêt pour écrire votre programme. Par exemple, le petit programme ci-dessous~:
-
-\begin{lstlisting}
-#include <stdio.h>
-
-int main() {
- printf("hello world\n");
- return 0;
-}
-\end{lstlisting}
-
-Il est possible de (de-)zoomer sur le code (changement de taille de la police) en utilisant \texttt{Ctrl+Roulette souris} sur la zone du code.
-
-\begin{warning}
- À chaque nouveau programme, il faut créer un nouveau projet !!
-
- Vous pouvez travailler sur plusieurs projets en même temps dans \texttt{Code::Blocks}.
-\end{warning}
-
-\espace
-
-Vous pouvez également créer un projet de type ``application console'' qui vous créera automatiquement le premier fichier du \texttt{main}. Pour l'insertion des fichiers suivants, il faudra procéder de la même manière que décrit ci-dessus.
-
-\subsubsection{Compilation et exécution d'un programme}
-
-Dans la Figure \ref{fig:codeblock3}, \texttt{Code::blocks} comporte deux projets \texttt{Test\_LangageC} et \texttt{exo2} visualisé dans la liste de gauche. Le projet actif est celui dont le nom est en gras (\texttt{Test\_LangageC} sur l'illustration).
-Dans les sources, on voit qu'un seul fichier ``\texttt{Test.c}'' fait partie du projet.
-
-\begin{figure}[ht]
- \centering
- \includegraphics[width=\defaultfigurewidth]{\Figures/CodeBlock3}
- % CodeBlock1.png: 1680x1050 pixel, 98dpi, 43.55x27.22 cm, bb=0 0 1234 771
- \caption{Interface d'accueil de \texttt{Code::Blocks}.}
- \label{fig:codeblock3}
-\end{figure}
-
-\begin{figure}[ht]
- \centering
- \includegraphics[width=.5\textwidth]{\Figures/CodeBlocks_barreexecution}
- \caption{Barre de menu pour la compilation dans \texttt{Code::Blocks}.}
- \label{fig:codeblock_barremenucompil}
-\end{figure}
-
-Pour compiler le programme, il suffit de cliquer sur l'icône en forme d'engrenage (icône à gauche sur la Figure \ref{fig:codeblock_barremenucompil}), en haut à gauche ou de faire \texttt{Ctrl+F9}. La fenêtre du bas indique les éventuels message d'erreurs (en rouge). En double-cliquant sur les éléments de cette liste vous déplacerez le curseur à l'emplacement de l'erreur dans le code (également repérée par un carré rouge).
-
-N'oubliez pas d'enregistrer vos fichiers après chaque modification pour qu'elle soit prise en compte dans la compilation !
-
-\espace
-
-Une fois les erreurs corrigées et la compilation réussie, il suffit de cliquer sur l'icône en forme de flèche pour exécuter le programme (second icône sur la Figure \ref{fig:codeblock_barremenucompil}) ou de faire \texttt{Ctrl+F10}.
-
-La touche de raccourcis \texttt{F9} permet de compiler et d'exécuter (l'exécution n'étant faite que si aucune erreur n'est trouvée dans le code). Vous pouvez faire la même chose à partir du troisième icône de la Figure \ref{fig:codeblock_barremenucompil}. Le dernier icône actif de la barre de menu permet de faire une reconstruction totale du projet (supprime les compilations intermédiaire et recommence de zéro). Le dernier icône sert à stopper un programme en court d'exécution.
-
-\espace
-
-Il est également possible d'exécuter votre programme depuis la console Windows (oui! ça existe aussi !!). Pour cela, il faut ouvrir la console Windows~:
-\begin{enumerate}
- \item aller dans le menu Windows, et utiliser l'icône ``Exécuter'' (ou faire \texttt{Ctrl+R} depuis le bureau)
- \item entrer la commande \texttt{cmd}
- \item valider
-\end{enumerate}
-
-Une fois dans la console, vous pouvez naviguer dans les répertoires avec les commandes \texttt{cd} et \texttt{dir} (équivalent de \texttt{ls}). Une fois positionné dans le répertoire de travail (les exécutables sont créés dans le répertoire \texttt{debug/bin} de votre projet \texttt{Code::Blocks}), il suffit taper le nom de l'exécutable (qui doit avoir le nom de votre projet), par exemple~: \texttt{Test\_LangageC.exe} ... et c'est partis.
-
-\subsection{Fonctionnalités de \texttt{Code::Blocks}}
-
-La première fonctionnalité dont vous bénéficiez est l'indentation automatique. Il y a deux moyens de bénéficier de l'indentation automatique dans \texttt{Code::Blocks}~:
-\begin{itemize}
- \item au fil de la frappe~: lorsque vous ajouter une nouvelle ligne, le curseur se place automatiquement à la bonne position.
- \item a posteriori~: en allant dans le menu \texttt{Plugins>Source code formatter}, le logiciel indente automatiquement tout votre code.
-\end{itemize}
-
-
-Voici quelques unes des fonctionnalités de \texttt{Code::Blocks} dont je vous laisse découvrir l'usage (en fonction de vos besoins)~:
-\begin{itemize}
- \item fonctionnalité de parcours de code par les fonctions, les symboles, ...
- \item auto-complétion,
- \item parcours des symboles (variables et fonctions).
-\end{itemize}
-
-\subsubsection{Débuggage interactif}
-
-Il est possible de faire du débuggage interactif simplement dans \texttt{Code::Blocks}. Pour cela, vous pouvez utiliser le menu dédié à l'exécution pas à pas d'un programme (\cf Figure \ref{fig:codeblock_barremenudebug}). De gauche à droite, les icônes permettent (en gras, les plus importants)~:
-\begin{itemize}
- \item \textbf{Continue} : lance le programme en mode ``debug'' ou relance la suite du programme après un arrêt pendant l'exécution pas à pas,
- \item \textbf{Run to cursor} : lance le programme en arrêtant l'exécution à la position du curseur,
- \item \textbf{Next} : exécute l'instruction C suivante (\ie généralement l'instruction sur la ligne du curseur)
- \item Next instruction : exécute l'instruction \textit{assembleur} suivante (pas utile !)
- \item \textbf{Step} : fait la même chose que Next, sauf si l'instruction est une fonction, dans ce cas, le programme ``rentre'' dans la fonction,
- \item Step out : sort de la fonction courante (exécution de la fin des instructions de la fonction),
- \item \textbf{Stop} : arrête l'exécution programme.
-\end{itemize}
-
-
-\begin{figure}[ht]
- \centering
- \includegraphics[width=.5\textwidth]{\Figures/CodeBlocks_barredebugage}
- \caption{Barre de menu pour le débuggage dans \texttt{Code::Blocks}.}
- \label{fig:codeblock_barremenudebug}
-\end{figure}
-
-Lors de l'arrêt d'un programme, il est possible de visualiser le contenu des variables dans la fenêtre \textit{Watches} qui peut être ouverte à partir du huitième icône (liste déroulante d'outils de visualisation).
-
-Finalement, il est possible d'ajouter des points d'arrêt (\textit{breakpoint}) dans votre programme en utilisant la touche \texttt{F5}. Cette touche ajoute ou supprime un \textit{breakpoint} à la ligne où se trouve le curseur. Ce \textit{breakpoint} imposera au débuggeur de s'arrêter juste avant cette ligne.
-
-\espace
-
-
-Dans l'illustration \ref{fig:codeblock_debug}, on visualise un court programme pour lequel on a mis un \textit{breakpoint} à la ligne 9 (visualisé par un rond rouge). Le débuggeur a été lancé. La flèche jaune visualise là où en est l'exécution du programme : actuellement, c'est à la ligne 11 (juste avant l'instruction de cette ligne). Sur la droite, la fenêtre des \textit{Watches} permet de connaître le contenu des variables \lstinline!p! et \lstinline!a!.
-
-\begin{figure}[ht]
- \centering
- \includegraphics[width=.5\textwidth]{\Figures/CodeBlock_Debug}
- %\caption{Barre de menu pour le débuggage dans \texttt{Code::Blocks}.}
- \label{fig:codeblock_debug}
-\end{figure}
diff --git a/Polyc/Pointeurs.tex~ b/Polyc/Pointeurs.tex~
deleted file mode 100644
index b85e2f43fa2f7470af1a16544ec7f4e9f490516c..0000000000000000000000000000000000000000
--- a/Polyc/Pointeurs.tex~
+++ /dev/null
@@ -1,955 +0,0 @@
-
-\chapter{Les pointeurs et allocation dynamique}\label{chp:pointeurs}
-\Opensolutionfile{solutions}{}
-
-Enfin nous voilà à LA partie intéressante~! Celle pour laquelle on fait du C, ou bien qu'on déteste ce langage ... la manipulation des pointeurs et l'auto-gestion de la mémoire. Bientôt vous pourrez vous ranger dans l'une ou l'autre des catégories de programmeurs~!
-
-\section{Les pointeurs}
-La notion de pointeur est difficile à acquérir. Il sera donc à peu près normal que cela vous bloque au début ... Leur usage est néanmoins fondamental en C~! Bien sûr, par mimétisme de bout de code, un grand nombre de programmeur amateur se débrouillent pour écrire du code en C sans en connaître toute la portée~!
-Espérons que vous puissiez dépasser cette étape lors de ce cours ...
-
-\subsection{Définition et déclaration}
-\begin{definition}[Pointeur]\label{def:Pointeur}
-Un pointeur est une variable qui contient l'adresse d'un emplacement mémoire.
-
-Cet emplacement mémoire correspond à une variable du programme.
-Le \textbf{type du pointeur} donne le type de la variable pointée.
-
-En mémoire, un pointeur est codé comme un entier positif sur un mot mémoire.
-\end{definition}
-
-Rappelons nous qu'une variable désigne un emplacement dans la mémoire de l'ordinateur. Nous avons mentionné\footnote{\cf cours sur l'architecture des machines, et en particulier sur l'organisation de la mémoire. Il serait intéressant de relire cette partie du cours si vous ne l'avez plus en mémoire.} que chaque emplacement peut être désigné par un indice (sa position sur la longue bande d'emplacements qu'est la mémoire) et par un taille (la place nécessaire pour coder une variable en mémoire qui dépend du type de la variable). Pour désigner un emplacement de la mémoire, il y a donc deux possibilités~:
-
-\begin{itemize}
-\item donner le nom associé à cet emplacement, \ie le nom de la variable
-\item donner l'adresse de cet emplacement, \ie la valeur du pointeur qui pointe sur cet emplacement.
-\end{itemize}
-
-Ici, toute la subtilité ne sera perçue que si vous faite un claire différence entre ``le nom'' d'une variable et ``la valeur'' d'une variable.
-
-\begin{remarque}
-Lors qu'on parle d'un ``pointeur'', on devrait conserver en mémoire qu'il s'agit plutôt d'une ``variable pointeur''.
-\end{remarque}
-
-Soit \lstinline!i! une variable de type \lstinline!int! et \lstinline!pi! une variable pointeur qui pointe sur \lstinline!i!, alors on peut représenter le contenu de la mémoire par le schéma illustratif ci-dessous. La variable pointeur désignée sous le nom \lstinline!pi! contient la valeur \texttt{@106} (lu ``adresse numéro 106''). Cette adresse correspond à l'emplacement mémoire de la variable \lstinline!i!. \lstinline!pi! pointe \textbf{donc} sur la variable \lstinline!i!.
-
-\begin{figure}[ht]
-\includegraphics[width=14.235cm,height=4.26cm]{\Figures/Poly-img008}
-\caption{Illustration de la représentation en mémoire d'un pointeur (\lstinline!pi!) et de sa variable pointée (\lstinline!i!).}
-\label{seq:refFigure7}
-\end{figure}
-
-Pour des raisons pratiques et mnémotechniques \textbf{les pointeurs sont typés}. De la sorte, le programmeur (et le compilateur) sait
-quel type de donnée contient l'adresse pointée par un pointeur et également (c'est très important) la taille de l'emplacement mémoire désigné.
-
-Pour déclarer une variable pointeur, il faut utiliser le symbole ``\lstinline!*!'' avant le nom de la variable. Le type de la variable sur laquelle pointe la variable pointeur est désigné par le type en début de ligne. Voici quelques exemples de déclaration de pointeur~:
-
-\begin{lstlisting}[numbers=none]
-int *pi ; //Pointeur sur un int
-double *pf0; //Pointeur sur un double
-char *s ; //Pointeur sur un caractere
-void *p; //Pointeur pur
-\end{lstlisting}
-
-Pour mieux comprendre comment fonctionne la déclaration d'un pointeur, voici, ci-dessous, un second exemple dans lequel on déclare
-\textbf{un entier } \lstinline!i! et \textbf{deux pointeurs} \lstinline!pj! \textbf{ et } \lstinline!pi! \textbf{ sur des entiers}. On voit que l'étoile doit se mettre avant le nom de la variable (et non après le type~!)
-
-\begin{lstlisting}[numbers=none]
-int *pi, i, *pj; //pi et pj sont des pointeurs, mais i est un entier !!
-\end{lstlisting}
-
-Allons directement dans le cambouis~: dans la mesure o\`u un pointeur est une variable, il également possible d'avoir un pointeur sur cette variable. On a alors un pointeur de pointeur~! Dans l'exemple ci-dessous, on a un pointeur sur un pointeur d'entier~:
-
-\begin{lstlisting}[numbers=none]
-int **ppi;
-\end{lstlisting}
-
-
-% Ne croyez pas que ça soit folklorique, c'est plutôt très commun en C ... Et pour preuve, le vrai profil de la fonction \lstinline!main! est le suivant~:
-%
-% \begin{lstlisting}[numbers=none]
-% void main(int argc, char **argv)
-% \end{lstlisting}
-%
-% On verra plus tard que \lstinline!argv! est une liste de chaînes de caractères (type \lstinline!char *!). Ce tableau contient en fait les arguments de la commande passée en ligne de commande dans le terminal.
-
-\begin{warning}
-Par convention personnelle, je donne des noms commençant par ``\lstinline!p!'' aux pointeurs.
-\end{warning}
-
-\subsection{Manipulation des pointeurs sur variables}
-
-\subsubsection{Référencement (opérateur \&) et affectation d'une variable pointeur}
-\begin{definition}[Référencement]
-L'opérateur de référencement, noté \lstinline!&!, est un opérateur unaire qui donne l'adresse mémoire d'une variable. L'opérateur se place avant le nom de la variable~:
-
-{\centering \lstinline!&variable! ou \lstinline!&(variable)! \par}
-\end{definition}
-
-Par exemple, sur la figure \ref{seq:refFigure7} , on a~:
-\begin{itemize}
-\item \lstinline!&i! donne la valeur \texttt{@(106)}
-\item \lstinline!&pi! donne la valeur \texttt{@(118)}
-\end{itemize}
-
-Cette opération est indispensable pour affecter notre variable pointeur avec l'adresse d'une autre variable.
-
-\begin{exemple}
-\begin{lstlisting}
-int i = 34;
-int *pi;
-pi = &i; // pi contient l'adresse de i
-\end{lstlisting}
-
-À la ligne 3, la variable \lstinline!pi! est affectée avec pour valeur, l'adresse de la variable \lstinline!i!. On se retrouve alors exactement dans la cas de la figure \ref{seq:refFigure7}.
-\end{exemple}
-
-\subsubsection{Déréférencement (opérateur *)}
-
-\begin{definition}[Déréférencement]
-L'opérateur de déréférencement, noté \lstinline!*!, est un opérateur unaire \textbf{sur un pointeur} qui désigne l'emplacement mémoire pointé par la variable pointeur \lstinline!p!. L'opérateur se place avant le nom de la variable pointeur~:
-\end{definition}
-
-{\centering \lstinline!*p! ou \lstinline!*(p)! \par}
-
-Le type de la variable \lstinline!*p! est donné en \textit{enlevant une étoile} à la déclaration de \lstinline!p!.
-
-\begin{exemple}
-Par exemple, si on déclare la variable \lstinline!g! suivante~:
-
-\lstinline!int ***g;!
-
-alors \lstinline!*g! est de type \lstinline!int**!, et \lstinline!**g! est de type \lstinline!int*! et enfin \lstinline!***g! est de type \lstinline!int! (il n'est pas possible n'aller plus loin~!)
-\end{exemple}
-
-
-\begin{exemple}
-Reprenons maintenant l'exemple de la figure \ref{seq:refFigure7}~: il est important de voir que \lstinline!*pi! désigne le \textbf{même} emplacement mémoire que \lstinline!i!.
-
-Ainsi, si on poursuit l'exemple avec les instructions après la ligne 3 ci-dessous. à la ligne 4, \lstinline!(*pi)! est une variable (de type \lstinline!int!), qui désigne le même emplacement que \lstinline!i!, et qui donc vaut 34. Donc, \lstinline!j! se voit attribué la valeur 34~!
-
-À la ligne 6, \lstinline!(*pi)! donc désigne le même emplacement que \lstinline!i!, et donc si on affecte cette variable avec une nouvelle valeur, on change le contenu de l'emplacement commun avec \lstinline!i!. Du coup, à la ligne 8, on affiche \texttt{0}!
-
-\begin{lstlisting}
-int i = 34, j=0;
-int *pi;
-pi = &i;
-j = *pi;
- //ICI j contient 34
-*pi = 0;
- //ICI i vaut maintenant 0
-printf("%d\n",i);
-\end{lstlisting}
-\end{exemple}
-
-{\bfseries
-Si vous avez bien compris cet exemple, vous êtes à même de poursuivre la lecture du cours ...}
-
-Quelques erreurs classiques~:
-\begin{itemize}
-\item Utilisation d'un pointeur non-initialisé
-\end{itemize}
-\begin{lstlisting}
-int *pi;
-*pi = 13;
-\end{lstlisting}
-
-Ici, pas de problème de type~: à ligne 2, j'affecte bien un \lstinline!int! (\lstinline!*pi! est un \lstinline!int!) avec une valeur entière. Le compilo va être très content. Mais ça ne va pas marché lors de l'exécution (\textit{segmentation fault})~! Vous n'avez pas initialisé la variable \lstinline!pi!~!!! La conséquence est que vous ne savez pas sur quel emplacement mémoire le pointeur pointe ... Mais ça ne pose pas de problème de conscience au compilo ... Alors admettons que \lstinline!pi! ait pour valeur latente 234 (du fait de la valeurs des bits existants précédemment)~! Alors lors de l'instruction de la ligne 2, il va modifier l'emplacement mémoire de l'adresse 234 sans se demander si il en a le droit ... et les conséquences seront nécessairement dramatiques\footnote{Dramatiques, mais pas trop quand même sur vos ordinateurs. En effet, tout système d'exploitation qui se respecte dispose d'un MMU. Cette partie du système fait attention à ce qu'un programme n'écrive pas partout et n'importe comment en mémoire... les programmeurs savent que tous les programmeurs font se genre d'erreur~! Normalement, vous n'aller pas tout cracher ... Mais, on rencontre parfois des systèmes sans MMU, c'est le cas par exemple du système de la nintendo DS, ce qui explique pourquoi elle a été si facile à craquer~!}.
-
-Conclusion, \textbf{il faut s'assurer que vos pointeurs pointent sur quelque chose en mémoire avant de les utiliser.}
-
-\begin{itemize}
-\item Comparaison de pointeurs à la place de la comparaison de valeurs
-\end{itemize}
-Dans le cas ci-dessous, le programme n'affiche rien~!
-
-\begin{lstlisting}
-int i =13, j =13, *pi, *pj;
-*pi = &i;
-*pj = &j;
-if( pi == pj ) {
- printf("coucou");
-}
-\end{lstlisting}
-
-Dans la condition, vous comparez deux pointeurs, c'est-à-dire deux adresses mémoires. Ici, \lstinline!pi! et \lstinline!pj! désignent respectivement les emplacements mémoire de \lstinline!i! et de \lstinline!j!. Donc la condition est fausse. Pour comparer les valeurs des variables désignées par les pointeurs, il faut faire quelque chose de la sorte~:
-\begin{lstlisting}[numbers=none]
-if( *pi == *pj )
-\end{lstlisting}
-
-
-\subsubsection{Le pointeur NULL}
-\begin{definition}[\lstinline!NULL!]
-Le pointeur \lstinline!NULL! (ou valant 0 en conversion en entiers) désigne un pointeur qui ne pointe sur rien.
-\end{definition}
-
-Il est bien d'initialiser tous ces pointeurs à \lstinline!NULL!, ou de remettre à \lstinline!NULL! tous les pointeurs dont vous ne servez plus! Par convention,
-la valeur NULL sert également de valeur de retour d'erreur pour certaines fonctions.
-
-Les opérateurs de l'arithmétique entière pouvant être utilisés pour les pointeurs, il est possible d'écrire ce genre d'expression~:
-\begin{lstlisting}
-int *p=NULL;
-...
-//Opérations sur p
-...
-if( p==NULL ) {
- printf("rien à faire\n");
-} else \{
- printf("Valeur pointee par p~: %d\n", *p);
-}
-\end{lstlisting}
-
-
-\subsection{Pointeurs et tableaux}
-
-Un tableau désigne tout un ensemble d'emplacements mémoire intéressants pour celui qui l'a déclaré. Tout naturellement, les pointeurs vont permettre de désigner ces emplacements mémoire.
-
-On commence cette section en introduisant des opérateurs sur les pointeurs. Ensuite, on fera le lien avec les tableaux.
-
-
-\subsubsection{Opérateurs arithmétiques}
-En interne, un pointeur est un nombre puisqu'il s'agit d'une adresse mémoire~! Alors, les opérateurs arithmétiques usuels fonctionnent très bien. En particulier, les opérateurs d'incrémentation et de décrémentation (\lstinline!++!, \lstinline!--!, \lstinline!+=! et \lstinline!-=!), et les opérateurs d'addition et soustraction usuels.
-
-L'exemple ci-dessous illustre la signification de ces opérateurs pour
-des pointeurs.
-
-\begin{lstlisting}[numbers=none]
-pa + 1; // désigne le pointeur qui pointe sur l'espace mémoire suivant
-pa + 2; // désigne le pointeur qui pointe sur l'espace mémoire encore suivant ...
-\end{lstlisting}
-
-
-\begin{figure}[ht]
-\includegraphics[width=13.309cm,height=5.318cm]{\Figures/Poly-img009}
-\caption{Illustration de l'arithmétique des pointeurs. Ici, \lstinline!pa! est un pointeur qui pointe avec l'emplacement mémoire de la variable \lstinline!a!. Au dessus, \lstinline!a! est de type \lstinline!long!, et en dessous, \lstinline!a! est de type \lstinline!int!.}
-\label{seq:refFigure8}
-\end{figure}
-
-La figure \ref{seq:refFigure8} illustre ce que signifie exactement ``l'espace mémoire suivant''.
-Supposons que l'adresse en mémoire de \lstinline!a! est \texttt{@(106)}. Si, dans le cas du haut, \lstinline!a! est un \lstinline!long!, (et \lstinline!long *pa!), alors l'adresse pointée par \lstinline!(pa+2)! est 106+16 = \texttt{@(132)}. En revanche, si \lstinline!a! est de type \lstinline!int! alors l'adresse pointée par \lstinline!(pa+2)! sera 106+8 = \texttt{@(116)}.
-
-Il faut comprendre que l'adresse de \lstinline!(pa+2)! est calculée par le compilateur en sachant la taille en mémoire du type de l'objet sur lequel pointe le pointeur (en fait, il utilise le type déclaré du pointeur).
-
-
-\begin{remarque}
-Ceci fonctionne non seulement avec les types de bases (\lstinline!int!, \lstinline!float!, \lstinline!double!), mais avec toutes les structures de données, y compris celles que vous auriez pu définir vous même (\cf la partie du cours sur la définition de types complexes).
-\end{remarque}
-
-\begin{remarque}
-Notez qu'il est également possible d'écrire des choses horribles comme des sommes ou des différences de pointeurs ... mais c'est là o\`u les libertés qu'offre le C lui nuisent~! Mieux vaut ne jamais faire cela ...
-\end{remarque}
-
-\subsubsection{Application aux tableaux}
-
-Comparons maintenant la Figure \ref{seq:refFigure8} ci-dessus et la Figure ci-dessous qui vous rappelle l'organisation en mémoire d'un
-tableau unidimensionnel.
-
-On constate que si un pointeur \lstinline!pa! désigne un élément du tableau, alors \lstinline!pa+1! va désigner l'élément suivant de ce tableau. Et donc, les opérateurs d'incrémentation ou de décrémentation permettent de faire des opérations naturelles sur les indices de tableaux.
-
-\begin{figure}[ht]
-\centering
-\includegraphics[width=10.821cm,height=2.011cm]{\Figures/Poly-img010}
-\end{figure}
-
-{\bfseries
-Un pointeur va pouvoir servir d'indice sur un élément du tableau~!}
-
-Maintenant, si on regarde de plus près le pointeur sur la variable \lstinline!tab!, on constate que le début de l'emplacement mémoire désigné par ce pointeur est le même que le début de l'emplacement mémoire désigné par le premier élément du tableau. La seule différence, importante, est que le type de pointeur est différent : dans le premier cas, l'emplacement mémoire désigné s'étend sur tout le tableau (\eg type \lstinline!int [10]!), et dans un second l'emplacement mémoire ne désigne qu'un élément du tableau (\eg type \lstinline!int!)~: le typage du pointeur à alors toute son importance~!
-
-Prenons maintenant un petit exemple pour voir les manipulations. Soit les déclarations suivantes~:
-\begin{lstlisting}[numbers=none]
-int tab[10];
-int *pi;
-\end{lstlisting}
-
-On peut initialiser le pointeur pour qu'il pointe sur un élément du tableau ainsi~:
-\begin{lstlisting}[numbers=none]
-pi = &z[5]; // pi pointe sur z[5]
-\end{lstlisting}
-
-Ensuite, il est possible de faire des opérations sur le pointeur qui désignera alors d'autres éléments du tableau~:
-\begin{itemize}
-\item \lstinline!pi++!~: \lstinline!pi! désignera alors le 6ème élément du tableau
-\item \lstinline!pi!--~: \lstinline!pi! désignera alors le 4ème élément du tableau (si on repart de la ligne 3 de l'exemple~!)
-\item \lstinline!pi+2!~: \lstinline!pi! désignera alors le 7ème élément du tableau
-\item \lstinline!pi+7!~: \lstinline!pi! désignera alors un élément hors du tableau (Attention~!!)
-\end{itemize}
-
-Maintenant, on peut très bien travailler sur les valeurs du tableau en utilisant l'opérateur de déréférencement~:
-\begin{itemize}
-\item \lstinline!*(pi)!~: donne la valeur de l'élément du tableau pointé
-\item \lstinline!*(pi+1)!~: donne la valeur de l'élément pointé suivant dans le tableau
-\item Plus généralement, \lstinline!*(pi+a)! donne la valeur de l'élément à \lstinline!a! case décalées de l'élément pointé par \lstinline!pi!~!
-\end{itemize}
-
-\begin{warning}
-Si \lstinline!pi! est un pointeur sur le premier élément d'un tableau \lstinline!tab!, et \lstinline!i! un entier alors~:
-\lstinline!p[i]! est équivalent à \lstinline!*(p+i)!
-
-Attention, il faut également que le type du pointeur corresponde au type du tableau, sinon les décalages ne se feront pas correctement~!
-\end{warning}
-
-Il est nécessaire d'avoir une référence absolue (initialisée) telle que \lstinline!pi! pour pourvoir désigner des éléments d'un tableau. En utilisant la seconde remarque tirée de l'observation des Figures précédentes, on peut facilement récupérer le pointeur sur le premier élément du tableau. Il y a juste à s'assurer du bon typage du pointeur.
-
-En C un tableau est un pointeur (avec quelques contraintes sémantiques supplémentaires sur la longueur du tableau). Ceci permet d'écrire l'initialisation d'un pointeur à partir d'une variable tableau.
-
-À la suite de l'exemple précédent, on peut ainsi écrire~:
-\begin{lstlisting}[numbers=none]
-pi=tab;
-\end{lstlisting}
-
-\lstinline!pi! sera alors un pointeur qui désigne le premier élément du tableau.
-
-\begin{remarque}
-Sur les tableaux à dimension multiple, ça ne marche pas aussi simplement à cause du typage de pointeur. L'exemple suivant illustre la façon de procéder pour récupérer un pointeur sur le premier élément d'un tableau d'entiers à 2 dimension. On se contente d'indiquer au compilateur qu'il faut utiliser le début de
-tableau de \lstinline!tab! comme début d'emplacement mémoire, mais qu'il faut l'interpréter comme un emplacement qui contient un entier~: ceci est entièrement de la responsabilité du programmeur, et donc un peu dangereux~!
-
-\begin{lstlisting}[numbers=none]
-int tab[10][5], *pi;
-pi=(int *)tab;
-\end{lstlisting}
-\end{remarque}
-
-\begin{exercice}[À vos crayons !]
-Faire un dessin pour illustrant les emplacements mémoire utilisés dans le programme suivant, et donner la valeur de \lstinline!x!.
-\begin{lstlisting}[numbers=none]
-int a[10];
-int *pa;
-pa = &a[0];
-int x=*pa;
-\end{lstlisting}
-\end{exercice}
-
-\begin{exemple}[Initialisation d'un tableau]
-L'exemple ci-dessous illustre l'\textbf{initialisation d'un tableau en utilisant des pointeur}~:
-\begin{lstlisting}
-int a[10];
-int *pa=a; // pa pointe sur le premier element du tableau
-for (int i=0; i<10;i++) {
- //initialisation du i-eme element du tableau:
- *(pa + i)= 1;
-}
-//ICI: pa pointe sur le premier element du tableau
-\end{lstlisting}
-
-l'exemple suivant est encore plus rapide~:
-\begin{lstlisting}
-pa = &a[0]; // pa pointe sur le premier element du tableau
-for(int i=0; i<10; i++) \{
- //initialisation du i-eme element du tableau:
- *pa = 1;
- pa++;
-}
-//ICI: pa pointe sur le dernier element du tableau
-\end{lstlisting}
-
-
-Ce second exemple est plus rapide que le premier grâce à l'utilisation de l'opérateur \lstinline!pa++!. Avec cet opérateur, il faut une seule instruction pour pointer sur l'indice suivant, alors que dans le premier cas, il faut d'une part faire l'incrémentation de \lstinline!i! et, d'autre part, l'addition de \lstinline!i! avec \lstinline!pa!. Donc on a divisé par deux le nombre d'instructions nécessaire pour cette opération~!
-
-Attention néanmoins à la différence en sortie de boucle~: \lstinline!pa! ne pointe pas vers les mêmes objets dans les deux cas~!
-\end{exemple}
-
-\begin{exercice}[Pointeurs]
-Indiquer quels seront les affichages produits par ce programme~:
-\begin{lstlisting}
-#include <stdio.h>
-int a[]={0,1,2,3,4};
-int main()
-{
- int i, *p;
- for( i=0; i<=4; i++) {
- printf("a[\%d] = %d, ", i, a[i]);
- }
- printf("\n");
- for( p=&a[0]; p<=&a[4]; p++) {
- printf("*p = %d, ", *p);
- }
- printf("\n");
- for( p=&a[0], i=1; i<=5; i++) {
- printf("p[%d] = %d, ", i, p[i]);
- }
- printf("\n");
- for( p=a, i=0; p+i<=a+4; p++, i++) {
- printf("*(p+%d) = %d, ", i, *(p+i));
- }
- printf("\n");
-}
-\end{lstlisting}
-
-\begin{Solution}
-\lstinline!a! est un tableau d'entiers mis en variable globale, \lstinline!i! est un entier et \lstinline!p! un pointeur sur un entier.
-
-Pour chaque boucle, les affichages se font sur une ligne et entre les boucles il y a des sauts de lignes.
-
-La première boucle est un simple parcours du tableau, rien de bien méchant.\\
-Dans la seconde boucle, l'itération s'effectue sur le pointeur \lstinline!p! de la position \lstinline!&a[0]!, c'est à dire la première case du tableau (équivalent à \lstinline!a!) jusqu'à la dernière case. On utilise l'opérateur \lstinline!p++! pour passer d'une case à l'autre du tableau. Comme on affiche \lstinline!*p!, on affiche à chaque fois ce sur quoi pointe \lstinline!p!, soit les case successive du tableau \lstinline!a!.\\
-Dans la troisième boucle, \lstinline!p! est initialisé en pointant sur la première case du tableau et on fait évoluer \lstinline!i! de 1 à 5. Comme on affiche \lstinline!p[i]!, on affiche la valeur pointé par \lstinline!p! déclalé de \lstinline!i! cases. On a donc un décalage dans le parcours du tableau et le dernier affichage sera très aléatoire ... c'est un dépassement de tableau! \\
-Dans la quatrième boucle, on utilise toujours un décalage, mais écrit différemment ... cette fois-ci tout fonctionne (attention, bien s'assurer de comprendre tous les détails, il y a plein d'astuces dans ce code !)
-
-Les affichages seront les suivants :
-\begin{verbatim}
-a[0] = 0, a[1] = 1, a[2] = 2, a[3] = 3, a[4] = 4,
-*p = 0, *p = 1, *p = 2, *p = 3, *p = 4,
-p[1] = 1, p[2] = 2, p[3] = 3, p[4] = 4, p[5] = 12542,
-*(p+0) = 0, *(p+1) = 1, *(p+2) = 2, *(p+3) = 3, *(p+4) = 4,
-\end{verbatim}
-\end{Solution}
-\end{exercice}
-
-\begin{exercice}[Voisinage dans un tableau à deux dimensions]
-
-On considère un tableau d'entier à 2 dimensions de taille $n \times m$ (\lstinline!int tab[n][m]!). Soit \lstinline!pi! un pointeur sur un élément de ce tableau (\lstinline!int *pi!). Indiquer, à partir de \lstinline!pi!, comment désigner simplement les éléments suivants du tableau~:
-\begin{itemize}
-\item l'élément à droite de celui désigné par \lstinline!pi!,
-\item l'élément à gauche de celui désigné par \lstinline!pi!,
-\item l'élément au dessus de celui désigné par \lstinline!pi!,
-\item l'élément, en diagonale, en dessous et à droite de celui désigné par \lstinline!pi!
-\end{itemize}
-Aide~: On considère qu'on se trouve bien au milieu du tableau, et pas sur un bord~! La taille du tableau est une donnée utile.
-
-\begin{Solution}
-
-Avant de répondre à cette question, il faut convenir de ce qui est ligne et de ce qui est colonne. Ici, on suppose que \lstinline!tab! comporte $n$ lignes et $m$ colonnes. \lstinline!tab[k]! désigne donc la k-ieme ligne (un tableau de $m$ valeurs).
-
-\begin{itemize}
-\item l'élément à droite de celui désigné par \lstinline!pi! : \lstinline!pi+1!,
-\item l'élément à gauche de celui désigné par \lstinline!pi! : \lstinline!pi-1!,
-\item l'élément au dessus de celui désigné par \lstinline!pi! : \lstinline!pi-m!,
-\item l'élément, en diagonale, en dessous et à droite de celui désigné par \lstinline!pi! : \lstinline!pi+m+1!
-\end{itemize}
-\end{Solution}
-\end{exercice}
-
-
-
-\subsection{Utiliser les pointeurs dans les paramètres de fonction}
-Il faut se rappeler que les fonctions utilisent un mécanisme de passage de paramètre par valeurs~: c'est à dire que les valeurs mis en arguments d'une fonction (lors de sont appel) sont ``recopiés localement'' pour l'exécution d'une fonction. Si, dans la fonction, on modifie la valeur de la variable paramètre, cela n'aura aucun effet sur la variable-argument qui a été utilisée lors de l'appel de la fonction.
-
-Lorsqu'on passe un pointeur en paramètre d'une fonction, c'est la même chose~: la valeur du pointeur, donc son adresse, est recopiée. En revanche, l'emplacement mémoire qui était désigné par l'argument-pointeur est le même que celui qui est désigné par le paramètre-pointeur et donc \textbf{si vous modifiez le contenu de l'emplacement désigné par le pointeur à l'intérieur d'une fonction, cette modification aura les mêmes conséquences à l'extérieur de la fonction appelée.}
-
-Mieux vaut un petit schéma qu'un long discours, voici une illustration pour le programme ci-dessous~:
-
-\begin{lstlisting}
-void modif(int *pp)
-{
- int i=0;
- *pp=20;
- pp=&i;
-}
-
-int main()
-{
- int val=10;
- int *pa=&val;
- modif(pa);
- printf("%d\n",val); //Affiche 20
-}
-\end{lstlisting}
-
-
-\begin{figure}[ht]
-\centering
-\includegraphics[width=0.7\textwidth]{\Figures/Poly-img011}
-\end{figure}
-
-Voici deux programmes qui semblent à première vue très similaire, mais le résultat va être très différent. Dans le premier, les paramètres de la fonction \lstinline!echanger! sont passés \textbf{par valeurs}, alors que dans le second cas on passe les paramètres \textbf{par pointeurs}.
-
-\begin{exemple}
-Premier cas~: affiche \texttt{12, 16}
-\begin{lstlisting}
-//Fonction avec passage des parametres par valeurs
-void echanger(int a, int b) {
- int temp;
- temp = x;
- x = y;
- y = x;
-}
-
-int main(void) {
- int a =12, b=16;
- echanger(a, b);
- printf("%d, %d\n", a,b);
-}
-\end{lstlisting}
-
-Second cas~: affiche \texttt{16, 12}
-\begin{lstlisting}
-//Fonction avec passage des parametres par pointeurs
-void echanger(int *x, int *y) {
- int temp;
- temp = *x;
- *x = *y;
- *y = *x;
-}
-
-int main(void) {
- int a =12, b=16;
- echanger(&a, &b);}
- printf("%d, %d\n", a,b);
-}
-\end{lstlisting}
-\end{exemple}
-
-Quel est l'intérêt du passage de pointeurs comme paramètres de fonctions~:
-
-\begin{enumerate}
-\item on peut éviter de recopier les données lors d'un appel de fonction. Lorsque les arguments sont des types simples, la recopie n'est pas longue, mais si vous aviez une structure de données lourde, ça peut être inefficace de la recopier systématiquement.
-\item on peut travailler par effet de bords, c'est-à-dire produire des effets dans une fonction qui ont des impactes à l'extérieur de la fonction (pas vraiment conseillé, mais parfois pratique~!)
-\end{enumerate}
-
-\subsection{Exercices}
-
-\begin{exercice}[Manipulation des pointeurs]
-
-\question{Opérations élémentaires sur les pointeurs}
-
-\begin{lstlisting}
-void main()
-{
- int A = 1;
- int B = 2;
- int C = 3;
- int *P1, *P2;
- P1=&A;
- P2=&C;
- *P1=(*P2)++;
- P1=P2;
- P2=&B;
- *P1-=*P2;
- ++*P2;
- *P1*=*P2;
- A=++*P2**P1;
- P1=&A;
- *P2=*P1/=*P2;
- return 0;
-}
-\end{lstlisting}
-
-Copiez le tableau suivant et complétez-le pour chaque instruction du programme ci-dessus.
-\begin{center}
-\begin{tabular}{|l|c|c|c|c|c|}
-\hline
- & A & B & C & P1 & P2 \\ \hline
- Init & 1 & 2& 3& / & /\\
- P1=\&A & 1& 2& 3& \&A & \\
- P2=\&C & & & & & \\
- *P1=(*P2)++ & & & & & \\
- P1=P2 & & & & & \\
- P2=\&B & & & & & \\
- *P1-=*P2 & & & & & \\
- ++*P2 & & & & & \\
- *P1*=*P2 & & & & & \\
- A=++*P2**P1 & & & & & \\
- P1=\&A & & & & & \\
- *P2=*P1/=*P2 & & & & & \\ \hline
-\end{tabular}
-\end{center}
-
-\question{arithmétique des pointeurs}
-On déclare les variables suivantes :
-\begin{lstlisting}
-int A[] = {12, 23, 34, 45, 56, 67, 78, 89, 90};
-int *P;
-P = A;
-\end{lstlisting}
-
-Quelles valeurs ou adresses fournissent ces expressions (ou les erreurs):
-\begin{enumerate}
-\item *P+2
-\item *(P+2)
-\item \&P+1
-\item \&A[4]-3
-\item A+3
-\item \&A[7]-P
-\item P+(*P-10)
-\item *(P+*(P+8)-A[7])
-\end{enumerate}
-
-\begin{Solution}
-\question{}
-
-\question{}
-
-*P désigne le premier élément de A, donc
-
-\begin{enumerate}
-\item *P+2 = 14
-\item *(P+2) = 34
-\item \&P+1 est l'adresse à côté celle de la variable P (valeur ???)
-\item \&A[4]-3 est l'adresse du second élément du tableau A
-\item A+3 (ceci doit provoquer une erreur et au mieux désigne l'adresse du quatrièmement élément de A : 1er élément décalé de 3)
-\item \&A[7]-P : ici c'est la différence d'adresse entre le 8ème élément de A et le premier élément de A (P), donc 7 (NB: la différence d'adresse n'a généralement pas de sens)
-\item P+(*P-10) : de nouveau, c'est absurde, on additionne des adresses avec des valeurs ... mais admettons *P-10 donne 2, donc P+2 est l'adresse du troisième élément de A !
-\item *(P+*(P+8)-A[7]) : *(P+8)-A[7] donne 89-78 = 11, on cherche donc *(P+11) : on tombe en dehors du tableau ...
-\end{enumerate}
-
-C'est vraiment absurde comme exercice ... je vous l'accorde ! Mais celui qui a tout bon à tout compris aux pointeurs !!
-
-\end{Solution}
-\end{exercice}
-
-% \begin{exercice}[Compréhension des pointeurs]
-%
-% Dans les questions suivantes, on vous fournit des programmes et on vous demande d'indiquer ce que vont afficher ces programmes\footnote{Copier et compiler les programmes pour vérifier ... mais bien évidemment, il faut mieux y réfléchir avant de les faire tourner.}.
-%
-% \question{Notion d'adresse en C. Opérateur \&}
-%
-% \lstinputlisting{\Sources/pointeurs_1.c}
-%
-% \question{Operateur *}
-%
-% \lstinputlisting{\Sources/pointeurs_2.c}
-%
-% \question{Arithmétique des pointeurs}
-%
-% Dans cet exemple, on montre s'intéresse à l'incrémentation d'un pointeur.
-%
-% \lstinputlisting{\Sources/pointeurs_3.c}
-%
-%
-% \begin{Solution}
-% \question{}
-% \begin{verbatim}
-% Variables globales
-% la valeur de i_global 270
-% l'adresse de i_global 134520864 (804a020)
-% la valeur de c_global 67
-% l'adresse de c_global 134520860 (804a01c)
-% Variables locales
-% la valeur de i 270
-% l'adresse de i -1079921784 (bfa1b388)
-% la valeur de c 67
-% l'adresse de c -1079921777 (bfa1b38f)
-% \end{verbatim}
-% \question{}
-% \begin{verbatim}
-% la valeur de i 3
-% l'adresse de i 3220915596 (bffb458c)
-% la valeur de ptr_int 3220915596 (bffb458c)
-% la valeur pointee par ptr_int 3
-%
-% Apres incrementation du contenu *ptr_int
-% la valeur de i 5
-% l'adresse de i 3220915596 (bffb458c)
-% la valeur de ptr_int 3220915596 (bffb458c)
-% la valeur pointee par ptr_int 5
-% \end{verbatim}
-% \question{}
-% \begin{verbatim}
-% valeur de a[0] = 0
-% adresse de a[0] = 3214156716 (bf9423ac)
-% valeur de ptr_int= 3214156716 (bf9423ac)
-% valeur pointee par ptr_int = 0
-%
-% apres incrementation de *ptr
-%
-% valeur de a[0] = 2
-% adresse de a[1] = 3214156720 (bf9423b0)
-% valeur de ptr_int apres (ptr_int++) 3214156720 (bf9423b0)
-% nombre d'entiers entre ptr_int (bf9423b0) et a[0] (bf9423ac) = 1
-% nombre de caracteres entre ptr_int (bf9423b0) et a[0] (bf9423ac) = 4
-% \end{verbatim}
-% \end{Solution}
-% \end{exercice}
-
-\begin{exercice}[incrémentation ou décrementation ??]
- \begin{lstlisting}
-void incrdecr(long *T, int n)
-{
- int i=0;
- long *p = T;
- for(; i<n; n++) {
- (*p)--;
- p++;
- }
-}
- \end{lstlisting}
-
-\question{Que fait cette fonction ?}
-\begin{Solution}
- Ce programme décremente les \lstinline!n! premières valeurs d'un tableau commençant à l'emplacement mémoire \lstinline!T!, en supposant que \lstinline!T! contienne au moins \lstinline!n! valeurs.
-\end{Solution}
-\end{exercice}
-
-\begin{exercice}[Tableaux de pointeurs]
-
-\question{Représentation des objets en présence}
-Dans la fonction \lstinline!main()!, on déclare et initialise les variables suivantes :
-\begin{lstlisting}
-char string0[]="Chaine A";
-char string1[]="Chaine B";
-char string2[]="Chaine C";
-
-char *temp=0; // pointeur sur une chaine de caracteres
-
-char *ps[3]; // Tableau de taille 3 contenant des pointeurs sur ces chaines de caracteres
-ps[0]=string0;
-ps[1]=string1;
-ps[2]=string2;
-\end{lstlisting}
-
-Représenter par une boîte chacune des chaines de caractères et par une seconde boîte le tableau \lstinline!ps! et faites des flèches pour indiquer ce sur quoi pointe chaque pointeur.
-
-\question{Fonction d'affichage}
-Écrire une fonction d'affichage avec le profil suivant : \lstinline!void affichage(char *tab[3])! qui pourra prendre en paramètre \lstinline!ps! et qui affichera les 3 chaînes de caractères pointées par \lstinline!tab! dans l'ordre du tableau.
-
-\question{Évolution}
-Pour chacune des instructions suivantes, refaire le schéma précédent en modifiant les flèches ! Indiquer le résultat des affichages.
-
-\NB On pourra également représenter également le pointeur \lstinline!temp!.
-
-\begin{lstlisting}
-temp=ps[1];
-ps[1]=ps[2];
-ps[2]=temp;
-affichage(ps);
-(*temp)[7]='D';
-ps[0]=temp;
-affichage(ps);
-\end{lstlisting}
-\end{exercice}
-%
-% \begin{exercice}[Pointeurs et chaînes de caractères]
-% \question{Longueur d'une chaîne}
-% \'Ecrire une fonction \lstinline!uint strlen(char *)! qui prend en paramètres une chaîne de caractères et qui retourne sa longueur (on se souviendra qu'un chaîne de caractère finit par le caractère \lstinline!'\0'!).
-%
-% \question{Compter des caractères}
-% \'Ecrire une fonction \lstinline!uint nbchar(char *s, char a)! qui compte le nombre d'occurrence du caractère \lstinline!a! dans la chaîne \lstinline!s!.
-%
-% \question{Comparaison de chaînes de caractères}
-% \'Ecrire une fonction \lstinline!uint strcmp(char *s1, char *s2)! qui retourne 0 si les deux chaînes \lstinline!s1! et \lstinline!s2! sont identiques, et retourne la \lstinline!position+1! du premier caractère différent entre les deux chaînes.
-%
-% \NB Dans la mesure où les positions commencent à 0, on sait que \lstinline!position+1! sera toujours différent de 0.
-%
-% \NB Les fonctions \lstinline!uint strlen(char *)!, \lstinline!uint nbchar(char *s, char a)! et \lstinline!uint strcmp(char *s1, char *s2)! existent dans la librairie \lstinline!string.h!. L'objectif est ici de les réimplémenter.
-% \end{exercice}
-
-
-\section{Gestion dynamique de la mémoire}\label{sec:gestiondynamique}
-Jusque là, les pointeurs permettaient de désigner des emplacements mémoires qui correspondent à des variables déclarées dans votre programme. La gestion dynamique de la mémoire va vous permettre de déclarer des emplacements mémoires purement désignés par des pointeurs (sans avoir de référence symbolique dans le programme).
-Notez que cela modifie la définition initiale d'un pointeur (Définition \ref{def:Pointeur}.) qui ne doit plus être vu que comme une adresse sur un emplacement mémoire.
-
-L'intérêt va encore se montrer important pour les tableaux. En particulier, cela va lever l'impossibilité que nous avions jusque là de déclarer des tableaux dont la taille n'est pas connue par le programmeur mais pourrait l'être lors de l'exécution.
-
-Nous allons présenter trois fonctions de la librairie \lstinline!stdlib.h!~:
-
-\begin{itemize}
-\item Fonction \lstinline!malloc!~: fonction d'allocation de mémoire
-\begin{lstlisting}[numbers=none]
- void *malloc( size_t s)
-\end{lstlisting}
-
-\item Fonction \lstinline!free!~: fonction de libération de mémoire
-\begin{lstlisting}[numbers=none]
-void free(void *)
-\end{lstlisting}
-
-\item Fonction \lstinline!sizeof!~: fonction qui calcule la place mémoire nécessaire d'un type de données
-\begin{lstlisting}[numbers=none]
-size_t sizeof(type_t t)
-\end{lstlisting}
-\end{itemize}
-
-\begin{exemple}[Allocation de mémoire]
-Exemple d'utilisation typique de ces fonctions~:
-\begin{lstlisting}
-int *p=0;
-p = (int *)malloc( sizeof(int) );
-*p=3400; //initialisation de l'emplacement memoire
-...// utilisation de l'emplacement memoire
-free(p); //libere l'emplacement mémoire
-\end{lstlisting}
-\end{exemple}
-
-
-\subsection{Allocation dynamique de la mémoire}
-\begin{definition}[Allocation dynamique]
-L'allocation de la mémoire consiste à réserver, auprès du système d'exploitation, un emplacement de la mémoire pour le besoin de l'exécution d'un programme. L'allocation est dite dynamique lorsqu'elle se fait lors de l'exécution du programme et qu'elle n'est que partiellement prévisible lors de la programmation.
-\end{definition}
-
-La fonction \lstinline!malloc! alloue de l'espace mémoire de la taille demandée et retourne un \textit{pointeur pur} (type \lstinline!void *!) sur le début de l'espace mémoire alloué.
-
-La taille demandée est fournie en paramètre de la fonction \lstinline!malloc!. Cette taille ne peut être inventée par vos soins~! Vous disposer de la fonction \lstinline!sizeof(...)! pour répondre correctement à la question de la taille mémoire.
-
-La fonction \lstinline!sizeof! donne la taille mémoire d'une variable à partir de son type. Par exemple~:
-
-\begin{itemize}
-\item \lstinline!sizeof(double)! donne la taille mémoire d'un \lstinline!double!,
-\item \lstinline!sizeof(uint)! donne la taille mémoire d'un \lstinline!unsigned integer!.
-\item \lstinline!sizeof(montype)! donne la taille mémoire d'une structure de données personnelle (nommée \lstinline!montype!)
-\end{itemize}
-
-\subsubsection{Allocation d'une variable}
-Utilisation dans le cas de l'allocation d'un emplacement pour une valeur de type \lstinline!montype! (peut être un type de base ou une structure de données)~:
-
-\begin{lstlisting}[numbers=none]
- montype *p = (montype *)malloc( sizeof(montype) );
-\end{lstlisting}
-
-Comme la fonction \lstinline!malloc! retourne un pointeur pur, il est nécessaire de faire la conversion explicite vers le type de pointeur désiré pour pouvoir affecter la variable \lstinline!p!.
-
-\subsubsection{Allocation d'un tableau}
-Si on veut allouer un tableau de données, il suffit d'utiliser le nombre d'éléments que doit comporter le tableau pour en déduire la taille de l'emplacement mémoire (par une simple multiplication).
-
-Pour allouer dynamiquement un tableau d'entiers de taille 10, on aura~:
-\begin{lstlisting}[numbers=none]
-int *tabint = (int *)malloc( sizeof(int) * 10 );
-\end{lstlisting}
-et pour tableau de taille \lstinline!x!, il est toujours possible d'écrire~:
-\begin{lstlisting}[numbers=none]
-int *tabint = (int *)malloc( sizeof(int) * x );
-\end{lstlisting}
-
-L'intérêt des pointeurs est ici mis en évidence dans le second exemple, car s'il est possible d'écrire \lstinline!int tabint[10]! pour déclarer un tableau de 10 entier comme dans le premier exemple, il est impossible d'écrire en C : \lstinline!int tabint[x]!~!!
-
-
-Si vous souhaitez déclarer dynamiquement un tableau à dimension multiple, il faut soit allouer le tout en 1 fois (solution efficace en calcul) et ``voir'' ce tableau linéaire comme un tableau à plusieurs dimension en jouant avec les indices, soit faire un tableau de ligne manuellement.
-
-Dans la mesure o\`u le pointeur désigne un emplacement mémoire qui ne réfère à une variable du programme, alors l'initialisation (et plus généralement l'affectation) du contenu de l'emplacement mémoire doit se faire au travers du pointeur. Par exemple~:
-\begin{lstlisting}[numbers=none]
-int *pi=(int *)malloc( sizeof(int) );
-*pi=0;
-\end{lstlisting}
-
-
-\subsubsection{Limitation dans l'allocation de la mémoire}
-C'est le système d'exploitation (le MMU du système d'exploitation) qui est en charge d'allouer la mémoire aux programmes qui s'exécutent sur un ordinateur. Mais la ressource n'est pas infinie~!
-Alors il est possible que si vous êtes trop gourmand, alors la fonction malloc retourne la valeur NULL auquel cas, le système ne vous aura pas trouver la mémoire nécessaire pour faire fonctionner votre programme.
-
-Pour information, le maximum de mémoire utilisable par un processus est un paramètre du noyau Linux (qui peut être changé à la compilation du noyau). De mémoire, un noyau standard propose 4Go de mémoire avant d'exploser~! Y'a de la marge ... mais pas tant que ça~! Pour des applications scientifiques lourdes, ça peut
-rapidement se montrer insuffisant (sans compter les courantes fuites de mémoire ... qui seront présentées dans la section suivante).
-
-\begin{definition}[Calcul en place]
-On parle de calcul en place (ou un algorithme en place) lorsque l'utilisation de la mémoire est bornée par une valeur prédéfinie pour toutes les exécutions du programme (et en particulier pour toutes les données d'entrée).
-C'est une bonne propriété d'un algorithme qu'on obtient généralement au dépend de son efficacité.
-\end{definition}
-
-\subsection{Exemple complet}
-
-Exemple d'application de l'allocation dynamique de mémoire : récupérer des saisies d'un utilisateur en nombre non-prédéfinie. On veut, par exemple, calculer la moyenne des nombres fournis par un utilisateur, sans lui imposer le nombre de nombres à entrer. Le programme va d'abord demander combien de nombres l'utilisateur veut entrer puis en faire la saisie dans un tableau.
-
-Ce problème ne peut pas se résoudre sans allocation dynamique, car on n'impose aucune limite de nombre à l'utilisateur. Il faut donc attribuer une taille au tableau de valeurs lors de la saisie de la première information.
-
-Hop... on y va~:
-\begin{lstlisting}
-#include <stdlib.h>
-#include <stdio.h>
-int main(void)
-{
- int tailleTableau=0;
- int nbreSaisis=0;
- double *floatTable=NULL;
- //Recuperation de la taille du tableau
- printf("Donner le nombre de nombres a rentrer\n");
- scanf("%d", &tailleTableau);
- if(tailleTableau <=0) \{
- printf("\t => saisie incorrecte\n");
- return 1;
- }
- //ICI tailleTableau >0
- //Allocation de la memoire pour le tableau de taille tailleTableau
- floatTable = (double *)malloc( sizeof(double)*tailleTableau );
- if( floatTable==NULL ) {
- printf("\t => Une erreur est survenue lors de l'allocation de la memoire\n");
- return 1;
- }
- //ICI: floatTable pointe sur un emplacement memoire de tailleTableau doubles !
- double *p=floatTable; // p designe un pointeur sur l'emplacement à remplir
- while( nbreSaisis < tailleTableau) {
- printf("Entrer votre nombre (%d/%d)\n",nbreSaisis, tailleTableau);
- if( scanf("%lf", p)~!= 1 )
- //Recuperation de la valeur (que l'on place directement dans l'emplacement pointe par p, c'est a dire l'emplacement courant a remplir !}
- //ICI la saisie n'a pas permis de reconnaitre un double
- printf("\terreur de saisie\n");
- return 1;
- }
- p++; //On passe a l'emplacement suivant
- nbreSaisis++; //Incrementation
- }
- //ICI toutes les données ont ete saisies
- printf("merci\n");
-
- //TODO HERE : traiter les donnees du tableau !
-
- free(floatTable); // On libere la memoire
- floatTable=NULL; // On place floatTable à NULL pour indiquer que le pointeur ne pointe plus sur rien !
- return 0;
-}
-\end{lstlisting}
-
-
-Avec cet exemple, vous êtes en mesure d'allouer un tableau de taille variable. Mais vous devez tout de même savoir quel sera la taille du tableau avant de le remplir ... Les structures comme les listes chaînées permettent de s'abstraire de cette contrainte.
-
-\subsection{Libération de la mémoire}
-
-Une fois la mémoire utilisée, il est nécessaire de la libérer proprement~! C'est un engagement implicite d'un programme par rapport au système d'exploitation~: dès que la mémoire allouée dynamiquement n'est plus utile, il est poli de la rendre à la communauté de processus pour qu'ils en bénéficient.
-
-\begin{definition}[Fuite de mémoire]
-Lorsqu'un programme a une fuite de mémoire, c'est qu'il alloue de plus en plus de mémoire sans la libérer.
-\end{definition}
-
-Un tout petit oubli de libération de mémoire par le programmeur peut avoir de grandes conséquences si le programme passe des milliers de fois sur cet oubli. Ceci peut aller jusqu'à la défaillance de tout le système d'exploitation.
-
-Pour libérer de la mémoire, rien de plus simple, il suffit d'appeler la fonction \lstinline!free! en passant en paramètre un pointeur qui désigne l'emplacement mémoire à libérer et voilà (\cf exemple précédent, ligne 47)!
-
-Une fois la mémoire libérée, l'emplacement n'appartient plus au programme, il est alors prudent de passer la valeur du pointeur à \lstinline!NULL! de sorte à ne plus garder trace d'un lien avec cet emplacement mémoire (\cf exemple précédent, ligne 41).
-
-\begin{warning}
-Il est possible de perdre la trace d'un emplacement mémoire alloué, auquel cas vous serez dans l'impossibilité de le libérer plus tard.
-\begin{lstlisting}
-int i=0;
-int *pi=(int *)malloc( sizeof(int) );
-*pi=20;
-pi= &i; // cette instruction fait perdre l'adresse de l'emplacement mémoire alloué dynamiquement!
-\end{lstlisting}
-\end{warning}
-
-\begin{warning}
-Les emplacements mémoires libérés sont perdus \textbf{définitivement}~! Si vous essayez de lire dans un emplacement mémoire libéré, c'est comme lire dans un emplacement non-alloué : vous ne savez pas ce qu'il contient, et quelles seront les conséquences de sa modification~!
-\end{warning}
-
-\begin{remarque} [État en mémoire des emplacements libérés]
-
-\textbf{La libération mémoire laisse la mémoire dans l'état où elle est}. Il est de la responsabilité du programmeur d'\textit{effacer} les informations pour qu'elles ne soient plus lisibles.
-
-En programmation défensive\footnote{La programmation défensive est un mode de programmation o\`u on vérifie plutôt deux fois qu'une que tout ce passe normalement au dépend de l'efficacité calculatoire.}, on replace toute la mémoire à \lstinline!NULL! avant de la libérer.
-\end{remarque}
-
-
-
-{\bfseries
-Tout l'intérêt et le problème de l'allocation et la libération dynamique de mémoire, c'est que c'est un travail dont le programmeur à l'entière responsabilité.}
-
-
-\begin{exercice}[Allocation et libération mémoire]
-
-On donne le programme ci-dessous :
- \lstinputlisting{\Sources/pointeurs_4.c}
-
-\question{Commentez ce programme, et essayez de prévoir le comportement de la mémoire (faire des dessins).}
-\question{Copiez, compilez et faites tourner ce programme.}
-\question{Réécrivez ce programme en affichant également les adresses des cases mémoires affichées. Qu'en déduisez vous ?}
-
-\textit{\underline{Aide :}} pour faire afficher l'adresse mémoire d'un pointeur \lstinline!p! en code hexadécimal, utiliser l'instruction \lstinline!printf("%x\n", p)!.
-
-\begin{Solution}
-L'affichage du programme est le suivant :
-\begin{verbatim}
-Valeur actuelle de la donnee referencee par ptr = 1
-Valeur actuelle de la donnee referencee par ptr = 2
-Valeur actuelle de la donnee referencee par ptr = 8
-Valeur actuelle de la donnee referencee par ptr = 3
-Valeur actuelle de la donnee referencee par ptr = 4
-Valeur actuelle de la donnee referencee par ptr = 10
-Valeur actuelle de l'element 0 du tableau dynamique défini par ptr = 1
-Valeur actuelle de l'element 1 du tableau dynamique défini par ptr = 5
-Valeur actuelle de l'element 2 du tableau dynamique défini par ptr = 10
-Valeur actuelle de l'element 3 du tableau dynamique défini par ptr = 15
-Valeur actuelle de l'element 4 du tableau dynamique défini par ptr = 20
-\end{verbatim}
-\end{Solution}
-\end{exercice}
-
-\section{Correction des exercices}
-\Closesolutionfile{solutions}
-\Readsolutionfile{solutions}
\ No newline at end of file
diff --git a/Polyc/Poly.cls~ b/Polyc/Poly.cls~
deleted file mode 100644
index f0a8d5ef5e9603709dab6738ae2474db1296f664..0000000000000000000000000000000000000000
--- a/Polyc/Poly.cls~
+++ /dev/null
@@ -1,468 +0,0 @@
-%% -------------------------------------------------------------
-%%
-%% This is the original source file `FormatBook.cls',
-%% No Copyright 2010
-%%
-%% author : Thomas Guyet, thomas.guyet@agrocampus-ouest.fr
-%% --------------------------------------------------------------
-%%
-%% It may be distributed and/or modified under the
-%% any conditions.
-%%
-
-\NeedsTeXFormat{LaTeX2e}
-\ProvidesClass{Poly}
-\usepackage[utf8]{inputenc}
-\RequirePackage[frenchb]{babel}
-\RequirePackage{}
-\RequirePackage{fancyhdr}
-\RequirePackage{ae}
-\RequirePackage{amsmath, amsfonts, amssymb, textcomp}
-\RequirePackage{graphicx}
-\RequirePackage{color}
-\RequirePackage{verbatim}
-\RequirePackage{ifthen}
-\RequirePackage{lipsum,framed}
-\RequirePackage{answers} % Package pour la gestion des exercices avec correction différée!
-
-\RequirePackage[T1]{fontenc}
-%\RequirePackage{arev}
-%\RequirePackage{iwona}
-%\RequirePackage{kurier}
-\RequirePackage{fourier}
-
-\RequirePackage{appendix}
-
-
-%pour faire apparaître une image de fond
-\newcommand{\bgimg}[1]{
-\AddToShipoutPicture
- {
- \put(\LenToUnit{0 cm},\LenToUnit{0 cm})
- {
- \includegraphics[width=\paperwidth,height=\paperheight]{#1}
- }
- }
-}
-
-
-%Sur la base d'un book : on passe les options
-%\DeclareOption*{\PassOptionsToClass{\CurrentOption}{book}}
-%\ProcessOptions
-\LoadClassWithOptions{book}
-
-
-% -------- Commandes de Writer2Latex
-%\newcommand\textsubscript[1]{\ensuremath{{}_{\text{#1}}}}
-
-
-%-------Réglage de la taille de la page ------
-\setlength{\textwidth}{16 cm} %Largeur du texte
-\setlength{\textheight}{23 cm}%Hauteur de texte
-\setlength{\topmargin}{-1 cm}
-%\setlength{\oddsidemargin}{0 cm} %Marge a gauche <0 pour réduire
-\setlength{\evensidemargin}{0 cm} %Marge a gauche <0 pour réduire
-
-
-%% Redéfinition de la page de garde!
-%% Utilisation logo
-%% Bas de page avec date de la dernière version!
-
-%Quelques variables globales supplémentaires
-\global\let\@subtitle\@empty
-\global\let\@annees\@empty
-\global\let\@institution\@empty
-\global\let\@pagewebcours\@empty
-\global\let\@version\@empty
-\newcommand{\subtitle}[1]{\def\@subtitle{#1}}
-\newcommand{\annees}[1]{\def\@annees{#1}}
-\newcommand{\institution}[1]{\def\@institution{#1}}
-\newcommand{\pagewebcours}[1]{\def\@pagewebcours{\href{#1}{#1}}}
-\newcommand{\version}[1]{\def\@version{#1}}
-
-\version{1.0}
-
-
-\renewcommand\maketitle{\begin{titlepage}%
- \newpage
- \thispagestyle{empty}
- \null
- \vskip -2cm
- \begin{figure}[h]
- \includegraphics{Figures/logo-agrocampusouest}
- \end{figure}
-
- \vskip 15em
-
- \begin{center}
- \let \footnote \thanks
- {\Huge \@title \par}
- {\LARGE \@subtitle \par}
- \vskip 6em
- {\large
- \lineskip .5em%
- \begin{tabular}[t]{c}
- \@author
- \end{tabular}\par}
- \vskip 1em
- {\large \@institution}
- \end{center}
-
- \vfill
-
- {\small
- Version \@version, Dernière modification : \@date\\
- \@pagewebcours
- }
- \end{titlepage}%
- \newpage
- \thispagestyle{empty}
- \pagestyle{fancy}
-}
-\renewcommand\contentsname{Table des matières}
-
-%-------Définition de la page par défaut -----
-\pagestyle{fancy}
-%\fancyhead[LO]{\it \@title}
-%\fancyhead[RO]{\it \title}
-%\fancyhead[C]{}
-%\fancyhead[RO]{\it \@title}
-\fancyhead[LE]{\it \@title - \@author}
-\fancyhead[RE]{}
-%\fancyfoot[L]{}
-\fancyfoot[CO]{}
-\fancyfoot[CE]{}
-\fancyfoot[LE]{\thepage}
-\fancyfoot[RO]{\thepage}
-
-%% Utilisation du package HyperRef pour faire de liens
-\RequirePackage[pdftex]{hyperref}
-% \makeatletter
-% \AtBeginDocument{
-% \hypersetup{
-% pdftitle = {\@title},
-% pdfauthor = {\@author}
-% }
-% }
-% \makeatother
-
-%% Utilisation de la couleuyr pour le package listing
-\RequirePackage{color}
-\definecolor{Brown}{cmyk}{0,0.81,1,0.60}
-\definecolor{Green}{cmyk}{0.64,0,0.95,0.40}
-\definecolor{Blue}{cmyk}{0.62,0.57,0.23,0}
-\definecolor{grisclair}{gray}{0.90}
-\definecolor{sable}{rgb}{0.9,0.9,0.7}
-\definecolor{bleuclair}{rgb}{0.1,0.5,0.74}
-\definecolor{orangeAO}{RGB}{241,90,34}
-\definecolor{vertAO}{RGB}{102,204,102}
-\definecolor{bleuAO}{RGB}{25,127,191}
-\definecolor{orangeAO_l}{RGB}{255,130,74}
-\definecolor{vertAO_l}{RGB}{152,254,152}
-\definecolor{bleuAO_l}{RGB}{65,167,231}
-
-%% Utilisation du package listing pour les bouts de code
-\RequirePackage{listings}
-% \lstset{language=C,
-% columns=flexible,
-% %,caption=\lstname,
-% caption=,
-% basicstyle=\small,
-% tabsize=2,
-% stringstyle=\ttfamily,
-% showstringspaces=false,
-% numbers=left,
-% numberfirstline=true,
-% numberstyle=\footnotesize, % the size of the fonts that are used for the line-numbers
-% stepnumber=1, % the step between two line-numbers. If it's 1 each line will be numbered
-% breaklines=true, % sets automatic line breaking
-% keywordstyle=\ttfamily\color{Green},
-% identifierstyle=\ttfamily\color{Blue}\bfseries,
-% commentstyle=\color{Brown},
-% }
-
-\lstset{
-%configuration de listings
- language=C,
- float=hbp,%
- %basicstyle=\sffamily\fontsize{8}{9}\selectfont\small, %
- basicstyle=\sffamily\footnotesize, %
- identifierstyle=\textbf, %
- keywordstyle=\color{bleuAO}\textbf, %
- stringstyle=\ttfamily, %
- showstringspaces=true,
- commentstyle=\textit, %
- emphstyle=\color{orangeAO}\textbf,
- columns=flexible, %
- tabsize=2, %
- frame=single, %
- frameround=tttt, %
- extendedchars=true, %
- %showspaces=false, %
- showstringspaces=false, %
- numbers=left, %
- numberstyle=\tiny, %
- breaklines=true, %
- breakautoindent=true, %
- captionpos=b,%
- %xrightmargin=0cm, %
- %xleftmargin=0cm
-}
-
-% Pour faire des insertions :
-%\lstinputlisting[label=samplecode,caption=A sample]{sourceCode/HelloWorld.c}
-
-%-------Commandes spéciales------------------
-
-\newcommand{\hard}{$\star$}
-
-\newcounter{NoEx}
-\stepcounter{NoEx}
-\newcounter{NoQ}
-\stepcounter{NoQ}
-
-\newcounter{NoExemple}
-\stepcounter{NoExemple}
-\newcounter{NoDef}
-\stepcounter{NoDef}
-\newcounter{NoRq}
-\stepcounter{NoRq}
-
-\newcommand{\NB}{{\underline{NB~:} }}
-\newcounter{iscorrection}
-\newcommand{\viewcorrection}{\setcounter{iscorrection}{1}}
-\newcommand{\hidecorrection}{\setcounter{iscorrection}{0}}
-
-\hidecorrection
-
-\newcommand{\correction}[1]
-{
- \ifthenelse{ \equal{\value{iscorrection}}{1} }
- {
- \vspace{5pt}
- \sffamily
- \setlength\leftmargin{5cm}
- \underline{\textbf{Correction :}}\vspace{0,1cm}\\ \null \hfill \parbox{.9\linewidth}{#1}\par
- \vspace{0,1cm}\rule{3cm}{0.5pt}
- \vspace{5pt}
- }
-}
-
-\newtheorem{Exc}{Exercice} %Utilisation d'un théorème pour le package ``answers''
-
-\newenvironment{exercice}[1][]
-{
- \lstset{xleftmargin=15pt}
- \def\FrameCommand{\vrule width 3pt \hspace{10pt} }%\fcolorbox{sable}{sable}
- \MakeFramed{\setlength{\hsize}{\textwidth} \advance\hsize-\width \FrameRestore}%
- %\vspace{-0,3cm}
- \noindent
- \begin{Exc}[#1]
- \setcounter{NoQ}{1}
-}{
- \end{Exc}
- \endMakeFramed
-}
-
-
-\newcommand{\question}[1]
-{
- \noindent
- \begin{center}\rule{\textwidth}{0pt}\end{center}\vspace{-0,7cm}
- \underline{Question \alph{NoQ})} \emph{#1} %\vspace{0,1cm}
- \stepcounter{NoQ}
-}
-
-
-\newenvironment{definition}[1][]
-{
- \def\FrameCommand{\fcolorbox{grisclair}{grisclair}}%
- \MakeFramed{\setlength{\hsize}{0.9\textwidth} \advance\hsize-\width \FrameRestore}%
- \vspace{-0,3cm}
- \noindent
- \begin{center}\rule{\textwidth}{1pt}\end{center}\vspace{-0,3cm}
- {\bf Definition \arabic{NoDef} \ifthenelse{ \equal{#1}{} }{}{- #1}}\vspace{-0,5cm}
- \begin{center}\rule{\textwidth}{1pt}\end{center}
- \stepcounter{NoDef}
-}
-{
- \endMakeFramed
-}
-%\renewcommand{\definition}[1]{\begin{definition}#1\end{definition}}
-
-\newenvironment{exemple}[1][]
-{
- \lstset{xleftmargin=15pt}
- %\fboxsep=30pt
- \def\FrameCommand{\fcolorbox{sable}{sable}}%\fcolorbox{vertAO}{vertAO_l}}%
- \MakeFramed{\setlength{\hsize}{\textwidth} \advance\hsize-\width \FrameRestore}%
- \vspace{-0,3cm}
- \noindent
- \begin{center}\rule{\textwidth}{1pt}\end{center}\vspace{-0,3cm}
- {\bf Exemple \arabic{NoExemple} \ifthenelse{ \equal{#1}{} }{}{- #1} } \vspace{-0,5cm}
- \begin{center}\rule{\textwidth}{1pt}\end{center}
- %\vspace{-0,2cm}
- \stepcounter{NoExemple}
- \it
-}
-{
- \endMakeFramed
-}
-
-
-\newenvironment{remarque}[1][]
-{
- \refstepcounter{NoRq}
- \noindent
- \begin{center}\rule{\textwidth}{1pt}\end{center}\vspace{-0,3cm}
- {\bf Remarque \arabic{NoRq} \ifthenelse{ \equal{#1}{} }{}{- #1}}\vspace{-0,5cm}
- \begin{center}\rule{\textwidth}{1pt}\end{center}
-}{
-\vspace{-0,5cm}\begin{center}\rule{\textwidth}{1pt}\end{center}
-}
-
-%\def\FrameCommand{\vrule width 3pt \hspace{10pt}}
-
-\newenvironment{warning}[1][]
-{
- \lstset{xleftmargin=15pt}
- \def\FrameCommand{\fcolorbox{orangeAO}{orangeAO_l}}%
- \MakeFramed{\setlength{\hsize}{0.9\textwidth} \advance \hsize-\width \FrameRestore}%
- \vspace{-0,3cm}
- \noindent
- \begin{center}\rule{\textwidth}{1pt}\end{center}\vspace{-0,3cm}
- {\bf ! Attention ! \ifthenelse{ \equal{#1}{} }{}{- #1}}\vspace{-0,5cm}
- \begin{center}\rule{\textwidth}{1pt}\end{center}
-}
-{
- \endMakeFramed
-}
-
-\newcommand{\espace}{\vspace{5pt}}
-\newcommand{\ie}{\emph{i.e.} }
-\newcommand{\eg}{\emph{e.g.} }
-\newcommand{\cf}{\emph{cf.} }
-
-%%%%% Configuration Package ANSWERS.STY %%%%%%
-\Newassociation{Solution}{Soln}{solutions}
-
-%\newcommand{\prehint}{~[Hint]}
-%\newcommand{\presolution}{~[Solution]}
-%\newcommand{\preSolution}{~[Homework]}
-%\newcommand{\Opentesthook}[2]% {\Writetofile{#1}{\protect\section{#1: #2}}}
-% introduction de la solution
-\renewcommand{\Solnlabel}[1]{\textbf{\underline{Solution à l'exercice #1}}\setcounter{NoQ}{1}}
-
-
-
-
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-%% Modification des styles de chapitres %%
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-
-%\RequirePackage{pstricks,psboxit}
-%\RequirePackage{xcolor}
-%\RequirePackage{pstricks}
-%\RequirePackage{psboxit}
-
-\makeatletter
-\def\thickhrulefill{\leavevmode \leaders \hrule height 1ex \hfill \kern \z@}
-\def\@makechapterhead#1{%
- \reset@font
- \parindent \z@
- \vspace*{10\p@}%
- \hbox{%
- \vbox{%
- \hsize=1.5cm%
- \begin{tabular}{c}
- \scshape \strut \@chapapp{} \\
- \colorbox{black}{\vbox{\hbox{\vbox to 1mm{}}\hbox{\color{white} \LARGE \bfseries \hspace{1mm}\thechapter\hspace{1mm}}\hbox{\vbox to 2cm{}}}}%
- \end{tabular}%
- }%
- \vbox{%
- \advance\hsize by -2cm
- \hrule height 0.4pt depth 0pt width \hsize
- \par
- \vskip 6pt%
- \hspace{20pt}%
- \parbox{300pt}{%
- \Huge \bfseries #1}%
- }%
- }%
- \vskip 20\p@
-}
-\def\@makeschapterhead#1{%
- \reset@font
- \parindent \z@
- \vspace*{10\p@}%
- \hbox{%
- \vbox{%
- \hsize=1.5cm%
- \begin{tabular}{c}
- \scshape \strut \phantom{\@chapapp{}} \\
- \colorbox{black}{\vbox{\hbox{\vbox to 1mm{}}\hbox{\color{white} \LARGE \bfseries \hspace{1mm}\phantom{\thechapter}\hspace{1mm}}\hbox{\vbox to 2cm{}}}}%
- \end{tabular}%
- }%
- \vbox{%
- \advance\hsize by -2cm
- \hrule height 0.4pt depth 0pt width \hsize
- \par
- \vskip 6pt%
- \hspace{20pt}%
- \parbox{260pt}{%
- \Huge \bfseries #1}%
- }%
- }%
- \vskip 100\p@
-}
-
-\def\chapter{%\cleardoublepage
-\clearpage
- \thispagestyle{plain} \global\@topnum\z@
- \@afterindentfalse \secdef\@chapter\@schapter}
-
-\def\section{\@ifstar\unnumberedsection\numberedsection}
-\def\numberedsection{\@ifnextchar[%]
- \numberedsectionwithtwoarguments\numberedsectionwithoneargument}
-\def\unnumberedsection{\@ifnextchar[%]
- \unnumberedsectionwithtwoarguments\unnumberedsectionwithoneargument}
-\def\numberedsectionwithoneargument#1{\numberedsectionwithtwoarguments[#1]{#1}}
-\def\unnumberedsectionwithoneargument#1{\unnumberedsectionwithtwoarguments[#1]{#1}}
-\def\numberedsectionwithtwoarguments[#1]#2{%
- \ifhmode\par\fi
- \removelastskip
- \vskip 2ex\goodbreak
- \refstepcounter{section}%
- \begingroup
- \noindent
- \leavevmode\Large\bfseries\raggedright
- \thesection\ #2\par\nobreak
- \endgroup
- \noindent\hrulefill\nobreak
- \vskip 1pt%0.1ex
- \nobreak
- \addcontentsline{toc}{section}{%
- \protect\numberline{\thesection}%
- #1}%
- }
-\def\unnumberedsectionwithtwoarguments[#1]#2{%
- \ifhmode\par\fi
- \removelastskip
- \vskip 2ex\goodbreak
-% \refstepcounter{section}%
- \begingroup
- \noindent
- \leavevmode\Large\bfseries\raggedright
-% \thesection\
- #2\par\nobreak
- \endgroup
- \noindent\hrulefill\nobreak
- \vskip 1pt
- \nobreak
- \addcontentsline{toc}{section}{%
-% \protect\numberline{\thesection}%
- #1}%
- }
-
-\makeatother
-
diff --git a/Polyc/Poly_Archi.tex~ b/Polyc/Poly_Archi.tex~
deleted file mode 100644
index ec940bc4ab737562d0eb00a9d01c60c3acb0de29..0000000000000000000000000000000000000000
--- a/Polyc/Poly_Archi.tex~
+++ /dev/null
@@ -1,49 +0,0 @@
-
-\documentclass[a4paper,11pt]{Poly}
-\usepackage[utf8]{inputenc}
-\usepackage[T1]{fontenc}
-\usepackage{array}
-\usepackage{supertabular}
-%\usepackage{hhline}
-\usepackage{graphicx}
-
-\newcommand{\Figures}{./Figures} % Répertoire des figures
-\newcommand{\Sources}{./Progs} % Répertoire des figures
-
-\newcommand{\defaultfigurewidth}{0.7\textwidth}
-
-\hypersetup{
- pdftitle={Langage C - Architecture et environnement de programmation},
- pdfauthor={Thomas Guyet},
- pdfsubject={},
- pdfkeywords={}
-}
-
-\begin{document}
-\title{Langage C}
-\subtitle{Architecture et environnement de programmation}
-
-\institution{\href{http://www.agrocampus-ouest.fr}{AGROCAMPUS-OUEST, Centre de Rennes}}
-\author{\href{mailto:thomas.guyet@agrocampus-ouest.fr}{Thomas Guyet}}
-%\pagewebcours{http://www.irisa.fr/dream/Pages\_Pros/Thomas.Guyet/}
-\maketitle
-
-\tableofcontents
-
-\input{Archi.tex}
-
-\input{Environnement.tex}
-
-\input{Compilation.tex}
-
-
-% \clearpage
-% ~\newpage~\newpage
-% \ifodd\thepage ~\newpage ~\newpage\fi~
-% %\cleardoublepage
-% %\null
-% \thispagestyle{empty}
-% \vfill
-% {\small Guyet Thomas, AGROCAMPUS-OUEST, \today}
-
-\end{document}
diff --git a/Polyc/Poly_LC_Avance.tex~ b/Polyc/Poly_LC_Avance.tex~
deleted file mode 100644
index 7d0387f0b292212d497fa20f88b1812bb1f22577..0000000000000000000000000000000000000000
--- a/Polyc/Poly_LC_Avance.tex~
+++ /dev/null
@@ -1,78 +0,0 @@
-% This file was converted to LaTeX by Writer2LaTeX ver. 1.1.4
-% see http://writer2latex.sourceforge.net for more info
-\documentclass[11pt]{Poly}
-\usepackage[utf8]{inputenc}
-\usepackage[T1]{fontenc}
-\usepackage{array}
-\usepackage{supertabular}
-%\usepackage{hhline}
-\usepackage{graphicx}
-
-\newcommand{\Figures}{./Figures} % Répertoire des figures
-\newcommand{\Sources}{./Progs} % Répertoire des figures
-
-\version{2.0}
-
-\newcommand{\defaultfigurewidth}{0.7\textwidth}
-
-% \renewenvironment{exemple}[1][]
-% {
-% \lstset{xleftmargin=15pt}
-% %\fboxsep=30pt
-% \def\FrameCommand{\fcolorbox{sable}{sable}}%\fcolorbox{vertAO}{vertAO_l}}%
-% \MakeFramed{\setlength{\hsize}{\textwidth} \advance\hsize-\width \FrameRestore}%
-% \vspace{-0,3cm}
-% \noindent
-% \begin{center}\rule{\textwidth}{1pt}\end{center}\vspace{-0,3cm}
-% {\bf Exemple \arabic{NoExemple} \ifthenelse{ \equal{#1}{} }{}{- #1} } \vspace{-0,5cm}
-% \begin{center}\rule{\textwidth}{1pt}\end{center}
-% %\vspace{-0,2cm}
-% \stepcounter{NoExemple}
-% \it
-% \small
-% }
-% {
-% \endMakeFramed
-% }
-%
-%
-% \renewenvironment{exercice}[1][]
-% {
-% \lstset{xleftmargin=15pt}
-% \def\FrameCommand{\vrule width 3pt \hspace{10pt} }%\fcolorbox{sable}{sable}
-% \MakeFramed{\setlength{\hsize}{\textwidth} \advance\hsize-\width \FrameRestore}%
-% %\vspace{-0,3cm}
-% \noindent
-% \begin{Exc}[#1]
-% \setcounter{NoQ}{1}
-% \small
-% }{
-% \end{Exc}
-% \endMakeFramed
-% }
-
-\hypersetup{
- pdftitle={Langage C avanc\'e - D\'ecomposition et pointeurs},
- pdfauthor={Thomas Guyet},
- pdfsubject={},
- pdfkeywords={}
-}
-
-
-\begin{document}
-\title{Langage C}
-\subtitle{Langage C avancé : décomposition et pointeurs}
-
-\institution{\href{http://www.agrocampus-ouest.fr}{AGROCAMPUS-OUEST, Centre de Rennes}}
-\author{\href{mailto:thomas.guyet@agrocampus-ouest.fr}{Thomas Guyet}}
-%\pagewebcours{http://www.irisa.fr/dream/Pages\_Pros/Thomas.Guyet/}
-\maketitle
-
-%\setcounter{tocdepth}{2}
-\tableofcontents
-
-\input{Decomposition.tex}
-
-\input{Pointeurs.tex}
-
-\end{document}
diff --git a/Polyc/Poly_LC_Base.tex~ b/Polyc/Poly_LC_Base.tex~
deleted file mode 100644
index 3c383eb693571acfd867303e7428808b5c38cb7b..0000000000000000000000000000000000000000
--- a/Polyc/Poly_LC_Base.tex~
+++ /dev/null
@@ -1,91 +0,0 @@
-% This file was converted to LaTeX by Writer2LaTeX ver. 1.1.4
-% see http://writer2latex.sourceforge.net for more info
-\documentclass[11pt]{Poly}
-\usepackage[utf8]{inputenc}
-\usepackage[T1]{fontenc}
-\usepackage{array}
-\usepackage{supertabular}
-%\usepackage{hhline}
-\usepackage{graphicx}
-
-\newcommand{\Figures}{./Figures} % Répertoire des figures
-\newcommand{\Sources}{./Progs} % Répertoire des figures
-
-\newcommand{\defaultfigurewidth}{0.7\textwidth}
-
-\hypersetup{
- pdftitle={Langage C - Bases du langage},
- pdfauthor={Thomas Guyet},
- pdfsubject={},
- pdfkeywords={}
-}
-
-% Text styles
-%\makeatletter
-%\newcommand\arraybslash{\let\\\@arraycr}
-%\makeatother
-
-
-\begin{document}
-\title{Langage C}
-\subtitle{Bases du langage C}
-
-\institution{\href{http://www.agrocampus-ouest.fr}{AGROCAMPUS-OUEST, Centre de Rennes}}
-\author{\href{mailto:thomas.guyet@agrocampus-ouest.fr}{Thomas Guyet}}
-%\pagewebcours{http://www.irisa.fr/dream/Pages\_Pros/Thomas.Guyet/}
-\maketitle
-
-% \chapter*{Préface}
-%
-% Ce document reprend des notes de cours sur le langage C. Il n'a aucune prétention de présenter l'intégralité du langage C (d'autres références bibliographique le font un peu mieux). Ce cours présente le langage C mais n'est pas un cours d'algorithmique. Néanmoins, certains exercices introduisent des notions fondammentales d'algorithmiques.
-%
-% Son but et son intérêt est de compléter les cours auquels vous assisterez. Ainsi, les notions y seront abordés de la même manière qu'en cours, ce qui ne sera pas nécessairement le cas si vous ouvrez une autre référence. Les définitions et les concepts ainsi formalisée vous permettrons d'alléger les prises de notes.
-%
-% Mais, de même que les cours, il vous place en tant que recepteur d'une information et non en tant qu'acteur. L'apprentissage de la programmation et d'un langage nécessite de la pratique (beaucoup en fait!!).
-% J'ai voulu faire en sorte que ce polycopier contiennent beaucoup d'exemple et d'exercices corrigés qui doivent vous servir d'inspiration pour vos propres programmes.
-% Alors, programmez en vous inspirant de ce document et de tout ce que vous pourrez trouver dans d'autres références (bibliographique ou sur internet).
-%
-% \espace
-%
-% Ce document est en perpétuelle évolution et est actuellement dans une version préliminaire. Certains exercices restent sans solution rédigée ... et je pense que de nombreuses coquilles se sont glissées dans les quelques bonnes lignes. Tous les commentaires sont les bienvenus.
-
-%\setcounter{tocdepth}{2}
-\tableofcontents
-
-%\input{Archi.tex}
-
-%\input{Environnement.tex}
-
-\input{AlgoC.tex}
-
-\input{Struct-C.tex}
-
-%\input{Decomposition.tex}
-
-%\input{Pointeurs.tex}
-
-%\input{Compilation.tex}
-
-% \chapter*{Références}
-%
-% \begin{enumerate}
-% \item ``Le langage C par l'exemple'', P. Robinet, edt Ellipse/TechnoSup
-% \item ``Le langage C, Norme ANSI'', Kernighan et Ritchie, edt Masson
-% \item ``Exercices corrigés sur le langage C, solutions des exercices du Kernighan et Ritchie'', C. Tondo et S. Gimpel, edt Dunod
-% \item ``Numerical recipes in C'', Press et al. également disponible \href{http://apps.nrbook.com/c/index.html}{en ligne}
-% \item ``Algorithmique en C'', J.M. Léry, edt Pearson/Syntex
-% \item ``Langage C'', B. Cassagne, polycopié de cours ENSIMAG
-% \end{enumerate}
-
-
-%
-% \clearpage
-% ~\newpage~\newpage
-% \ifodd\thepage ~\newpage ~\newpage\fi~
-% %\cleardoublepage
-% %\null
-% \thispagestyle{empty}
-% \vfill
-% {\small Guyet Thomas, AGROCAMPUS-OUEST, \today}
-
-\end{document}
diff --git a/Polyc/Poly_LC_RC.tex~ b/Polyc/Poly_LC_RC.tex~
deleted file mode 100644
index 64a2516a4aad85d2f86a8510bfcf8292e4f3af36..0000000000000000000000000000000000000000
--- a/Polyc/Poly_LC_RC.tex~
+++ /dev/null
@@ -1,983 +0,0 @@
-% This file was converted to LaTeX by Writer2LaTeX ver. 1.1.4
-% see http://writer2latex.sourceforge.net for more info
-\documentclass[a4paper,11pt]{Poly}
-\usepackage[utf8]{inputenc}
-\usepackage[T1]{fontenc}
-\usepackage{array}
-\usepackage{supertabular}
-%\usepackage{hhline}
-\usepackage{graphicx}
-
-\newcommand{\Figures}{./Figures} % Répertoire des figures
-\newcommand{\Sources}{./Progs/InterfaceRC} % Répertoire des figures
-
-\newcommand{\defaultfigurewidth}{0.7\textwidth}
-
-% Text styles
-%\makeatletter
-%\newcommand\arraybslash{\let\\\@arraycr}
-%\makeatother
-
-\lstset{morekeywords={PROTECT, UNPROTECT, SEXP, REAL, REALSXP, INTSXP, GET_LENGTH, AS_NUMERIC, NUMERIC_POINTER, AS_INTEGER, INTEGER_POINTER, R_NilValue, allocVector, NEW_INTEGER, NEW_INTEGER}}
-
-\hypersetup{
- pdftitle={Langage C - interfa\c{c}age R/C},
- pdfauthor={Thomas Guyet},
- pdfsubject={},
- pdfkeywords={}
-}
-
-\begin{document}
-\bgimg{draft} %ajout de l'image draft en image de fond
-
-\title{Langage C}
-\subtitle{Interfaçage entre R et C}
-
-\institution{\href{http://www.agrocampus-ouest.fr}{{\sc Agrocampus Ouest}, Centre de Rennes}}
-\author{\href{mailto:thomas.guyet@agrocampus-ouest.fr}{Thomas Guyet}}
-%\pagewebcours{http://www.irisa.fr/dream/Pages\_Pros/Thomas.Guyet/}
-\maketitle
-
-\chapter{Introduction}
-%Interfaçage entre R et C}
-\Opensolutionfile{solutions}{}
-
-
-%\section{Introduction}
-
-%Ce polycopié décrit les modalités de mise en place d'un interfaçage entre les langage R et C.
-
-Dans cette partie du cours, nous introduisons les principes de l'interfaçage des langage R et C. L'interfaçage consiste à pouvoir utiliser les qualités d'un des langages dans l'autre. Le langage R propose une utilisation facile de fonction statistiques qui n'existent pas dans R. Il peut alors être intéressant d'aller chercher ces fonctionnalités existantes pour développer des outils en C qui nécessite des calculs statistiques.
-Dans l'autre sens, le langage C est un langage universel et puissant. En tant que langage universel, il donne accès à de nombreuses fonctionnalités de traitement de données développées dans des librairies dédiées. En tant que langage très proche de la machine, il offre des capacités d'exploitation des processeurs beaucoup plus pointues que le langage R et, en particulier, il peut aider les programmeur à traiter de grands volumes de données, et d'améliorer les performances de temps de calcul.
-
-
-\espace
-
-Certains de mes polycopiés sont peu utiles, parce qu'ils sont redondants avec bon nombre de cours librement accessible sur le net. Dans ce cas du sujet de ce document, les documentations claires sont peu nombreuses, la documentation officielle est difficile d'accès et des tutoriels didactiques inexistants. J'espère donc que le lecteur trouvera un polycopié comblant ce manque.
-
-
-Il s'adresse à des lecteurs plutôt statisticiens, avec une bonne connaissance de R mais non-néces\-sairement informaticiens.
-Des connaissances préalables des langages C sont également nécessaires\footnote{il s'agit de connaissance données dans le cadre d'un enseignement court d'introduction au langage C pour des non-informaticien.} pour suivre les exemples présentés. Une compréhension des pointeurs est nécessaire et un certain recul sur la gestion de la mémoire sera également utile.
-
-
-\section{Préparation de l'environnement de programmation}
-
-\subsection{Installation sous Linux}
-
-% \subsection{Compiler la bibliothèque}
-% La bibliothèque n'est pas compilé automatiquement pendant l'installation de la R. On peut actuellement être compilée en invoquant la commande
-%
-% make .. /.. / bin / libR.so
-%
-% à partir de src/main sous la distribution R. Comme indiqué, le résultat (partagée) bibliothèque est installée dans le répertoire bin/ dans la distribution R.
-%
-% Notez que généralement cette commande sera effectué après l'exécution de la construction régulière / installation. Notez que cet objet (c.-à- .o ) les fichiers seront généralement ont été compilées pour relier dans une bibliothèque partagée. Plus précisément, le sera pas nécessairement contenir du code indépendant de la position (PIC). En outre, tous les fichiers contenant le code qui est conditionnellement définis dans le cadre de la bibliothèque partagée embedable (code à l'intérieur de #ifdef R_EMBEDDED ) devront être recompilés avec les drapeaux pertinents.
-
-\subsection{Installation sous Windows}
-
-
-Notons que la démarche d'incorporation de C en R est la même peu importe la plateforme informatique avec laquelle on travaille si tous les logiciels nécessaires sont correctement installés.
-
-\section{Benchmark ``Quicksort'' et objectif}
-
-L'algorithme Quicksort est un algorithme très efficace de tri d'un tableau. Cet algorithme est particulièrement inadapté à R parce que~:
-\begin{enumerate}
- \item il nécessite beaucoup de tests et que la complexité des structures de données de R rend la simple comparaison d'entier plutôt compliqué,
- \item la récursivité de l'algorithme nécessite beaucoup d'appel de fonctions, ces appels de fonctions sont peu efficaces en R,
- \item il ne peut pas facilement être vectorisé et donc l'usage des méthodes de programmation vectorielle\footnote{Les fonctions \texttt{mapply}, \texttt{sapply}, etc. sont des fonctions qui permettent de faire efficacement des traitements sur un ensemble de données représentées respectivement dans des vecteurs ou dans des séquences. La modification des algorithmes pour qu'ils utilisent ces fonctions s'appelle la vectorisation.} ne sont pas très utiles.
-\end{enumerate}
-
-On donne dans l'Annexe de la section \ref{sec:Annexe_Quicksort} les implémentations de l'algorithme Quicksort en langage R et en langage C.
-
-Voici les temps de calculs obtenus pour ces programmes en ordonnant un tableau d'entiers de taille 20000 à 200000. On constate alors que le temps de calcul est entre 260 et 600 fois inférieur pour un programme en C.
-Il n'est donc pas raisonnable d'utiliser l'algorithme Quicksort développé en R. \textbf{L'un des objectifs applicatif de l'interfaçage est d'utiliser la fonction Quicksort développée C directement dans l'environnement R} pour bénéficier de ses performances dans l'environnement de programmation R.
-
-\begin{center}
- \begin{tabular}{|l|c|c|}
-\hline
-\textbf{Taille tableau} & \textbf{C (s)} & \textbf{R (s)} \\ \hline
-20000 & 0.010 & 5.544 \\ \hline
-40000 & 0.030 & 18.217 \\ \hline
-60000 & 0.070 & 37.867 \\ \hline
-80000 & 0.120 & 54.831 \\ \hline
-100000 & 0.180 & 70.081 \\ \hline
-120000 & 0.260 & 82.801 \\ \hline
-140000 & 0.350 & 110.747 \\ \hline
-160000 & 0.460 & 124.584 \\ \hline
-180000 & 0.570 & 148.761 \\ \hline
-200000 & 0.700 & 183.423 \\ \hline
- \end{tabular}
-\end{center}
-
-
-
-\chapter{Étendre les capacités de R grâce au langage C}
-
-L'hypothèse de base de cette partie est que le programmeur souhaite réaliser un programme dans l'environnement de programmation R. Il aura par exemple déjà à disposition une partie de son programme en C et souhaitera offrir la possibilité d'avoir les fonctionnalités de son programme dans l'environnement R.
-
-\section{Principe}
-
-Le principe de la création de code C utilisable dans R consiste à développer une fonction C dans un fichier \texttt{.c} qui sera compilé avec le compilateur de R (en fait des options de R de votre compilateur C). La compilation ne consistera pas à construire un programme exécutable, mais uniquement une librairie partagée (\emph{shared object} avec l'extension \texttt{.so} sous Linux et \emph{dynamic linked library} avec l'extension \texttt{.dll} sous Windows). Ces fichiers comprennent des versions de vos fonctions compilées pour votre ordinateur.
-
-Pour utiliser ces fonctions compilées dans R, il faut charger ce fichier compilé.
-
-\espace
-
-%\subsection{Incorporation du code C en R}
-Illustrons maintenant les trois étapes présentées dans l'introduction afin d'incorporer du code C en R en prenant l'exemple du programme ``Hello, world!'' tiré de \cite{Peng2002}.
-
-Le fichier \texttt{hello.c} contenant le code C très simple est donné ci-dessous. Ce programme contient une fonction qui affiche à l'écran $n$ fois la chaîne de caractères ``Hello, world!''.
-\begin{lstlisting}
-#include <R.h>
-
-void hellofct(int *n)
-{
- int i;
- for(i=0; i < *n; i++) {
- Rprintf("Hello, world!\n");
- }
-}
-\end{lstlisting}
-
-Ce programme à quelques particularités par rapport à nos programmes habituellement développés :
-\begin{itemize}
- \item il n'y a pas de fonction \lstinline!main()!. En effet, nous n'allons pas créer un programme exécutable, donc il n'y a pas de ``point de départ'' d'exécution, mais juste une collection de fonctions (ici, une seule fonction \lstinline!hellofct()!).
-\item le programme commence par la ligne \lstinline!#include <R.h>!. En ajoutant le fichier d'en-tête \texttt{R.h}, nous rendons possible la compilation de ce fichier pour R.
-\item la fonction usuelle \lstinline!printf! est remplacée par la fonction \lstinline!Rprintf! qui permet de faire afficher du texte dans la console de R,
-%\item les fonctions C appelées en R doivent avoir des profils particulier. Sur cet exemple simple, on constate que le type de retour est \lstinline!void! et que les arguments passés aux fonctions C sont des pointeurs. Ces contraintes vont variées en fonction de l'usage prévu dans R (\cf différentes interfaces).
-\end{itemize}
-
-\subsection{Compilation du code C}
-
-La première étape consiste à compiler le code C afin de créer une librairie partagée (fichier \texttt{.so} si on travaille sur Linux ou fichier \texttt{.dll} si on travaille sur Windows). On effectue cette étape dans une fenêtre terminal sur Linux ou dans une fenêtre de commandes sur Windows. On se place d'abord dans le répertoire où se trouve le fichier contenant le code C, puis on tape la commande~:
-\begin{verbatim}
- R CMD SHLIB hello.c
-\end{verbatim}
-L'objet partagé ou la librairie dynamique créé par cette commande se nommera \texttt{hello.so} ou \texttt{hello.dll}. Dans la suite, je ne considérerai plus le cas Windows, mais le lecteur sera adapté les instructions sans problème.
-
-\begin{remarque}
- Il est tout à fait possible d'intégrer plusieurs fichiers \texttt{.c} dans une même librairie partagée. C'est plutôt même une bonne démarche d'avoir décomposé votre code dans plusieurs fichiers différents. La commande ci-dessous permettra de créer une librairie \texttt{malib.so} à partir de trois fichiers source.
-
-\begin{verbatim}
- R CMD SHLIB -o malib.so fichier1.c fichier2.c fichier3.c
-\end{verbatim}
-
-Je précise également que tous les fichiers \texttt{.h} qui sont inclus dans un fichier \texttt{.c} seront bien intégrés dans la librairie partagée sans que vous les listiez. Le préprocesseur se sera charger de faire l'inclusion.
-
-Pour plus de détails et de compréhension sur les étapes de compilation, je reporte le lecteur à la partie du cours qui traite explicitement de ces questions.
-
-%Il faudra simplement s'assurer que les fichiers ne contiennent pas deux fonctions avec les mêmes profils sinon, il y aura une erreur de compilation.
-\end{remarque}
-
-
-\subsection{Chargement en R du code C compilé}
-
-La suite de la procédure se déroule dans R. Il faut donc commencer par lancer R, et par choisir le répertoire contenant votre librairie partagée comme répertoire de travail de R\footnote{la choix du répertoire de travail n'est pas indispensable, mais utile pour ne pas se poser de question sur la localisation des fichiers.}.
-
-Il faut ensuite charger en R la librairie partagée avec la fonction \lstinline!dyn.load! (le nom du fichier doit obligatoirement être entre guillemets) :
-\shorthandoff{!}
-\begin{lstlisting}[numbers=none,language=R]
-dyn.load("hello.so")
-\end{lstlisting}
-\shorthandon{!}
-
-On peut ici faire un test pour s'assurer que les fonctions C ont été correctement chargées en R. Pour ce faire, on utilise la fonction \lstinline!is.loaded! avec, en argument, le nom entre guillemets d'une fonction C contenue dans notre fichier. Si cette commande retourne \lstinline!TRUE!, alors tout est correct.
-% Sinon, le premier point de la section 5 vous intéressera
-
-\subsection{Appel en R des fonctions programmées en C}\label{sec:appelR}
-On peut finalement appeler en R les fonctions créées dans le code C avec la fonction d'interface \lstinline!.C!. On utilise cette fonction de la façon suivante~:
-\begin{verbatim}
-.C("nomfonction",argument1,argument2,...)
-\end{verbatim}
-
-Dans le cas de notre fonction servant d'exemple, nous pourrions ainsi faire appel à la commande suivante faire appel à la fonction \lstinline!hellofct! avec en paramètre 3.
-\shorthandoff{!}
-\begin{lstlisting}[numbers=none,language=R]
-.C("hellofct",3)
-\end{lstlisting}
-\shorthandon{!}
-
-\begin{warning}[Passage des paramètres]
-Le paramètre de la fonction C est bien un pointeur, mais lorsqu'on utilise l'interface R, alors l'argument qui est donné à la fonction est bien un pointeur sur un emplacement mémoire qui contiendra la valeur désirée (ici, 3).
-\end{warning}
-
-\begin{warning}[Vérification des types des paramètres]
- Le langage R est un langage de script, il n'y a pas de vérification a priori des type, en revanche, si les types ne sont pas compatibles, au mieux ça plante, au pire la fonction C est bien exécutée sans que personne ne sache bien ce qu'il va se passer !!
-
-Il est préférable de s'assurer que chaque argument passé à la fonction C est du bon type en leur appliquant une fonction de conversion de type telle que \lstinline!as.integer!, \lstinline!as.double!, \lstinline!as.character! ou \lstinline!as.logical!. Souvenez vous qu'en R, les nombres sont des \lstinline!double! par défaut, ceci peut poser des problèmes si vous pensiez que c'était des entiers.
-\end{warning}
-
-Pour rendre les appels à la fonction C totalement transparents (ce sera plus facile à utiliser !), il est conseillé de créer une fonction R qui \texttt{enveloppe} l'appel à la fonction C~:
-\shorthandoff{!}
-\begin{lstlisting}[numbers=none,language=R]
-Hello <- function(n){
- .C("hellofct",as.integer(n))
-}
-\end{lstlisting}
-\shorthandon{!}
-On peut ensuite utiliser cette fonction pour afficher 4\footnote{par exemple!} fois \texttt{Hello, world!} par la commande \lstinline!Hello(4)!.
-
-\section{Interfaces}
-
-Lorsqu'on parle d'interfaces, on parle ici de fonctions R qui vont permettre d'appeler les fonctions chargées depuis une librairie partagée. Elles réfèrent aux différents modes d'appels d'une fonction C dans un script R. Il en existe trois, du plus limité au plus général (et donc du plus simple au plus complexe pour le programmeur)~:
-\begin{itemize}
- \item \texttt{.C}
- \item \texttt{.Call}
- \item \texttt{.External}
-\end{itemize}
-
-Chacune de ces interfaces impose au programmeur le profil de la fonction C qui peut être chargé.
-Il faut comprendre les contraintes liées à l'utilisation ces différentes interfaces pour choisir la plus appropriée et l'utiliser correctement.
-
-\subsection{Interface \texttt{.C} : extension simple(-iste)}
-
-L'interface \texttt{.C} est l'interface simple pour charger une fonction C. Cette interface est simple parce qu'elle ne va pas demander beaucoup de travail de modification du code C, que le programmeur n'aura pas à entrer dans les détails de R pour la comprendre mais elle ne permettra pas de faire tout ce qu'on pourrait imaginer car tous les types de variable de R ne pourront être utilisés (en particulier les listes).
-
-%\espace
-
-\begin{definition}[Fonction pour l'interface \texttt{.C}]
-Une fonction C qui peut être chargée par l'interface \texttt{.C} est une fonction dont
-\begin{itemize}
- \item les arguments passés sont des pointeurs sur un type simple (\eg \lstinline!int!, \lstinline!double!, \lstinline!char! ou \lstinline!char*!). Toutes les variables simples de R étant des vecteurs, il faut s'attendre à ce qu'une variable récupérée dans la fonction C soit un tableau.
- \item le type de retour de la fonction doit être \lstinline!void!. Les résultats d'une fonction doivent être retournés par les pointeurs passés en paramètre.
-\end{itemize}
-
-Le résultat de la fonction \texttt{.C} est une \emph{liste} R contenant les valeurs des arguments après l'exécution de la fonction.
-\end{definition}
-
-
-
-\begin{exemple}[Fonction \lstinline!max()!]
-On donne comme exemple une fonction de calcul d'un maximum de deux nombres réels. Dans le fichier R, on retrouve le chargement de la librairie (nommée ici \texttt{max.so}) ainsi que la création d'une fonction enrobant l'interface. Ce fichier se termine en montrant l'utilisation de la fonction pour afficher le maximum de deux nombres.
-
-Dans le fichier C, on propose une fonction calculant simplement le maximum de deux nombres \lstinline!d1! et \lstinline!d2! passés en paramètre. Notez que comme il s'agit de pointeurs, il faut bien penser à les déréférencer.
-
-Une troisième argument \lstinline!output! sert de variable de sortie de la fonction. On ne peut pas utiliser de \lstinline!return! alors on dépose le résultat dans l'emplacement mémoire désigné par \lstinline!output! pour que ce résultat soit récupéré dans R.
-
-Dans l'appel de l'interface \texttt{.C}, on a récupéré une variable \lstinline!tmp! qui contient la valeurs des emplacements mémoires pointés par arguments de la fonction. En particulier, le troisième élément de la liste contient la valeur de \lstinline!output!. Dans la fonction R, on peut donc récupérer le résultat de notre fonction C.
-
-\shorthandoff{!}
-\lstinputlisting[language=r]{\Sources/ex1_max.R}
-\shorthandon{!}
-\lstinputlisting{\Sources/ex1_max.c}
-\end{exemple}
-
-% \begin{exemple}[Illustration des passages de paramètres]
-% L'exemple ci-dessous montre
-% \begin{lstlisting}[numbers=none]
-% void fnctC(int *i, double *d, char **c, int *l) {
-% i[0] = 11;
-% d[0] = 2.333;
-% c[1] = "g";
-% l[0] = 0;
-% }
-% \end{lstlisting}
-% \end{exemple}
-
-Le tableau ci-dessous donne la correspondance entre les types R et les types du langage C \cite{WritingRExt}. Comme indiqué en section \ref{sec:appelR}, le programmeur doit assurer la cohérence entre les données envoyées par l'interface et le profil de la fonction C.
-\begin{center}
-\begin{tabular}{lll}
-\textbf{Type R} &\textbf{Type C} & \textbf{Type interne (\texttt{SEXPTYPE})}\\
-\texttt{logical}& \texttt{int *} & \texttt{LGLSXP}\\
-\texttt{integer}& \texttt{int *} & \texttt{INTSXP}\\
-\texttt{double} &\texttt{double *} & \texttt{REALSXP}\\
-\texttt{complex}&\texttt{Rcomplex *} (type de R.h) & \texttt{CPLXSXP}\\
-\texttt{character} &\texttt{char **} & \texttt{STRSXP}\\
-\texttt{raw unsigned} &\texttt{char *} & \texttt{RAWSXP}\\
-\texttt{list} & & \texttt{LISTSXP}\\
-\texttt{vector} & & \texttt{VECSXP}\\
-\end{tabular}
-\end{center}
-
-\begin{remarque}[\texttt{REAL} et \texttt{NUMERIC}]
- La dénomination des types pour les nombres à virgule (\lstinline!double!) n'est pas très stable dans la librairie de R. Parfois il est question de \texttt{NUMERIC} (principalement dans \texttt{Rdefines.h}, compatible avec S) et parfois de \texttt{REAL} comme ci-dessus. Cette inconstance est regrettable.
-\end{remarque}
-
-
-\begin{warning}[Attention aux NULL]
-L'utilisation de notre fonction dans le cas ci-dessous va provoquer une grave erreur (\emph{segmentation fault}). Le cas de passage d'une variable \lstinline!NULL! n'a pas été prévu dans notre code.
- \shorthandoff{!}
-\begin{lstlisting}[language=r, numbers=none]
-a <- 34
-b <- NULL
-m<-max(a, b)
-\end{lstlisting}
-\shorthandon{!}
-
-Trois solutions possibles pour éviter ce problème aux utilisateurs :
-\begin{itemize}
- \item Prévoir les cas de pointeurs nuls dans la fonction C (\cf exemple suivant),
- \item Prévoir les cas de variables R nulles dans la fonction d'enrobage définie en R,
- \item Faire les deux protections ci-dessus (!).
-\end{itemize}
-\end{warning}
-
-
-\begin{exemple}[Maximum deux à deux]
-Les variables de R étant par défaut des vecteurs, il est préférable de proposer des fonctions qui vont traiter des vecteurs. On modifie donc le code de notre programme pour traiter des vecteurs~: on cherche le maximum dans un tableau de nombres.
-\shorthandoff{!}
-\lstinputlisting[language=r]{\Sources/ex2_max.R}
-\shorthandon{!}
-\lstinputlisting{\Sources/ex2_max.c}
-\end{exemple}
-
-\begin{warning}[Taille des tableaux]
-Vous savez que vous récupérez un pointeur sur un tableau, mais vous ne savez pas quel sera la taille du tableau ! Il peut être très utile d'ajouter des paramètres pour connaître la taille du tableau à traiter.
-\end{warning}
-
-\begin{remarque}[Utilisation sur différentes structures de données R]
-Avec l'interface \texttt{.C}, votre traitement sur des vecteurs fonctionnera aussi bien sur des variables de type \lstinline!list! ou de type \lstinline!array!.
-
-Notez néanmoins qu'une liste dans R ne comporte pas nécessairement des objets de même type ... là, je ne sais pas comment ça se passera pour votre programme, mais il faut s'attendre à un beau bug ! L'utilisation des listes nécessite d'utiliser une interface plus complexe !
-\end{remarque}
-
-
-\subsection{Interface \texttt{.Call} : extension complète}
-
-\begin{definition}[Fonction pour l'interface \texttt{.Call}]
-Une fonction C qui peut être chargée par l'interface \texttt{.Call} est une fonction dont
-\begin{itemize}
- \item les arguments passés sont de type \lstinline!SEXP! (\cf définition \ref{def:SEXP} ci-dessous). Le nombre de paramètre est limité à 65 ... je pense que ça devrait aller pour la plupart des usages.
- \item le type de retour de la fonction doit être \lstinline!SEXP!.
-\end{itemize}
-
-L'utilisation du type \lstinline!SEXP! nécessite a définition d'une fonction avec l
-
-Le résultat de la fonction \texttt{.Call} est une \emph{liste} contenant les valeurs des arguments à la fin de la fonction.
-\end{definition}
-
-\begin{definition}[Types \lstinline!SEXP! et \lstinline!SEXPREC!]\label{def:SEXP}
- \lstinline!SEXP! correspond à un \texttt{pointeur} sur une variable de type \lstinline!SEXPREC!. Ces types de données correspondent aux représentations internes des variables de R.
- Le terme \lstinline!SEXP! signifie à ``\emph{Simple-Expression}''.% Il s'agit d'une structure de données communes dans des langages comme LISP.
-
-\espace
-
-Nous ne rentrerons pas dans les détails de la structure de données \lstinline!SEXPREC!. Il faut imaginer que, comme pour une variable R, c'est une variable qui peut contenir différents type de données (c'est une \lstinline!union!). Pour plus de détails, vous pouvez consulter \cite{WritingRExt} ou le fichier \texttt{Rinternals.h}.
-
-% Plus précisément, ce type est définie ainsi :
-% \begin{lstlisting}[numbers=none]
-% typedef struct SEXPREC {
-% SEXPREC_HEADER;
-% union {
-% struct primsxp_struct primsxp;
-% struct symsxp_struct symsxp;
-% struct listsxp_struct listsxp;
-% struct envsxp_struct envsxp;
-% struct closxp_struct closxp;
-% struct promsxp_struct promsxp;
-% } u;
-% } SEXPREC, *SEXP;
-% \end{lstlisting}
-
-%Donnons tout de même quelques mots d'explication sur ce type de données. Tout d'abord, ce type contient un \lstinline!SEXPREC_HEADER! qui masque la définition de quelques éléments.
-%On voit avant tout qu'est c'est une \lstinline!union! de type. C'est-à-dire que ce que contient cette variable peut changer de forme
-\end{definition}
-
-\begin{exemple}[Profil de la fonction \lstinline!max!]
-Continuons à créer des fonctions de calcul de maximum et revenons au cas d'un max de valeurs. Le profil de la fonction que nous aurons à implémenter sera le suivant~:
- \begin{lstlisting}[numbers=none]
- SEXP max(SEXP d1, SEXP d2)
- \end{lstlisting}
-
-On peut alors faire deux remarques~:
-\begin{itemize}
- \item Nous n'avons plus besoin de passer par un argument de fonction pour faire un retour, nous pourrons utiliser l'instruction \lstinline!return! et renvoyer une variable de type \lstinline!SEXP!
- \item Les deux arguments sont des variables utilisées par R ... mais qu'est ce qu'il y a dedans ?? comment récupérer leurs valeurs ?
-\end{itemize}
-\end{exemple}
-
-La bibliothèque \texttt{Rinternals.h} propose des ``fonctions'' (plutôt des macros) pour extraire les données d'un \lstinline!SEXP!. Si \lstinline!x! est une variable de type \lstinline!SEXP!,
-\begin{itemize}
- \item \lstinline!CHAR( x )! : récupère un pointeur sur un caractère (chaîne de caractères),
- \item \lstinline!INTEGER( x )! : récupère un pointeur sur un entier,
- \item \lstinline!REAL( x )! : récupère un pointeur sur un double.
-\end{itemize}
-
-Bien évidemment, pour les utiliser, il faut connaître le type des variables que contient la variable \lstinline!x!. Ceci est possible en imposant correctement la correspondance des types entre la fonction enrobant l'utilisation de l'interface \texttt{.Call} (peu générique et dangeureux), ou en utilisant des fonctions C pour tester les types des variables (\eg \lstinline!isString!, \lstinline!isReal!, \lstinline!isInteger! ... et des fonctions comme \lstinline!length!). Nous ne rentrons pas dans les détails de cette seconde solution.
-
-\begin{exemple}[Fonction \lstinline!max! avec \texttt{.Call}]
- Voici donc la fonction \lstinline!max! avec l'utilisation l'interface \texttt{.Call}. Le premier code illustre l'utilisation de la fonction \texttt{.Call}. On constate que la variable récupérée en retour de \texttt{.Call} contient uniquement le résultat de notre fonction.
-
-Pour la fonction en C, les lignes 7 et 8 servent à récupérer les valeurs des variables passées en paramètre. Aucune vérification du type réel des variables R n'est effectué. La variable \lstinline!output! sert comme variable de retour. Comme un \lstinline!SEXP! est fondamentalement un pointeur, il faut donc penser à allouer de la mémoire pour la variable grâce à la fonction \lstinline!allocVector! (\cf Section \ref{sec:allocVector}. De plus, on utilise les macros \lstinline!PROTECT! et \lstinline!UNPROTECT! pour indiquer à R que cette variable est en cours d'utilisation (\cf Section \ref{sec:PROTECT}).
-
-\shorthandoff{!}
-\lstinputlisting[language=r]{\Sources/ex3_max.R}
-\shorthandon{!}
-\lstinputlisting{\Sources/ex3_max.c}
-\end{exemple}
-
-\begin{remarque}[Valeur de non-retour]
- En cas d'absence de retour, il est possible \lstinline!R_NilValue! comme valeur de retour.
-\end{remarque}
-
-\begin{remarque}[Copie des arguments dans l'interface \texttt{.C}]
-Avec l'interface \texttt{.C}, les objets de R sont copiés avant d'être transmis à la fonction C même si se sont des pointeurs. Ils sont également recopié dans la liste de variables R lors du retour de la fonction. Lorsque vous utilisez les variables de type \lstinline!SEXP! vous manipuler directement les mêmes variables que R, celles-ci ne sont donc pas recopiées, c'est un gain d'efficacité notable.
-\end{remarque}
-
-\begin{warning}
-Vous devez traiter les paramètres de la fonction uniquement en lecture et ne pas les modifier sans protection particulière.
-Pour les modifier, il est nécessaire de les ``protéger'' à l'aide de la fonction \lstinline!PROTECT! que nous verrons plus en détail dans la section \ref{sec:PROTECT}.
-\end{warning}
-
-\begin{exemple}[Récupération d'un vecteur d'entiers / macros de \texttt{Rdefines.h}]
-\texttt{Rdefines.h} propose des macros et des fonctions plus avancées que \texttt{Rinternals.h}. Dans l'exemple ci-dessous, on donne une fonction qui illustre comment récupérer un tableau d'entiers directement issu d'un vecteur R en utilisation l'interface \texttt{.Call}.
-
-On trouve dans cet exemple l'utilisation de fonctions comme \lstinline!GET_LENGTH! permettant de récupérer la longueur d'un vecteur dans un \lstinline!SEXP!, \lstinline!AS_INTEGER! pour convertir proprement un \lstinline!SEXP! en \lstinline!INTSXP! ou encore \lstinline!INTEGER_POINTER! pour récupérer le pointeur sur le tableau des données.
-
-\lstinputlisting{\Sources/ex_myint.c}
-
-Pour connaître les différentes macros très utiles de \texttt{Rdefines.h}, vous pouvez directement consulter ce fichier (il faut simplement le rechercher sur votre ordinateur ...). Il est très lisible.
-\end{exemple}
-
-\begin{exemple}[Calcul du min et du max d'un vecteur de réels]
- L'exemple ci-dessous permet d'illustrer une fonction qui prend en argument un vecteur à traiter et qui retourne également un vecteur (de taille 2). Le vecteur retourné comprend la valeur minimal et maximale du vecteur en entrée.
-
-% \shorthandoff{!}
-% \lstinputlisting[language=r]{\Sources/ex4_max.R}
-% \shorthandon{!}
-\lstinputlisting{\Sources/ex4_max.c}
-\end{exemple}
-
-\begin{warning}[Pensez à retourner qqc !!]
-Il est très important que votre fonction retourne un \lstinline!SEXP!~! Si votre fonction ne doit rien retourner alors il faut retourner la valeur \lstinline!R_NilValue!. Contrairement à beaucoup de librairie qui représente leur constante ``valeur nulle'' par 0, la constante \lstinline!R_NilValue! correspond à autre chose (ben oui! un \lstinline!SEXP! est un pointeur~!).
-
-Si vous oubliez le \lstinline!return!, \textbf{le compilateur ne vous blâmera pas nécessairement} et risque d'imaginer que vous souhaitiez faire un \lstinline!return 0;!. S'il vous venait cette idée, ce serait un pur attentat contre R qui planterait lors de l'utilisation de votre valeur de retour !
-\end{warning}
-
-
-\subsection{Interface \texttt{.External} : extension la plus générale}
-
-\begin{definition}[Fonction pour l'interface \texttt{.External}]
-Une fonction C qui peut être chargée par l'interface \texttt{.External} est une fonction dont
-\begin{itemize}
- \item tous les arguments sont rangés dans une unique liste R passés en paramètre de la fonction C. La fonction n'a donc qu'un seul argument de type \lstinline!SEXP!. Il n'y a plus de limitation de nombre de paramètre.
- \item le type de retour de la fonction doit être \lstinline!SEXP!, comme pour la fonction \texttt{.Call}.
-\end{itemize}
-\end{definition}
-
-L'interface \texttt{.External} est la plus générale. La seule différence avec l'interface \texttt{.Call} est dans le passage des paramètres. Sinon tout est identique.
-
-\begin{exemple}[Profil de la fonction \lstinline!max!]
-Toujours sur la fonction de calcul de maximum, le profil de la fonction que nous aurons à implémenter sera le suivant~:
- \begin{lstlisting}[numbers=none]
- SEXP max(SEXP args)
- \end{lstlisting}
-
-mais on peut remarquer que se profil de fonction sera toujours le même quelque soit le nom de la fonction : 1 seul argument de type \lstinline!SEXP! et un type de retour \lstinline!SEXP!.
-\end{exemple}
-
-
-Les macros ci-dessous offrent un accès facile aux quatre premiers arguments de la liste de paramètres (variable \lstinline!args!).
-\begin{lstlisting}[numbers=none]
-SEXP first = CADR(args);
-SEXP second = CADDR(args);
-SEXP third = CADDDR(args);
-SEXP fourth = CAD4R(args);
-\end{lstlisting}
-
-De manière beaucoup plus générique, il est possible d'utiliser les macros ci-dessous pour extraire tous les arguments de la liste~:
-
-\begin{lstlisting}[numbers=none]
-args = CDR(args); a = CAR(args);
-args = CDR(args); b = CAR(args);
-\end{lstlisting}
-
-La fonction \lstinline!CDR! ``dépile'' un élément de la liste des arguments, \ie enlever le élément premier élément de la liste. Tandis que la fonction \lstinline!CAR! accède au dernier élément ``dépilé'' de la liste, pour récupérer sa valeur (variable de type \lstinline!SEXP!).
-
-\espace
-
-Je ne crois pas qu'il soit bien nécessaire de rentrer plus dans les détails de cette fonction. Son utilisation ne se justifie que pour un nombre d'argument au delà de 65 (contrairement à \texttt{.Call}) ... je ne vois pas bien qui cela concerne ??
-
-\section{Gestion de la mémoire}
-
-R gère lui même sa mémoire avec un \emph{garbage collector}. Le \emph{garbage collector} est un petit démon\footnote{Un démon est un petit programme transparent qui fonctionne en permanence.} qui cherche les emplacements non-protégés pour les libérer.
-
-Si vous ne voulez pas de mauvaises surprises (désallocation de votre mémoire sans que vous ayez rien demandé) il faut protéger les espaces mémoire allouées~! On verra ensuite comme allouer de la mémoire utilisable dans votre code C mais également après l'exécution de votre fonction, dans le R principal.
-
-\subsection{Protection des variables contre le \emph{garbage collector} de R}
-\label{sec:PROTECT}
-
-Dès que vous utiliser des variables de type \lstinline!SEXP!, il faut penser qu'il s'agit de variables gérées par R. Votre fonction ne sera qu'utilisatrice de cette variable même si c'est elle qui l'a créée.
-
-En R, \textbf{toutes les variables doivent être protégées avant d'être utilisées}. C'est grâce à ce mécanisme de protection que le \emph{garbage collector} peut fonctionner correctement.
-
-Lorsque vous programmer une fonction avec l'interface \texttt{.Call} ou \texttt{.External}, vous disposez de deux macros pour gérer la protection de vos variables :
-\begin{itemize}
- \item \lstinline!PROTECT( SEXP x )! : indique à R de protéger un emplacement mémoire,
- \item \lstinline!UNPROTECT( int n )! : dé-protège les $n$ derniers emplacements protégés.
-\end{itemize}
-
-Il faut noter que la macro \lstinline!PROTECT! permet également de rapporter l'existante d'une variable nouvelle créée. Toute variable ayant pour but d'exister dans R (en dehors de la fonction C) doit protégée.
-
-\begin{exemple}[Protection de la mémoire]\label{ex:PROTECT}
-L'exemple ci-dessous illustre des protections de variables \lstinline!SEXP!. La protection est réalisée en même temps que leur déclaration.
-
-\begin{lstlisting}[numbers=none]
-SEXP ab, i;
-PROTECT(ab = NEW_NUMERIC(1)); //Allocation d'un nombre reel et protection
-PROTECT(i = NEW_INTEGER(1)); //Allocation d'un nombre entier et protection
-
-SEXP val;
-PROTECT( val = allocVector(REALSXP, 3) ); // Alloue un tableau de 3 reels et protege tout le tableau
-REAL(val)[0] = 128.4; //Attribution de la valeur au premier élément du tableau
-REAL(val)[1] = 28.4;
-REAL(val)[2] = -456.123;
-
-REAL(ab)[0] = REAL(val)[1];
-
-UNPROTECT(1); //libere val
-//ICI, on ne doit pas utiliser val !!
-
-REAL(i)[0]=REAL(ab)[0];//Copie du contenu de ab dans i
-
-UNPROTECT(2); //libere ab et i
-\end{lstlisting}
-\end{exemple}
-
-
-La protection des variables fonctionne sur le principe d'une pile\footnote{Peu d'entre vous savent ce qu'est une pile, mais pour les lecteurs ayant pratiqué un peu d'algorithmique, cela les aidera ! Je les aiderai encore plus si je dis que c'est une pile FILO (soit \emph{First In, Last Out}).}. C'est-à-dire qu'une variable est déposée sur une pile (imaginer une pile de papier avec le nom de la variable à protéger), et lorsque vous faites appel à un \lstinline!UNPROTECT!, la première feuille de la pile est enlevée, donc la variable correspondante est libérée.
-\textbf{Il n'est pas possible de désigner une variable à libérer}.
-
-La protection des variables est donc nécessairement imbriquée. Dans l'exemple \ref{ex:PROTECT}, une fois que la variable \lstinline!val! a été protégée, il n'est plus possible de libérer la variable \lstinline!i! directement. Il faudra d'abord libérer \lstinline!val!.
-
-\espace
-
-En cas d'erreur dans les protections, vous pouvez voir apparaître un message d'avertissement comme ci-dessous. Même si ce n'est qu'un \emph{warning}, il est préférable de résoudre cette erreur qui a des conséquences sur la protection de toutes les autres variables (décalage de la pile).
-\begin{verbatim}
-Warning: stack imbalance in '.Call', 36 then 37
-Warning: stack imbalance in '<-', 34 then 35
-\end{verbatim}
-
-\begin{remarque}[Inutile de protéger les variables passées en paramètres]
- Les variables passées en paramètre d'une fonction C appelée par une interface n'ont pas besoin d'être protégées dans la fonction. Si elles ont été passées en paramètre, c'est que leur usage aura été annoncé au \emph{garbage collector} avant l'appel. Il n'y a donc pas de risque de leur suppression inopinée.
-\end{remarque}
-
-\subsection{Allocation de mémoire pour des \texttt{SEXP}}
-\label{sec:allocVector}
-
-L'allocation de la mémoire d'une variable destinée à être utilisées dans R doit se faire au moyen de la fonction d'allocation \lstinline!allocVector(SEXPTYPE type, R_len_t taille)!.
-
-Les variables R étant toutes des vecteurs (car un \lstinline!SEXP! est un pointeur, donc un tableau), la fonction permet d'allouer un tableau de valeurs d'un même type. Cette fonction prend ainsi deux paramètres :
-\begin{itemize}
- \item \lstinline!type! : le type des variables R (\lstinline!CHARSXP!, \lstinline!INTSXP!, \lstinline!REALSXP!, \lstinline!VECSXP!, etc.)
- \item \lstinline!taille! : la taille du tableau, c'est-à-dire le nombre d'éléments du tableau. Peu importe le type interne (\lstinline!R_len_t!), vous pouvez simplement mettre un entier (\lstinline!int!).
-\end{itemize}
-
-Tous les éléments sont bien de même type.
-Si vous souhaitez faire des listes R, c'est-à-dire des structures de données R qui contiennent des vairables de type différents, ceci se représente en interne comme un vecteur de \lstinline!SEXP!, \ie un \lstinline!VECSXP!. Pour plus de détails sur les listes, consulter la Section \ref{sec:listesR}.
-
-
-\begin{remarque}[Libération de la mémoire allouée]
- L'avantage du \emph{garbage collector}, c'est que vous n'avez pas à vous soucier de la libération de la mémoire.
-\end{remarque}
-
-
-\begin{remarque}[Peut on continuer à utiliser des \lstinline!malloc!/\lstinline!free! comme avant ?]
- Tout d'abord, je vous remercie de cette question intéressante ... à laquelle je vais donner une réponse assez peu claire, car je n'ai pas trouvé cette réponse dans les différentes documentations.
-
-\espace
-
-Disons que si vous avez besoin de variables locales à votre programme C, \ie des variables qui ne seront jamais utilisées à l'extérieur de l'appel de la fonction C utilisée dans l'interface \texttt{.Call} ou \texttt{.External}. Alors, il semble possible d'utiliser les fonctions \lstinline!malloc! et \lstinline!free! pour gérer vous même votre mémoire (ça peut être utile si vous croyez être plus malin que le \emph{garbage collector}). Ceci sera d'autant plus vrai si vous utiliser des variables statiques (le mot clé \lstinline!static! n'ayant pas été abordé dans ce cours, je vous invite à explorer ailleurs pour comprendre cette remarque !).
-
-Quelques remarques :
-\begin{itemize}
- \item le \emph{garbage collector} ne traquera pas votre espace mémoire,
- \item éviter d'utiliser vos allocations personnalisées sur des variables de types \lstinline!SEXP! (déjà que c'est pas très catholique, il faudrait pas n'énerver trop !),
- \item vous ne disposerez pas de plus de mémoire qu'avec les allocations de R.
-\end{itemize}
-
-
-\textbf{Mais}, il reste un doute ... donc mieux vaut éviter de les utiliser trop.
-
-\end{remarque}
-
-\section{Utilisation des listes}\label{sec:listesR}
-
-La structure de données les plus fréquemment utilisées en R est certainement la liste. Cette structure de données est complexe puisqu'il est possible, entre autre :
-\begin{itemize}
- \item de nommer les éléments de cette liste,
- \item d'avoir des éléments de différents types (y compris d'autres listes)
-\end{itemize}
-
-Dans cette partie, on propose un exemple tiré de \cite{Gopi2005} pour créer une liste dans une fonction C qui pourra être appelée par \texttt{.Call} ou \texttt{.External}.
-
-\begin{definition}[Listes R]\label{def:listeR}
-Une liste R est une structure de données qui contient plusieurs ``variables'' pouvant être de types différents. D'un point de vue C, on peut imaginer que c'est une liste de \lstinline!SEXP!, c'est à dire des pointeurs, mais du fait de la nature pluriforme d'un \lstinline!SEXP!, l'élément pointé peut être de différents types.
-
-La particularité de la structure de liste de R est que chaque élément de la liste peut être identifiée soit par sa position dans la liste (un index) soit par un nom.
-
-\espace
-
-Intimement parlant, une liste R reste une variable R, c'est donc un \lstinline!SEXP!, mais qui pointe vers un \lstinline!VECSXP!, c'est à dire un vecteur de \lstinline!SEXP!.
-\end{definition}
-
-Pour traiter les listes, nous allons devoir expliquer comment les manipuler en détaillant : 1) comment allouer une liste en mémoire, 2), comment donner un nom aux éléments de notre liste, 3) comment remplir les éléments d'une liste, 4) comment accéder aux éléments d'une liste. À chacune de ces étapes, des fonctions ou macros de \texttt{Rdefines.h} seront introduites.
-
-\subsubsection{Allocation d'une liste R}
-
-L'exemple ci-dessous illustre comment allouer une nouvelle liste \lstinline!list! comprenant 2 valeurs~:
-\begin{lstlisting}[numbers=none]
-SEXP list;
-PROTECT( list = allocVector(VECSXP, 2) );
-\end{lstlisting}
-
-\subsubsection{Donner des noms aux éléments de la liste}
-
-Pour donner un nom aux éléments de la liste, il faut attribuer (fonction \lstinline!setAttrib!) un vecteur de chaîne de caractère à notre liste. Pour cela, il faut créer ce vecteur de nom, \lstinline!name! dans l'exemple ci-dessous. Le premier élément de la liste s'appellera \texttt{random\_values} et le second \texttt{size}.
-
-\begin{lstlisting}[numbers=none]
-SEXP names;
-PROTECT( names = allocVector(STRSXP, 2) );
-SET_STRING_ELT(names, 0, mkChar('random_values') );
-SET_STRING_ELT(names, 1, mkChar('size') );
-
-setAttrib(list, R_NamesSymbol, names);
-\end{lstlisting}
-
-\subsubsection{Donner des noms aux éléments de la liste}
-
-Notez que pour le moment, on a juste créé une liste avec deux éléments et leurs noms, mais on n'a pas spécifier ce qu'il va y avoir dedans! En particulier, nous n'avons pas choisi le type des données à y mettre. Dans la suite de l'exemple, nous allons mettre un vecteurs de 10 réels dans \texttt{random\_values} et la taille de ce vecteur, un entier, dans \texttt{size}.
-
-Pour cela, il faut allouer la mémoire nécessaire pour toutes ces données. Comme se sont des objets R, on utilise naturellement l'allocation mémoire des \lstinline!SEXP!.
-
-Les deux dernières lignes de l'exemple ci-dessous permettent d'associer le premier élément de \lstinline!list! (index 0) au \lstinline!SEXP! \lstinline!dim1! et le second élément de \lstinline!list! (index 1) à \lstinline!dim2!.
-
-\begin{lstlisting}[numbers=none]
-SEXP dim1, dim2;
-PROTECT( dim1 = allocVector(REALSXP, 10) );
-for(int i=0; i<10; i++)
- REAL(dim1)[0] = rnorm(0, 1.0);
-
-PROTECT( dim2 = allocVector(INTSXP, 1) );
-INTEGER(dim2)[0] = 10;
-
-SET_VECTOR_ELT(list, 0, dim1);
-SET_VECTOR_ELT(list, 1, dim2);
-\end{lstlisting}
-
-
-\subsubsection{Accès aux éléments d'une liste par nom}
-
-Nous reprenons ici la fonction \lstinline!getListElement! de \cite{Gopi2005} pour faciliter l'accès aux éléments d'une liste par nom. Cette fonction parcours la liste des noms de la liste et retourne l'élément de la liste correspondant. Si aucun élément ne correspond à ce nom, alors la fonction retourne \lstinline!R_NilValue!.
-
-\begin{lstlisting}[numbers=none]
-SEXP getListElement(SEXP list, const char *str) {
- SEXP elmt = R_NilValue;
- const char *tempChar;
- int i;
- PROTECT(SEXP names=getAttrib (list, R_NamesSymbol));
-
- for(i=0; i<length(list); i++) {
- tempChar = CHAR(STRING_ELT(names, i));
- if( strcmp(tempChar,str) == 0) {
- elmt = VECTOR_ELT(list, i);
- break;
- }
- }
- UNPROTECT(1);
- return elmt;
-}
-\end{lstlisting}
-
-\subsubsection{Utilisation des paramètres d'une fonction}
-
-\begin{lstlisting}[numbers=none]
-SEXP viewValue(SEXP arglist)
-{
- int val=0;
- SEXP sval;
-
- if( !IS_LIST(arglist) )
- error("la fonction attend une liste comme argument");
-
- sval = getListElement(arglist, "value");
- if( sval==R_NilValue )
- error("Impossible de trouver l'élément 'value' dans la liste");
-
- PROTECT(val=INTEGER(sval)[0]);
-
- Rprintf("L'élément est %d\n", val);
- UNPROTECT(1);
-}
-\end{lstlisting}
-
-
-% \subsubsection{Exemple complet}
-%
-% \begin{exemple}[Utilisation de listes]
-%
-% \end{exemple}
-
-
-
-\section{Débugger un programme C interfacé avec R}
-
-Et oui, même si vous bénéficier d'un super cours je ne peux pas m'engager contractuellement sur le fait que vous ne fassiez plus d'erreurs ... alors autant les anticiper.
-
-\subsection{Gestion des erreurs}
-
-\begin{definition}[Fonction \lstinline!error!]
- La fonction \lstinline!void error(const char *)! est une fonction qui permet de générer proprement une erreur dans votre fonction C. L'appel de cette fonction met immédiatement fin à l'exécution de la fonction et affiche le message d'erreur dans la console R.
-\end{definition}
-
-\begin{remarque} [Comportement avec \lstinline!PROTECT!]
- Je ne sais pas comment est géré la pile de protection dans le cas d'une erreur. Il ne me semble pas que les variables préalablement protégées soient libérées automatiquement. Il est donc préférable de libérer manuellement les variables qui auraient été protégées pour éviter les problèmes de déséquilibre de \lstinline!PROTECT!.
-\end{remarque}
-
-
-\subsection{Quelques erreurs}
-
-TODO : à compléter au gré de l'expérience ...
-
-
-\subsubsection{Débordement de pile}
-
-Vous pouvez rencontrer le problème de débordement de la pile (\emph{stack overflow}) 1) si vous exécutez le code C sur un ensemble de données énormes dans R ou 2) si vous utilisez un programme récursif. Pour le second cas, chaque appel récursif utilise un peu de mémoire de la pile, mais si les appels récursifs sont nombreux, on peut facilement dépasser l'espace de stockage. La suppression de la récursivité peut parfois résoudre le problème.
-
-La taille de la pile est une limite imposée par le système d'exploitation. La seule façon de résoudre ce problème consiste à manuellement allouer plus de mémoire physique pour la pile en modifiant les paramètres de votre système d'exploitation.
-Sous Linux, Vous pouvez connaître les limites intrinsèques à votre système en utilisant la commande \texttt{ulimit -a}.
-
-
-
-\subsection{Utiliser le débuggeur C dans R}
-
-
-\chapter{Utiliser des fonctions R dans C}
-
-On part du principe que le programmeur cherche à réaliser un programme en langage C qui nécessite des fonctionnalités statistiques riches.
-Le programmeur fainéant (donc malin) propose d'utiliser les fonctions de R pour son besoin plutôt que de refaire (en moins bien) les fonctions statistiques utiles.
-
-On commence par présenter une partie facile ... puis on donne quelques idées sur les possibilités d'intégration de R dans des programmes écris en C sans rentrer dans les détails (pas seulement pour des raisons d'accessibilité du lecteur, mais parce que votre serviteur n'a pas pris le temps de rentrer dans les entrailles profondes de R ... lui aussi à ses limites !).
-
-\section{Utilisation de fonctions de base de R dans un programme C autonome}
-
-Si l'installation de R le permet, c'est-à-dire si cela a été prévu à l'étape de configuration, l'utilisation de la librairie \texttt{Rmath.h} de R est possible depuis un programme C autonome, dite \emph{standalone}.
-Il est possible d'utiliser en C certaines fonctions mathématiques R en incluant le fichier d'en-tête \texttt{Rmath.h} dans votre code C par la ligne \lstinline!#include <Rmath.h> ! Ceci nécessitera néanmoins que vous ayez installé R en précisant que vous souhaitiez cette possibilité !
-
-Les fonctions statistiques qui peuvent être directement utilisées dans un programme C comprennent :
-\begin{itemize}
- \item des fonction de génération aléatoire (normales, uniformes, exponentielles).
- \item des distributions (Uniform, Normal, Chi-2, Student, Poisson, Binomial, Multinomial, Hypergeometric, Geometric, F, logistic, Beta, Exponential, Cauchy, Gamma, Wilcoxon, Weibull),
- \item des fonctions liées à la fonction Gamma,
- \item les fonctions de Bessel.
-\end{itemize}
-
-\begin{lstlisting}
-#define MATHLIB_STANDALONE
-#include <Rmath.h> // inclusion du fichier de R qui déclare les programmes
-#include <stdio.h>
-void ma_norm(int N, double *res) {
- int i;
- for (i=0; i< N; i++) {
- res[i] = norm_rand(); //Utilisation de la fonction norm_rand de Rmath.h
-
- printf("res[%d] = %f\n", i, res[i]);
- } // fin i
-
-}
-
-int main() {
- int N=5;
- double res[N];
- ma_norm(N, res);
- return(0);
-}
-\end{lstlisting}
-
-En début de programme, avant l'inclusion de \texttt{Rmath.h}, nous avons placé une variable d'environnement (\lstinline!#define MATHLIB_STANDALONE!) pour indiquer que nous utiliserons les fonctions de R en dehors de R.
-
-%\subsection{Génération de nombres aléatoires}
-
-\begin{exemple}[Génération de nombres aléatoires]
-
-Voici un exemple permettant d'utiliser un générateur aléatoire de R.
-\begin{lstlisting}
-#include <stdio.h>
-#include <time.h>
-#define MATHLIB_STANDALONE
-#include "Rmath.h"
-
-void main(){
- int i,n;
- double sum;
-
- //Initialisation du generateur aleatoire
- set_seed(time(NULL),77911);
-
- printf("Nombre de tirage ?");
- scanf("%d",&n);
-
- sum = 0.;
- for(i=0;i<n;i++){
- sum += rnorm(0,1);
- }
-
- printf("La moyenne est %lf\n",sum/(double)n);
-}
-\end{lstlisting}
-\end{exemple}
-
-
-%\subsection{Compilation d'un programme C avec les librairies R}
-La commande de compilation doit spécifier l'emplacement de la librairie Rmath qui contient les implémentations compilées des fonctions R. Cet emplacement varie selon les installations. Par exemple (chez moi) :
-\begin{verbatim}
-gcc -o rd -I/usr/share/R/include -L/usr/lib/R/lib -lRmath -lm Rmath_genrand.c
-\end{verbatim}
-
-
-\section{Évaluer des expressions R dans un programme C}
-\begin{center}
-\begin{warning}
-\textbf{! Cette partie est à faire !}
-\end{warning}
-\end{center}
-
-\section{Intégration R dans d'autres applications}
-
-\begin{center}
-\begin{warning}
-\textbf{! Cette partie est très préliminaire !}\\ Voir \url{http://developer.r-project.org/embedded.html} pour plus informations (illisibles).
-\end{warning}
-\end{center}
-
-
-%http://developer.r-project.org/embedded.html
-
-Sous Linux, il est possible de compiler R comme une bibliothèque autonome qui pourra être chargée dynamiquement dans d'autres applications. Il est alors possible de lancer le \emph{moteur} de R directement depuis ces autres applications.
-L'intérêt est alors de bénéficier de toute la puissance de R (plus étendue que si on utilise uniquement la version autonome) dans un logiciel sans que l'utilisateur n'est à lancer R ou même installer R.
-Une fois le \emph{moteur} de R lancé, il est possible d'utiliser l'interface de programmation défini dans les extensions R pour évaluer les expressions de R, appeler des fonctions de R, accéder aux routines mathématiques, etc comme il a été vu dans la section précédente.
-
-\subsection{Initialisation de R embarqué dans une application}
-La fonction \lstinline!Rf_initEmbeddedR! initialise le moteur R et \lstinline!Rf_endEmbeddedR! l'arrête. Ces fonctions sont disponibles depuis le fichier \texttt{Rembedded.h}.
-
-\lstinputlisting{\Sources/test_embed.c}
-
-\subsection{Compilation et exécution d'une application embarquant R}
-
-Pour compiler sous Linux, je vous conseille la commande suivante, en supposant que le fichier s'appelle \texttt{test\_embed.c} :
-\begin{verbatim}
- gcc -o test_embed `pkg-config --cflags --libs libR` test_embed.c
-\end{verbatim}
-Notez que la commande de compilation comprend des \emph{backquotes}, guillemets à l'envers pour faire appel à la commande \texttt{pkg-config}.
-
-\espace
-
-Lorsque ce programme est appelée, les variables d'environnement telles que \texttt{R\_HOME}, \texttt{R\_PROFILE}, \texttt{R\_LIBS} doivent être correctement configurées (en particulier \texttt{R\_HOME}). Si ce n'est pas le cas, il peut y avoir une erreur.
-Pour exécuter la commande, vous pouvez alors utiliser la commande suivante (qui assure que la variable \texttt{R\_HOME} est bien définie) :
-\begin{verbatim}
-R_HOME=/usr/lib/R ./test_embed
-\end{verbatim}
-
-En exécutant le programme, vous pourrez observer que R a été lancé par l'information de version traditionnellement affiché lors de l'exécution d'une console R. Pour masquer cet affichage, ajouter l'option \texttt{--quiet} ainsi :
-\begin{verbatim}
-R_HOME=/usr/lib/R ./test_embed --quiet
-\end{verbatim}
-
-Voilà pour le principe ... toute la suite est suffisamment complexe pour que je l'élude !
-
-%REF INTERESSANTE : http://www.asiantravelhotel.com/windows/r-from-c-mdash-simplest-possible-helloworld.html
-
-
-% \subsection{Gestion des erreurs}
-% Une application qui intègre R prendre soin de gérer les erreurs qui se produisent dans le moteur R. Dans la version autonome de R, une erreur (après d'autres \lstinline!on.error()! le contrôle des activités de retour dans chaque cadre d'évaluation) à l'entrée principale-eval-print boucle. En général, ce n'est pas ce qui est souhaité dans une autre application.
-% Au lieu de cela, nous voulons pour intercepter les erreurs de R tels et de les manipuler, d'où l'application a passé le contrôle du moteur R.
-%
-% Cela peut être fait plus facilement en utilisant la routine C \lstinline!R_tryEval! pour évaluer l'expression S. C'est exactement ce que nous voulons, en garantissant de revenir sur ce point dans le code appelant si une erreur s'est produite ou non dans l'évaluation de l'expression. Cette routine est semblable à \lstinline!eval!, en tenant à la fois l'expression à évaluer et à un environnement dans lequel effectuer l'évaluation. Il prend un troisième argument qui est l'adresse d'un entier. Si ce n'est pas \lstinline!NULL!, lorsque l'appel, celui-ci contient un drapeau indiquant s'il ya eu une erreur ou non.
-%
-%
-% \begin{exemple}[Gestion des erreurs]
-% \begin{lstlisting}
-% int callFoo()
-% {
-% SEXP e, val;
-% int errorOccurred;
-% int result = -1;
-%
-% PROTECT(e = allocVector(LANGSXP, 1));
-% SETCAR(e, Rf_install("foo"));
-%
-% val = R_tryEval(e, R_GlobalEnv, &errorOccurred);
-%
-% if(!errorOccurred) {
-% PROTECT(val);
-% result = INTEGER(val)[0];
-% UNPROTECT(1);
-% } else {
-% fprintf(stderr, "An error occurred when calling foo\n");
-% fflush(stderr);
-% }
-% /* Assume we have an INTSXP here. */
-% UNPROTECT(1); /* e */
-%
-% return(result);
-% }
-% \end{lstlisting}
-% \end{exemple}
-%
-% Notez que ce sera, par défaut, prendre soin de traiter tous les types d'erreurs que R serait manient normalement y compris les signaux. Donc, si l'utilisateur envoie une interruption à un calcul (par exemple en utilisant \texttt{Ctrl-C}), tandis que l'expression R est en cours d'évaluation, \lstinline!R_tryEval! reviendra et signaler une erreur. Si l'application hôte change cependant le masque de signaux et / ou les gestionnaires de celles propres de R, bien sûr, ce ne sera pas nécessairement se produire. En d'autres termes, l'application hôte peut contrôler la gestion des signaux différemment.
-
-
-\chapter{Construction d'un package R incluant du code C}
-
-
-\chapter{Conclusion}
-Les deux langages R et C s'opposent fortement dans leur philosophie. Il est donc très intéressant de les croiser. Pour les applications R, le gain d'efficacité et la meilleur gestion de la mémoire est très intéressant pour arriver à traiter de grand jeux de données. Pour les applications C, l'accès aux fonctionnalités de haut niveau en statistiques pallie un manque de développement de librairie dans ce domaine.
-Il faut noter également que la facilité d'insertion de code C dans un package R rend cette solution très attrayante.
-
-Pour profiter de cette richesse, cela à un prix ! Il est nécessaire pour le programmeur d'avoir quelques bases solides de C.
-
-\espace
-
-Tout ce qui est dans ce document n'est pas nécessairement utile à la production de code C pour l'extension des fonctionnalités en R. Le lecteur aura certainement intelligemment fait la distinction entre les exemples didactiques amenant une compréhension des mécanismes sousjacents et les exemples pragmatiques desquels s'inspirer pour adapter ses proposes solutions.
-
-Si je devais vous faire un résumer pragmatique, je vous inviterai à vous concentrer sur la compréhension de l'interface \texttt{.Call}, de bien comprendre l'utilisation du type \lstinline!SEXP! à l'aide des macros de \texttt{Rdefines.h}.
-
-Ensuite, il faudra penser à tous les pièges du C et en particulier à la gestion de la mémoire par R : penser à protéger les allocations !
-
-
-\espace
-
-%On peut noter cependant quelques limites dans l'utilisation des objets S : ils n'existent pas en C.
-
-Ce document est certainement incomplet. Sa compréhension permettra peut être aux plus acharnés de mieux aborder les (quelques) autres documents disponibles. Mais si le lecteur n'y trouve toujours pas son compte, il peut toujours se plaindre auprès de l'\href{mailto:thomas.guyet@agrocampus-ouest.fr}{auteur} et lui transmettre ses doléances. Qui sait, dans un bon jour, il en tiendra peut être compte.
-
-
-
-\chapter*{Annexes}
-
-\begin{appendix}
-\renewcommand\thesection{Annexe \Alph{section}}
-
-% \section{White card \texttt{Rmath.h} : les fonctions de R dans C }
-%
-% \section{White card \texttt{Rdefines.h}}
-%
-% Liste des fonctions et des types utiles pour la réalisation de fonction C à interfacer avec \texttt{.Call}.
-
-
-
-
-\section{Implémentation du Quicksort}\label{sec:Annexe_Quicksort}
-
-\shorthandoff{!}
-\lstinputlisting[language=r, caption={Implémentation de Quicksort en R}]{\Sources/quicksort.R}
-\shorthandon{!}
-\lstinputlisting[caption={Implémentation de Quicksort en langage C}]{\Sources/quicksort.c}
-
-\end{appendix}
-
-\nocite{*}
-\bibliographystyle{plain}
-\bibliography{bibRC}
-
-
-%
-% \clearpage
-% ~\newpage~\newpage
-% \ifodd\thepage ~\newpage ~\newpage\fi~
-% %\cleardoublepage
-% %\null
-% \thispagestyle{empty}
-% \vfill
-% {\small Guyet Thomas, AGROCAMPUS-OUEST, \today}
-\end{document}
diff --git a/Polyc/Poly_v3.tex~ b/Polyc/Poly_v3.tex~
deleted file mode 100644
index 05f91c9c9464c78b5caa8e5a1c20e4df41258cb6..0000000000000000000000000000000000000000
--- a/Polyc/Poly_v3.tex~
+++ /dev/null
@@ -1,81 +0,0 @@
-% This file was converted to LaTeX by Writer2LaTeX ver. 1.1.4
-% see http://writer2latex.sourceforge.net for more info
-\documentclass[12pt]{Poly}
-\usepackage[utf8]{inputenc}
-\usepackage[T1]{fontenc}
-\usepackage{array}
-\usepackage{supertabular}
-%\usepackage{hhline}
-\usepackage{graphicx}
-
-\newcommand{\Figures}{./Figures} % Répertoire des figures
-\newcommand{\Sources}{./Progs} % Répertoire des figures
-
-% Text styles
-%\makeatletter
-%\newcommand\arraybslash{\let\\\@arraycr}
-%\makeatother
-
-
-\begin{document}
-\title{Langage C}
-
-\institution{\href{http://www.agrocampus-ouest.fr}{AGROCAMPUS-OUEST, Centre de Rennes}}
-\author{\href{mailto:thomas.guyet@agrocampus-ouest.fr}{Thomas Guyet}}
-%\pagewebcours{http://www.irisa.fr/dream/Pages\_Pros/Thomas.Guyet/}
-\maketitle
-
-\chapter*{Préface}
-
-Ce document reprend des notes de cours sur le langage C. Il n'a aucune prétention de présenter l'intégralité du langage C (d'autres références bibliographique le font un peu mieux). Ce cours présente le langage C mais n'est pas un cours d'algorithmique. Néanmoins, certains exercices introduisent des notions fondammentales d'algorithmiques.
-
-Son but et son intérêt est de compléter les cours auquels vous assisterez. Ainsi, les notions y seront abordés de la même manière qu'en cours, ce qui ne sera pas nécessairement le cas si vous ouvrez une autre référence. Les définitions et les concepts ainsi formalisée vous permettrons d'alléger les prises de notes.
-
-Mais, de même que les cours, il vous place en tant que recepteur d'une information et non en tant qu'acteur. L'apprentissage de la programmation et d'un langage nécessite de la pratique (beaucoup en fait!!).
-J'ai voulu faire en sorte que ce polycopier contiennent beaucoup d'exemple et d'exercices corrigés qui doivent vous servir d'inspiration pour vos propres programmes.
-Alors, programmez en vous inspirant de ce document et de tout ce que vous pourrez trouver dans d'autres références (bibliographique ou sur internet).
-
-\espace
-
-Ce document est en perpétuelle évolution et est actuellement dans une version préliminaire. Certains exercices restent sans solution rédigée ... et je pense que de nombreuses coquilles se sont glissées dans les quelques bonnes lignes. Tous les commentaires sont les bienvenus.
-
-%\setcounter{tocdepth}{2}
-\tableofcontents
-
-\input{Archi.tex}
-
-\input{Environnement.tex}
-
-\input{AlgoC.tex}
-
-\input{Struct-C.tex}
-
-\input{Decomposition.tex}
-
-\input{Pointeurs.tex}
-
-\input{Compilation.tex}
-
-\chapter*{Références}
-
-\begin{enumerate}
- \item ``Le langage C par l'exemple'', P. Robinet, edt Ellipse/TechnoSup
- \item ``Le langage C, Norme ANSI'', Kernighan et Ritchie, edt Masson
- \item ``Exercices corrigés sur le langage C, solutions des exercices du Kernighan et Ritchie'', C. Tondo et S. Gimpel, edt Dunod
- \item ``Numerical recipes in C'', Press et al. également disponible \href{http://apps.nrbook.com/c/index.html}{en ligne}
- \item ``Algorithmique en C'', J.M. Léry, edt Pearson/Syntex
- \item ``Langage C'', B. Cassagne, polycopié de cours ENSIMAG
-\end{enumerate}
-
-
-
-\clearpage
-~\newpage~\newpage
-\ifodd\thepage ~\newpage ~\newpage\fi~
-%\cleardoublepage
-%\null
-\thispagestyle{empty}
-\vfill
-{\small Guyet Thomas, AGROCAMPUS-OUEST, \today}
-
-\end{document}
diff --git a/Polyc/Progs/InterfaceRC/ex1_max.c~ b/Polyc/Progs/InterfaceRC/ex1_max.c~
deleted file mode 100755
index 8a0dc61a17e206bee0b33e35f5aeae95f66a439e..0000000000000000000000000000000000000000
--- a/Polyc/Progs/InterfaceRC/ex1_max.c~
+++ /dev/null
@@ -1,6 +0,0 @@
-#include <R.h>
-
-void max(double *d1, double *d2, double *output)
-{
- *output = (*d1>*d2?*d1:*d2);
-}
diff --git a/Polyc/Progs/exemple_compilation_pp.c~ b/Polyc/Progs/exemple_compilation_pp.c~
deleted file mode 100644
index 8befa7048c374f15f80eba20f0929b206976d462..0000000000000000000000000000000000000000
--- a/Polyc/Progs/exemple_compilation_pp.c~
+++ /dev/null
@@ -1,15 +0,0 @@
-
-#include <stdio.h>
-#define LIMITE 10
-#define VALEUR_ABSOLUE(x) ( ((x) < 0)?-(x):(x) )
-
-
-int main() {
- int i=0;
- for(i=-LIMITE; i< LIMITE; i++) {
- int val = VALEUR_ABSOLUE(i*i*i);
- printf("%d\n", val);
- }
- return 0;
-}
-
diff --git a/Polyc/Struct-C.tex~ b/Polyc/Struct-C.tex~
deleted file mode 100644
index 72ada282c76086a08079ffa02a132288c97130dc..0000000000000000000000000000000000000000
--- a/Polyc/Struct-C.tex~
+++ /dev/null
@@ -1,342 +0,0 @@
-\chapter{Structures de données \label{chp:structuresdonnees}}
-\Opensolutionfile{solutions}{}
-
-Dans cette partie du cours, j'introduis la notion de structure de données (mots clés \lstinline!struct!, \lstinline!union!, \lstinline!enum! et \lstinline!typedef!) pour définir de nouveaux types à partir des types de base.
-
-Dans la vie réelle, les données qui sont traitées dans les programmes ne peuvent pas toujours se réduire à des nombres ou des caractères. Les données sont très souvent structurées et organisées.
-Par exemple, si les numéros de facture d'une entreprise sont de la forme 021100576 avec comme les deux premiers chiffres qui indiquent le mois de l'années de la facture puis deux chiffres pour l'année, ensuite trois chiffres pour le numéro de la facture dans le mois et enfin deux chiffres pour coder le nom de l'employé qui a édité la facture. On peut choisir de représenter ce numéro de facture sous la forme d'un nombre entier. Dans ce cas, à chaque fois que l'ordinateur voudra connaître le mois d'édition de cette facture, il devra réaliser des opérations arithmétiques. Il semble plus raisonnable de structurer ces informations dans un seul bloc et avec les données de mois, années, numéro et employé clairement séparées, facilement accessibles sans calcul complexe.
-
-L'objectif des structures de données est de faciliter la vie du programmeur en lui offrant la possibilité de définir ses propres structures de données composites.
-
-\section{Définir de nouveaux types avec \texttt{typedef}}
-L'instruction \lstinline!typedef! permet de définir de nouveau type de données. Sa syntaxe est la suivante~:
-
-{\centering\itshape
-\lstinline!typedef! description\_du\_type nom\_du\_type;
-\par}
-
-Vous pouvez ainsi définir le type \lstinline!bool! à partir des entiers ainsi~:
-\begin{lstlisting}
-typedef int bool;
-bool b;
-\end{lstlisting}
-
-%typedef uint unsigned int;
-
-\section{Types énumérés}
-
-\subsection{Définition d'un type énumeré}
-Un type énuméré est constitué par une famille finie de nombres entiers, chacun associé à un identificateur qui en est le nom. Mis à part ce qui touche à la syntaxe de leur déclaration, il n'y a pas grand-chose à dire à leur sujet.
-
-Les valeurs d'un type énuméré se comportent comme des constantes entières ; elles font donc double emploi avec celles qu'on définit à l'aide de \lstinline!#define!. Leur unique avantage réside dans le fait que certains compilateurs détectent parfois, mais ce n'est pas exigé par la norme, les mélanges entre objets de types énumérés
-distincts (par exemple, ne pas mettre une valeur de type \lstinline!mois_annee! dans une variable de type \lstinline!jour_semaine!) ; l'utilisation de ces types permet alors d'augmenter la sécurité des programmes.
-
-La syntaxe de la déclaration des énumérations est décrite dans les exemples suivants.
-
-\begin{exemple}
-La ligne ci-dessous introduit un type énuméré, appelé \lstinline!enum jour_semaine!, constitué par les constantes
-\lstinline!lundi! valant 0, \lstinline!mardi! valant 1, \lstinline!mercredi! valant 2, etc.
-
-\begin{lstlisting}[numbers=none]
-enum jour_semaine {lundi, mardi, mercredi, jeudi, vendredi, samedi, dimanche};
-\end{lstlisting}
-
-Ainsi, les expressions \lstinline!mardi+2! et \lstinline!jeudi! représentent la même valeur. Ces valeurs peuvent être directement utilisées dans le code.
-
-Pour définir une variable ayant ce type, il y a deux solutions~:
-
-\begin{itemize}
-\item sans \lstinline!typedef!
-\begin{lstlisting}[numbers=none]
-enum jour_semaine maVariableJour;
-\end{lstlisting}
-
-\item avec typedef (on définit un nouveau type)
-\begin{lstlisting}[numbers=none]
-typedef enum jour_semaine {lundi, mardi, mercredi, jeudi, vendredi} type_jour_ouvre;
-type_jour_ouvre maVariableJourOuvre;
-\end{lstlisting}
-\end{itemize}
-\end{exemple}
-
-
-
-\begin{exemple} [Type booléen]
-\begin{lstlisting}[numbers=none]
-typedef enum valeurs_booleenne {false, true} bool;
-bool b=true;
-\end{lstlisting}
-
-Dans cet exemple, l'énumération permet de définir deux valeurs (conforme à l'usage usuel en C)~: \lstinline!false! (avec la valeur 0 ) et \lstinline!true! (avec la valeur 1), et de définir le type \lstinline!bool!.
-\end{exemple}
-
-\begin{remarque}
-Lors de la déclaration des éléments énumérés on peut explicitement donner des valeurs entières à chacune des valeurs symboliques.
-
-Par exemple~:
-\begin{lstlisting}[numbers=none]
-enum Booleen {Vrai =1, Faux = 0};
-\end{lstlisting}
-
-\end{remarque}
-
-\subsection{Utilisation d'un type énumeré}
-
-Les type énumérés peuvent servir avec des \lstinline!switch! à distinguer des comportements en fonction de la valeur d'une variable de ce type.
-
-\begin{exemple}[Type énuméré et switch]
-
-\begin{lstlisting}
-typedef enum {MR, MME, MLLE, DR} civilite;
-
-void main() {
- civilite c;
-
- //... initialisation de c
-
-
- printf("Bonjour ");
-
- //Suite de l'affichage en fonction de civilité :
- switch(c) {
- case MR:
- printf("Monsieur");
- break;
- case MLLE:
- printf("Madame");
- break;
- case MME:
- printf("Madame");
- break;
- case DR:
- printf("Docteur");
- break;
- default:
- }
- printf(",\n");
-}
-\end{lstlisting}
-\end{exemple}
-
-
-\section{Les structures de données}
-\begin{definition}[Structures]
-Les structures sont des variables \textbf{composées de champs} de types différents.
-\end{definition}
-
-\subsection{Définition d'une nouvelle structure}
-Pour définir une structure, il faut utiliser le mot clé \lstinline!struct!. À la suite du mot-clé, on indique~:
-
-\begin{itemize}
-\item facultativement, le nom que l'on souhaite donner à la structure (\lstinline!Point3D! dans l'exemple). Ce nom de structure pourra être utilisé comme un nom de type.
-\item entre accolades~: la liste des déclarations des champs de la structure séparés par des virgules. Chaque champs à un type et un nom (ça s'écrit comme la déclaration d'une variable). Chaque champ peut avoir un type quelconque (y compris un autre type structure, bien s\^ur).
-\end{itemize}
-
-La structure ci-dessous illustre un structure de point en 3 dimensions~:
-\begin{lstlisting}
-struct Point3D {
- double x,
- double y,
- double z
-};
-\end{lstlisting}
-
-La définition d'une structure permet de définir de nouveau type en combinant le mot clé \lstinline!struct! avec le mot clé \lstinline!typedef!~:
-
-\begin{lstlisting}
-typedef struct {
- // declarations des champs
-} nom_type;
-\end{lstlisting}
-
-\begin{warning}
-Le nom du type définit par \textup{typedef} se situe à la fin des accolades.
-\end{warning}
-
-\begin{exemple} [Structure Point2D]
-Nous allons définir d'un type de structure \lstinline!Point2D! et déclaration d'une variable \lstinline!p! de type \lstinline!Point2D!.
-\begin{lstlisting}
-typedef struct {
- double x;
- double y;
-} Point2D ;
-
-Point2D p;
-\end{lstlisting}
-\end{exemple}
-
-\begin{remarque}[Alignement des données] Contrairement aux tableaux, l'organisation en mémoire peut être plus complexe que la simple contigu\"ité des champs. Pour des raisons d'efficacité, certains compilateurs ``décalent'' les emplacements mémoire pour les ``aligner'' sur des multiples de tailles élémentaires.
-\end{remarque}
-
-\subsection{Utilisation des variables-structure}
-Pour cette partie, on définit le type de structure ci-dessous~:
-
-\begin{lstlisting}
-typedef struct {
- int numero,
- char nom[32],
- char prenom[32],
- double salaire
-} Fiche;
-\end{lstlisting}
-
-\begin{itemize}
-\item Accès aux champs d'une structure~: utilisation de la ``notation pointée''
-\begin{lstlisting}
-Fiche f1, f2;
-//Mettre ici l'initialisation de f1 et f2
-f1.numero = 1;
-if( f1.salaire>f2.salaire ) {
- printf("%s gagne plus que %s", f1.nom, f2.nom);
-} else {
- printf("%s gagne plus que %s", f2.nom, f1.nom);
-}
-\end{lstlisting}
-
-\item Accès aux champs d'une structure définie par un pointeur\footnote{se référer au chapitre \ref{chp:pointeurs} pour la compréhension de cette notation.}~: utilisation de la ``notation fléchée''
-\begin{lstlisting}
-Fiche *f1, *f2; // declaration de deux pointeurs sur des structures
-//Mettre ici allocation des pointeurs f1 et f2 et initialisation du contenu des emplacements pointes
-f1->numero = 1;
-if( f1->salaire > f2->salaire ) {
- printf("%s gagne plus que %s",f1->nom, f2->nom);
-} else {
- printf("%s gagne plus que %s", f2->nom, f1->nom);
-}
-\end{lstlisting}
-\end{itemize}
-
-Notez que pour l'allocation mémoire d'une structure, tout ce passe exactement pareil qu'avant. En particulier, la fonction \lstinline!sizeof! va se charger de calculer la place nécessaire pour une instance de votre structure. Ainsi,
-dans ce cas, l'allocation ressemblerait à cela~:
-
-\begin{lstlisting}
-f1 = (Fiche *)malloc( sizeof(Fiche) );
-\end{lstlisting}
-
-\begin{itemize}
-\item Initialisation d'une structure~: l'initialisation d'une structure peut se faire manuellement (champs par champs en utilisant la notation pointée ou fléchée), ou bien à la déclaration ainsi~:
-\end{itemize}
-\begin{lstlisting}
-Fiche f1 ={1, "Guyet","Thomas", 3500.0};
-\end{lstlisting}
-
-\begin{exemple}[Exemple de structures complexes]
-
-\begin{itemize}
-\item une structure avec des champs diversifiés
-\begin{lstlisting}
-typedef struct {
- FILE *imagefile; // fichier image
- char *filename; // nom du fichier correspondant a l'image
- int height, width; // dimensions de l'image
- Point2D points[height*width]; // tableau de points de l'image (de taille < height*width)
-} Image;
-\end{lstlisting}
-
-\item une structure d'un n{\oe}ud d'arbre binaire
-\begin{lstlisting}
-typedef struct snode {
- snode *fd; // noeud fils droite
- snode *fg; // noeud fils gauche
-} node;
-\end{lstlisting}
-
-\item une structure d'un élément d'une liste doublement chaînée de \lstinline!double!
-\begin{lstlisting}
-typedef struct selem {
- selem *prec; // element precedent
- double value; // valeur contenu par l'element
- selem *succ; // element suivant
-} elem;
-\end{lstlisting}
-
-\end{itemize}
-\end{exemple}
-
-\begin{exercice}
-Nous voulons définir un type composé Joueur qui comprend 4 informations : le nom du joueur, le nombre de match joués, le nombre de match gagnés et le nombre de matchs restant à jouer.
-
-\question{Définir la structure \lstinline!Joueur!}
-
-\question{Écrire une fonction \lstinline!SaisieJoueur! pour saisir au clavier les informations d'un joueurs. Cette fonction retournera une variable de type \lstinline!Joueur!}
-
-\question{Écrire une fonction \lstinline!Saisies! pour remplir un tableau de joueurs. Cette fonction prendra comme paramètre d'entrée \lstinline!TabJ! : un tableau de joueur. La fonction ne retournera pas de résultat. Le nombre de joueur sera contenu dans une variable de pré-processing \lstinline!NB_JOUEUR!}
-
-\question{(\hard) Écrire \lstinline!Calcul! pour calculer le nombre total de match restant à jouer en fonction du nombre de match que chaque joueur doit jouer (paramètre de la fonction)}.
-
-\begin{Solution}
-\question{Structure}
-
-\begin{lstlisting}
-typedef struct {
- char nom[20];
- int nbmj;
- int nbmg;
- int nbmrj;
-} Joueur;
-\end{lstlisting}
-
-\question{SaisieJoueur}
-
-\begin{lstlisting}
-Joueur SaisieJoueur(){
- Joueur j;
- printf("Nom?\n");
- scanf("%s",&j.nom);
- printf("Nombre de matchs joués?\n");
- scanf("%d",&j.nbmj);
- printf("Nombre de matchs gagnés?\n");
- scanf("%d",&j.nbmg);
- printf("Nombre de matchs restants?\n");
- scanf("%d",&j.nbmrj);
-}
-\end{lstlisting}
-
-\question{Saisies}
-
-\begin{lstlisting}
-#define NB_JOUEUR 3
-void saisies(Joueur J[NB_JOUEUR]){
- int i;
- for(i=0; i<NB_JOUEUR; i++) {
- printf("JOUEUR %d\n", i+1);
- Joueur j = SaisieJoueur();
- J[i]=j;
- }
-}
-\end{lstlisting}
-
-\question{Calcul}
-
-\begin{lstlisting}
-int Calcul(Joueur J[NB_JOUEUR], int nb) {
- int i, deuxtotaljoue=0;
-
- int nbmatchs = NB_JOUEUR * nb;
-
- for(i=0; i<NB_JOUEUR; i++) {
- deuxtotaljoue+=J[i].nbmrj;
- }
-
- return nbmatchs-deuxtotaljoue/2;
-}
-\end{lstlisting}
-
-\end{Solution}
-\end{exercice}
-
-% \begin{exercice}(Allo !!! (\hard\hard))
-% À l'aide d'un tableau de personnes (nom, prénom, numéro dans la rue, rue, code postal, ville, numéro de téléphone), faire un programme de recherche automatique de toutes les informations sur les personnes répondant à une valeur d'une rubrique donnée (tous les PATRICK , tous ceux de Cesson, travaillant à AGROCAMPUS, etc...). On suppose que le tableau est déjà initialisé.
-%
-% \begin{Solution}
-% Voici le code complet de la solution à l'exercice :
-% \lstinputlisting{\Sources/exo_Allo.c}
-% \end{Solution}
-%\end{exercice}
-
-
-
-
-\section{Correction des exercices}
-\Closesolutionfile{solutions}
-\Readsolutionfile{solutions}
diff --git a/Polyc/bibRC.bib~ b/Polyc/bibRC.bib~
deleted file mode 100644
index de58e3e6d5181cfb3df44b2c0e1cf05a18084d54..0000000000000000000000000000000000000000
--- a/Polyc/bibRC.bib~
+++ /dev/null
@@ -1,47 +0,0 @@
-@techreport{Peng2002,
-author={Peng, R.D et Leeuw, J.},
-year={2002},
-title={An introduction to the {.C} Interface to {R}.},
-institution={UCLA Department of Statistics},
-note={\url{http://www.ats.ucla.edu/stat/r/library/interface.pdf}}
-}
-
-
-@article{Eddelbuettel2011,
- author ={Dirk Eddelbuettel and Romain Francois},
- title ={{Rcpp}: Seamless {R} and {C++} Integration},
- journal ={Journal of Statistical Software},
- volume ={40},
- number ={8},
- pages ={1--18},
- day = {13},
- month ={4},
- year = {2011},
- note = {\url{http://www.jstatsoft.org/v40/i08}}
-}
-
-@techreport{WritingRExt,
-title={Writing {R} extensions},
-author={R Development Core Team},
-note={\url{http://cran.r-project.org/doc/manuals/R-exts.html}},
-version={2.15.0},
-institution={CRAN},
-year={2012}
-}
-
-@misc{Blay2012,
-author={Sigal Blay},
-howpublished={\url{http://www.sfu.ca/~sblay/R-C-interface.txt}}
-}
-
-@misc{Gopi2005,
-author={Gopi Goswami},
-howpublished={CCR05 courses (Harvard)}
-}
-
-@techreport{Chaudhary2007,
-title={An Introduction to the Interface Between {C} and {R}},
-year={2007},
-institution={EPFL},
-note={\url{http://infoscience.epfl.ch/record/112204}},
-}
diff --git a/TD/TD1.tex~ b/TD/TD1.tex~
deleted file mode 100755
index 9866a4442c8ab1e70120ef04580fab6de618e695..0000000000000000000000000000000000000000
--- a/TD/TD1.tex~
+++ /dev/null
@@ -1,190 +0,0 @@
-\documentclass[a4paper,10pt]{article}
-
-\usepackage{../TP/exos}
-
-\title{Feuille TD : Structures de contrôle}
-\author{Guyet T.}
-\date{}
-
-\begin{document}
-
-\maketitle
-
-\hidecorrection
-
-\begin{exercice}[Les conditions]
-
-\question{Pour les deux programmes ci-dessous, donner l'affichage du programme pour les valeurs de $i$ ci-dessous}
-\begin{itemize}
-\item \lstinline!int i=-1;!
-\item \lstinline!int i=2;!
-\item \lstinline!int i=4;!
-\item \lstinline!int i=6;!
-\end{itemize}
-
-\begin{figure}[h]
- \begin{minipage}[c]{.46\linewidth}
-\begin{lstlisting}
-if( i>0 ) {
- printf("i (%d) est fitisop \n",i);
-} else if ( i<0 ) {
- printf("i (%d) est fitagen \n",i);
-} else {
- printf("lun");
-}
-\end{lstlisting}
- \end{minipage} \hfill
- \begin{minipage}[c]{.46\linewidth}
-\begin{lstlisting}
-int j=10;
-if( i < 4) {
- if( j > 4) {
- printf("ici ?\n");
- }
-} else {
- if( j > 4 ) {
- printf("la?\n");
- } else {
- printf("ou la?\n");
- }
-}
-\end{lstlisting}
- \end{minipage}
-\end{figure}
-
-
-
-\question{Que fait le programme ci-dessous ?}
-
-{\it \underline{Aide :} aidez vous d'un tableau d'évolution des variables sur l'exemple des valeurs proposé.}
-
-\begin{lstlisting}
- float x,y,z,t;
- int lim=22;
-
- x=23.4;
- y=120;
- z=22.3;
-
- if ( x > y ) {
- t=x;
- x=y;
- y=t;
- }
- printf("%f %f %f\n", x,y,z);
-
- if ( y > z ) {
- t=y;
- y=z;
- z=t;
- }
- printf("%f %f %f\n", x,y,z);
-
- if ( x > y ) {
- t=x;
- x=y;
- y=t;
- }
- printf("%f %f %f\n", x,y,z);
-\end{lstlisting}
-
-\end{exercice}
-
-\begin{exercice}[Boucle \texttt{while} et fonctions mathématiques]
-
-\begin{lstlisting}
-float f=81.0;
-int nbTours=0;
-
-while ( f > 5 ) {
- f = sqrt(f);
- nbTours++;
-}
-\end{lstlisting}
-
-
-\question{Faire un tableau d'évolution des variables}
-
-Quel sera le résultat final ?
-
-\question{Mêmes questions en remplacant la condition du \texttt{while} par \lstinline!f>0!}
-\end{exercice}
-
-\begin{exercice}[Boucle \texttt{for}]
-
-\begin{lstlisting}
-int j=100;
-double d= 13;
-for(j=16; j >= 1 ; j=j/2 ) {
- d=d/2;
-}
-printf("result : d=%f\n",d);
-\end{lstlisting}
-\question{Faire un tableau d'évolution des variables}
-\question{Affichage ?}
-\end{exercice}
-
-\begin{exercice}[Boucle \texttt{for} (2)]
-
-\begin{lstlisting}
-char c[] = "voici un texte";
-int i;
-for(i=0; c[i] != '\0' && c[i+1] != '\0'; i+=2) {
- printf("%c ", c[i]);
-}
-printf("\n");
-\end{lstlisting}
-
-\question{Faire un tableau d'évolution des variables}
-\question{Affichage ?}
-\question{Quel est l'intérêt de la double condition \lstinline!c[i]\!='\\0' && c[i+1]\!='\\0'! ?}
-\end{exercice}
-
-\begin{exercice}[Boucle : transformer un \texttt{for} en \texttt{while}]
-
-Transformer le programme précédent avec l'instruction \texttt{for} en un programme avec une instruction \texttt{while}.
-\end{exercice}
-
-\begin{exercice}[Double boucle \texttt{for}]
-\begin{lstlisting}
-int i,j;
-for(i=0; i<4; i++) {
- for(j=0; j<4; j++) {
- printf("i : %d, j : %d\n", i,j);
- }
-}
-\end{lstlisting}
-\question{Faire un tableau d'évolution des variables}
-\question{Affichage ?}
-\end{exercice}
-
-\begin{exercice}[Interruption d'une boucle]
-% Mieux en TP !!
-
-L'exécution normale d'une boucle peut être interrompue explicitement pour tenir compte de déroulements particuliers. Il s'agit des instructions \lstinline!break! et \lstinline!continue!. Le programme ci-dessous illustre le fonctionnement de ces deux instructions dites ``de branchement''.
-
-\begin{lstlisting}
-char text[] = "voici un texte";
-int i=0, ne=0, nu=0;
-
-while(1) {
- if( text[i] == 'e' ) {
- ne++;
- } else if ( text[i] == 'a' ) {
- continue;
- } else if ( text[i] == 'u' ) {
- nu++;
- } else if( text[i] == 'x' ) {
- break;
- }
- i++;
-}
-printf("ne %d, nu %d\n", ne, nu);
-\end{lstlisting}
-
-\question{Faire un tableau d'évolution des variables}
-\question{Qu'affichagera le programme lors de son exécution ?}
-\question{Que se passe-t-il si \lstinline!text[] = "voila un texte";! ?}
-\end{exercice}
-
-\end{document}
diff --git a/TD/TD_Pointeurs.tex~ b/TD/TD_Pointeurs.tex~
deleted file mode 100644
index 5360e04f4ddc06ca2cde0c96f4d165f4aef548af..0000000000000000000000000000000000000000
--- a/TD/TD_Pointeurs.tex~
+++ /dev/null
@@ -1,273 +0,0 @@
-\documentclass[a4paper,10pt]{article}
-\usepackage[utf8]{inputenc}
-\usepackage[T1]{fontenc}
-
-\usepackage{../TP/exos}
-
-\title{Pointeurs}
-\author{Guyet T.}
-\date{2009-2010}
-
-\begin{document}
-\maketitle
-
-\begin{exercice}[Manipulation des pointeurs]
-
-\question{Opérations élémentaires sur les pointeurs}
-
-\begin{lstlisting}
-int main() {
- int A = 1;
- int B = 2;
- int C = 3;
- int *P1, *P2;
- P1=&A;
- P2=&C;
- *P1=(*P2)++;
- P1=P2;
- P2=&B;
- *P1-=*P2;
- ++*P2;
- *P1*=*P2;
- A=++*P2**P1;
- P1=&A;
- *P2=*P1/=*P2;
- return 0;
-}
-\end{lstlisting}
-
-Construire un tableau d'évolution de variables donnant les valeurs des 5 variables (A, B, C, P1 et P2) pour chaque instruction du programme ci-dessus.
-% \begin{center}
-% \begin{tabular}{|l|c|c|c|c|c|}
-% \hline
-% & A & B & C & P1 & P2 \\ \hline
-% Init & 1 & 2& 3& / & /\\
-% P1=\&A & 1& 2& 3& \&A & \\
-% P2=\&C & & & & & \\
-% *P1=(*P2)++ & & & & & \\
-% P1=P2 & & & & & \\
-% P2=\&B & & & & & \\
-% *P1-=*P2 & & & & & \\
-% ++*P2 & & & & & \\
-% *P1*=*P2 & & & & & \\
-% A=++*P2**P1 & & & & & \\
-% P1=\&A & & & & & \\
-% *P2=*P1/=*P2 & & & & & \\ \hline
-% \end{tabular}
-% \end{center}
-
-\question{arithmétique des pointeurs avec tableaux}
-On déclare les variables suivantes :
-\begin{lstlisting}
-int A[] = {12, 23, 34, 45, 56, 67, 78, 89, 90};
-int *P;
-P = A;
-\end{lstlisting}
-
-Quelles valeurs ou adresses fournissent ces expressions:
-\begin{enumerate}
-\item *P+2
-\item *(P+2)
-\item \&P+1
-\item \&A[4]-3
-\item A+3
-\item \&A[7]-P
-\item P+(*P-10)
-\item *(P+*(P+8)-A[7])
-\end{enumerate}
-
-\question{Tableaux à plusieurs dimensions}
-Soit la déclaration d'un tableau \lstinline!int b[3][5]!. En considérant que l'allocation du tableau se fait linéairement en mémoire, donnez l'état du tableau b après l'exécution du code C suivant :
-\begin{lstlisting}
- int b[3][5];
- int *a = *b, i;
- for (i=0 ; i<15 ; *a++ = i++)
- ;
- **b = 15; **(b+1) = 16; *(b[0]+1) = 17;
- *(*b+8) = 18; *(b[1]+2) = 19; *(*(b+1)+5) = 20;
- *(b[2]+3) = 21; *(*(b+2)+2) = 22;
-\end{lstlisting}
-
-\end{exercice}
-
-
-\begin{exercice}[Pointeurs]
-
-\begin{lstlisting}
-void proc(int * ad, int j) {
- *ad = (*ad + j)*3;
- /* dessiner l'etat de la memoire */
-}
-
-int main() {
- double a = 0.001, b = 0.003;
- double c, *pa, *pb;
- int i=0;
- /* dessiner l'etat de la memoire */
- pa = &a; *pa *= 2;
- pb = &b;
- c = 3*(*pb - *pa);
- /* dessiner l'etat de la memoire */
- proc(&i,4);
- /* dessiner l'etat de la memoire */
- return 0;
-}
- \end{lstlisting}
-
-Dessinez l'état de la mémoire à chaque fois que c'est indiqué en commentaire. Vous supposerez que les variables sont stockées à partir de l'adresse @106, et qu'elles sont allouées de manière contigüe et qu'un \lstinline!int! occupe 4 octets (1 case = 1 octet).
-
-\end{exercice}
-
-%
-% \begin{exercice}[Compréhension des pointeurs]
-%
-% Dans les questions suivantes, on vous fournit des programmes et on vous demande d'indiquer ce que vont afficher ces programmes.
-%
-% \question{Notion d'adresse en C. Opérateur \&}
-%
-% \begin{lstlisting}[caption=pointeurs\_1.c]
-% #include <stdio.h>
-%
-% int i_global;
-% int c_global;
-%
-% int main()
-% {
-% int i;
-% char c;
-%
-% i_global=270;
-% c_global='C';
-% i=270;
-% c='C';
-%
-% printf("Variables globales\n\t");
-%
-% /*valeur et adresse associees a la variable i_global */
-% printf("la valeur de i_global %d\n\t", i_global);
-% printf("l'adresse de i_global %u (%x)\n\t", &i_global,&i_global);
-%
-% /*valeur et adresse associees a la variable c_global */
-% printf("la valeur de c_global %d\n\t", c_global);
-% printf("l'adresse de c_global %d (%x)\n", &c_global,&c_global);
-%
-% printf("Variables locales\n\t");
-%
-% /*valeur et adresse associees a la variable i */
-% printf("la valeur de i %d\n\t", i);
-% printf("l'adresse de i %d (%x)\n\t", &i,&i);
-%
-% /*valeur et adresse associees a la variable c */
-% printf("la valeur de c %d\n\t", c);
-% printf("l'adresse de c %d (%x)\n", &c,&c);
-% }
-% \end{lstlisting}
-%
-% \question{Operateur *}
-%
-% \begin{lstlisting}[caption=pointeurs\_2.c]
-% #include <stdio.h>
-%
-% int main()
-% {
-% int i=3;
-% int *ptr_int;
-%
-% ptr_int=&i;
-%
-% printf("la valeur de i %d\n", i);
-% printf("l'adresse de i %u (%x)\n", &i, &i);
-% printf("la valeur de ptr_int %u (%x)\n",ptr_int, ptr_int);
-% printf("la valeur pointee par ptr_int %d\n",*ptr_int);
-%
-% /*incrementation du contenu de l'emplacement memoire pointe par ptr_int*/
-% *ptr_int=*ptr_int+2;
-%
-% printf("\nApres incrementation du contenu *ptr_int\n");
-% printf("la valeur de i %d\n", i);
-% printf("l'adresse de i %u (%x)\n", &i, &i);
-% printf("la valeur de ptr_int %u (%x) \n",ptr_int, ptr_int);
-% printf("la valeur pointee par ptr_int %d\n",*ptr_int);
-%
-% return 0;
-% }
-% \end{lstlisting}
-%
-% \question{Arithmétique des pointeurs}
-%
-% Dans cet exemple, on montre s'intéresse à l'incrémentation d'un pointeur.
-%
-% \begin{lstlisting}[caption=pointeurs\_3.c]
-% #include <stdio.h>
-%
-% main() {
-% int a[3]={0,2,5} ;
-% int dist ;
-% int *ptr_int;
-%
-% ptr_int=&a[0];
-%
-% printf("valeur de a[0] = %d\n", a[0]) ;
-% printf("adresse de a[0] = %u (%x)\n", &a[0],&a[0]) ;
-% printf("valeur de ptr_int= %u (%x)\n", ptr_int, ptr_int) ;
-% printf("valeur pointee par ptr_int = %d\n",*ptr_int);
-%
-% *ptr_int=*ptr_int+2; //incrementation du contenu pointe par ptr_int
-% printf("\n apres incrementation de *ptr\n\n");
-% printf("valeur de a[0] = %d\n", *ptr_int) ;
-%
-% ptr_int++; //incrementation de l'adresse memoire contenu dans ptr_int
-%
-% printf("adresse de a[1] = %u (%x) \n", &a[1],&a[1]) ;
-% printf("valeur de ptr_int apres (ptr_int++) %u (%x)\n",ptr_int, ptr_int);
-%
-% dist=ptr_int-&a[0];
-%
-% printf("nombre d'entiers entre ptr_int (%x) et a[0] (%x) = %d\n", ...
-% ptr_int,&a[0],dist);
-% dist=(char*)ptr_int-(char*)&a[0];
-% printf("nombre de caracteres entre ptr_int (%x) et a[0] (%x) = %d\n",...
-% ptr_int,&a[0],dist);
-% }
-% \end{lstlisting}
-% \end{exercice}
-
-
-\begin{exercice}[Pointeurs et allocation mémoire]
-
-\begin{lstlisting}
-int main() {
- int e = 10;
- double r = 3.14;
- int * p1;
- double * p2;
- int i;
- p1 = (int*) malloc (5*sizeof(int));
- if(p1 == NULL) {
- printf("Allocation ratee \n");
- exit(1);
- }
- p2 = (double*) malloc (sizeof(double));
- if(p2 == NULL) {
- printf("Allocation ratee \n");
- exit(1);
- }
- for(i=0 ; i < 5 ; i++) {
- p1[i] = e-i;
- }
- *p2 = r;
- (*p1)*=5;
- *p2=p1[3]*2.0;
- e = 25;
- r = -8.3;
- free(p1);
- free(p2);
- return 0;
-}
-\end{lstlisting}
-
-
-\end{exercice}
-
-
-\end{document}
diff --git a/TP/Exam/Exam2011.tex~ b/TP/Exam/Exam2011.tex~
deleted file mode 100644
index f49f3c6b5f6b744f177972e0c12dae8b0e9a021c..0000000000000000000000000000000000000000
--- a/TP/Exam/Exam2011.tex~
+++ /dev/null
@@ -1,143 +0,0 @@
-\documentclass[a4paper,10pt]{article}
-
-\usepackage{../exos}
-
-\title{Examen C}
-\author{Guyet T.}
-\date{2010-2011}
-
-\begin{document}
-
-\maketitle
-
-\underline{Modalités :}
-\begin{itemize}
- \item Durée : 2h00 (et y'a du boulot ...)
- \item Documents autorisés,
- \item Calculatrices et ordinateurs interdits.
-\end{itemize}
-
-\espace
-
-Le barème est indicatif.
-
-Vos réponses aux questions doivent être claires et précises, rédigées en français ou en anglais (avec une tolérance dans la clareté pour les natifs d'une autre langue que ces deux là).
-
-Dans toutes vos réponses, vous pouvez recourrir à des schémas pour illustrer vos propos. Néanmoins, un schéma seul ne pourra servir de réponse~: des explications de celui-ci sont attendues.
-
-Si question vous invite à donner une réponse finale, le correcteur pourra prendre avec indulgence les réponses fausses si le raisonnement, les étapes intermédiaires ou autres détails sont ajoutés aux réponses.
-
-Les erreurs d'énoncés sont à signaler dans votre copie (avec les modifications éventuelles que vous feriez de celui-ci). Néanmoins, il n'y a pas de piège : tous les programmes proposés sont corrects (et vérifié).
-
-\begin{exercice}[Pointeurs ... (/3)]
-
-On supposera que l'adresse en mémoire des variables sont les suivantes et que 1 case correspond à un entier (type \lstinline!int!) :
-\begin{itemize}
- \item @\lstinline!a! : 121
- \item @\lstinline!p! : 126
- \item @\lstinline!pp! : 119
-\end{itemize}
-
-Donnez et expliquez l'affichage qui produira ce programme.
-
-\lstinputlisting{pointeurs2.c}
-
-\end{exercice}
-
-
-\begin{exercice}[Compréhension d'un algorithme (/6)]
-
-On vous propose d'étudier le programme ci-dessous inspiré des algorithmes d'automates cellulaires~:
-
-\lstinputlisting{CellularAutomata1D.c}
-
-\question{Représentez en mémoire les variables utilisées dans la fonction \lstinline!void print(raw r)!. Vous utiliserez 1 case pour représenter un entier (\lstinline!int!). Expliquez ? (/1)}
-
-\question{Expliquez ce que fait la fonction \lstinline!void init(raw r)!~? (/1)}
-
-\question{Les modifications de \lstinline!r! dans la fonction \lstinline!init! auront-elles de l'influence sur la variable R à la ligne 69~? Expliquez~? (/1)}
-
-\question{En supposant que le début de l'exécution ait conduit à l'affichage ci-dessous, reprendre la suite de l'exécution à partir de la ligne 73 (à exécuter) et donner l'affichage qui sera obtenu dans la suite. (/3)}
-
-\begin{verbatim}
-| ** * |
-\end{verbatim}
-
-% \begin{Solutions}
-% \begin{verbatim}
-% | ** * |
-% |* *****|
-% | ** *|
-% \end{verbatim}
-% \end{Solution}
-
-\end{exercice}
-
-
-\begin{exercice}[Définition d'un type de données pour les complexes (/7)]
-
-L'objectif de cet exercice est de définir un nouveau type de données pour traiter les nombres complexes.
-
-Pour rappel l'ensemble des nombres complexes est un corps commutatif, c'est-à-dire, disposant de deux opérations ($+$ et $\times$) commutatives, associatives et distributives. Un complexe est formé de deux parties, la partie réelle et la partie imaginaire :
-$$\forall c \in \mathbb{C},\; c=Re(c)+Im(c).\mathrm{i},$$
-
-où $Re(c) \in \mathbb{R}$ est la partie réelle de $c$ et $Im(c) \in \mathbb{R}$ est la partie imaginaire de $c$. Ces deux parties sont donc représentées par des nombres réels.
-
-On rappelle la propriété algébrique des nombres réels\footnote{$\mathrm{i}$ est l'unique solution dans $\mathbb{C}$ de l'équation $c\times c=-1$}~:
-$$\mathrm{i} \times \mathrm{i}=-1$$
-
-On définit le module d'un nombre complexe par~:
-$$|c|=\sqrt{Re(c)^2+Im(c)^2}$$
-
-
-Dans cet exercice, on vous demande de créer le type de données qui représente ces nombres, et des fonctions qui vont permettre de faire des opérations sur ces nombres~:
-\begin{itemize}
- \item addition : pour deux complexes $c_1$ et $c_2$, le complexe $c_3=c_1+c_2$ comme valant $Re(c_1)+Re(c_2) + \mathrm{i}.(Im(c_1)+Im(c_2))$
- \item produit : pour deux complexes $c_1$ et $c_2$, le complexe $c_3=c_1\times c_2$ comme valant $Re(c_1).Re(c_2)-Im(c_1).Im(c_2)+\left(Re\left(c_1\right).Im\left(c_2\right)+Im\left(c_1\right).Re\left(c_1\right)\right)\mathrm{i}$
- \item conjugué : pour un nombre complexe $c$, le conjugué est $c'=Re(c)-Im(c). \mathrm{i}$
-% \item la racine carrée : pour un complexe $c$, le complexe $c'$ tel que~: $c'.c'=c$
-\end{itemize}
-
-%Note sur la racine : la racine carrée correspond à trouver le nombre (a',b') tel que (a,b)=(a',b').(a',b'). La racine carrée d'un nombre Réel r positif donne les deux racines carrées réelles connues : \sqr{r} et -\sqr{r}, celles d'un réel négatif : \sqr{r}.j et -\sqr{r}j.
-
-\question{Définir le nouveau type de données, nommé \lstinline!complexe!, en utilisant l'instruction \lstinline!typedef! (/1)}
-\question{Définir une fonction d'affichage \lstinline!void print(complexe c)! qui affiche le nombre complexe sous la forme ci-dessous (/1)}
-\begin{center}
-\begin{verbatim}
- 2.3 + 5.6i
-\end{verbatim}
-\end{center}
-
-\question{Définir les fonctions qui permettrons de réaliser des opérations de manipulation des nombres. Les profils de fonction ci-dessous sont à finaliser. (/4)}
-\begin{lstlisting}[numbers=none]
-... add(...);
-... mult(...);
-... conj(...);
-\end{lstlisting}
-
-\question{Écrire un \lstinline!main()! qui réalise les opérations suivantes sur les complexes avec vos fonctions et affiche le résultat $r$. (/1)}
-\begin{eqnarray*}
-a &=& 3 + 4\mathrm{i}\\
-b &=& 2\\
-c &=& a + b'\\
-r &=& c \times c
-\end{eqnarray*}
-\end{exercice}
-
-
-\begin{exercice}[Calcul de $e$ (/4)]
-
-Comme tous les irrationnels, il est impossible d'obtenir la valeur exacte de $e$\footnote{$e$ est le nombre tel que $\ln(e)=1$, où $\ln$ est le logarithme néperien.}. On propose d'utiliser une formule de développement limité pour approximer la valeur de $e$.
-
-On sait que~:
-$$e = \sum_{n=0}^{\infty} \frac{1}{n!} = 1 + \frac{1}{2!} + \frac{1}{3!} + \frac{1}{4!}+ ...$$
-
-
-\question{Écrire une fonction \lstinline!long fact(int d)! qui calcule $d! = d \times (d-1) \times (d-2) \times (d-3) \times ...$}
-
-\question{Écrire une fonction qui approxime $e$ en calculant $p$ termes de la série ci-dessus ($p$ étant un paramètre de la fonction).}
-
-\end{exercice}
-
-
-\end{document}
\ No newline at end of file
diff --git a/TP/TP1/TP1.tex~ b/TP/TP1/TP1.tex~
deleted file mode 100755
index 697c52f4206a31188ab5630719241bc6e76e2727..0000000000000000000000000000000000000000
--- a/TP/TP1/TP1.tex~
+++ /dev/null
@@ -1,126 +0,0 @@
-\documentclass[a4paper,10pt]{article}
-
-\usepackage{../exos}
-\usepackage[utf8]{inputenc}
-\usepackage[T1]{fontenc}
-
-
-\title{TP C : Introduction}
-\author{Guyet T.}
-\date{2011-2012}
-
-\begin{document}
-
-\maketitle
-
-\underline{Objectifs du TP :}
-\begin{itemize}
- \item Découvrir l'environnement de programmation \texttt{Code::Blocks},
- \item Savoir compiler un programme C simple (dans les deux environnements),
- \item Savoir résoudre les problèmes de compilation,
- \item Initiation au débuggage dans \texttt{Code::Blocks},
- \item Précision des nombres à virgule flottante
-\end{itemize}
-
-\section{Environnement de programmation \texttt{Code::Blocks} sous Windows}
-
-Depuis Windows, lancer \texttt{Code::Blocks} depuis le menu Windows (dans les applications scientifiques).
-
-\subsection{Création d'un premier programme}
-
-En vous aidant du polycopié sur l'environnement de programmation \texttt{Code::Blocks},
-\begin{enumerate}
- \item créer un nouveau projet dans lequel vous créerez un fichier qui contiendra votre premier programme C,
- \item modifier le fichier de votre projet pour qu'il contienne le programme ci-dessous,
- \item compiler votre programme,
- \item exécuter votre programme.
-\end{enumerate}
-
-\begin{lstlisting}
-#include <stdio.h>
-
-/*
-Ceci sera mon premier programme
-*/
-int main()
-{
- printf("Je teste mon premier programme !\n");
- printf("Et en plus il est en C !\n");
-
- return 0;
-}
-\end{lstlisting}
-
-\newpage
-
-\subsection{Débuggage d'un programme}
-
-\begin{exercice}[Correction de la syntaxe d'un programme]
-
-Le programme ci-dessous contient des erreurs qui font qu'il ne compile pas~!
-
-\lstinputlisting{fichier_errone.c}
-
- \question{Analysez le programme et essayer de trouver toutes les erreurs qu'il contient~?}
- \question{Créez un nouveau projet\footnote{Attention~: dans \texttt{Code::Blocks} un projet ne peut contenir qu'une seule et unique fonction \lstinline!main!. Pour chaque nouveau programme, il faut donc créer un nouveau projet.} et recopier le programme en supprimant les erreurs (du mieux que vous pouvez ... mais il faut que ça compile) et compiler votre programme. Corriger toutes les erreurs restantes et les \textit{warnings}.}
- \question{Créez un nouveau projet à partir du programme contenu dans le fichier \texttt{?????.c} et corriger les erreurs et les \textit{warnings} en vous aidant du compilateur. L'objectif est que vous regardiez les messages d'erreur et que vous cherchiez à les comprendre.}
-\end{exercice}
-
-\begin{exercice}[Debbugage 1]
-
- Les programmes \texttt{exo\_bug\_boucle1.c} sont corrects pour le compilateur, mais rien ne dis qu'ils soient dénués de bugs. Exécutez les, patientez un peu, mais pas trop~!
-
- \question{Si besoin, identifier le problème en utilisant le débuggeur, sinon expliquer pourquoi le programme marche.}
- \question{Proposer une modification du programme pour corriger le bug.}
-
-\underline{Aide :} vous pourrez insérer un breakpoint à la ligne 6 et visualiser le contenu des variables. Comparez alors le résultat du programme avec le résultat attendu.
-\end{exercice}
-
-
-\begin{exercice}[Debbugage 2]
-%avec tableau
-
- Le programme \texttt{exo\_bug\_tab.c} est correct pour le compilateur. Chez moi, il produit une erreur bizarre (que j'espère se voir reproduire chez vous ...)
-
- \question{(\hard) Identifier le problème en utilisant le débuggeur .}
- \question{Proposer une modification du programme pour corriger le bug.}
-\end{exercice}
-
-\section{Exercices sur les types de données}
-
-\begin{exercice}[Précision des nombres à virgule flottante]
-
-\lstinputlisting{exo4.c}
-
-\question{Que fait ce programme ? Vous pourrez griboullé un tableau d'évolution de variable pour répondre à cette question.}
-
-Implémentez ce programme, compilez le et executez le.
-\question{Donnez le résultat de ce programme. Que peut-on en déduire ?}
-\question{Faites de même en changeant le type de la variable \lstinline!f! et concluez.}
-\begin{itemize}
- \item \lstinline!double f=1;!
- \item \lstinline!long double f=1;!
-\end{itemize}
-\question{Modifier la test de la boucle par \lstinline!(10000+f)==10000!. Que concluez vous de la nouvelle valeur de \lstinline!i! ?}
-\end{exercice}
-
-
-\begin{exercice}[Transtypage 1]
-
-Essayez de prévoir l'affichage du programme ci-dessous. Ensuite, exécuter le programme et expliquer ce qu'il affiche.
-\lstinputlisting{transtypage_3.c}
-\end{exercice}
-
-\begin{exercice}[Transtypage 2]
-
-\lstinputlisting{transtypage.c}
-
-L'instruction \lstinline!scanf! est une instruction pour attendre la saisie d'une valeur au clavier. Le programme est bloqué à ce point tant que l'utilisateur d'appuie pas sur la touche \texttt{Return}. Le premier paramètre est une chaîne de formatage : elle décrit le type de saisie qui est attendue (si l'utilisateur se trompe ... ben ça fait n'importe quoi), ici on attend un entier. Le second paramètre est un \textbf{pointeur} sur la variable dans laquelle sera mise la valeur saisie. Le \lstinline!&i! désigne le pointeur sur la variable \lstinline!i!.
-
-\question{Avant de compiler le programme, prévoyez les affichages pour les saisies de nombres suivantes : 46, 56, 78, -45, 10, 50000000000}
-\question{Compiler et tester le programme avec les valeurs précédentes (au moins)}
-\question{En vous inspirant de ce programme, créer un nouveau programme qui attend la saisie d'un caractère et affiche sa correspondance en nombre entier}
-
-\end{exercice}
-
-\end{document}
\ No newline at end of file
diff --git a/TP/TP1/TP1_Correction.tex~ b/TP/TP1/TP1_Correction.tex~
deleted file mode 100644
index d81ebf923822f2a955a8add09f67e7ae80de373d..0000000000000000000000000000000000000000
--- a/TP/TP1/TP1_Correction.tex~
+++ /dev/null
@@ -1,51 +0,0 @@
-\documentclass[a4paper,10pt]{article}
-
-\usepackage{../exos}
-
-\title{TP C : Introduction}
-\author{Guyet T.}
-\date{2010-2011}
-
-\begin{document}
-
-\begin{exercice}[Précision des nombres à virgule flottante]{3}
-
-\question{Que fait ce programme ? Vous pourrez griboullé un tableau d'évolution de variable pour répondre à cette question.}
-
-Le programme teste itérativement la variable \lstinline!f! qui s'approche de plus en plus de 0 (divisé par 10) à chaque tour de boucle.
-
-\question{Donnez le résultat de ce programme. Que peut-on en déduire ?}
-
-Avec un \lstinline!float!, le programme s'arrête avec \lstinline!i=46!. C'est à dire que lorsqu'on a divisé 46 fois 1 par 10, alors l'ordinateur n'arrive plus a distinguer cet infinitécimal avec 0 (bien qu'il soit formellement différent).
-
-\question{Faites de même en changeant le type de la variable \texttt{f} et concluez.}
-Avec un \lstinline!double!, le programme s'arrête pour \lstinline!i=324!, et pour un \lstinline!double!, le programme s'arrête pour \lstinline!i=4951!. On illustre ainsi la différence de précision entre les deux nombres.
-
-\question{Modifier la test de la boucle par \lstinline!(10000+f)==10000!. Que concluez vous de la nouvelle valeur de \lstinline!i! ?}
-En réalisant cette expérience avec \lstinline!f! défini comme un \lstinline!float!, alors la boucle s'arrête pour \lstinline!i=16!. Ceci implique qu'à proximité de 10000, on a moins de précision qu'à proximité de 0. La précision des doubles n'est donc pas uniforme.
-\end{exercice}
-
-
-\begin{exercice}[Transtypage]
-
-ATTENTION : il y avait une erreur dans le programme précédent (ligne 10), le programme correct est celui-ci :
-\lstinputlisting{transtypage.c}
-
-\question{Avant de compiler le programme, prévoyez les affichages pour les saisies de nombres suivantes : 46, 56, 78, -45, 10, 50000000000}
-
-\begin{itemize}
- \item 46, 56, 78 : rien de particulier. Dans un premier cas, on a le caractère ``.'', et dans le second, on a le caractère '8' à ne pas confondre avec la valeur numérique 8, et finalement 78 donne le caractère ``N''.
- \item -45 : n'est pas un caractère, le programme n'affiche rien ou n'importe quoi. Il est plus intéressant de regarder le nombre convertis en entier signé. Le bit de poid fort (qui valait 1 car le nombre était négatif) code maintenant $2^16$, on affiche donc un très grand nombre !
- \item 10 : est le caractère spécial de saut de ligne, on voit donc apparaître des sauts de lignes vides. De même, si on utilise la valeur 7 comme caractère, celle-ci fais sonner la cloche de l'ordinateur (caractère spécial BELL).
- \item 5000000000 : plus grand que les limites d'un entier bloque la valeur au maximum des enteirs (sur mon PC : 2147483647).
-\end{itemize}
-
-\setcounter{NoQ}{2}
-
-\question{En vous inspirant de ce programme, créer un nouveau programme qui attend la saisie d'un caractère et affiche sa correspondance en nombre entier}
-
-\lstinputlisting{transtypage_2.c}
-\end{exercice}
-
-
-\end{document}
\ No newline at end of file
diff --git a/TP/TP2/TP2.tex~ b/TP/TP2/TP2.tex~
deleted file mode 100644
index 5b22a897d3b4945e19d07a8e26ffb544de44df1d..0000000000000000000000000000000000000000
--- a/TP/TP2/TP2.tex~
+++ /dev/null
@@ -1,210 +0,0 @@
-\documentclass[a4paper,10pt]{article}
-\usepackage[french]{babel}
-\usepackage[utf8]{inputenc}
-\usepackage{../exos}
-\usepackage{amsfonts}
-
-\title{TP 2 : entrées/sorties}
-\author{Guyet T.}
-%\date{2010-2011}
-
-\begin{document}
-
-\maketitle
-
-\underline{Objectifs du TP :}
-\begin{itemize}
- \item Algorithmique générale
- \item Utilisation des fonctions \lstinline!printf! et \lstinline!scanf!
- \item Utilisation des fonctions \lstinline!fprintf! et \lstinline!fscanf! pour la lecture/écriture de fichiers
-\end{itemize}
-
-\espace
-
-
-\section{Interactions utilisateurs}
-
-
-\begin{exercice}[Guessing game]
-
-Cet exercice est un grand classique mais il est intéressant pour faire un peu d'algo et un peu d'I/O ...
-
-\question{Version classique}
-Le programme ``pense'' à un nombre entier : à vous de le trouver avec le moins possible de tentative alors que la machine ne répond que par ``plus grand'', ``plus petit'' ou ``gagné''.
-
-Implémenter le programme du \textit{Guessing game} avec les spécifications suivantes :
-\begin{itemize}
- \item Initialement, le programme tire un nombre au hasard entre 0 et 100.
- \item Une invite annonce à l'utilisateur qu'il doit donner un nombre entre 0 et 100.
- \item À chaque proposition de l'utilisateur, le programme répond par ``plus grand'', ``plus petit'' ou ``gagné''. Si l'utilisateur n'a pas gagné, l'invite est réaffichée.
- \item \textbf{Tant que} le joueur n'a pas gagné, il doit fournir des propositions.
- \item ``Gagné'' met fin au jeu.
-\end{itemize}
-
-{\it
-\underline{Aide :}
-\begin{itemize}
- \item le code suivant permet de tirer un nombre aléatoire entre 0 et 120 (nécessite d'importer les bibliothèques \texttt{<time.h>} et \texttt{<stdlib.h>} (\cf le fichier exemple \texttt{alea.c}).
-\end{itemize}
-\begin{lstlisting}
-srand( time(NULL) );
-int rnum=rand()%120;
-\end{lstlisting}
-}
-
-\question{Limiter le nombre d'essais}
-\begin{itemize}
- \item définissez une constante du programme (\lstinline!#define MAX_TRIES 8!) pour désigner le nombre maximum d'essai d'un utilisateur,
- \item modifier votre programme précédent pour faire en sorte d'affiché ``Perdu!! Le nombre correct etait XXX'',
- \item à chaque nouvel invite de jeu, il faudra rappeler à l'utilisateur combien d'essais il lui reste.
-\end{itemize}
-
-{\it
-\underline{Aide :} Lors de la fin du jeu, vous devrez savoir si c'est parce que l'utilisateur à trouvé le bon nombre (``gagne!'') ou si c'est parce qu'il n'a plus d'essais (``Perdu'').
-}
-
-\question{Quitter le jeu}
-\begin{itemize}
- \item Si le joueur en a marre, il peut répondre '\texttt{q}' pour quitter le jeu (\hard).
- \item On pourra essayer de faire une invite proposant les issues de sortie suivantes : revenir au jeu, sortir en connaissant le résultat, sortir sans connaître le résultat.
-\end{itemize}
-
-\question{Version ``chaud'', ``froid'' (\hard)}
-
-Cette fois, le principe est le même, mais la machine donne les réponses suivantes aux propositions, en fonction de la distance entre la proposition du joueur et le nombre recherché
-\begin{itemize}
- \item si la distance est très grande (mettons distance $>$50), alors la réponse est ``très froid'',
- \item si la distance est grande (mettons distance $>$20), alors la réponse est ``froid'',
- \item si la distance est proche (mettons $<$10), alors la réponse est ``chaud'',
- \item si la distance est très proche (mettons $<$5), alors la réponse est ``très chaud'',
- \item dans le cas de la distance intermédiaire, indiquer ``tiède'',
- \item si la distance est nul, alors c'est gagné !
-\end{itemize}
-
-\NB les valeurs pour les limites du ``chaud'' et du ``froid'' devront pouvoir se modifiées facilement !
-\end{exercice}
-
-
-\begin{exercice}[Le jeu du pendu (\hard)]
-
-L'exemple ci-dessous illustre le début du programme permettant de demander un mot à l'utilisateur
-\begin{lstlisting}
-#include <stdio.h> //Pour les fonctions printf et scanf
-#include <stdlib.h>
-
-int main()
-{
- char mot[20];
- printf("saisir un mot a deviner\n");
- scanf("%s", mot);
- getchar(); // ajouter cette fonction pour "manger" le retour chariot
- system("clear"); // ligne permettant d'effacer les saisies precedentes (masque le mot a deviner)
-
-
- printf("%s\n", mot); //affichage du mot pour test !
-
-
- return 0;
-}
-\end{lstlisting}
-
-\question{Que se passe-t-il si on saisit un mot de longueur supérieure à 19 ? pourquoi 19 ? Comment se fait-il que l'affichage soit correct pour un mot de taille inférieur à 19 ? En déduire ce que fait \lstinline!scanf! pour des chaînes de caractères.}
-
-\question{Vérification des caractères spéciaux} Avant de pouvoir jouer, il faut tester que le mot qui a été saisi est bien un mot ``valable''. Pour nous, un mot valable sera un mot qui ne contient aucun caractère spécial (par de signe de ponctuation ou des chiffres), mais également qui ne contient ni caractères accentuer ni caractères majuscules. Si l'un des caractères interdit apparaît dans le mot, alors il faut signifier à l'utilisateur le problème et arrêter le programme.
-
-\NB : Le cas des espaces est un peu particulier !
-
-Pour finir le programme, vous avez ici deux solutions :
-\begin{itemize}
- \item \lstinline!exit(45)! est une instruction qui donne immédiatement fin au programme avec la valeur 45,
- \item \lstinline!return(45)! est une instruction qui sort de la fonction \lstinline!main()!, ce qui donne également fin au programme avec la valeur 45.
-\end{itemize}
-
-\NB : un programme UNIX retourne toujours une valeur entière (d'où le type de retour de la fonction \lstinline!main()!). Par convention, lorsqu'un programme retourne 0, c'est que tout c'est bien passé, sinon il y a eu un problème.
-
-\underline{Aide :} Pour savoir si un caractère est valable, il faut qu'il se trouve dans la plage de valeur acceptable de la table ASCII. Consulter une table ASCII sur internet et utiliser un transtypage si nécessaire.
-
-\question{Implémentation de la ``boucle de jeu'' (\hard)}
-Le principe du jeu est le suivant :
-\begin{itemize}
- \item \textbf{Tant que} le joueur n'a pas trouvé le mot,
- \begin{itemize}
- \item On demande à l'utilisateur s'il veut faire une proposition ou bien découvrir une lettre
- \begin{itemize}
- \item Si il veut découvrir une lettre : 1) il saisit une lettre et 2) le programme affiche les positions de la lettre
- \item Si il veut faire une tentative : 1) il saisit sa proposition et 2) le programme affiche si le joueur a gagné ou non (dans le cas du gain, c'est la fin du jeu).
- \end{itemize}
-\end{itemize}
-\end{itemize}
-
-Commencez par implémenter la boucle de jeu permettant à l'utilisateur de jouer selon le principe ci-dessus. On laisse de côté pour le moment l'affichage des positions des lettres (insérer un commentaire à l'emplacement prévu pour cette partie du programme).
-
-\NB pour la comparaison de chaînes de caractères, vous aurez besoin de la fonction \lstinline!strcmp! disponible dans la librairie \texttt{<string.h>} (consulter la documentation en ligne ou le poly pour plus d'infos).
-
-Exemple de déroulement de programme dans le cas du mot caché ``toto'' :
-\begin{verbatim}
-Voulez vous proposez un mot (o/n) ou tester une nouvelle lettre ?
-n
-saisir une lettre
-t
-Voulez vous proposez un mot (o/n) ou tester une nouvelle lettre ?
-n
-saisir une lettre
-t
-Voulez vous proposez un mot (o/n) ou tester une nouvelle lettre ?
-o
-saisir un mot
-coucou
-!!! ce n'est pas le mot recherche !!!
-Voulez vous proposez un mot (o/n) ou tester une nouvelle lettre ?
-o
-saisir un mot
-toto
-!!! gagne !!!
-\end{verbatim}
-
-\question{Affichage des positions des lettres} Modifier votre programme précédent en insérant l'affichage des positions auxquelles se trouve une lettre. Par exemple, dans le cas du mot caché ``tartes'' pour lequel le joueur teste la lettre 't', on affiche :
-\begin{verbatim}
-1
-5
-\end{verbatim}
-
-\question{Ajouter en début de programme l'affichage de la longueur du mot. (\hard) } \textit{Faisable en 1 ligne à partir du travail de la question 2.}
-
-\question{Compter les points :} le joueur à 2 point lorsqu'il teste une lettre et 1 points quand il teste un mot. Le joueur cherche donc à avoir le plus petit nombre de point possible.
-
-\question{Affichage du mot ``découvert'' (\hard\hard)} Plutôt que d'afficher les positions trouvées pour une lettre, vous afficherez le mot en masquant les lettres non dérouvertes par des '*'. Par exemple, dans le cas du mot caché ``tartes'' pour lequel le joueur aura déjà testé les lettre 't' et 's', le programme affichera :
-\begin{verbatim}
-t***t*s
-\end{verbatim}
-
-\end{exercice}
-
-
-
-\section{Lecture/écriture de fichiers}
-
-La lecture ou l'écriture d'un fichier se déroule en trois phases~:
-\begin{enumerate}
- \item ouverture du fichier dans un mode adéquate (lecture/écriture, binaire/texte)
- \item lecture pas à pas du fichier (soit par caractère, soit par ligne, ...)
- \item fermeture du fichier
-\end{enumerate}
-
-Le code présenté dans l'exercice \ref{ex:banque} peut servir d'exemple pour les exercices suivants.
-
-\espace
-
-\begin{exercice}[Haut les mains]\label{ex:banque}
-
-Décrire ce que va faire le programme ci-dessous (le code source et le fichier lu peuvent être téléchargés). Le fichier \texttt{banque.txt} est un fichier qui contient les sommes contenus en banque par différentes personnes :
-
-\lstinputlisting{copie_fichierbanque.c}
-
-Vous trouverez une bonne documentation sur les fonctions disponibles dans les bibliothèques standard en suivant le lien suivant~:
-\href{http://www.cplusplus.com/reference/clibrary/}{http://www.cplusplus.com/reference/clibrary/}
-
-\NB Le nom de l'exercice est un piètre jeu de mots entre le mot clé \lstinline!main! et le hold'up se déroulant sous vos yeux ...
-\end{exercice}
-
-\end{document}
diff --git a/TP/TP2/correction_guessinggame/guessinggame.c~ b/TP/TP2/correction_guessinggame/guessinggame.c~
deleted file mode 100644
index 30079ca394b9424a171988e132eb39585100bfe3..0000000000000000000000000000000000000000
--- a/TP/TP2/correction_guessinggame/guessinggame.c~
+++ /dev/null
@@ -1,106 +0,0 @@
-/*
-* Jeu du guessing game
-* T. Guyet, AGROCAMPUS-OUEST, 2013
-*/
-#include <stdio.h> //Pour les fonctions printf et scanf
-#include <stdlib.h> //Pour rand
-#include <time.h>
-#include <string> // Pour strcpy
-
-#define MAX_TRIES 8
-
-
-int main()
-{
- int toguess=0;
- int val=-1, nb=0;
- int limits[]={5,10,20,50};
- char messages[5][100]; // 4 messages textuels
- strcpy(messages[0], "tres chaud");
- strcpy(messages[1], "chaud");
- strcpy(messages[2], "tiede");
- strcpy(messages[3], "froid");
- strcpy(messages[4], "très froid");
-
- //On prepare les distances aux carrees
- for(int i=0; i<4; i++ ) {
- limits[i]=limits[i]*limits[i];
- }
-
- //tirage aléatoire d'un nombre
- srand( time(NULL) );
- toguess = rand() % 100;
-
- while( nb<MAX_TRIES ) {
- printf("Saisir une valeur (plus que %d essais)\n", MAX_TRIES-nb);
- scanf("%d", &val);
- nb++;
- int r = val-toguess;
- if( !r ) { //peu se traduire par : if( r!=0 )
- printf("Vous avez gagné en %d coups!\n", nb);
- break;
- }
- int dist = r*r;
-
- //
- int pos=0;
- while( dist < limits[pos] && pos<4 ) {
- pos++;
- }
- printf("Vous êtes %s\n",messages[pos]);
- }
-
- //Question 2
- int i;
- for(i=0; i<100 && mot[i]!='\0'; i++) {
- if( (int)(mot[i])<97 || (int)(mot[i])>122 ) {
- printf("Le mot saisi n'est pas valide\n");
- exit(0);
- }
- }
- system("clear");
-
- // Question 5
- printf("Le mot est de longueur %d\n", i);
- //fin question 5
-
- //Boucle de jeu : question 3
- while(1) {
- printf("Voulez vous proposez un mot (o/n) ou tester une nouvelle lettre ? (points : %d)\n", cpt);
- scanf("%c", &saisie);
- getchar();
- if( saisie=='o' ) {
- //test d'un mot
- printf("saisir un mot\n");
- scanf("%s", mottente);
- getchar();
- if( !strcmp(mot, mottente) ) {
- printf("!!! gagne !!!!\n");
- printf("Nombre de points : %d\n", cpt);
- break;
- } else {
- cpt+=1;
- printf("!!! ce n'est pas le mot recherche !!!\n");
- }
- } else {
- //test d'une lettre
- printf("saisir une lettre\n");
- scanf("%c", &saisie);
- getchar();
-
- //Question 4 :
- //tester la lettre et afficher les positions correspondante :
- printf("positions de la lettre :\n");
- for(i=0; i<100 && mot[i]!='\0'; i++) {
- if( mot[i]==saisie ) {
- printf("%d\n", i);
- }
- }
- cpt+=2;
- }
- }
-
- return 0;
-}
-
-
diff --git a/TP/TP2/pendu.c~ b/TP/TP2/pendu.c~
deleted file mode 100644
index c013d5431a9c700668c97ab06ce73d2cc096038e..0000000000000000000000000000000000000000
--- a/TP/TP2/pendu.c~
+++ /dev/null
@@ -1,15 +0,0 @@
-/*
-* Jeu du pendu
-* T. Guyet, AGROCAMPUS-OUEST, 2013
-*/
-#include <stdio.h> //Pour les fonctions printf et scanf
-
-int main()
-{
- char mot[100];
-
-
- return 0;
-}
-
-
diff --git a/TP/TP4/TP4.tex~ b/TP/TP4/TP4.tex~
deleted file mode 100644
index f1aa84b1395a025508754c93ab5f4194deb18e9e..0000000000000000000000000000000000000000
--- a/TP/TP4/TP4.tex~
+++ /dev/null
@@ -1,69 +0,0 @@
-\documentclass[a4paper,12pt]{article}
-\usepackage[utf8]{inputenc}
-\usepackage{../exos}
-
-\title{TP C : Fonctions et tableaux}
-\author{Guyet T.}
-\date{} %version 2013
-
-\begin{document}
-\maketitle
-
-
-\espace
-Ce TP aborde les fonctions et les pointeurs. Dans un premier temps, je propose quelques exercices pour revenir sur le cours précédent sur les fonctions et les pointeurs. Dans un second temps, je reprends exactement les mêmes questions algorithmique sur les tableaux que le TP précédent en vous proposant d'y répondre par des fonctions.
-
-\section{Exercices de cours}
-
-\begin{exercice}[Un peu de pointeurs]
-
-Analyser le programme \texttt{exoPointeurs.c} ci-dessous pour prévoir l'affichage, \textbf{puis} exécuter le pour vérifier. Vous pourrez utiliser le mode debug pour exécuter pas à pas le programme.
-
-N'hésitez pas à faire une petit dessins pour visualiser les données en mémoire et les positions des pointeurs.
-
-\lstinputlisting{ressources/exoPointeurs.c}
-\end{exercice}
-
-\begin{exercice}[Fonction et pointeur]
-
-Analyser le programme \texttt{exoFonction1.c} ci-dessous pour prévoir l'affichage, \textbf{puis} exécuté le pour vérifier. Vous pourrez utiliser le mode debug pour exécuter pas à pas le programme.
-\lstinputlisting{ressources/exoFonction1.c}
-\end{exercice}
-
-\section{Manipulation de tableaux par des fonctions}
-
-\begin{exercice}[Exercices sur les tableaux à 1 dimension]
-
-L'archive \texttt{mainFT.c} donne une base pour le développement de nouvelles fonctions de traitement d'un tableau de données. Il implémente quelques fonctions et donne un programme principal qui illustre l'utilisation des fonctions.
-
-
-Dans cet exercice, votre travail est d'écrire de nouvelles fonctions et de les utiliser de le fichier du \lstinline!main()! pour vérifier leur bon fonctionnement.
-
-\question{Écrire des fonctions qui calcule la moyenne et le maximum des éléments d'un tableau.}
-\question{Écrire une fonction \lstinline!void cherche(int *tab, int length, int elem)! qui recherche un élément \lstinline!elem! et \textbf{affiche} toutes les positions de cet élément dans le tableau. Faire de même en affichant uniquement le premier élément (et en s'arrêtant).}
-\question{Écrire une fonction qui modifie le tableau en décalant tous les éléments~: le premier passe en second, le second passe en troisième, etc. Le dernier passe en premier.}
-\question{Écrire une fonction qui modifie le tableau en inversant l'ordre des éléments d'un premier tableau.}
-\question{Écrire une fonction \lstinline!int palindrome(int *tab, int length)! qui vérifie si un tableau est symétrique ou non. Si c'est le cas, la fonction retourne 1 et 0 sinon.}
-\end{exercice}
-
-\begin{exercice}[Exercices sur les tableaux à 2 dimensions \& compilation séparée]
-
-On appelle ici ``matrice'' un tableau à 2 dimensions\footnote{Voir le poly de cours pour l'utilisation des tableaux à deux dimensions en C.}. Il est possible de désigner un matrice de réels (\lstinline!double mat[23][45]!) par un pointeur du genre \lstinline!double **!. Néanmoins, l'expression avec double pointeur se trouve être plus générale que l'expression crochetée. Pour dépasser ce problème, l'archive \texttt{FM.zip} contient le code pour la manipulation simple de matrice en deux dimensions.
-
-Cette fois ci, l'archive \texttt{FM.zip} fournit 3 fichiers :
-\begin{itemize}
-\item \texttt{fonctionMatrice.h} : déclare les fonctions qui pourront être utilisées par d'autres partie du programme,
-\item \texttt{fonctionMatrice.cc} : implémente les fonctions déclarées dans le fichier \texttt{.h},
-\item \texttt{mainFM.c} : donne le programme principal qui illustre l'utilisation des fonctions
-\end{itemize}
-
-\question{Écrire une fonction qui initialise aléatoirement tous les éléments d'une matrice.}
-\question{Écrire une fonction qui calcule la somme de tous les éléments d'une matrice.}
-\question{Écrire une fonction qui calcule la somme des éléments diagonaux d'une matrice.}
-\question{(\hard)Écrire une fonction d'addition de deux matrices.}
-\question{(\hard\hard)Écrire une fonction \lstinline!void mult(double **tab, double **tab, int width, int height)! qui fait la multiplication de deux matrices.}
-Je rappelle que le résultat d'un produit de matrices $A$ et $B$ est une matrice $C$ dont les éléments sont calculés ainsi :
-$$ c_{i,j} = \sum_{k=1}^{n}{a_{i,k}.b_{k,j}}$$
-\end{exercice}
-
-\end{document}
diff --git a/TP/TP4/ressources/mainFT.c~ b/TP/TP4/ressources/mainFT.c~
deleted file mode 100644
index 8da346a70b68e5ed2843857407daba3f366004d7..0000000000000000000000000000000000000000
--- a/TP/TP4/ressources/mainFT.c~
+++ /dev/null
@@ -1,105 +0,0 @@
-/**
-* @file mainFT.c
-* @author T. Guyet, Agrocampus-Ouest
-* @date 03/2013
-*/
-
-#include <stdio.h>
-
-
-/**
-* @brief Fonction d'affichage de tableau avec les valeurs de 0 à length-1
-* @param tab : tableau à afficher
-* @param length : taille du tableau; prérequis: length doit être inférieur à la taille du tableau en mémoire
-*/
-void print(int *tab, int length)
-{
- int i=0;
-
- for(i=0; i<length; i++) {
- //Afficage sans retour à la ligne : les valeurs sont séparées par des virgules :
- printf("%d, ",tab[i]);
- }
- //Retour à la ligne final
- printf("\n");
-}
-
-/**
-* @brief Fonction qui somme les éléments du tableau de 1 à length
-* @param tab : tableau à traiter
-* @param length : taille du tableau; prérequis: length doit être inférieur à la taille du tableau en mémoire
-* @return : la somme des éléments
-*/
-int somme(int *tab, int length)
-{
- int i=0, somme=0;
-
- for(i=0; i<length; i++) {
- somme+=tab[i];
- //INVARIANT: à la j-ieme boucle somme contient la somme des j premières cases du tableau
- }
- //ICI somme contient la somme des 'length' premières cases du tableau
- return somme;
-}
-
-/**
-* @brief Fonction d'initialisation d'un tableau avec des valeurs aléatoires entre 0 et mac
-* @param tab : tableau à afficher
-* @param length : taille du tableau; prérequis: length doit être inférieur à la taille du tableau en mémoire
-* @param max : valeur maximal des nombres aléatoires générés
-*/
-void initalea(int *tab, int length, int max)
-{
- int i=0;
-
- //Initialisation du générateur aléatoire:
- srand ( time(NULL) );
-
- //On remplit effectivement le tableau
- for(i=0; i<length; i++) {
- tab[i] = rand() % max;
- //INVARIANT : tous les éléments de 0 à i du tableau sont initialisés avec des valeurs aléatoires entre 0 et max-1 (compris)
- }
-}
-
-/**
-* @brief Fonction d'initialisation d'un tableau
-* @param tab : tableau à afficher
-* @param length : taille du tableau; prérequis: length doit être inférieur à la taille du tableau en mémoire
-*
-* Les modifications du contenu du tableau tab sont conservées en dehors de la fonction
-*/
-void init(int *tab, int length)
-{
- int i=0;
- for(i=0; i<length; i++) {
- tab[i] = i;
- //INVARIANT : tout élément j du tableau de 0 à i est initialisé avec la valeur j
- }
-}
-
-
-
-/**
-* @brief Programme principal
-* Le programme initialise un tableau de taille TAB_SIZE avec des valeurs
-* aléatoires entre 1 et VAL_MAX, affiche celui-ci et affiche la somme de ses
-* éléments.
-*/
-int main()
-{
- int tab[40];
-
- //Initialisation du tableau
- initalea(tab, 40, 15);
-
- //Affichage du tableau
- print(tab, 40);
-
- //Calcul de la somme des éléments du tableau
- int ret=somme(tab, 40);
- printf("La somme des éléments est %d.\n", ret);
-
- return 0;
-}
-
diff --git a/TP/TP5/TP5.tex~ b/TP/TP5/TP5.tex~
deleted file mode 100644
index 53f3f5f06f39a3348852a30b107367a7c5551bcf..0000000000000000000000000000000000000000
--- a/TP/TP5/TP5.tex~
+++ /dev/null
@@ -1,198 +0,0 @@
-\documentclass[a4paper,12pt]{article}
-\usepackage[utf8]{inputenc}
-\usepackage[T1]{fontenc}
-
-\usepackage{../exos}
-
-\title{TP C : Calcul de $C_n^k$ et $\pi$}
-\author{Guyet T.}
-\date{}
-
-\begin{document}
-\maketitle
-
-
-\espace
-
-\section{Calculs des coefficients binomiaux $C_n^k$}
-
-Pour rappel, $C_n^k$ donne le nombre de sous-ensemble de taille $k$ dans un ensemble de taille $n$... mais peut importe, il s'agit ici de fournir une fonction efficace pour le calcul de ces valeurs.
-On vous propose pour cela trois exercices qui conduieront à trois solutions différentes plus ou moins efficace.
-
-\subsection{Expression avec factorielle}
-
-Comme vous devez en avoir déjà entendu parlé, on a la formule suivante :
-$$C_n^k = \frac{n!}{k!(n-k)!}.$$
-
-Bon ben ... on aura une fonction simple si on est capable de calculer la factorielle d'un nombre quelconque.
-
-
-\begin{exercice}[$C_n^k$ : formule avec factorielle itérative]
-
-L'expression d'une factorielle peut être écrite ainsi :
-$$n! = \prod_{k=1}^n k $$
-
-\question{Écrire une fonction \lstinline!long fact(int n)! qui calcule la factorielle, $n!$, de manière itérative.}
-
-\question{Écrire une fonction \lstinline!long combi(int n, int k)! qui calcule le coefficient binomiale $C_n^k$ à partir de l'expression avec des factorielles.}
-
-\underline{Attention :} vous ferez attention à l'ordre de vos opérations sur les entiers en prenant en compte que la division entière peut facilement biaiser un résultat. Par exemple, en informatique le résultat de $(100*10)/100$ ne sera pas le même que $100*(10/100)$ (seul le premier cas donnera le bon résultat).
-\end{exercice}
-
-\begin{exercice}[$C_n^k$ avec factorielle récursive]
-
-Nous avons également d'une factorielle peut être écrite par une expression récursive :
-$$n! = n * (n-1)!$$
-
-\question{Écrire une fonction \lstinline!long factr(int n)! qui calcule la factorielle, $n!$, de manière récursive.}
-
-\underline{Aide~:} si je voulais ré-écrire une fonction pour faire des exponentiations par un entier, je pourrais utiliser la formulation récursive suivante~:
- $$a^n = a * a^{n-1}$$
-
-Du coup, en C, j'écrirais la fonction suivante~:
-\begin{lstlisting}[numbers=none]
-double expo(double a, int n) {
- double val;
- if( n==0 ) {
- // Cas terminal
- val = 1;
- } else {
- val = a * expo(a, n-1);
- }
- return val;
-}
-\end{lstlisting}
-
-\question{Inclure dans votre fonction un affichage du calcul permettant de visualiser l'appel de fonction.}
-Par exemple~:
-\begin{lstlisting}[numbers=none]
- printf("appel factr( %d )\n", n);
-\end{lstlisting}
-
-
-\question{Modifier la fonction \lstinline!long combi(int n, int k)! pour calculer le coefficient binomiale $C_n^k$ avec cette nouvelle fonction.}
-\end{exercice}
-
-%\exercice{$C_n^k$ avec factorielles statiques}
-
-%On voit bien qu'on a
-
-
-\subsection{Expression récursive}
-
-\begin{exercice}[$C_n^k$ récursif]
-
-En s'inspirant de la formule récursive suivante pour calculer un coefficient binomiale, proposer une nouvelle fonction \lstinline!long combir(int n, int k)! qui calcule $C_n^k$ sans utiliser de fonction factorielle.
-
-$$C_n^k=C_n^{k-1}+C_{n-1}^{k-1}$$
-
-\section{Calculs de $\pi$ par des méthodes itératives}
-Ce TP aborde le problème du calcul de $\pi$ qui, comme tous les irrationnels, pose quelques problèmes ... En gros, comme il est irrationnel, il ne peut pas être calculés numériquement et exactement et encore moins représenté en mémoire. Il nous faut donc faire des approximations de sa valeur.
-
-Notez qu'il est usuel de définir manuellement $\pi$ par une constante de préprocessing (j'ai eu la main lourde sur le nombre de décimale ...) :
-\begin{lstlisting}[numbers=none]
- #define PI (double)3.1415926535897932384626433832795028841971693993751
-\end{lstlisting}
-
-\espace
-
-Pour ceux que $\pi$ passionne, vous pouvez trouver une bonne centaine de méthodes différentes pour calculer ce nombre sur ce site : \\ \href{http://mathworld.wolfram.com/PiFormulas.html}{http://mathworld.wolfram.com/PiFormulas.html}
-\end{exercice}
-
-
-\subsection{Calcul de $\pi$ avec la série de Gregory}
-
-La série de Gregory et Leibniz, définie ci-dessous, converge vers $\frac{\pi}{4}$, comme les termes de la suite sont de plus en plus petit (en valeur absolue), alors plus on calcule de terme de cette liste, plus on s'approche de la valeur réelle de $\pi$. Néanmoins, après le $n$-ème terme de la série, on peut montrer que l'erreur d'approximation du calcul est plus grande que $\frac{1}{2n}$, il faut ainsi calculer 300 termes de la suite pour obtenir une approximation avec 2 chiffres corrects. C'est donc une méthode à ``convergence lente'' ... voire très lente.
-
-$$ \frac{\pi}{4} = \sum_{k=1}^{\infty}\frac{(-1)^{k+1}}{2k-1}$$
-
-\begin{exercice}[Implementation du calcul de la série de Gregory]
-
-\question{Écrire une fonction avec le profil ci-dessous qui calcule les $n$ premiers termes de la série de Gregory.}
-
-\begin{lstlisting}[numbers=none]
- double gregory(int n);
-\end{lstlisting}
-
-
-\question{Écrire une fonction avec le profil ci-dessous qui calcule les termes de la séries tant que l'erreur d'approximation est plus grande que $10^{p}$ où $p$ est la précision recherchée, passée en paramètre de la fonction. La fonction retournera alors le nombre de termes qu'il a fallu calculé.}
-
-\begin{lstlisting}[numbers=none]
- int testgregory(int p);
-\end{lstlisting}
-
-Quelques remarques :
-\begin{itemize}
- \item On prendra comme référence la valeur de $\pi$ donnée par le \lstinline!#define PI! plus haut.
- \item Pour calculer la précision $10^{-p}$, vous utiliserez la fonction \lstinline!double pow(double, double)! de la librairie \lstinline!<math.h>!\footnote{Consulter ce site pour plus d'information sur la fonction \lstinline!pow! : \href{http://www.cplusplus.com/reference/clibrary/cmath/pow/}{http://www.cplusplus.com/reference/clibrary/cmath/pow/}}.
-\end{itemize}
-
-\end{exercice}
-
-\subsection{Approximation de $\pi$ par une méthode de type Monte-Carlo}
-
-Les approches Monte-Carlo désigne l'ensemble des méthodes qui utilise des tirages aléatoires pour approximer un nombre ou une fonction. Ces méthodes sont très utilisées pour appoximées le calcul de disctributions statistiques.
-
-\espace
-
-On propose d'appliquer une telle méthode pour calculer la valeur de $\pi$. Pour cela on va s'appuyer sur la formule bien connue de l'aire d'un cercle de rayon $R$ (pour rappel $\pi.R^{2}$). On en déduit que la probabilité $p$ qu'un point choisi au hasard dans le carré se trouve dans le disque est lié à sa surface par $p = \frac{\pi}{R^{2}}$. On va donc approximer cette probabilité $p$ pour obtenir la valeur de $\pi$.
-
-Le principe de la méthode est le suivant : on tire aléatoirement, et de manière équiprobable, un grand nombre de points dans le carré OIAJ de côté 1. Pour chaque tirage $(x,y)$, on regarde si le point appartient à l'intérieur du cercle de rayon 1 ou pas (pour cela, il suffit de regarder la quantité $x^2+y^2$).
-
-\begin{figure}[ht]
- \centering
- \includegraphics{./Ressources/pi}
-\end{figure}
-
-\espace
-
-\begin{exercice}[Approximation de $\pi$ par Monte-Carlo]
-
-De même que l'exercice précédent :
-
-\question{\'Ecrire une fonction qui calcule l'approximation de $\pi$ par la méthode de Monte-Carlo}
-\question{\'Ecrire une fonction qui calcule le nombre de tour de boucle nécessaire pour arriver une précision fixée avec la méthode de Monte-Carlo}
-\question{Comparer les deux algorithmes}
-
-\espace
-
-Remarques :
-\begin{itemize}
- \item Vous utiliserez la fonction suivante pour réaliser des tirages uniforme en double précision :
-\begin{lstlisting}[numbers=none]
-double unif() {
- return (double)((float)rand() / ((float)RAND_MAX + 1.0)) ;
-}
-\end{lstlisting}
- \item pensez à initialiser le générateur aléatoire avec \lstinline!srand(time(NULL))!
-\end{itemize}
-\end{exercice}
-
-
-\subsection{Aller plus loin avec ... une méthode à convergence rapide (\hard)}
-
-\begin{exercice}[Méthode de Borwein]
-
-La méthode suivante de Jonathan et Peter Borwein (1985) calcule les valeurs de suite $(a_k)$. La suite $(\frac{1}{a_k})$ converge quadratiquement vers $\pi$, donc ... très rapidement : en trois itérations, vous avez 15 chiffres corrects\footnote{Me demandez pas comment ca marche ... mais ca marche ! Plus d'infos \href{http://en.wikipedia.org/wiki/Borwein's\_algorithm}{http://en.wikipedia.org/wiki/Borwein's\_algorithm}} !! C'est apparamment la méthode la plus utilisées pour calculer $\pi$.
-
-\begin{eqnarray*}
- y_0 & = &\sqrt{2}-1 \\
- a_0 &=& 6 -4\sqrt{2} \\
- y_{k+1}&=&(1-f(y_k))/(1+f(y_k))\\
- a_{k+1} &= &a_k(1+y_{k+1})^4 - 2^{2k+3} y_{k+1}(1+y_{k+1}+y_{k+1}^2)
-\end{eqnarray*}
-
-avec $f(y)=(1-y^4)^{1/4}$
-
-\question{Implémenter la fonction \lstinline!double JPBorwein(int n)! de calcul de $\pi$ par cette méthode.}
-
-\underline{Aide :} pour réaliser ce calcul, il faut calculer successivement les valeurs de $y_{k}$ et $a_{k}$ à partir des valeurs qui viennent d'être calculées. Il est donc nécessaire de se souvenir des anciennes valeurs de $y_{k}$ et $a_{k}$ pour calculer les valeurs $y_{k+1}$ et $a_{k+1}$.
-
-\underline{Remarque :} il est aussi ``simple'' d'écrire des algorithmes de manière itérative que récursive. En terme de performance, l'algorithme récursif sera largement battu, et risque de provoquer une erreur de type \texttt{stack overflow} ... plus de détails sur questionnement direct de votre enseignant !
-
-\end{exercice}
-
-
-
-
-\end{document}
diff --git a/TP/TP_Fractales/TP_Fractales.tex~ b/TP/TP_Fractales/TP_Fractales.tex~
deleted file mode 100755
index 007aac3e26b5f78c6941db27d8e8ef8b30ed8ca2..0000000000000000000000000000000000000000
--- a/TP/TP_Fractales/TP_Fractales.tex~
+++ /dev/null
@@ -1,191 +0,0 @@
-\documentclass[a4paper,10pt]{article}
-\usepackage{amsmath}
-
-\usepackage{../exos}
-
-
-\title{TP C : Tracés de fractales}
-\author{Guyet T.}
-\date{}
-
-\begin{document}
-
-\maketitle
-
-% \underline{Objectifs du TP :}
-% \begin{itemize}
-% \item calculs de suites
-% \item représentation des images
-% \itme calcul de fractales
-% \end{itemize}
-
-%\section{Introduction}
-
-%Les fractales peut être représenté (à ma connaissance) par le lieu géométrique d'une fonction non-linéaire. Pour dessiner une fractale, il faut donc calculer ce lieu géométrique. Dans la suite on parlera de bassin d'attraction.
-
-% Dans cette section, on vous introduit les méthodes nécessaire à la réalisation de ce TP:
-% \begin{itemize}
-% \item une méthode de résolution d'équations non-linéaires : la méthode de Newton\footnote{Très simple, mais très mauvaise en fait ... ce n'est pas l'objet du TP.}
-% \item la définition du bassin d'attraction
-% \end{itemize}
-
-
-% Considérons le problème de la résolution d'un système d'équation non-linéaire~:
-% $$f(x)=0,\; x\in\mathbb{R}^{n}$$
-%
-% où la fonction $f:\mathbb{R}^n\rightarrow\mathbb{R}^n$ est supposée être au moins une fois différentiable. Si $x_0 \in \mathbb{R}^n$ est une approximation de la solution cherchée, on linéarise $f(x)$ autour de $x_0$.
-%
-% $$f(x)\approx f(x_0)+f'(x_0)(x-x_0)$$
-
-%La méthode de Newton consiste à utiliser itérativement cette forme pour s'approcher de plus en plus de la solution $x$ telle que $f(x)=0$
-
-
-%Avec de bonne propriétés sur la fonction $f$ ($f$ doit être 3 fois continuement différentiable), alors il est possible de montrer la convergence locale de la méthode de Newton. La convergence locale indique que si $X_0$ est \textit{suffisamment proche} d'une solution $A$ de l'équation différentielle, alors la méthode va convergée vers cette solution $A$.
-%On parle alors de bassin d'attraction de $A$.
-%En revanche, il n'existe pas de résultat\footnote{En tout cas, je n'en connais pas pour des cas suffisamment générique pour être intéressant !} sur la convergence globale, c'est-à-dire qui indiquerait que la méthode converge en tout point vers une solution.
-
-
-%Fort de ce résultat, le bassin d'attraction sera donc approximé par le calcul de l'ensemble des points $X_0$ qui convergent vers une solution $A$.
-
-La théorie récente des fractales (le terme ``fractal'' a été employé pour la 1ère fois en 1975 par Benoît Mandelbrot) a permis de faire le lien entre des modèles mathématiques déterministes et le comportement, apparemment ``chaotique'', de certains systèmes physiques.
-
-La fractale de Newton classique est associée au racine du polynôme complexe $z^3 - 1$. Les trois racines de ce polynôme sont : $a_1=1$,$ a_2=-1/2+\frac{\sqrt{3}}{2}i$ et $a_3=-1/2-\frac{\sqrt{3}}{2}i$.
-
-\begin{figure}[ht]
- \centering
- \includegraphics[width=.3\textwidth]{./bassins.jpg}
- % bassins.jpg: 1000x1000 pixel, 72dpi, 35.28x35.28 cm, bb=0 0 1000 1000
-\end{figure}
-
-%\espace
-
-\question{Écrire une fonction \lstinline!int is_root(double x, double y, double prox)! qui retourne 0 si un le point $(x,y)$ est à une distance supérieure à $prox$ d'une des racines du polynôme $z^3 - 1$ et qui retourne 1, 2 ou 3 dans le cas contraire (le chiffre sert alors à identifier la racine qui est proche de $(x,y)$).}
-
-Vous pourrez utiliser la librairie \texttt{math.h} pour avec la fonction $\sqrt{.}$.
-
-
-
-\section{Méthode de Newton pour la résolution de $z^3-1 = 0$}
-
-Ces racines peuvent également être obtenues de manière numérique en résolvant numériquement l'équation $f(z)=0$ avec~:
-$$f(z)=z^3-1, \; z \in \mathbb{C} \text{ ce qui s'écrit également }f(x,y)=\left\{ \begin{array}{l}
-x^3-3xy^2-1\\
-3x^2y-y^3
-\end{array} \right.,\; (x, y) \in \mathbb{R}^2$$
-
-Ceci peut se faire en utilisant une méthode de résolution numérique comme la méthode de Newton\footnote{Ce n'est pas l'objet de ce TP que de parler de cette méthode.}. Dans cette méthode, la solution est obtenue en calculant les termes de la suite suivante~:
-
-$$z_{k+1} = z_{k} - \frac{z_{k}^3-1}{3z_{k}^2} = \frac{1}{3}\left(2z_{k}+\frac{1}{z_{k}^2}\right).$$
-
-ou en projetant sur les deux axes~:
-
-$$
-\left\{ \begin{array}{l}
-x_{k+1}=\frac{1}{3}\left(2x_k+\frac{x_k^2-y_k^2}{(x_k^2+y_k^2)^2}\right)\\
-y_{k+1}=\frac{2}{3}\left(y_k-\frac{x_k.y_k}{(x_k^2+y_k^2)^2}\right)
-\end{array} \right.
-$$
-
-\espace
-
-\question{Écrire une fonction \lstinline!int converge(double x0, double y0, double prox)! qui calcule itérativement les termes de la suite jusqu'à avec un terme proche d'une racine (plus proche que $prox$). $(x_0, y_0)$ servira comme valeur initiale de la suite. La fonction retournera le numéro de la racine vers laquelle la méthode à convergé.}
-
-Notez qu'il n'est pas utile de se poser la question de la convergence~: vous supposerez que la suite converge effectivement vers l'une des racines.
-
-\espace
-
-Ce qui est ammusant de constater, c'est que en fonction de l'état initial $(x_0, y_0)$, le résultat de la résolution numérique par la méthode de Newton converge vers l'une des trois solutions.
-On appelle alors \textit{bassin d'attraction} de $a\in\{a_1, a_2, a_3\}$ l'ensemble des points $(x, y)$, servant de point de point de départ à la résolution par la méthode de Newton, qui font converger la suite vers $a$.
-
-
-\section{Calcul des bassins d'attraction}
-
-L'algorithme général de la méthode pour le calcul des bassins d'attraction est la suivante :
-
-\begin{lstlisting}[mathescape=true,numbers=none]
-for($x_0$ entre -1 et 1) {
- for($y_0$ entre -1 et 1) {
- //Trouver la solution vers laquelle converge l'equation
- int sol = convergence($x_0$, $y_0$, $prox$);
- //Sauvegarder la valeur dans une matrice :
- mat[$x_0$][$y_0$]=sol;
- }
-}
-\end{lstlisting}
-
-\question{Implémenter l'algorithme général qui fait appel à la fonction \lstinline!convergence!}
-
-Remarques:
-\begin{itemize}
- \item vous utiliserez une constante pour définir le nombre de valeurs pour $x_0$ et $y_0$,
- \item vous commencez avec des matrices de taille 100 * 100, puis vous pourrez passer à des matrices plus importante lorsque vous serez sûr du bon fonctionnement du programme,
- \item vous pourrez utiliser, par exemple, $0.001$ la valeur de $prox$.
-\end{itemize}
-
-\section{Écrire une matrice dans un fichier image}
-
-Maintenant qu'on dispose d'une jolie matrice, on voudrait la visualiser pour mieux comprendre ce qui se passe ! On va donc enregistrer la matrice dans une image au format PPM. Le format PPM est un format d'image très simple. une image PPM est un fichier texte à l'allure suivante~:
-\begin{verbatim}
-P3
-100 100 255
-0 0 234 123 234 340 0 0 56 ...
-\end{verbatim}
-
-Le \texttt{P3} indique le format des valeurs, ici il s'agit d'un encodage utilisant des couleurs RGB. À la ligne suivante, les trois valeurs indiquent la taille de l'image (100x100) et la profondeur des couleurs (255 valeurs). À la troisème ligne, on donne, pixel à pixel, la couleur de chacun des pixels de l'images (100x100x3 entiers entre 0 et 255).
-
-\espace
-
-La fonction ci-dessous permet d'enregistrer une matrice sous la forme d'une image :
-
-\begin{lstlisting}[numbers=none]
-#define SIZE 100
-void saveimage(int mat[SIZE][SIZE])
-{
- int i,j;
-
- //On construit l'entete du fichier d'image PPM
- FILE *output=fopen("bassins.ppm", "w");
- fprintf (output, "P3\n%d %d 255\n", SIZE, SIZE);
-
- //On enregistre les valeurs par triplets de valeurs
- for(i=0; i<SIZE; i++) {
- for(j=0; j<SIZE; j++) {
- int val=80*mat[i][j];
- fprintf(output,"%d %d %d ", val, val, val);
- }
- }
- fclose(output);
-}
-\end{lstlisting}
-
-
-\section{Ensemble de Julia}
-
-Soit $c \in \mathcal{C}$ et un système dont les états successifs sont modélisés par la suite complexe~:
- $$z_{n+1} =z_{n}^2 + c = F_c (z_n),\; z_0 \in \mathbb{C}.$$
-
-On définit les ensembles suivants d'après le comportement de la suite $z_{n+1} =z_n^2 + c$ suivant les valeurs de $z_0$ :
- $$A_c = \{z_0 \in \mathbb{C};\, \|z_n\|\rightarrow \infty \text{ quand } n\rightarrow \infty \} \text{ et } K_c = \{z_0 \in \mathbb{C} | \exists r \in \mathcal{R},\text{ tq } n \in \mathcal{N}, \|z_n\| < r \}$$
-
-L'ensemble de Julia proprement dit (d'après le mathématicien français Gaston Julia qui étudia ces suites dès 1918 ) est l'ensemble $J_c$ frontière de $K_c$ (et de $A_c$ ).
-%
-% L'ensemble $K_c$, est connexe si $0 \in K_c$; sinon il est constitué d'une ``poussière de Cantor''.
- À part $J_0$ et $J_{-2} =[-2,+2]$, les ensembles $J_c$ sont fractals.
-
-Pour tracer $J_c$, on utilise la méthode des ``orbites inverses'' : soit $z'_0$, quelconque, il y a $2N$ suites $\{z'_n\}_{n \in \mathbb{N}}$ définies par $z'_{n+1} = \pm\sqrt{z'_{n}-c}$. Les points $z'_n$ appartiennent tous à l'orbite inverse de $z'_0$, et presque sûrement se répartissent sur $J_c$ , sauf les premiers points.
-
-\question{Programmer un algorithme de dessin de $J_c$ en traçant $m$ points successifs d'une orbite inverse $\{z'_0, z'_1,..., z'_m\}$ où le signe de chacun des $z'_n$ successifs est choisi ``au hasard''.}
-
-\begin{itemize}
- \item utilisez la fonction \lstinline!rand! définie dans \texttt{stdlib} pour faire des tirages aléaloires
- \item quelques valeurs numériques utiles
-\begin{itemize}
-\item $J_c \subset [-2, 2]\times [-2, 2]$
-\item Quelques valeurs intéressantes $c = -1$, $c=i$ , $c= 0.05+0.95i$, $c=0.12 + 0.68i$.
-\item Un bon point de départ $z'_0$ est une des solutions de $z^2-z+c=0$.
-\end{itemize}
-\end{itemize}
-
-\question{Faire le tracé graphique de cet ensemble en utilisant une image PPM}
-
-\end{document}
diff --git a/TP/TP_LectureFichier/TP_LectureFichier.tex~ b/TP/TP_LectureFichier/TP_LectureFichier.tex~
deleted file mode 100644
index c23f91bd72f8030097f42d40563aebf8ded81f24..0000000000000000000000000000000000000000
--- a/TP/TP_LectureFichier/TP_LectureFichier.tex~
+++ /dev/null
@@ -1,56 +0,0 @@
-\documentclass[a4paper,10pt]{article}
-
-\usepackage{../exos}
-
-\title{TP C : Lecture de fichiers}
-\author{Guyet T.}
-\date{2010-2011}
-
-\begin{document}
-
-\maketitle
-
-\underline{Objectifs du TP :}
-\begin{itemize}
- \item Découvrir l'environnement Linux,
- \item Découvrir l'environnement de programmation \texttt{Code::Block},
- \item Savoir compiler un programme C simple (dans les deux environnements),
- \item Précision des nombres à virgule flottante
-\end{itemize}
-
-
-\section{Lecture/Écriture de fichier}
-
-\subsection{Les fonctions utiles à la lecture de fichier}
-
-
-\lstinline!getc()! lit le caractère courant sur le flux d'entrée spécifié en paramètre et retourne sa valeur en tant qu'entier (\lstinline!int!) car en cas d'échec (c'est-à-dire lorsqu'aucun caractère n'a pu être lu), elle doit retourner une valeur qui ne peut être celle d'un ``caractère'' valide et cette valeur est représentée par la macro \lstinline!EOF!.
-
-
-\subsection{Écriture de fichier}
-
-\subsubsection{Principe}
-Le C connait deux familles de fichiers~: les fichiers binaires et les fichiers textes.
-
-La différence entre ces deux types de fichiers réside dans l'interprétation que les fonctions de gestions de fichiers vont faire des données présentes dans le fichiers. En mode binaire, aucune interprétation des données n'est effectuée par le programme. En mode texte, certaines séquences de caractères sont interprétés comme étant une fin de ligne ou une fin de fichier etc.
-
-L'utilisation du spécificateur '\texttt{b}' dans le mode d'ouverture permet d'indiquer qu'il s'agit d'un fichier binaire et de le traiter comme tel. Si rien n'est précisé, le fichier est ouvert en mode texte.
-
-\subsection{Lecture de fichier}
-
-\subsubsection{Principe}
-stdin
-
-lecture en texte ou en binaire
-
-
-\subsubsection{Un exemple propre}
-
-Contrairement à une pratique trop souvent rencontrée, la fonction \lstinline!feof()! ne sert pas à détecter la fin d'un fichier mais, lorsqu'une lecture a échoué, à savoir si cet échec est du à la rencontre de la fin de fichier.
-
-La bonne pratique pour lire intégralement un fichier consiste donc à parcourir le fichier tant qu'aucune erreur de lecture n'est remontée et d'utiliser \lstinline!ferror()! et \lstinline!feof()! pour déterminer, suite à une erreur, la cause de cette erreur.
-
-Le programme suivant compte les octets contenus dans un fichier pour déterminer sa taille.
-\lstinputlisting{lecture_getc.c}
-
-\end{document}
diff --git a/TP/TP_Matrice/TP_Matrice.tex~ b/TP/TP_Matrice/TP_Matrice.tex~
deleted file mode 100644
index 733e777284612ea22ce3e7fad09f7c2a0b1246eb..0000000000000000000000000000000000000000
--- a/TP/TP_Matrice/TP_Matrice.tex~
+++ /dev/null
@@ -1,152 +0,0 @@
-\documentclass[a4paper,11pt]{article}
-\usepackage[utf8]{inputenc}
-\usepackage[T1]{fontenc}
-\usepackage{../exos}
-\usepackage{amsfonts}
-
-
-\setlength{\textwidth}{18 cm} %Largeur du texte
-\setlength{\textheight}{25 cm}%Hauteur de texte
-\setlength{\topmargin}{-1 cm}
-\setlength{\oddsidemargin}{-1 cm} %Marge a gauche <0 pour réduire
-\setlength{\headheight}{15pt}
-
-
-
-\title{TP : sujets en vrac ...}
-\author{Guyet T.}
-%\date{2010-2011}
-
-\begin{document}
-
-\maketitle
-
-\underline{Objectifs du TP :}
-\begin{itemize}
- \item Matrices à deux dimensions,
- \item Allocation mémoire,
- \item Utilisation de fichiers.
-\end{itemize}
-
-\espace
-
-\begin{exercice}[Matrices (\hard)]
-Les deux fonctions ci-dessous permettent de créer une matrice d'entiers. Représentez en mémoire le fonctionnement de ces fonctions. Expliquez les différences.
-
-\begin{lstlisting}[numbers=none]
-int** create_matrix_A(int size_x, int size_y)
-{
- int** matrix;
- int i, j;
- matrix = malloc( size_x*sizeof(int*) );
- for(i=0; i<size_x; i++) {
- matrix[i] = malloc( size_y*sizeof(int) );
- if (matrix==NULL) printf("Probleme d'allocation memoire");
- }
- for(i=0; i<size_x; i++) {
- for(j=0; j<size_y; j++) {
- matrix[i][j] = 0;
- }
- }
- return matrix;
-}
-\end{lstlisting}
-
-\begin{lstlisting}[numbers=none]
-int** create_matrix_B(int vsize, int hsize)
-{
- int i;
- int **matrix;
- int *imptr;
-
- matrix=(int**)malloc( sizeof(int*)*vsize );
- if (matrix==NULL) printf("Probleme d'allocation memoire");
-
- imptr=(int*)malloc( sizeof(int)*hsize*vsize );
- if (imptr==NULL) printf("Probleme d'allocation memoire");
-
- for(i=0;i<vsize;i++,imptr+=hsize)
- matrix[i]=imptr;
-
- return matrix;
-}
-\end{lstlisting}
-\end{exercice}
-
-\begin{exercice}[Traitement d'images]
-L'objectif applicatif de cet exercice est de réaliser un petit traitement sur une image, c'est-à-dire une matrice de pixels. Pour les images noir et blanc, il s'agit d'une matrice d'entiers entre 0 (noir) et 255 (blanc).
-
-Pour cela, on vous fournit un projet \texttt{Code::Block} qui contient trois fichiers :
-\begin{itemize}
- \item le fichier \texttt{image.h}~: contient uniquement les entêtes de fonctions à utiliser,
- \item le fichier \texttt{image.c}~: contient les implémentations des fonctions déclarées dans le fichier \texttt{.h}.
- \item le fichier \texttt{main.c}~: utilise les fonctions des fichiers précédent pour charger et sauvegarder une copie de l'image.
-\end{itemize}
-
-Écrire une fonction avec le profil ci-dessous qui inverse les niveaux de l'image : le noir devient blanc et réciproquement (commencez par exprimer ``mathématiquement'' la relation entre la valeur d'un pixel avant et après la transformation.
-
-\begin{lstlisting}[numbers=none]
- void invert(int **image, int width, int height)
-\end{lstlisting}
-\end{exercice}
-
-
-\begin{exercice}[Guessing game]
-Cet exercice est un grand classique mais il est intéressant pour faire un peu d'algo et un peu d'I/O ...
-
-\question{Version classique}
-Le programme ``pense'' à un nombre entier : à vous de le trouver avec le moins possible de tentative alors que la machine ne répond que par ``plus grand'', ``plus petit'' ou ``gagné''.
-
-Implémenter le programme du \textit{Guessing game} avec les spécifications suivantes :
-\begin{itemize}
- \item Initialement, le programme tire un nombre au hasard entre 0 et 100.
- \item Une invite annonce à l'utilisateur qu'il doit donner un nombre entre 0 et 100.
- \item À chaque proposition de l'utilisateur, le programme répond par ``plus grand'', ``plus petit'' ou ``gagné''. Si l'utilisateur n'a pas gagné, l'invite est réaffichée.
- \item \textbf{Tant que} le joueur n'a pas gagné, il doit fournir des propositions.
- \item ``Gagné'' met fin au jeu.
-\end{itemize}
-
-{\it
-\underline{Aide :}
-\begin{itemize}
- \item le code suivant permet de tirer un nombre aléatoire entre 0 et 120 (nécessite d'importer les bibliothèques \texttt{<time.h>} et \texttt{<stdlib.h>} (\cf le fichier exemple \texttt{alea.c}).
-\end{itemize}
-\begin{lstlisting}
-srand( time(NULL) );
-int rnum=rand()%120;
-\end{lstlisting}
-}
-
-\question{Limiter le nombre d'essais}
-\begin{itemize}
- \item définissez une constante du programme (\lstinline!#define MAX_TRIES 8!) pour désigner le nombre maximum d'essai d'un utilisateur,
- \item modifier votre programme précédent pour faire en sorte d'affiché ``Perdu!! Le nombre correct etait XXX'',
- \item à chaque nouvel invite de jeu, il faudra rappeler à l'utilisateur combien d'essais il lui reste.
-\end{itemize}
-
-{\it
-\underline{Aide :} Lors de la fin du jeu, vous devrez savoir si c'est parce que l'utilisateur à trouvé le bon nombre (``gagne!'') ou si c'est parce qu'il n'a plus d'essais (``Perdu'').
-}
-
-\question{Quitter le jeu}
-\begin{itemize}
- \item Si le joueur en a marre, il peut répondre 'q' pour quitter le jeu (\hard).
- \item On pourra essayer de faire une invite proposant les issues de sortie suivantes : revenir au jeu, sortir en connaissant le résultat, sortir sans connaître le résultat.
-\end{itemize}
-
-\question{Version ``chaud'', ``froid''}
-
-Cette fois, le principe est le même, mais la machine donne les réponses suivantes aux propositions, en fonction de la distance entre la proposition du joueur et le nombre recherché
-\begin{itemize}
- \item si la distance est très grande (mettons distance $>$50), alors la réponse est ``très froid'',
- \item si la distance est grande (mettons distance $>$20), alors la réponse est ``froid'',
- \item si la distance est proche (mettons $<$10), alors la réponse est ``chaud'',
- \item si la distance est très proche (mettons $<$5), alors la réponse est ``très chaud'',
- \item dans le cas de la distance intermédiaire, indiquer ``tiède'',
- \item si la distance est nul, alors c'est gagné !
-\end{itemize}
-
-\NB les valeurs pour les limites du ``chaud'' et du ``froid'' devront pouvoir se modifiées facilement !
-\end{exercice}
-
-\end{document}
diff --git a/TP/TP_Tableaux/LectureQuestionnaireCSV.tex~ b/TP/TP_Tableaux/LectureQuestionnaireCSV.tex~
deleted file mode 100644
index 67cfffd99506eda8389cf197c808f360318e625f..0000000000000000000000000000000000000000
--- a/TP/TP_Tableaux/LectureQuestionnaireCSV.tex~
+++ /dev/null
@@ -1,55 +0,0 @@
-\documentclass[a4paper,12pt]{article}
-
-\usepackage{../exos}
-
-\title{TP C : Chargement d'un questionnaire}
-\author{Guyet T.}
-\date{}
-
-\begin{document}
-\maketitle
-
-Les sources de votre programme (c'est-à-dire le fichier \texttt{.c}) pour le premier est à renvoyer par mail à \href{mailto:thomas.guyet@agrocampus-ouest.fr}{thomas.guyet@agrocampus-ouest.fr}.
-
-
-\section{Exercices}
-
-\begin{exercice}[Chargement d'un fichier]
-
-Le fichier initial est le fichier \texttt{Pref\_jus\_orange.xls}. Il a été transformé en fichier texte \texttt{Pref\_jus\_orange.csv} pour être facilement manipulable par un programme C. Le fichier texte vous est fournis pour la suite et vous trouverez, en fin de TP, la manipulation pour l'obtenir à partir d'un fichier XLS.
-
-Ce fichier contient des réponses à un questionnaire sur des jus d'oranges. Vous vous refererez au fichier XLS pour connaître les significations des colonnes.
-
-\question{Définir une nouvelle structure de données \lstinline!Reponse! pour contenir une ligne du fichier.}
-
-\question{Construire un programme pour remplir un tableau de réponse (\lstinline!Reponse reponses[100];!) à partir du fichier \texttt{Pref\_jus\_orange.csv}.}
-\end{exercice}
-
-
-\begin{exercice}[Chargement complet (subsidiaire) (\hard)]
-
-En suivant la méthode décrite en section \ref{sec:XLStoCSV}, exportez de nouveau le fichier XLS en conservant la première ligne contenant les noms de colonnes.
-
-\espace
-
-Construire un programme pour charger ce nouveau fichier sans tenir compte de la première colonne
-\end{exercice}
-
-
-
-\section{Transformer un fichier XLS en fichier CSV}\label{sec:XLStoCSV}
-
-Les fichiers CSV (Comma separate values) sont des représentations textuelles d'une feuille de calcul excel. Tous les tableurs (Excel, OpenOffice, ...) permettent d'ouvrir et d'exporter les feuilles de calculs dans ce format.
-
-Pour transformer un fichier XLS en fichier CSV, j'ai procédé de la sorte~:
-\begin{enumerate}
- \item ouvrir le fichier \texttt{Pref\_jus\_orange.xls} avec OpenOffice (je sais me servir d'OpenOffice, mais pas trop de Excel !)
- \item ``enregistrer sous'' le fichier avec le type de fichier \texttt{csv}, et cocher la case en bas ``Éditer les paramètres du filtre''.
- \item Cliquer sur enregistrer et confirmer le format
- \item Une fenêtre ``Export'' doit s'afficher. Choisir \texttt{\{espace\}} comme séparateur de colonne et rien comme séparateur de texte.
- \item valider avec ``entrée'' puis quitter OpenOffice
- \item ouvrir le fichier \texttt{Pref\_jus\_orange.csv} avec un éditeur de texte (utiliser un clique-droit$>$ouvrir avec$>$Notepad++)
- \item supprimer la première ligne !
-\end{enumerate}
-
-\end{document}
diff --git a/TP/TP_Tableaux/TP3.tex~ b/TP/TP_Tableaux/TP3.tex~
deleted file mode 100755
index ac38a77295fdeb337f415f30c4d73e11c7260a5d..0000000000000000000000000000000000000000
--- a/TP/TP_Tableaux/TP3.tex~
+++ /dev/null
@@ -1,154 +0,0 @@
-\documentclass[a4paper,12pt]{article}
-\usepackage[utf8]{inputenc}
-\usepackage[T1]{fontenc}
-
-\usepackage{../exos}
-
-\title{TP C : Tableaux et fonctions}
-\author{Guyet T.}
-\date{}
-
-\begin{document}
-\maketitle
-
-\underline{Objectifs du TP :}
-\begin{itemize}
- \item Algorithmique sur les tableaux (suite)
- \item Allocation mémoire,
- \item Tableaux à 2 dimensions.
-\end{itemize}
-
-\espace
-
-Pour ce TP comme les suivants, les étoiles annoncent des questions (\hard) moins faciles, (\hard\hard) difficiles (nécessitant une bonne compréhension du cours) ou (\hard\hard\hard) hors-programme (nécessitant plus que le cours)!
-
-
-\section{Algorithmique sur les tableaux}
-
-\subsection{Version avec allocation de mémoire}
-
-\begin{exercice}[Compréhension de l'algorithme]
-
-Commençons par l'exemple ci-dessous qui fait appel à une allocation de mémoire.
-
-\lstinputlisting{ressources/test_malloc.c}
-
-\question{Rappeller ce que fait la fonction \lstinline!malloc! de la ligne 10.}
-
-\question{Expliquer ce que fait le programme. Que valent \lstinline!T! et \lstinline!TT! après l'appel de fonction de la ligne 27 (vous pourrez faire un dessin de la mémoire).}
-
-\question{Que fait la ligne 36, quel est son intérêt ici ? (\hard)}
-
-\question{Essayez de comprendre pourquoi la ligne 28 n'est pas correcte pour le compilateur (\hard\hard\hard).}
-
-\end{exercice}
-
-
-
-\begin{exercice}[Exercice sur les tableaux (\hard)]\label{ex:tableaux}
-
-Dans cet exercice, on vous demande de créer des fonctions s'inspirant de l'exercice précédent, c'est à dire que vous devrez créer un nouveau tableau dans la fonction. %que les opérations se fassent \textit{en place}, c'est-à-dire que vous ne pouvez pas déclarer un autre tableau pour servir d'intermédiaire (il faut faire comme si vous ne connaissiez pas la taille du tableau initial).
-
-\question{Écrivez un programme qui effectue un décalage de 1 case de tous les éléments d'un tableau. La case à gauche est affectée à 0.}
-
-{\it \underline{Exemple:} 1 2 7 4 5 $\rightarrow$ 0 1 2 7 4}
-
- \question{Écrivez un programme qui inverse les éléments d'un tableau. Cette inversion s'effectue sur le tableau lui-même}.
-
-{\it \underline{Exemple:} 4 5 6 7 $\rightarrow$ 7 6 5 4}
-
-
-%\question{Écrivez un programme qui élimine les valeurs en double (ou plus) d'un tableau de chiffres (c'est-à-dire des entiers entre 0 et 9) en remplaçant ces valeurs en double par leur valeur négative. La première apparition de la valeur reste inchangée.}
-
-%{\it \underline{Exemple:} 1 2 3 1 1 2 4 5 5 3 $\rightarrow$ 1 2 3 -1 -1 -2 4 5 -5 -3}
-
-
- \question{En réutilisant la fonction de la question a), écrire une fonction \lstinline!int *decaln(int *tab, int length, int nbdecal)! qui décale \lstinline!nbdecal! fois le tableau \lstinline!tab!.}
- %Question qui pose la question de la libération de la mémoire !
-
-\end{exercice}
-
-
-\begin{exercice}[Calcul d'un histogramme (\hard\hard)]
- On suppose qu'on dispose d'un tableau \lstinline!tab! dans lequel on dispose d'un grand nombre de valeurs entières positives. Par exemple \lstinline!tab=[2,5,2,2,6]!. On cherche à calculer l'histogramme de ce tableau, c'est à dire un tableau qui contient le nombre d'occurrence de chacun des éléments du tableau. Dans l'exemple on aurait pour résultat : \lstinline![0,0,3,0,1,1]! : le tableau contient sucessivement le nombre de valeur de 0, puis de 1, etc ... La taille du tableau dépend donc de la valeur maximale du tableau.
-
- \question{ Écrire une fonction \lstinline! int *histo(int *tab, int length, int *valmax)! qui construit et retourne l'histogramme du tableau \lstinline!tab! de longueur \lstinline!length!. Le paramètre \lstinline!valmax! servira à retourner la valeur maximale du tableau \lstinline!tab!.}
- \question{ Tester votre fonction dans un programme principal en affichant l'histogramme obtenu}
-
- \underline{NB :} les deux question doivent être traitées en même temps !!
-\end{exercice}
-
-
-\subsection{Version ``en place''}
-
-Un algorithme ``en place'' est un algorithme dont on sait initialement la taille mémoire qui sera utile à le faire fonctionner ou, autrement dit, l'espace mémoire nécessaire est indépendant des données d'entrée (en particulier de la taille d'un tableau). Il s'agit des mêmes tâches que ceux de l'exercice \ref{ex:tableaux} mais dans lesquels vous n'avez pas besoin d'utiliser l'allocation de mémoire (en contrepartie, c'est algorithmiquement plus difficile). Les algorithmes du type de la section précédente sont typiquement des algorithmes qui ne sont pas en place puisque des tableaux sont créés avec une taille dépendant du tableau d'entré.
-
-\begin{exercice}[Opérations \textit{en place} sur les indices des tableaux (\hard)]
-
-Dans cet exercice, on demande que les opérations se fassent \textit{en place}, c'est-à-dire que vous ne pouvez pas déclarer ni allouer un autre tableau pour servir d'intermédiaire (il faut faire comme si vous ne connaissiez pas la taille du tableau initial).
-
-\question{Écrivez un programme qui effectue un décalage de 1 case de tous les éléments d'un tableau. La case à gauche est affectée à 0.}
-
-{\it \underline{Exemple:} 1 2 3 4 5 $\rightarrow$ 0 1 2 3 4}
-
- \question{Écrivez un programme qui inverse les éléments d'un tableau. Cette inversion s'effectue sur le tableau lui-même}.
-
-{\it \underline{Exemple:} 4 5 6 7 $\rightarrow$ 7 6 5 4}
-
-
-%\question{Écrivez un programme qui élimine les valeurs en double (ou plus) d'un tableau de chiffres (c'est-à-dire des entiers entre 0 et 9) en remplaçant ces valeurs en double par leur valeur négative. La première apparition de la valeur reste inchangée.}
-
-%{\it \underline{Exemple:} 1 2 3 1 1 2 4 5 5 3 $\rightarrow$ 1 2 3 -1 -1 -2 4 5 -5 -3}
-\end{exercice}
-
-
-\section{Tableaux à deux dimensions}
-
-\begin{exercice}[Allocation d'un tableau à deux dimensions(\hard\hard)]
-Analyser les deux codes ci-dessous. Comparer le résultat réel par rapport à la définition d'un tableau à 2 dimensions du langage C (section 1.3.3 du polycopié), indiquer lequel des deux correspond bien à un tableau à deux dimensions et lequel n'est pas un ``vrai'' tableau à deux dimensions.
-
-\begin{lstlisting}
-float **alloc1(int nrow, int ncol) {
- float **mat = (float **)malloc( sizeof(float*)*rnow);
- if (mat==NULL) {
- fprintf(stderr, "Erreur d'allocation de memoire");
- return NULL;
- }
- int i;
- for(i=0; i<rnow;i++) {
- mat[i]=(float *)malloc( sizeof(float)*ncol );
- }
- return mat;
-}
-\end{lstlisting}
-
-\begin{lstlisting}
-float **alloc2(int nrow, int ncol) {
- float **s;
- s=(int**)malloc( sizeof(float*)*nrow );
- if (s==NULL) {
- fprintf(stderr, "Erreur d'allocation de memoire");
- return NULL;
- }
- float *imptr=(float*)malloc( sizeof(float)*nrow*ncol );
- if (imptr==NULL) {
- fprintf(stderr, "Erreur d'allocation de memoire");
- return NULL;
- }
-
- for(i=0;i<nrow;i++,imptr+=ncol) {
- s[i]=imptr;
- }
- return s;
-}
-\end{lstlisting}
-
-\underline{NB :} notez que la confusion des deux codes peut conduire à des erreurs bizarres que le compilateur ne débusquera pas, mais dans la plupart des utilisations (utilisation des notations double-crocheté), cela se passe bien.
-
-\end{exercice}
-
-\vspace{1cm}
-
-\textit{Continuez avec les exercices sur les tableaux à deux dimensions de la feuille d'exercice précédente.}
-
-\end{document}
diff --git a/TP/TP_Tableaux/ressources/test_malloc.c~ b/TP/TP_Tableaux/ressources/test_malloc.c~
deleted file mode 100644
index ca060293849d251497a98d93f3366a3089ebe2ad..0000000000000000000000000000000000000000
--- a/TP/TP_Tableaux/ressources/test_malloc.c~
+++ /dev/null
@@ -1,39 +0,0 @@
-#include <stdlib.h>
-#include <stdio.h>
-
-/**
-* @brief TODO
-*/
-int* cp( int* tab, int length) {
- int i;
- int *p=tab, *pret;
- int *tret = (int *) malloc( sizeof(int)*length );
-
- pret=tret;
- for( i=0; i<length; i++, p++, pret++) {
- *pret=*p;
- *p=i;
- }
-
- return tret;
-}
-
-int main() {
- int i;
- int T[]={6,5,4,3,2,1};
- int len=6;
-
- int *TT=NULL;
- TT=cp(T, len);
- T=cp(T, len);
-
- //utilisation de TT
- for( i=0; i<len; i++) {
- printf("%d, ", TT[i]);
- }
- printf("\n");
-
- free( TT );
-
- return 0;
-}
diff --git a/TP/exos.sty~ b/TP/exos.sty~
deleted file mode 100755
index 5abec9d98aae29e567f5f2127be9e5fd81ae701d..0000000000000000000000000000000000000000
--- a/TP/exos.sty~
+++ /dev/null
@@ -1,166 +0,0 @@
-
-\RequirePackage{ifthen}
-\RequirePackage[french]{babel}
-%\RequirePackage[utf8]{inputenc}
-\RequirePackage{fancyhdr}
-\RequirePackage{graphicx}
-\RequirePackage{amsfonts}
-%\RequirePackage[ruled,vlined]{algorithm2e}
-\RequirePackage{color}
-
-
-\renewenvironment{maketitle}{
-\begin{center}
-{\Large \@title\par}
-\end{center}
-\vspace{5pt}
-}{}
-
-
-\setlength{\textwidth}{16 cm} %Largeur du texte
-\setlength{\textheight}{23 cm}%Hauteur de texte
-\setlength{\topmargin}{-1 cm}
-\setlength{\oddsidemargin}{0 cm} %Marge a gauche <0 pour réduire
-\setlength{\headheight}{15pt}
-
-\pagestyle{fancy}
-\fancyhead[L]{ {\sc Agrocampus Ouest}, {\it \@author}}
-\fancyhead[C]{}
-\fancyhead[R]{\@date}
-\fancyfoot[L]{}
-\fancyfoot[C]{\thepage}
-
-%Quelques commandes :
-\newcommand{\eg}{{\emph{e.g.} }}
-\newcommand{\cf}{{\emph{cf.} }}
-\newcommand{\ie}{{\emph{i.e.} }}
-\newcommand{\NB}{{\underline{NB~:}~}}
-\newcommand{\espace}{\vspace{10pt}}
-\newcommand{\sep}{\vspace{-0.3cm}\rule{3cm}{0.5pt}}
-\newcommand{\psep}{\par\hspace{-0.5cm}\rule{3cm}{0.5pt}\vspace{-0.2cm}}
-\newcommand{\hard}{$\star$}
-
-\newcounter{NoEx}
-\stepcounter{NoEx}
-\newcounter{NoQ}
-\stepcounter{NoQ}
-
-\newcounter{iscorrection}
-\newcommand{\viewcorrection}{\setcounter{iscorrection}{1}}
-\newcommand{\hidecorrection}{\setcounter{iscorrection}{0}}
-
-\hidecorrection
-
-\newcommand{\correction}[1]
-{
- ~\\
- \ifthenelse{ \equal{\value{iscorrection}}{1} }
- {
- \vspace{5pt}
- \sffamily
- \setlength\leftmargin{5cm}
- \underline{\textbf{Correction :}}\vspace{0,1cm}\\ \null \hfill \parbox{.9\linewidth}{#1}\par
- \vspace{0,1cm}\rule{3cm}{0.5pt}
- \vspace{5pt}
- }
- {
- }
-}
-%
-% \newenvironment{Correction}[1][]
-% {
-%
-% ~\\
-% \begin{minipage}[1cm]{15cm}
-% \ifthenelse{ \equal{\value{iscorrection}}{1} }
-% {
-% % \vspace{5pt}
-% % \sffamily
-% % \setlength\leftmargin{5cm}
-% % \underline{\textbf{Correction :}}\vspace{0,1cm}\\ %\null \hfill
-% }{
-% \fontsize{5pt}{0pt}
-% \color{white}
-% }
-%
-%
-% }{
-% \ifthenelse{ \equal{\value{iscorrection}}{1} }
-% {
-% }{
-% }
-% \end{minipage}
-% % \par
-% % \vspace{0,1cm}\rule{3cm}{0.5pt}
-% % \vspace{5pt}
-% }
-
-\newtheorem{Exc}{Exercice} %Utilisation d'un théorème pour le package ``answers''
-\newenvironment{exercice}[1][]
-{
- %\lstset{xleftmargin=15pt}
- %\def\FrameCommand{\vrule width 3pt \hspace{10pt} }%\fcolorbox{sable}{sable}
- %\MakeFramed{\setlength{\hsize}{\textwidth} \advance\hsize-\width \FrameRestore}%
- %\vspace{-0,3cm}
- \noindent
- \begin{Exc}[#1]
- \setcounter{NoQ}{1} ~ \newline\vspace{-1em}
- \em
-
-}{
- \end{Exc}
- %\endMakeFramed
-}
-
-%
-% \newcommand{\exercice}[2]
-% {
-% \noindent
-% \begin{center}\rule{\textwidth}{1pt}\end{center}\vspace{-0,3cm}
-% {\bf Exercice \arabic{NoEx} - #2} \hspace{0,2cm}{\it #1}\vspace{-0,5cm}
-% \begin{center}\rule{\textwidth}{1pt}\end{center}
-% %\vspace{-0,2cm}
-% \stepcounter{NoEx}
-% \setcounter{NoQ}{1}
-% }
-
-
-\newcommand{\question}[1]
-{
- \noindent
- \begin{center}\rule{\textwidth}{0pt}\end{center}\vspace{-0,7cm}
- \underline{Question \alph{NoQ})} \emph{#1} \vspace{0,1cm}
- \stepcounter{NoQ}
-}
-
-%% Utilisation du package HyperRef pour faire de liens
-\RequirePackage{hyperref}
-
-%% Utilisation du package listing pour les bouts de code
-\RequirePackage{color}
-\definecolor{Brown}{cmyk}{0,0.81,1,0.60}
-\definecolor{Green}{cmyk}{0.64,0,0.95,0.40}
-\definecolor{Blue}{cmyk}{0.62,0.57,0.23,0}
-
-\RequirePackage{listings}
-\lstset{
-language=C,
-columns=flexible,
-%,caption=\lstname,
-caption=,
-basicstyle=\small,
-tabsize=2,
-stringstyle=\ttfamily,
-showstringspaces=false,
-numbers=left,
-numberfirstline=true,
-numberstyle=\footnotesize, % the size of the fonts that are used for the line-numbers
-stepnumber=1, % the step between two line-numbers. If it's 1 each line will be numbered
-breaklines=true, % sets automatic line breaking
-keywordstyle=\ttfamily\color{Green},
-identifierstyle=\ttfamily\color{Blue}\bfseries,
-commentstyle=\color{Brown}
-}
-
-\lstloadlanguages{R}
-