%%  Format et mise en page 

\def\presentation{
\voffset -.50in  \hoffset -.19in
\oddsidemargin 0in \evensidemargin 0in
\marginparwidth .75in \marginparsep 7pt \topmargin 0in
\headheight 12pt \headsep .25in
\footheight 18pt \footskip .35in
\textheight 9.5in \textwidth 6.5in
\columnsep 10pt \columnseprule 0pt }

\def\program#1{{\it{#1}}}
\def\programwithlink#1#2{{\it{{#1}/{#2}}}}
\def\href#1#2{#1\footnote{#2}}
\def\option#1{-#1}
\def\longoption#1{- -#1}
\def\filename#1{{\bf{#1}}}
\def\filepath#1{{\bf{#1}}}

\def\bookref#1{{\it{#1}}}
\def\errormessage#1{{\it{#1}}}
\def\directoryname#1{{\it{#1}}}
\def\command#1{{\it{#1}}}
\def\codeline#1{{\it{#1}}}
\def\function#1{{\it{#1}}}
\def\alert#1{{\bf{#1}}}
\def\commandarray#1{\begin{center}{\it{#1}}\end{center}}
\def\paperwithlink#1#2{{\it{#1}}}
\def\equline#1{\begin{math}#1\end{math}}

\documentclass[a4paper,11pt,twoside,openright]{book}
\voffset -.50in  \hoffset -.19in
\oddsidemargin 0in \evensidemargin 0in
\marginparwidth .75in \marginparsep 7pt \topmargin 0in
\headheight 12pt \headsep .25in
\textheight 9.5in \textwidth 6.5in
\columnsep 10pt \columnseprule 0pt 

\usepackage[francais]{babel}
\usepackage[french]{minitoc}
\usepackage{longtable}

\begin{document}


\setcounter{chapter}{1}

\chapter{Les variables}

