\documentclass[xcolor=hyperref,hyperef={naturalnames,pdfpagelabels},french]{beamer}
\usepackage{etex}
\usepackage[beamer]{preambule}
\usepackage[french,vlined,boxed]{algorithm2e}

\usepackage{movie15}
%\usepackage{multimedia}
\usepackage{cclicenses}
\usepackage{cclicence}

\graphicspath{{/home/moi/Lycee/2nde/2009_10/}{/home/moi/Photos/Maths/}{/home/moi/Figures/FigSTI/}{/home/moi/Figures/FigSeconde/}{/home/moi/Figures/figuresTS/}{/home/moi/Lycee/TDmaple/2007_8/}{/home/moi/IREM/IREM10_06_09/}}



\lstset{numbers=none,language=Caml,xleftmargin=10pt,%
keywordstyle =\color{blue!30}\usefont{OT1}{cmtt}{b}{n},basicstyle=\ttfamily\color{white},commentstyle=\normalfont\scriptsize\slshape,breaklines=true,backgroundcolor=\color{black!90},frame=trBL,framerule=1pt,framesep=4pt,rulesep=1pt,showstringspaces=false,stringstyle=\slshape,captionpos=b}

\renewcommand\FancyVerbFormatLine[1]{\colorbox{green}{#1}}

\mode<presentation>
{
  \usetheme[secheader]{Madrid}
  % or ...Warsaw

  \setbeamercovered{highly dynamic}
  % or whatever (possibly just delete it)
}
\usepackage{elephantbird}

\title[] % (optional, use only with long paper titles)
{CAML pour l'impatient}

\subtitle{ l'essentiel pour utiliser CAML au lycée}

\author[] % (optional, use only with lots of authors)
{Guillaume CONNAN  }
% - Give the names in the same order as the appear in the paper.
% - Use the inst{?} command only if the authors have different
%   affiliation.

\institute{\textsc{IREM} de Nantes}% (optional, but mostly needed)

\logo{\includegraphics[scale=0.15]{logoirem}}

\date[] % (optional, should be abbreviation of conference name)
{\today}
% - Either use conference name or its abbreviation.
% - Not really informative to the audience, more for people (including
%   yourself) who are reading the slides online

\subject{CAML pour l'impatient}


\beamerdefaultoverlayspecification{<+->}

\AtBeginSubsubsection[]
{
  \begin{frame}<beamer>
    \frametitle{Sommaire}
 {\scriptsize
%\begin{multicols}{2}
    \tableofcontents[currentsection,currentsubsection]
%       \end{multicols}
}

  \end{frame}
}




\AtBeginSubsection[]
{
  \begin{frame}<beamer>
    \frametitle{Sommaire}
 {\scriptsize
%\begin{multicols}{2}
    \tableofcontents[currentsection,currentsubsection]
%       \end{multicols}
}

  \end{frame}
}





\AtBeginSection[]
{
  \begin{frame}<beamer>
    \frametitle{Sommaire}
 {\scriptsize
%\begin{multicols}{2}
    \tableofcontents[currentsection]
%       \end{multicols}
}

  \end{frame}
}


% If you wish to uncover everything in a step-wise fashion, uncomment
% the following command: 

\beamerdefaultoverlayspecification{<+->}









\begin{document}


\begin{frame}
  \titlepage
\end{frame}

\begin{frame}
 \frametitle{Sommaire}
{\scriptsize
%\begin{multicols}{2} 
 \tableofcontents
%\end{multicols}
}

 
 \end{frame}






\section{Installation et utilisation}


\begin{frame}
  
Pour   tous   les   O.S.   il   existe   des   distributions   de   CAML
\emph{clé-en-main}           sur           le          page           de
\href{http://pagesperso-orange.fr/jean.mouric/}{Jean Mouric}.

Pour   les    utilisateurs   de   Emacs,   vous    pouvez   charger   le
\href{http://www.emacswiki.org/emacs/TuaregMode}{mode tuareg}.

\end{frame}


\begin{frame}
  
CAML sous Emacs avec le mode tuareg~:

\begin{figure}
\begin{center}
  \includegraphics[width=\linewidth]{caml1}
\end{center}
\end{figure}
\end{frame}


\begin{frame}
  CAML sous JavaCaml~:

\begin{figure}
\begin{center}
  \includegraphics[width=\linewidth]{caml2}
\end{center}
\end{figure}
\end{frame}




\section{Les nombres}



\begin{frame}
  
Nous utiliserons  dans tout le document  la version basique  de CAML (en
fait  OCAML  (c'est-à-dire  CAML  avec  des modules  pour  faire  de  la
programmation orientée  objet) ou CAML  Light (c'est la version  de base
que  nous utiliserons))  sans  charger de  modules complémentaires  sauf
éventuellement  pour créer  des graphiques  ou travailler  sur certaines
listes.

\end{frame}



\begin{frame}
  Nous  travaillerons  en   mode  \emph{toplevel}  c'est-à-dire  que  nous
compilerons automatiquement de manière  interactive. Pour se repérer, ce
que nous  taperons sera  précédé d'un  \# et ce  que renverra  CAML sera
précédé le plus souvent d'un -.

\end{frame}


\begin{frame}[fragile]
  On peut travailler avec des entiers~:

\begin{lstlisting}[caption={}]
#  1+2;;
- : int = 3
\end{lstlisting}
\end{frame}



\begin{frame}[fragile]
  

Vous remarquerez  que CAML répond que  le résultat de 1+2  est un entier
(\verb+int+) égal  à 3. En  effet, CAML est adepte  de l'\emph{inférence
de type}, c'est-à-dire qu'il devine  quel type de variable vous utilisez
selon ce que vous avez tapé. Nous en reparlerons plus bas.

\end{frame}


\begin{frame}[fragile]
  
Les  priorités des opérations  sont respectées.  En cas  d'ambiguïté, un
parenthésage implicite à gauche est adopté~:

\begin{lstlisting}[caption={}]
# 1+2*3;;
- : int = 7
# 1-2+3;;
- : int = 2
# 1-(2+3);;
- : int = -4
# (1+2)*3;;
- : int = 9
\end{lstlisting}

\end{frame}




\begin{frame}[fragile]
  

La division renvoie le quotient entier bien sûr~:

\begin{lstlisting}[caption={}]
# 11/3;;
- : int = 3
# 11/3*2;;
- : int = 6
# 11/(3*2);;
- : int = 1
\end{lstlisting}
\end{frame}




\begin{frame}[fragile]
  
On peut utiliser \verb+mod+ pour le reste entier~:

\begin{lstlisting}[caption={}]
# 7 mod 2;;
- : int = 1
# 7/2;;
- : int = 3
# 7-7/2*2;;
- : int = 1
\end{lstlisting}
\end{frame}







\begin{frame}
  
Enfin, les entiers sont de base compris entre $-2^{30}$ et $2^{30}-1$.


\end{frame}




\begin{frame}[fragile]
  
Les nombres non entiers sont de type \emph{float}. Ils sont représentés
en interne par deux entiers~:~une \emph{mantisse} $m$ et un exposant $n$
tel  que  le nombre  flottant  soit  $m\times  10^{n}$. En  externe,  il
apparaît sous forme décimale, le séparateur étant le point.


\pause

\begin{lstlisting}[caption={}]
# 1.;;
- : float = 1.
\end{lstlisting}

\end{frame}



\begin{frame}[fragile]
  
Attention alors aux opérations~:

\begin{lstlisting}[caption={}]
# 3.14 + 2;;
Characters 0-4:
  3.14 + 2;;
  ^^^^
Error: This expression has type float but an expression was expected of type int
\end{lstlisting}


\pause


Cela indique que  vous avez utilisé l'addition des  entiers pour ajouter
un  entier à un  flottant. CAML  en effet  n'effectue pas  de conversion
implicite et  demande que celle-ci soit explicite.  Cela peut apparaître
comme contraignant mais  permet l'inférence de type qui  évite nombre de
\og bugs\fg{}.

\end{frame}





\begin{frame}
  
Les opérations  arithmétiques sur les entiers doivent  donc être suivies
d'un point~:

\end{frame}


\begin{frame}[fragile]
  
\begin{lstlisting}[caption={}]
# 1. +. 2.1 ;;
- : float = 3.1
# 1.2 +. 2.1 ;;
- : float = 3.3
# 1./.2.;;
- : float = 0.5
# 1.5e-5 *. 100. ;;
- : float = 0.0015
# sqrt(2.);;
- : float = 1.41421356237309515
\end{lstlisting}

\end{frame}







\begin{frame}[fragile]
  
\begin{lstlisting}[caption={}]
# 3.**2.;;
- : float = 9.
# log(2.);;
- : float = 0.693147180559945286
# exp(1.);;
- : float = 2.71828182845904509
# cos(0.);;
- : float = 1.
# cos(2.*.atan(1.));;
- : float = 6.12303176911188629e-17
# sin(2.*.atan(1.));;
- : float = 1.
\end{lstlisting}

\end{frame}



\begin{frame}[fragile]
  
Il existe des moyens de convertir un entier en flottant~:

\begin{lstlisting}[caption={}]
# float(1) +. 3.1;;
- : float = 4.1
# float 1 +. 3.1;;
- : float = 4.1
\end{lstlisting}

\end{frame}


\begin{frame}[fragile]
  

et inversement~:

\begin{lstlisting}[caption={}]
# int_of_float(sqrt(2.));;
- : int = 1
\end{lstlisting}

\end{frame}





\begin{frame}[fragile]
  Il ne faut pas confondre \verb+int_of_float+ et \verb+floor+


\begin{lstlisting}[caption={}]
# floor(2.1);;
- : float = 2.
# int_of_float(2.1);;
- : int = 2
\end{lstlisting}

\end{frame}



\section{Les autres types de base}


\subsection{Les booléens}



\begin{frame}[fragile]
  
Ils sont bien sûr au  nombre de deux~:~\verb+true+ et \verb+false+. Nous
en aurons besoin pour les  tests. Les fonctions de comparaison renvoient
un booléen. On  peut combiner des booléens avec  \verb+not+, \verb+&+ et
\verb+or+~:
\end{frame}


\begin{frame}[fragile]
  \begin{lstlisting}[caption={}]
# 3>2;;
- : bool = true
# 3=2;;
- : bool = false
# (3>2) & (3=2);;
- : bool = false
# (3>2) or (3=2);;
- : bool = true
# (3>2) & not(3=2);;
- : bool = true
# (3>2) & not(3=2) & (0<1 or 1>0);;
- : bool = true
\end{lstlisting}

\end{frame}






\subsection{Les chaînes de caractères}


\begin{frame}[fragile]
  
En anglais~:~\emph{string}. On les entoure de guillemets \verb+"+ et on les
concatène avec \verb+^+~:

\pause

\begin{lstlisting}[caption={}]
# "Tralala "^"pouet pouet";;
- : string = "Tralala pouet pouet"
\end{lstlisting}

\end{frame}



\subsection{Les caractères}

\begin{frame}[fragile]
  
En    CAML~:~\emph{char}.   On   les    utilisera   surtout    pour   la
cryptographie.  Il sont entrés entre accents aigus~:

\pause


\begin{lstlisting}[caption={}]
# 'a';;
- : char = 'a'
\end{lstlisting}

\end{frame}




\section{Les définitions}


\begin{frame}[fragile]
  
C'est  comme  en  maths...mais  en  anglais~! Donc  \emph{Soit}  se  dit
\emph{Let}~:


\pause

\begin{lstlisting}[caption={}]
# let x=3*2;;
val x : int = 6
# 2+x;;
- : int = 8
# let pi=acos(-1.);;
val pi : float = 3.14159265358979312
# sin(pi/.2.);;
- : float = 1.
\end{lstlisting}
\end{frame}


\begin{frame}
\begin{block}{attention}
Le nom des identificateurs doit commencer par une lettre minuscule.

\end{block}
\end{frame}


\begin{frame}[fragile]
  

On  peut définir  \emph{localement}  une variable,  c'est-à-dire que  sa
portée ne dépassera pas l'expression où elle a été définie~:

\pause

\begin{lstlisting}[caption={}]
# let x=99 in x+1;;
- : int = 100
# x;;
- : int = 6
# let a=3 and b=2 in a*a+b*b;;
- : int = 13
\end{lstlisting}

\end{frame}


\section{Fonctions}


\begin{frame}[fragile]
  
On peut créer des fonctions avec \verb+function+~:


\pause

\begin{lstlisting}[caption={}]
# let delta = function
  | (a,b,c) -> b*b-4*a*c;;
  val delta : int * int * int -> int = <fun>

# delta(1,1,1);;
- : int = -3
\end{lstlisting}

\pause


Notez le \verb+val delta  : int * int * int ->  int = <fun>+ qui indique
que la  fonction construite...est une fonction (\verb+<fun>+)  qui va de
$\bbz^3$ dans $\bbz$.


\end{frame}




\begin{frame}[fragile]
  
On peut de manière plus standard (informatiquement parlant~!) définir la
fonction par son expression générale~:

\pause

\begin{lstlisting}[caption={}]
# let discriminant(a,b,c)=b*b-4*a*c;;
val discriminant : int * int * int -> int = <fun>
# discriminant(1,1,1);;
- : int = -3
\end{lstlisting}
\end{frame}


\begin{frame}[fragile]
  
On peut disjoindre des cas~:


\pause

\begin{lstlisting}[caption={}]
# let sina = function
  | 0. -> 1.
  | x -> sin(x)/.x;;
    val sina : float -> float = <fun>

# sina(0.);;
- : float = 1.

# sina(0.1);;
- : float = 0.998334166468281548
\end{lstlisting}

\end{frame}




\begin{frame}[fragile]
  
On peut travailler avec autre chose que des nombres~:


\pause

\begin{lstlisting}[caption={}]
# let mystere = function
  | (true,true) -> true
  | _           -> false;;
    val mystere : bool * bool -> bool = <fun>
# mystere(3>2,0=1-1);;
- : bool = true
# mystere(3>2,0>1);;
- : bool = false
\end{lstlisting}


\pause

\begin{block}{remarque}

Le tiret \verb+_+ indique \og dans tous les autres cas\fg{}.

\end{block}


\end{frame}









\begin{frame}[fragile]
  
On peut  aussi créer des fonctions  \emph{polymorphes}, c'est-à-dire qui
ne travaillent pas sur des types de variables particuliers.

\pause

\begin{lstlisting}[caption={}]
# let composee(f,g) = function
  | x ->f(g(x));; 
  val composee : ('a -> 'b) * ('c -> 'a) -> 'c -> 'b = <fun>
\end{lstlisting}

\pause

Ici, $f$ est  toute fonction transformant un type de  variable $a$ en un
type de variable $b$ et $g$ une fonction transformant un type de  variable $c$ en un
type de variable $a$. La fonction composée transforme bien  un type de  variable $c$ en un
type de variable $b$.
\end{frame}



\begin{frame}[fragile]
  
Si nous reprenons la fonction définie précédemment~:

\pause

\begin{lstlisting}[caption={}]
# let carre = function
  | x -> x*.x;;
  val carre : float -> float = <fun>

# composee(sina,carre);;
- : float -> float = <fun>

# composee(sina,carre)(3.);;
- : float = 0.04579094280463962
\end{lstlisting}



\end{frame}







\section{If...then...else}


\begin{frame}[fragile]
  
On  peut   utiliser  une  structure  conditionnelle   pour  définir  une
fonction~:

\pause

\begin{lstlisting}[caption={}]
# let val_abs = function
  | x-> if x>=0 then x else -x;;
  val val_abs : int -> int = <fun>
\end{lstlisting}
\end{frame}



\begin{frame}[fragile]
  

ou bien 

\begin{lstlisting}[caption={}]
# let valeur_abs(x)=
     if x>=0 then x
     else -x;; 
    val valeur_abs : int -> int = <fun>
\end{lstlisting}


\end{frame}



\section{Fonctions récursives}




\begin{frame}[fragile]
  
C'est une fonction  construite à partir d'elle-même. On  utilise la même
syntaxe que pour  une fonction simple mais on  fait suivre le \verb+let+
d'un \verb+rec+.
\end{frame}


\begin{frame}[fragile]
  
\begin{lstlisting}[caption={}]
# let rec factorielle = function
  | 0 -> 1
  | n -> n*factorielle(n-1);;
    val factorielle : int -> int = <fun>

# let rec fact(n)=
      if n=0 then 1
      else n*fact(n);; 
    val fact : int -> int = <fun>
\end{lstlisting}
\end{frame}






\end{document}

%%% Local Variables: 
%%% TeX-master: t
%%% End: 