\section{G\'en\'eralit\'es}

Toute variable en PERL doit avoir un nom qui commence par le symbole {\textdollar}. Ainsi \codeline{{\textdollar}a=1} affecte la valeur 1 \`a la variable \codeline{{\textdollar}a}. Contrairement \`a d'autres langages, PERL n'est pas un langage typ\'e. Ceci signifie que nous n'avons pas \`a d\'eclarer au pr\'ealable quel type (entier, flottant, cha\^{\i}ne de caract\`eres, ...) est associ\'e \`a une variable. De m\^eme, le type de variable peut changer en cours d'ex\'ecution. Ainsi pour le morceau de programme suivant\\

\begin{center}
\begin{longtable}{|rl|}
\hline
1.&{\textdollar}a = 1;\\
2.&{\textdollar}a = "Newton";\\
\hline
\end{longtable}
\end{center}


Apr\`es la ligne 1, \codeline{{\textdollar}a} est un nombre valant 1, alors qu'apr\`es la ligne 2, \codeline{{\textdollar}a} est une cha\^{\i}ne de caract\`eres contenant Newton. 

Toute variable peut \^etre affich\'ee en la passant comme argument \`a l'instruction \function{print}. Ainsi le programme suivant affiche le contenu de la variable \codeline{{\textdollar}a} \`a l'\'ecran:\\

\begin{center}
\begin{longtable}{|rl|}
\hline
1.&\#!/usr/bin/perl\\
2.&\\
3.&{\textdollar}a = "Newton";\\
4.&print ({\textdollar}a);\\
\hline
\end{longtable}
\end{center}



\section{Op\'erations de base avec les cha\^{\i}nes de caract\`eres}

L'op\'eration la plus simple que nous puissions imaginer entre deux cha\^{\i}nes de caract\`eres est l'op\'eration de concat\'enation, c'est \`a dire l'ajout d'une cha\^{\i}ne \`a la suite d'une autre. L'op\'eration est not\'ee . en PERL et s'utilise ainsi:\\

\begin{center}
\begin{longtable}{|rl|}
\hline
1.&\#!/usr/bin/perl\\
2.&\\
3.&{\textdollar}a = "Hello";\\
4.&{\textdollar}b = "World";\\
5.&{\textdollar}c = {\textdollar}a.{\textdollar}b;\\
6.&print ({\textdollar}c);\\
\hline
\end{longtable}
\end{center}


Ce progamme affiche HelloWorld qui est bien la concat\'enation de \codeline{{\textdollar}a} et de \codeline{{\textdollar}b}. Il n'est pas oblig\'e de passer par la variable (temporaire) \codeline{{\textdollar}c} pour stocker le r\'esultat de l'op\'eration.\\

\begin{center}
\begin{longtable}{|rl|}
\hline
1.&\#!/usr/bin/perl\\
2.&\\
3.&{\textdollar}a = "Hello";\\
4.&{\textdollar}b = "World";\\
5.&print ({\textdollar}a.{\textdollar}b);\\
\hline
\end{longtable}
\end{center}


Le Hello World que nous venons d'afficher souffre de deux probl\`emes. Les deux mots qui le composent ne sont pas s\'epar\'es par un espace. Un retour \`a la ligne serait aussi judicieux. R\'eparons de suite ces quelques d\'efauts de jeunesse\\

\begin{center}
\begin{longtable}{|rl|}
\hline
1.&\#!/usr/bin/perl\\
2.&\\
3.&{\textdollar}a = "Hello";\\
4.&{\textdollar}b = "World";\\
5.&print ({\textdollar}a." ".{\textdollar}b."{\textbackslash}n");\\
\hline
\end{longtable}
\end{center}


Comme vous le constatez, il est possible de cha\^{\i}ner plusieurs op\'erations de concat\'enation (comme nous ferions pour des additions) et directement utiliser des cha\^{\i}nes de caract\`eres sans passer par des variables.

Un langage de programmation n'en serait pas un s'il n'\'etait pas possible de faire des tests conditionnels et des branchements. Il est grand temps d'introduire le couple infernal \function{if/else}. Il s'utilise de la fa\c{c}on suivante\\

\begin{center}
\begin{longtable}{|rl|}
\hline
1.&if (condition)\\
2.&\{ \\
3.&bloc d'instruction \`a ex\'ecuter si la condition est v\'erifi\'ee\\
4.&\hspace{0.25cm}\}\\
5.&else\\
6.&\hspace{0.25cm}\{\\
7.&bloc d'instruction \`a ex\'ecuter si la condition n'est pas v\'erifi\'ee   \\ 
8.&\}	\\
\hline
\end{longtable}
\end{center}


L'indentation du code n'est pas obligatoire mais le rend beaucoup plus lisible. Comme dans les langages proche du C, tout bloc d'instruction doit \^etre d\'efini entre accolades. PERL est m\^eme plus strict que le C de ce point de vue puisque les accolades sont obligatoires m\^eme lorsque le bloc n'est compos\'e que d'une seule ligne de commande. Le bloc d'instructions \`a ex\'ecuter si la condition n'est pas v\'erifi\'ee n'est pas obligatoire et une syntaxe du type\\

\begin{center}
\begin{longtable}{|rl|}
\hline
1.&if (condition)\\
2.&\{ \\
3.&bloc d'instruction \`a ex\'ecuter si la condition est v\'erifi\'ee\\
4.&\hspace{0.25cm}\}\\
\hline
\end{longtable}
\end{center}


est parfaitement l\'egale. Il est aussi possible de consid\'erer la n\'egation d'une condition en pla\c{c}ant le symbole ! devant celle-ci\\

\begin{center}
\begin{longtable}{|rl|}
\hline
1.&if (!(condition))\\
2.&\{ \\
3.&bloc d'instruction \`a ex\'ecuter si la condition n'est pas v\'erifi\'ee\\
4.&\hspace{0.25cm}\}\\
\hline
\end{longtable}
\end{center}


Pour ceux qui se demanderaient s'il n'y a pas un probl\`eme de mise en page dans ces notes de cours, ne voyant pas le rapport entre ce qui pr\'ec\`ede et les cha\^{\i}nes de caract\`eres, nous allons nous int\'eresser \`a la comparaison de ces derni\`eres. Pour comparer deux cha\^{\i}nes, il y a six op\'erateurs
\begin{itemize}
\item \function{eq} teste si deux cha\^{\i}nes sont identiques.
\item \function{ne} teste si deux cha\^{\i}nes sont diff\'erentes.
\item \function{le} (resp. \function{lt}) teste si la cha\^{\i}ne \`a gauche de l'op\'erateur est plus petite (resp. strictement plus petite) que celle \`a droite de l'op\'erateur.
\item \function{ge} (resp. \function{gt}) teste si la cha\^{\i}ne \`a gauche de l'op\'erateur est plus grande (resp. strictement plus grande) que celle \`a droite de l'op\'erateur.
\end{itemize}

Ces op\'erateurs s'utilisent ainsi:\\

\begin{center}
\begin{longtable}{|rl|}
\hline
1.&\#!/usr/bin/perl\\
2.&\\
3.&{\textdollar}a = "toto";\\
4.&if ({\textdollar}a eq "toto");\\
5.&\hspace{0.25cm}\{\\
6.&\hspace{0.5cm}print ("la cha\^{\i}ne de caract\`ere vaut toto{\textbackslash}n");\\
7.&\hspace{0.25cm}\}\\
8.&else\\
9.&\hspace{0.25cm}\{\\
10.&\hspace{0.5cm}print ("la cha\^{\i}ne de caract\`ere est diff\'erente de toto{\textbackslash}n");\\
11.&\hspace{0.25cm}\}\\
\hline
\end{longtable}
\end{center}


Plusieurs remarques sont \`a faire concernant ces comparaisons. Elles sont sensibles \`a la casse: si dans notre programme pr\'ec\'edent, \codeline{{\textdollar}a} contenait Toto, le test aurait \'echou\'e. Pour savoir si une cha\^{\i}ne est plus petite ou plus grande qu'un autre, PERL compare le code ASCII de chacun des caract\`eres et s'arr\^ete d\`es que la condition n'est plus v\'erifi\'ee (ce n'est pas a priori un test sur la longueur de la cha\^{\i}ne).

Pour terminer ce rapide (et premier) tour des cha\^{\i}nes de caract\`eres. Nous terminerons par deux fonctions utiles. La premi\`ere s'appelle \function{chomp} et permet d'enlever le caract\`ere retour \`a la ligne si ce dernier est pr\'esent en fin de cha\^{\i}ne. Ainsi pour le code\\

\begin{center}
\begin{longtable}{|rl|}
\hline
1.&{\textdollar}a = "toto{\textbackslash}n";\\
2.&chomp({\textdollar}a);\\
\hline
\end{longtable}
\end{center}


La variable \codeline{{\textdollar}a} contient apr\`es la ligne 2 la cha\^{\i}ne toto. 

Dernier point, et non des moindres, est la technique pour r\'ecup\'erer le r\'esultat d'une ligne tap\'ee au clavier lors de l'ex\'ecution du script\\

\begin{center}
\begin{longtable}{|rl|}
\hline
1.&\#!/usr/bin/perl\\
2.&\\
3.&{\textdollar}a = {\textless}STDIN{\textgreater};\\
4.&print ("vous venez de taper ".{\textdollar}a);\\
\hline
\end{longtable}
\end{center}


Affecter \codeline{{\textless}STDIN{\textgreater}} (STDIN d\'esignant l'entr\'ee standard) \`a \codeline{{\textdollar}a} permet de r\'ecup\'erer ce qui est tap\'e au clavier dans cette variable, jusqu'\`a ce que la touche entr\'ee soit enfonc\'ee. Le caract\`ere de saut de ligne est inclus, il est donc souvent utile d'appliquer un \command{chomp} \`a la variable \`a laquelle on a effect\'e \codeline{{\textless}STDIN{\textgreater}}, en particulier si vous avez demand\'e un nombre.



\section{Op\'erations de base avec les nombres}

Bien que PERL n'ait pas vocation \`a \^etre un langage permettant la cr\'eation de logiciels scientifiques performants, il g\`ere aussi bien que le C les nombres entiers et \`a virgule flottante. La pr\'ecision des flottants est \'equivalente \`a celle des doubles en C (une mantisse avec 14 chiffres significatifs et un exposant pouvant aller de -308 \`a +308). Pour \^etre totalement rigoureux concernant les entiers (et ceci a son importance pour nous, les physiciens), PERL n'a pas vraiment de type entier en interne et travaille avec des double. Les entiers sont donc compris entre \equline{-10^{14}} et \equline{10^{14}}.
PERL poss\`ede tous les op\'erateurs binaires de base 
\begin{itemize}
\item l'addition \equline{(+)}.
\item la soustraction \equline{(-)}.
\item la multiplication \equline{(*)}.
\item la division \equline{(/)}.
\item le reste de la division enti\`ere ou modulo \equline{(\%)}.
\item la puissance \equline{(**)}.
\end{itemize}

Les r\`egles de priorit\'e des ces op\'erateurs sont les m\^eme que celles dont nous avons l'habitude en math\'ematiques ou en C. 

PERL poss\`ede aussi un certain nombre de fonctions num\'eriques de base dont la liste exhaustive est donn\'ee ci-dessous
\begin{itemize}
\item \function{abs}: valeur absolue.
\item \function{int}: partie enti\`ere.
\item \function{sqrt}: racine carr\'ee.
\item \function{atan2}: arctangente du rapport de deux nombres. atan2({\textdollar}y, {\textdollar}x) retourne l'arctangente de {\textdollar}y/{\textdollar}x (entre \equline{-\pi} et \equline{\pi}).
\item \function{cos}: cosinus.
\item \function{sin}: sinus.
\item \function{exp}: exponentielle.
\item \function{log}: logarithme en base n\'eperienne.
\item \function{rand}: retourne un nombre entre 0 et 1 si aucun argument n'est pass\'e, ou entre 0 et {\textdollar}x si {\textdollar}x est l'argument pass\'e.
\item \function{srand}: fixe la graine du g\'en\'erateur de nombres al\'eatoires.
\end{itemize}

Pour ceux qui auraient de gros besoin (calcul formel, precision infinie, FFT, diagonalisation et m\^eme calcul quantique!), il existe de nombreuses extensions de ce type pour \href{PERL}{http://www.cpan.org/\-modules/\-01modules.index.html} (environ 150). Mais ne nous emportons pas, l'utilisation des modules n'est pas encore \`a l'ordre du jour.

La comparaison entre deux nombres se fait via des op\'erateurs diff\'erents de ceux utilis\'es dans le cas des cha\^{\i}nes de caract\`eres:
\begin{itemize}
\item \equline{==} teste si deux nombres sont \'egaux.
\item \equline{!=} teste si deux nombres sont diff\'erents.
\item \equline{{\textless}}= (\equline{{\textless}}) teste si le nombre \`a gauche de l'op\'erateur est plus petit ou \'egal (resp. strictement plus petit) que celui \`a droite de l'op\'erateur.
\item \equline{{\textgreater}}= (\equline{{\textgreater}}) teste si le nombre \`a gauche de l'op\'erateur est plus grand ou \'egal (resp. strictement plus grand) que celui \`a droite de l'op\'erateur.
\end{itemize}

Pour ceux qui se poseraient la question de l'utilit\'e de diff\'erencier les op\'erateurs de comparaison des cha\^{\i}nes et ceux des nombres, regardez le petit programme suivant\\

\begin{center}
\begin{longtable}{|rl|}
\hline
1.&\#!/usr/bin/perl\\
2.&\\
3.&{\textdollar}a = 4;\\
4.&{\textdollar}b = 23;\\
5.&if ({\textdollar}a \equline{{\textless}} {\textdollar}b )\\
6.&\hspace{0.25cm}\{\\
7.&\hspace{0.5cm}print ({\textdollar}a." est plus petit que ".{\textdollar}b."{\textbackslash}n");\\
8.&\hspace{0.25cm}\}\\
9.&else\\
10.&\hspace{0.25cm}\{\\
11.&\hspace{0.5cm}print ({\textdollar}a." est plus grand que ou egal a ".{\textdollar}b."{\textbackslash}n");\\
12.&\hspace{0.25cm}\}\\
13.&if ({\textdollar}a lt {\textdollar}b )\\
14.&\hspace{0.25cm}\{\\
15.&\hspace{0.5cm}print ({\textdollar}a." est plus petit que ".{\textdollar}b."{\textbackslash}n");\\
16.&\hspace{0.25cm}\}\\
17.&else\\
18.&\hspace{0.25cm}\{\\
19.&\hspace{0.5cm}print ({\textdollar}a." est plus grand que ou egal a ".{\textdollar}b."{\textbackslash}n");\\
20.&\hspace{0.25cm}\}\\	
\hline
\end{longtable}
\end{center}


Voici le r\'esultat que vous devez observer:\\

\begin{center}\begin{longtable}{|rl|}
\hline
&{\it 4 est plus petit que 23}\\
&{\it 4 est plus grand que ou egal a 23}\\
\hline
\end{longtable}
\end{center}


Le r\'esultat est surprenant pour un physicien mais pas pour un informaticien. La ligne 5 correspond \`a un test entre deux nombres. Le r\'esultat de la comparaison est bien celui escompt\'e. Par contre \`a la ligne 13, il s'agit d'une comparaison entre cha\^{\i}nes de caract\`eres. PERL va donc commencer par convertir \codeline{{\textdollar}a} et \codeline{{\textdollar}b} en cha\^{\i}ne de caract\`eres. De ce point de vue, le premier caract\`ere de \codeline{{\textdollar}a} (4) est plus grand que celui de \codeline{{\textdollar}b} (2). Le test s'arr\^ete \`a ce point et \'echoue. D'o\`u le r\'esultat que nous obtenons.

Parmi les structures de base faisant appel aux nombres, il y a les boucles. PERL poss\`ede l'\'equivalent des instructions \function{while} et \function{for} du C et consorts. Le petit programme suivant affiche dix fois Hello World:\\

\begin{center}
\begin{longtable}{|rl|}
\hline
1.&\#!/usr/bin/perl\\
2.&\\
3.&{\textdollar}a = 0;\\
4.&while ({\textdollar}a {\textless} 10)\\
5.&\hspace{0.25cm}\{\\
6.&\hspace{0.5cm}print ("Hello World{\textbackslash}n");\\
7.&\hspace{0.5cm}{\textdollar}a ={\textdollar}a + 1;\\
8.&\hspace{0.25cm}\}\\
\hline
\end{longtable}
\end{center}


Le programme ex\'ecute le bloc d'instructions qui suit le \function{while} tant que la condition entre parenth\`eses est v\'erifi\'ee. Notez qu'il n'y a pas de point virgule apr\`es la condition. 

Une remarque concernant la ligne 7. Ce type de commande qui consiste \`a incr\'ementer une variable peut se r\'e\'ecrire de plusieurs mani\`eres. Tout d'abord, il est possible d'utiliser l'op\'erateur += (soit \codeline{{\textdollar}a += 1}) qui ajoute la variable ou la constante situ\'ee \`a droite de l'op\'erateur \`a la variable situ\'ee gauche. Signalons que l'\'equivalent de cet op\'erateur existe pour les op\'erations math\'ematiques -, *, et / et l'op\'eration de concat\'enation . . L'autre technique est d'utiliser la syntaxe \codeline{{\textdollar}a++} qui incr\'emente la variable \codeline{{\textdollar}a} de 1 (il existe aussi \codeline{{\textdollar}a- -} qui d\'ecr\'emente \codeline{{\textdollar}a} de 1).

Le m\^eme type de programme s'\'ecrit de la fa\c{c}on suivante \`a l'aide de l'instruction \command{for}

\begin{center}
\begin{longtable}{|rl|}
\hline
1.&\#!/usr/bin/perl\\
2.&\\
3.&for ({\textdollar}a = 0; {\textdollar}a {\textless} 10; {\textdollar}a++)\\
4.&\hspace{0.25cm}\{\\
5.&\hspace{0.5cm}print ("Hello World{\textbackslash}n");\\
6.&\hspace{0.25cm}\}\\
\hline
\end{longtable}
\end{center}


La syntaxe est identique \`a celle du C. L'instruction \function{for} est suivie par une expression entre parenth\`eses qui contient trois parties: l'initialisation (\codeline{{\textdollar}a=0}), la condition \`a v\'erifier pour continuer la boucle et l'instruction \`a ex\'ecuter \`a la fin de chaque it\'eration (en g\'en\'eral, un incr\'ement). Chacune de ces parties est s\'epar\'ee de l'autre par un point-virgule. Apr\`es les parenth\`eses, nous retrouvons le bloc d'instuctions \`a ex\'ecuter \`a chaque it\'eration.



\section{Variables particuli\`eres}

(N.B: cette section peut \^etre pass\'ee en premi\`ere lecture).\\
PERL poss\`ede quelques variables dont le nom est r\'eserv\'e. Le but ici n'est pas de les d\'ecrire toutes mais au moins dans donner la liste:\\

\codeline{{\textdollar}ARG, {\textdollar}\_, {\textdollar}1, {\textdollar}2, ..., {\textdollar}MATCH, {\textdollar}\&, {\textdollar}PREMATCH, {\textdollar}`, {\textdollar}POSTMATCH, {\textdollar}', {\textdollar}LAST\_PAREN\_MATCH, {\textdollar}+, {\textdollar}{\textasciicircum}N, {\textdollar}*, {\textdollar}INPUT\_LINE\_NUMBER, {\textdollar}NR, {\textdollar}.,  {\textdollar}LIST\_SEPARATOR, {\textdollar}", {\textdollar}SUBSCRIPT\_SEPARATOR, {\textdollar}SUBSEP, {\textdollar};, {\textdollar}\#, {\textdollar}ACCUMULATOR, {\textdollar}{\textasciicircum}A, {\textdollar}CHILD\_ERROR, {\textdollar}?, {\textdollar}\{{\textasciicircum}ENCODING\}, {\textdollar}OS\_ERROR, {\textdollar}ERRNO, {\textdollar}!, {\textdollar}EXTENDED\_OS\_ERROR, {\textdollar}{\textasciicircum}E, {\textdollar}EVAL\_ERROR, {\textdollar}\@, {\textdollar}PROCESS\_ID, {\textdollar}PID, {\textdollar}{\textdollar}, {\textdollar}REAL\_USER\_ID, {\textdollar}UID, {\textdollar}{\textless}, {\textdollar}EFFECTIVE\_USER\_ID, {\textdollar}EUID, {\textdollar}{\textgreater},{\textdollar}REAL\_GROUP\_ID, {\textdollar}GID, {\textdollar}(,{\textdollar}EFFECTIVE\_GROUP\_ID, {\textdollar}EGID, {\textdollar}), {\textdollar}PROGRAM\_NAME, {\textdollar}0,{\textdollar}[, {\textdollar}], {\textdollar}COMPILING, {\textdollar}{\textasciicircum}C,{\textdollar}DEBUGGING, {\textdollar}{\textasciicircum}D, {\textdollar}SYSTEM\_FD\_MAX, {\textdollar}{\textasciicircum}F, {\textdollar}{\textasciicircum}H, {\textdollar}INPLACE\_EDIT, {\textdollar}{\textasciicircum}I, {\textdollar}{\textasciicircum}M, {\textdollar}OSNAME, {\textdollar}{\textasciicircum}O, {\textdollar}\{{\textasciicircum}OPEN\},{\textdollar}PERLDB, {\textdollar}{\textasciicircum}P, {\textdollar}LAST\_REGEXP\_CODE\_RESULT, {\textdollar}{\textasciicircum}R, {\textdollar}EXCEPTIONS\_BEING\_CAUGHT, {\textdollar}{\textasciicircum}S, {\textdollar}BASETIME, {\textdollar}{\textasciicircum}T, {\textdollar}\{{\textasciicircum}TAINT\}, {\textdollar}\{{\textasciicircum}UNICODE\}, {\textdollar}PERL\_VERSION, {\textdollar}{\textasciicircum}V, {\textdollar}WARNING, {\textdollar}{\textasciicircum}W, {\textdollar}\{{\textasciicircum}WARNING\_BITS\}, {\textdollar}EXECUTABLE\_NAME, {\textdollar}{\textasciicircum}X, {\textdollar}ARGV}.

Pour une description compl\`ete, vous pouvez consulter les pages man perlvar. Nous nous contenterons d'\'etudier la variable \codeline{{\textdollar}\_} ou variable par d\'efaut. Si vous utilisez une fonction (comme \function{print} ou \function{chomp}) qui n\'ecessite a priori un argument et que vous l'omettez, PERL va utiliser la variable \codeline{{\textdollar}\_} comme argument. Regardons le petit programme suivant:\\

\begin{center}
\begin{longtable}{|rl|}
\hline
1.&\#!/usr/bin/perl\\
2.&\\
3.&{\textdollar}\_ = "essai{\textbackslash}n";\\
4.&print;\\
\hline
\end{longtable}
\end{center}


Le contenu de la variable par d\'efaut est bien affich\'e. Quel est l'int\'er\^et de cette variable? Une des devises de PERL est "There's more than one way to do it", comprendre il y a plus d'une fa\c{c}on de le faire. Et il n'est pas rare de voir certains \'ecrire leur code PERL de la fa\c{c}on la plus compacte possible. Certains font m\^eme des miracles en une seule ligne (les one-liners). Ce genre d'exploits montrera \`a quel point vous \^etes un virtuose du PERL, mais \`a tendance \`a rendre le code compl\`etement illisible et peut provoquer un isolement vis-\`a-vis de vos proches (y compris de vos coll\`egues th\'eoriciens).



\section{Exercices}


Calulez \equline{\pi} par deux techniques
\begin{itemize}
\item Mont\'e Carlo. Vous demanderez le nombre d'it\'erations \`a effectuer et v\'erifierez que le nombre obtenu est positif. Nous rappelons que cet algorithme consiste \`a tirer deux nombres al\'eatoires \equline{x} et \equline{y} et \`a incrementer une variable not\'ee \equline{N} si \equline{x^{2} + y^{2} {\textless}= 1}. Le rapport entre N et le nombre d'it\'erations tend vers \equline{\pi / 4}.
\item int\'egrale de \equline{\int_{0}^{+\infty} dx\;\; exp(-x^{2}/2)} par la m\'ethode des trap\`ezes. Vous demanderez le nombre de subdivisions et la borne sup\'erieure. Vous v\'erifierez que les nombre obtenu sont valides. 
\end{itemize}




\end{document}


