File: ProfLycee-doc.tex

package info (click to toggle)
texlive-lang 2022.20230122-1
links: PTS, VCS
area: main
in suites: bookworm
size: 1,447,264 kB
sloc: perl: 61,377; xml: 53,781; makefile: 4,525; sh: 4,338; ansic: 2,892; python: 2,861; ruby: 1,031; lisp: 750; awk: 649; java: 159; sed: 142; csh: 25
file content (6359 lines) | stat: -rw-r--r-- 234,729 bytes
% !TeX TXS-program:compile = txs:///arara
% arara: lualatex: {shell: yes, synctex: no, interaction: batchmode}
% arara: pythontex: {rerun: always}
% arara: lualatex: {shell: yes, synctex: no, interaction: batchmode}
% arara: lualatex: {shell: yes, synctex: no, interaction: batchmode} if found('log', '(undefined references|Please rerun|Rerun to get)')

\documentclass{article}
\def\PLversion{2.1.6}
\def\PLdate{17 Janvier 2023}
\usepackage[pythontex]{ProfLycee}
\usepackage{mathtools}
\usepackage{lualatex-math}
\usepackage{luatexbase}
\usepackage[math-style=french,bold-style=ISO]{fourier-otf}
\usepackage{tkz-euclide}
\usepackage{tkz-tab}
\tikzstyle{every picture}+=[remember picture]
\usetikzlibrary{hobby}
\usepackage[group-minimum-digits=4]{siunitx}
\sisetup{locale=FR}
\usepackage{fancyvrb}
\usepackage{fancyhdr}
\usepackage{multicol}
%fancy
\fancyhf{}
\renewcommand{\headrulewidth}{0pt}
\lfoot{\sffamily \small [ProfLycee]}
\cfoot{\sffamily \small - \thepage{} -}
\rfoot{\hyperlink{matoc}{\small\faArrowAltCircleUp[regular]}}

\usepackage{graphics}
\usepackage{hvlogos}
\usepackage{simplekv}
\usepackage{menukeys}
\let\tab\relax
\usepackage{tabto}
\usepackage{pgf,pgfplots}
\pgfplotsset{compat=newest,xlabel near ticks,ylabel near ticks}
\usepackage{listofitems}
\usepackage{xintexpr}
\usepackage{codehigh}
\usepackage{scontents}
\usepackage{hyperref}
\urlstyle{same}
\hypersetup{pdfborder=0 0 0}
\usepackage{geometry}
\geometry{margin=1.5cm}
\usepackage[french]{babel}
\usepackage{newverbs}
\newverbcommand{\pverb}{\color{purple}}{}
\newverbcommand{\rverb}{\color{red}}{}
\newverbcommand{\vverb}{\color{ForestGreen}}{}
\newverbcommand{\averb}{\color{CadetBlue}}{}
\newverbcommand{\overb}{\color{orange}}{}
\newverbcommand{\bverb}{\color{blue}}{}
\setlength{\parindent}{0pt}
\definecolor{LightGray}{gray}{0.9}

\tcbset{vignettes/.style={%
	nobeforeafter,box align=base,boxsep=0pt,enhanced,sharp corners=all,rounded corners=southeast,%
	boxrule=0.75pt,left=7pt,right=1pt,top=0pt,bottom=0.25pt,%
	}
}
\tcbset{vignettelatex/.style={%
	fontupper={\vphantom{pf}\footnotesize\ttfamily},
	vignettes,%
	colframe=CadetBlue,coltitle=white,colback=CadetBlue!5,%
	overlay={\begin{tcbclipinterior}%
		\fill[fill=lightgray!50]($(interior.south west)$) rectangle node[rotate=90]{\tiny \sffamily{\textcolor{CadetBlue}{\scalebox{0.6}[0.75]{\textbf{\LaTeX}}}}} ($(interior.north west)+(5pt,0pt)$);%
	\end{tcbclipinterior}}
	}
}

\tcbset{vignetteMaJ/.style={%
	fontupper={\vphantom{pf}\footnotesize\ttfamily},
	vignettes,%
	colframe=ForestGreen!50!black,coltitle=white,colback=ForestGreen!25,%
	overlay={\begin{tcbclipinterior}%
		\fill[fill=ForestGreen!75]($(interior.south west)$) rectangle node[rotate=90]{\tiny \sffamily{\textcolor{Black}{\scalebox{0.85}[0.75]{\textbf{MàJ}}}}} ($(interior.north west)+(5pt,0pt)$);%
	\end{tcbclipinterior}}
	}
}

\newtcblisting{codetex}[1][]{%
	colback=white,colframe=red!75!black,title={\small \faCode} Code \LaTeX,fonttitle=\sffamily\bfseries,left=3pt,right=3pt,top=2pt,bottom=2pt,#1}

\newtcolorbox{codeattention}[1][]{%
	colback=Yellow!50,colframe=Yellow!50!Black,title={\small \faBomb} Attention,fonttitle=\sffamily\bfseries,left=3pt,right=3pt,top=2pt,bottom=2pt,#1}

\newtcolorbox{codesortie}[1][]{%
	colback=white,colframe=red!75!black,title={\small \faArrowAltCircleRight[regular]} Sortie \LaTeX,fonttitle=\sffamily\bfseries,left=3pt,right=3pt,top=2pt,bottom=2pt,#1}

\newtcolorbox{codeidee}[1][]{%
	colback=white,colframe=PeachPuff!75!black,title={\small \faLightbulb[regular]} Idée(s),fonttitle=\sffamily\bfseries,left=3pt,right=3pt,top=2pt,bottom=2pt,#1}

\newtcolorbox{codeinfo}[1][]{%
	colback=white,colframe=SteelBlue,title={\small \faPuzzlePiece} Information(s),fonttitle=\sffamily\bfseries,left=3pt,right=3pt,top=2pt,bottom=2pt,#1}

\newtcolorbox{codecles}[1][]{%
	colback=white,colframe=ForestGreen!75,title={\small \faPaperclip} Clés et options,fonttitle=\sffamily\bfseries,left=3pt,right=3pt,top=2pt,bottom=2pt,#1}

%petite vignette tex
\newcommand\ctex[1]{\tcbox[vignettelatex]{#1}}

%petite vignette màj
\newcommand\cmaj[1]{%
	{\tcbox[vignetteMaJ]{#1}\xspace}%
}

%gestion de la fenêtre v2 directement dans le tikzpicture
\tikzset{%
	xmin/.store in=\xmin,xmin/.default=-5,xmin=-5,
	xmax/.store in=\xmax,xmax/.default=5,xmax=5,
	ymin/.store in=\ymin,ymin/.default=-5,ymin=-5,
	ymax/.store in=\ymax,ymax/.default=5,ymax=5,
	xgrille/.store in=\xgrille,xgrille/.default=1,xgrille=1,
	xgrilles/.store in=\xgrilles,xgrilles/.default=0.5,xgrilles=0.5,
	ygrille/.store in=\ygrille,ygrille/.default=1,ygrille=1,
	ygrilles/.store in=\ygrilles,ygrilles/.default=0.5,ygrilles=0.5,
	xunit/.store in=\xunit,unit/.default=1,xunit=1,
	yunit/.store in=\yunit,unit/.default=1,yunit=1
}
\newcommand\tgrilles[1][ultra thin,lightgray]{%
	\draw[xstep=\xgrilles,ystep=\ygrilles,#1] (\xmin,\ymin) grid (\xmax,\ymax);%
}
\newcommand\tgrillep[1][thin,gray]{%
	\draw[xstep=\xgrille,ystep=\ygrille,#1] (\xmin,\ymin) grid (\xmax,\ymax);%
}

\newcommand\genfenetre{%
	%styles
	\tikzset{noeudexpl/.style={purple,font=\sffamily\small}}
	\tikzset{portionexpl/.style={orange,thick,<->,>=latex}}
	\tikzset{expl/.style={midway,inner sep=1pt,above right=0,orange,font=\sffamily\scriptsize,rotate=45}}
	\tikzset{coeffs/.style={CadetBlue!50!black,circle,draw=CadetBlue,thick,fill=CadetBlue!5,font=\small\ttfamily}}
	\tikzset{tangente/.style={teal,line width=1pt,dashed}}
	%grilles & axes
	\tgrilles[line width=0.3pt,lightgray!50]
	\tgrillep[line width=0.6pt,lightgray!50]
	\draw[line width=1.5pt,->,gray,>=latex] (\xmin,0)--(\xmax,0) ;
	\draw[line width=1.5pt,->,gray,>=latex] (0,\ymin)--(0,\ymax) ;
	\foreach \x in {0,1,...,10} {\draw[gray,line width=1.5pt] (\x,4pt) -- (\x,-4pt) ;}
	\foreach \y in {0,1,...,6} {\draw[gray,line width=1.5pt] (4pt,\y) -- (-4pt,\y) ;}
}

\newcommand\gennotice{%
	%notice
	\draw (0,1) node[noeudexpl,below] {point 1} ;
	\draw (4,3.667) node[noeudexpl,above] {point 2} ;
	\draw (7.5,1.75) node[noeudexpl,below] {point 3} ;
	\draw (9,2) node[noeudexpl,above] {point 4} ;
	\draw (10,0) node[noeudexpl,below] {point 5} ;
	\draw[portionexpl] (0,6)--(4,6) node[expl] {portion 1} ;
	\draw[portionexpl] (4,6)--(7.5,6) node[expl] {portion 2} ;
	\draw[portionexpl] (7.5,6)--(9,6) node[expl] {portion 3} ;
	\draw[portionexpl] (9,6)--(10,6) node[expl] {portion 4} ;
	\draw[orange,densely dashed,thick] (4,0)--(4,6) (7.5,0)--(7.5,6) (9,0)--(9,6) (10,0)--(10,6) ;
}

\newcommand\gentangentes{%
	%tangentes
	\draw[tangente] (0,1)--(1,1) ;
	\draw[tangente,domain=3:5] plot (\x,{-1/3*(\x-9)+2}) ;
	\draw[tangente] (6.5,1.75)--(8.5,1.75) ;
	\draw[tangente,domain=8:10] plot (\x,{-1/3*(\x-9)+2}) ;
	\draw[tangente,domain=9.5:10] plot (\x,{-10*(\x-10)+0}) ;%
}

\newcommand\listecoeffs[4]{%
	\draw (0,5.5) node[left,CadetBlue,font=\small\ttfamily] {Coeffs} ;
	\node[coeffs] at (2,5.5) {#1} ;
	\node[coeffs] at ({(4+7.5)/2},5.5) {#2} ;
	\node[coeffs] at ({(7.5+9)/2},5.5) {#3} ;
	\node[coeffs] at ({(9+10)/2},5.5) {#4} ;%
}

\title{%
\begin{minipage}{0.85\linewidth}
	\begin{tcolorbox}[colframe=yellow,colback=yellow!15]
		\begin{center}
			\begin{tabular}{c}
				\lstinline!ProfLycee!\\
				\\
				Quelques \textit{petites} commandes pour  \LaTeX{} (au lycée)
			\end{tabular}
		\end{center}
	\end{tcolorbox}
\end{minipage}
}
\author{
	\begin{tabular}{c}
		Cédric Pierquet\\
		{\ttfamily c pierquet -- at -- outlook . fr}
	\end{tabular}
}
\date{Version \PLversion{} -- \PLdate}

\newcommand\Cle[1]{{\bfseries\sffamily\textlangle #1\textrangle}}
\newcommand\deblst{{\tiny\faCode}~}

\begin{document}

\pagestyle{fancy}

\maketitle

\thispagestyle{empty}

{\sffamily{\bfseries Résumé} : Quelques commandes pour faciliter l'utilisation de \LaTeX{} pour les enseignants de mathématiques en lycée.}

\medskip

{\small\noindent%
{\deblst} résoudre, de manière approchée, des équations \\
{\deblst} tracer \textit{facilement} des repères/grilles/courbes\\
{\deblst} tracer  des courbes \textit{lisses} avec gestion des extrema et des dérivées\\
{\deblst} simuler une fenêtre de logiciel de calcul formel, une console d'exécution \\
{\deblst} présenter du code \textsf{python} ou \textsf{pseudocode} \\
{\deblst} tracer rapidement un pavé, un tétraèdre \\
{\deblst} simplifier des calculs sous forme fractionnaire, simplifier des racines \\
{\deblst} effectuer des calculs avec des suites récurrentes \\
{\deblst} créer la \textit{toile} pour une suite récurrente \\
{\deblst} afficher et utiliser un cercle trigo \\
{\deblst} afficher un petit schéma pour le signe d'une fonction affine ou d'un trinôme \\
{\deblst} travailler sur les statistiques à deux variables (algébriques et graphiques) \\
{\deblst} convertir entre bin/dec/hex avec détails \\
{\deblst} présenter un calcul de PGCD \\
{\deblst} créer un pixelart avec correction éventuelle \\
{\deblst} effectuer des calculs de probas (lois binomiale, exponentielle, de Poisson, normale) \\
{\deblst} créer des arbres de probas \og classiques \fg \\
{\deblst} générer des listes d'entiers aléatoires (avec ou sans répétitions)\\
{\deblst} déterminer la mesure principale d'un angle \\
{\deblst} \ldots}

~

\hfill{}\textsl{Merci à Anne pour ses retours et sa relecture !}

\hfill{}\textsl{Merci à Christophe pour ses retours et ses éclairages !}

\hfill{}\textsl{Merci aux membres du groupe \faFacebook{} du \og Coin \LaTeX{} \fg{} pour leur aide et leurs idées !}

\vfill

\hrule

\medskip

\begin{tblr}{width=\linewidth,colspec={X[c]X[c]X[c]X[c]X[c]X[c]},cells={font=\sffamily\LARGE}}
	{\LaTeX} & & & & &\\
	& {\pdfLaTeX} & & & & \\
	& & {\LuaLaTeX} & & & \\
	& & & {\TikZ} & & \\
	& & & & {\TeXLive} & \\
	& & & & & {\MiKTeX} \\
\end{tblr}

\medskip

\hrule

\vfill

~

\newpage

\phantomsection
\hypertarget{matoc}{}

\tableofcontents

\newpage

\part{Introduction}

\section{Le package ProfLycee}

\subsection{\og Philosophie \fg{} du package}

\begin{codeidee}
Ce \ctex{package}, très largement inspiré (et beaucoup moins abouti !) de l'excellent \ctex{ProfCollege} de C. Poulain et des excellents \ctex{tkz-*} d'A. Matthes, va définir quelques outils pour des situations particulières qui ne sont pas encore dans \ctex{ProfCollege}.

On peut le voir comme un (maigre) complément à \ctex{ProfCollege}, et je précise que la syntaxe est très proche (car pertinente de base) et donc pas de raison de changer une équipe qui gagne !

\medskip

Il se charge, dans le préambule, par \ctex{\textbackslash usepackage\{ProfLycee\}}. Il charge quelques {packages} utiles, mais j'ai fait le choix de laisser l'utilisateur gérer ses autres {packages}, comme notamment \ctex{amssymb} qui peut poser souci en fonction de la \textit{position} de son chargement.

L'utilisateur est libre de charger ses autres {packages} utiles et habituels, ainsi que ses \textsf{polices} et \textsf{encodages} habituels !
\end{codeidee}

\begin{codeinfo}
Le {package} \ctex{ProfLycee} charge les {packages} :

\begin{itemize}
	\item \ctex{xcolor} avec les options \textsf{[table,svgnames]} ;
	\item \ctex{tikz}, \ctex{pgf}, \ctex{pgffor} ;
	\item \ctex{xparse}, \ctex{xstring}, \ctex{simplekv}, \ctex{xinttools} ;
	\item \ctex{listofitems}, \ctex{xintexpr} , \ctex{xintbinhex}, \ctex{xintgcd} ;
	\item \ctex{tabularray}, \ctex{fontawesome5}, \ctex{tcolorbox}, \ctex{randomlist}, \ctex{fancyvrb}, \ctex{csvsimple} ;
	\item \ctex{piton} (uniquement si compilation en \LuaLaTeX{} !) et \ctex{pythontex}.
\end{itemize}
\end{codeinfo}

\begin{codeidee}
J'ai utilisé les {packages} de C. Tellechea, je vous conseille d'aller jeter un œil sur ce qu'il est possible de faire en \LaTeX{} avec \ctex{listofitems}, \ctex{randomlist}, \ctex{simplekv} ou encore \ctex{xstring} !
\end{codeidee}

\subsection{Chargement du package}

\begin{codetex}[listing only]
%exemple de chargement pour une compilation en (pdf)latex
\documentclass{article}
\usepackage{ProfLycee}
\usepackage[utf8]{inputenc}
\usepackage[T1]{fontenc}
\usepackage[french]{babel}
...
\end{codetex}

\begin{codetex}[listing only]
%exemple de chargement pour une compilation en (xe/lua)latex
\documentclass{article}
\usepackage{ProfLycee}
\usepackage{fontspec}
\usepackage[french]{babel}
...
\end{codetex}

\subsection{Options du package}

\begin{codeattention}
\cmaj{2.0.0} Une compilation \textsf{shell-escape} est recommandée pour l'utilisation de \ctex{ProfLycee}, notamment pour le package \ctex{minted} et la coloration syntaxique de code.

Cependant, si vous ne \underline{souhaitez pas} charger (et utiliser) \ctex{minted} vous pouvez charger le package \ctex{ProfLycee} avec l'option \Cle{nonshellescape}.
\end{codeattention}

\begin{codetex}[listing only]
...
\usepackage[nonshellescape]{ProfLycee}
%package <minted> et librairie <minted> non chargés
...
\end{codetex}

\begin{codeattention}
\cmaj{2.1.0} Le package\ctex{pythontex} nécessitant une chaîne de compilation particulière, j'ai décidé de le mettre en \textit{option}.

Pour utiliser le package \ctex{pythontex} et utiliser les commandes qui lui sont liées, il faut désormais charger \ctex{ProfLycee} avec l'option \Cle{pythontex}.
\end{codeattention}

\begin{codetex}[listing only]
...
\usepackage[pythontex]{ProfLycee}
...
\end{codetex}

\begin{codeinfo}
En compilant (notamment avec les packages \ctex{minted} et \ctex{pythontex}) on peut spécifier des répertoires particuliers pour les (ou des) fichiers auxiliaires.

Avec l'option \Cle{build}, l'utilisateur a la possibilité de placer les fichiers temporaires de \ctex{minted} et \ctex{pythontex} dans un répertoire \menu{build} du répertoire courant.

\smallskip

Dans ce cas il vaut mieux créer au préalable le répertoire \menu{build} avant de compiler un fichier !
\end{codeinfo}

\begin{codetex}[listing only]
...
\usepackage[build]{ProfLycee}
...
\end{codetex}

\begin{codeinfo}
Les options précédentes sont cumulables, et, pour info, elles conditionnent le chargement des {packages} avec les options :

\begin{itemize}
	\item \ctex{\textbackslash setpythontexoutputdir\{./build/pythontex-files-\textbackslash jobname\}}
	\item \ctex{\textbackslash RequirePackage[outputdir=build]\{minted\}}
\end{itemize}
\end{codeinfo}

\begin{codetex}[listing only]
...
%chargement de ProfLycee sans minted, et avec pythontex
\usepackage[pythontex,nonshellescape]{ProfLycee}
...
\end{codetex}

\pagebreak

\section{Compléments}

\subsection{Changements à partir de la version 2 !!}

\begin{codeattention}
\cmaj{2.0.0} Pour des raisons pratiques, les commandes et environnements disponibles dans \ctex{ProfLycee} ont été renommés, pour utiliser des noms plus génériques et explicites.

La nomenclature des \Cle{clés} a été également revue, avec -- dans la grande majorité des cas -- une majuscule en début.

\smallskip

Je préfère faire ces ajustements tant que le package est assez \textit{jeune} !
\end{codeattention}

\begin{codeattention}
\cmaj{2.0.0} L'ancienne version (qui ne sera mise à jour !!) du package \ctex{ProfLycee} est toutefois encore disponible, pour une migration en douceur, elle est désormais accessible sous le nom \ctex{ProfLycee-old}, et la documentation est également encore disponible.
\end{codeattention}

\begin{codetex}[listing only]
...
\usepackage[options]{ProfLycee-old} %nouveautés non disponibles par contre...
...
\end{codetex}

\subsection{Le système de \og clés/options \fg}

\begin{codeidee}
L'idée est de conserver -- autant que faire se peut -- l'idée de \Cle{Clés} qui sont :
%
\begin{itemize}
	\item modifiables ;
	\item définies (en majorité) par défaut pour chaque commande.
\end{itemize}

Pour certaines commandes, le système de \Cle{Clés} pose quelques soucis, de ce fait le fonctionnement est plus \textit{basique} avec un système d'\textsf{arguments} optionnels (entre \textsf{[\ldots]}) ou mandataires (entre \textsf{\{\ldots\}}).

\smallskip

À noter que les :
%
\begin{itemize}
	\item les \Cle{Clés} peuvent être mises dans n'importe quel ordre, elles peuvent être omises lorsque la valeur par défaut est conservée ;
	\item les \textsf{arguments} doivent, eux, être positionnés dans le \textit{bon ordre}.
\end{itemize}
\end{codeidee}

\begin{codeinfo}
Les \textsf{commandes} et \textsf{environnements} présentés seront explicités via leur \textsf{syntaxe} avec les \textsf{options/clés} ou \textsf{arguments}.

Autant que faire se peut, des exemples/illustrations/remarques seront proposés à chaque fois.

\smallskip

Les \textsf{codes} seront présentés dans des \textsf{boîtes} \textcolor{red!75!black}{{\small \faCode} Code \LaTeX}, si possible avec la \textsf{sortie} dans la même boîte, et sinon la \textsf{sortie} sera visible dans des \textsf{boîtes} \textcolor{red!75!black}{{\small \faArrowAltCircleRight[regular]} Sortie \LaTeX}.

Les \textsf{clés} ou \textsf{options} seront présentées dans des \textsf{boîtes} \textcolor{ForestGreen}{{\small \faPaperclip} Clés}.
\end{codeinfo}

%\subsection{Outils disponibles}
%
%\begin{codeidee}
%Le {package}, qui s'enrichira peut-être au fil du temps permet -- pour le moment -- de :
%
%\begin{itemize}
%	\item tracer des splines cubiques avec gestion \textit{assez fine} des tangentes ;
%	\item tracer des tangentes (ou portions) de tangentes sur la même base que pour les splines ;
%	\item simuler une fenêtre de logiciel formel (\textit{à la manière de} \textsf{XCas}) ;
%	\item mettre en forme du code \textsf{python} ou \textsf{pseudocode} ;
%	\item simuler une fenêtre de terminal (win/unix/osx) ;
%	\item créer un cartouche \textit{à la manière de} Capytale ;
%	\item créer rapidement un pavé droit ou un tétraèdre en \TikZ, avec gestion des nœuds ;
%	\item créer rapidement un ensemble d'éléments, avec gestion des espaces ;
%	\item créer, dans un environnement \TikZ, la \og toile \fg{} pour une suite récurrente :
%	\item etc
%\end{itemize}
%\end{codeidee}

\begin{codeinfo}
À noter que certaines commandes disponibles sont liées à un environnement \ctex{tikzpicture}, elles ne sont pas autonomes mais permettent de conserver -- en parallèle -- toute commande liée à \TikZ{} !
\end{codeinfo}

\pagebreak

\subsection{Compilateur(s)}

\begin{codeinfo}
Le package \ctex{ProfLycee} est compatible avec les compilateurs classiques : \textsf{latex}, \textsf{pdflatex} ou encore \textsf{lualatex}.

\smallskip

En ce qui concerne les codes \textsf{python}, il faudra :

\begin{itemize}
	\item compiler en chaîne \textsf{(xxx)latex + pythontex + (xxx)latex} pour les environnements avec \ctex{pythontex} ;
	\item compiler avec  \textsf{shell-escape} (ou \textsf{write18}) pour les environnements avec \ctex{minted}.
\end{itemize}
\end{codeinfo}

\begin{codeattention}
Certains commandes ou environnements nécessitent une compilation spécifique, qui sera indiquée clairement dans la documentation !
\end{codeattention}

\subsection{Problèmes éventuels\ldots}

\begin{codeinfo}
Certaines \textsf{commandes} sont à intégrer dans un environnement \TikZ, afin de pouvoir rajouter des éléments, elles ont été testés dans des environnement \ctex{tikzpicture}, à vérifier que la gestion des axes par l'environnement \ctex{axis} est compatible\ldots

\smallskip

Certains packages ont une fâcheuse tendance à être tatillons sur leurs options (les \textit{fameux} \textsf{option clash for} \ldots) ou leur \textit{position} dans le chargement, donc attention notamment au chargement de \ctex{xcolor} et de \ctex{amssymb} !

\smallskip

En dehors de cela, ce sont des tests multiples et variés qui permettront de détecter d'éventuels bugs !
\end{codeinfo}

\pagebreak

~

\vfill

%\hfill{\Huge $\leftrightsquigarrow$ Bonne(s) découverte(s) $\leftrightsquigarrow$}\hfill~

\hfill\tikz \draw (0,0) node[above right=0pt,inner sep=0pt,outer sep=0pt,rotate=25,scale=4] {$\leftrightsquigarrow$ Bonne(s) découverte(s) $\leftrightsquigarrow$} ;\hfill~

\vfill

~

\newpage

\part{Liste des commandes, par thème}

\begin{codeinfo}
\cmaj{2.0.0} Cette section contient un \textit{résumé} des différentes commandes et environnements disponibles dans \ctex{ProfLycee}.

Elles sont présentées de manière \textit{succincte}, mais elles sont présentées de manière \textit{détaillée} dans la suite de la documentation.
\end{codeinfo}

\begin{codetex}[listing only]
%Résolution approchée d'une équation f(x)=k
\ResolutionApprochee[clés]{équation}[macro]

%Présentation d'une solution par balayage (TVI)
\SolutionTVI[options]{fonction}{valeur}

%Calculer le terme d'une suite récurrente simple, toile pour une suite récurrente simple
\CalculTermeRecurrence[options]{fonction associée}
\ToileRecurrence[clés][options du tracé][option supplémentaire des termes]

%Mise en forme de la conclusion d'un seuil
\SolutionSeuil[options]{fonction associée}{seuil}
\end{codetex}

\begin{codetex}[listing only]
%fenêtre de repérage en tikz et courbe
\GrilleTikz[options][options grille ppale][options grille second.]
\AxesTikz[options] \AxexTikz[options]{valeurs} \AxeyTikz[options]{valeurs}
\FenetreSimpleTikz[options](opt axes)<opt axe Ox>{liste valx}<opt axe Oy>{liste valy}
\CourbeTikz[options]{fonction}{valxmin:valxmax}

%courbe d'interpolation, tangente, dans un environnement tikz
\SplineTikz[options]{liste}
\TangenteTikz[options]{liste}

%schémas pour le signe affine/trinôme, dans un environnement tikz
\MiniSchemaSignes[clés]
\MiniSchemaSignesTkzTab[options]{numligne}[échelle][décalage horizontal]
\end{codetex}

\begin{codetex}[listing only]
%présentation type calcul formel, dans un environnement tikz
\CalculFormelParametres[options]
\CalculFormelLigne[options]{commande}{résultat}

%présentation de code Python
\begin{CodePythonLst}(*)[largeur]{commandes tcbox}...\end{CodePythonLst}
\begin{CodePiton}[options]...\end{CodePiton}
\begin{CodePythontex}[options]...\end{CodePythontex}    %avec l'option [pythontex]
\begin{CodePythonMinted}(*)[largeur][options]...\end{CodePythonMinted}

%console Python avec l'option [pythontex]
\begin{ConsolePythontex}[options]...\end{ConsolePythontex}

%présentation de pseudocode
\begin{PseudoCode}(*)[largeur][options]...\end{PseudoCode}
\end{codetex}

\begin{codetex}[listing only]
%terminal OS
\begin{TerminalWin}[largeur]{clés}[options]...\end{TerminalWin}
\begin{TerminalUnix}[largeur]{clés}[options]...\end{TerminalUnix}
\begin{TerminalOSX}[largeur]{clés}[options]...\end{TerminalOSX}

%code Capytale
\CartoucheCapytale(*)[options]{code capytale}
\end{codetex}

\begin{codetex}[listing only]
%pavé et tétraèdre, dans un environnement tikz
\PaveTikz[options]
\TetraedreTikz[options]

%cercle trigo, dans un environnement tikz
\CercleTrigo[clés]
\end{codetex}

\begin{codetex}[listing only]
%paramètres d'une régression linéaire, nuage de points
\CalculsRegLin[clés]{listeX}{listeY}
\PointsRegLin[clés]{listeX}{listeY}

%stats à 2 variables, dans un environnement tikz
\GrilleTikz[options][options grille ppale][options grille second.]
\AxesTikz[options]
\AxexTikz[options]{valeurs} \AxeyTikz[options]{valeurs}
\FenetreTikz \OrigineTikz
\FenetreSimpleTikz[options](opt axes)<opt axe Ox>{liste valx}<opt axe Oy>{liste valy}
\NuagePointsTikz[options]{listeX}{listeY}
\PointMoyenTikz[options]
\CourbeTikz[options]{formule}{domaine}

%boîte à moustaches, dans un environnement tikz
\BoiteMoustaches[options]
\BoiteMoustachesAxe[options]
\end{codetex}

\begin{codetex}[listing only]
%loi binomiale B(n,p)
\CalcBinomP{n}{p}{k}
\CalcBinomC{n}{p}{a}{b}
\BinomP(*)[prec]{n}{p}{k}
\BinomC(*)[prec]{n}{p}{a}{b}

%loi de Poisson P(l)
\CalcPoissP{l}{k}
\CalcPoissC{l}{a}{b}
\PoissonP(*)[prec]{l}{k}
\PoissonC(*)[prec]{l}{a}{b}
\end{codetex}

\begin{codetex}[listing only]
%loi géométrique G(p)
\CalcGeomP{p}{k}
\CalcGeomC{l}{a}{b}
\GeomP{p}{k}
\GeomC{l}{a}{b}

%loi hypergéométrique H(N,n,m)
\CalcHypergeomP{N}{n}{m}{k}
\CalcHypergeomP{N}{n}{m}{a}{b}
\HypergeomP{N}{n}{m}{k}
\HypergeomC{N}{n}{m}{a}{b}
\end{codetex}

\begin{codetex}[listing only]
%loi normale N(m,s)
\CalcNormC{m}{s}{a}{b}
\NormaleC(*)[prec]{m}{s}{a}{b}

%loi exponentielle E(l)
\CalcExpoC{l}{a}{b}
\ExpoC(*)[prec]{l}{a}{b}

%arbres de probas
\ArbreProbasTikz[options]{donnees}
\begin{EnvArbreProbasTikz}[options]{donnees}...\end{EnvArbreProbasTikz}

%schémas lois continues
\LoiNormaleGraphe[options]<options tikz>{m}{s}{a}{b}
\LoiExpoGraphe[options]<options tikz>{l}{a}{b}
\end{codetex}

\begin{codetex}[listing only]
%entier aléatoire entre a et b
\NbAlea{a}{b}{macro}
%nombre décimal (n chiffres après la virgule) aléatoire entre a et b+1 (exclus)
\NbAlea[n]{a}{b}{macro}
%création d'un nombre aléatoire sous forme d'une macro
\VarNbAlea{macro}{calcul}
%liste d'entiers aléatoires
\TirageAleatoireEntiers[options]{macro}
\end{codetex}

\begin{codetex}[listing only]
%arrangement Anp
\Arrangement(*)[option]{p}{n}

%arrangement Cnp (p parmi n)
\Combinaison(*)[option]{p}{n}
\end{codetex}

\begin{codetex}[listing only]
%conversions
\ConversionDecBin(*)[clés]{nombre}
\ConversionBinHex[clés]{nombre}
\ConversionVersDec[clés]{nombre}
\ConversionBaseDix[clés]{nombre}{base de départ}
\ConversionDepuisBaseDix[options]{nombre en base 10}{base d'arrivée}

%PGCD présenté
\PresentationPGCD[options]{a}{b}
\end{codetex}

\begin{codetex}[listing only]
%conversion en fraction, simplification de racine
\ConversionFraction[option]{argument}
\SimplificationRacine{expression}

%ensemble d'éléments
\EcritureEnsemble[clés]{liste}

%trinôme, trinôme aléatoire
\EcritureTrinome[options]{a}{b}{c}

%mesure principale
\MesurePrincipale[options]{angle}
\end{codetex}

\begin{codetex}[listing only]
%pixelart, dans un environnement tikz
\PixelArtTikz[clés]{fichier.csv}

%sudomaths
\SudoMaths[options]{liste}
\begin{EnvSudoMaths}[options]{grille}...\end{EnvSudoMaths}
\end{codetex}

\newpage

\part{Outils pour l'analyse}

\section{Résolution approchée d'une équation}\label{resolapprox}

\subsection{Idée}

\begin{codeidee}
\cmaj{2.1.4} L'idée est de proposer une commande pour résoudre, de manière approchée, une équation du type $f(x)=k$ sur un intervalle (fermé) donné.

\smallskip

La méthode utilisée est la \textbf{dichotomie}, pour plus de rapidité que la méthode \textit{simple} par balayage.
\end{codeidee}

\begin{codetex}[listing only]
\ResolutionApprochee[clés]{équation}[macro]
\end{codetex}

\begin{codetex}[]
\ResolutionApprochee[Intervalle=0:10]{x**3-2*x**2-x-1=2}%
$x_0 \approx \num[minimum-decimal-digits=2]{\masolutiond}$ par défaut ;\\
$x_0 \approx \num[minimum-decimal-digits=2]{\masolutione}$ par excès ;\\
$x_0 \approx \num[minimum-decimal-digits=2]{\masolutiona}$ arrondi à $10^{-2}$.\\

\hfill\includegraphics[scale=0.45]{./graphics/pl-solve_a}\hfill~
\end{codetex}

\subsection{Clés et options}

\begin{codecles}
Quelques explications sur les \Cle{clés} et sur les arguments :

\begin{itemize}
	\item la clé \Cle{Précision} qui permet de spécifier le nombre de chiffres après la virgule de la solution ; \hfill{}défaut \Cle{2}
	\item la clé (obligatoire !) \Cle{Intervalle} qui permet de préciser l'intervalle initial de recherche ;
	\item la clé \Cle{Variable} qui permet de spécifier la variable de l'équation ;\hfill{}défaut \Cle{x}
	\item l'argument \textit{mandataire} est l'équation, sous la forme $f(\ldots)=k$ (ou $f(\ldots)$ pour $f(\ldots)=0$) ;
	\item l'argument \textit{optionnel} est la base de la \textit{<macro>} qui sert à stocker les valeurs :\hfill{}défaut \Cle{masolution}
	\begin{itemize}
		\item \ctex{\textbackslash<macro>d} pour la valeur approchée par défaut ;
		\item \ctex{\textbackslash<macro>e} pour la valeur approchée par excès ;
		\item \ctex{\textbackslash<macro>a} pour la valeur approchée.
	\end{itemize}
\end{itemize}
\end{codecles}

\begin{codetex}[]
\ResolutionApprochee[Precision=4,Intervalle=0:2]{exp(0.5*x)+x**2-4=0}%
Une valeur approchée, à $10^{-4}$ près, d'une solution de $\text{e}^{0,5x}+x^2-4=0$ sur $\left[0;2\right]$ est $\beta$ avec :
\begin{itemize}
	\item $\beta \approx \num[minimum-decimal-digits=4]{\masolutiond}$ par défaut ;
	\item $\beta \approx \num[minimum-decimal-digits=4]{\masolutione}$ par excès ;
	\item $\beta \approx \num[minimum-decimal-digits=4]{\masolutiona}$.
\end{itemize}
\ResolutionApprochee[Variable=t,Intervalle=-1:2]{3*t*exp(-0.5*t+1)=4}[SolA]%
Une valeur approchée, à $10^{-2}$ près d'une solution de $3t\,\rm{e}^{-0,5t+1}=4$ est $t_1$ avec :
\begin{itemize}
	\item $t_1 \approx \num[minimum-decimal-digits=2]{\SolAd}$ par défaut ;
	\item $t_1 \approx \num[minimum-decimal-digits=2]{\SolAe}$ par excès ;
	\item $t_1 \approx \num[minimum-decimal-digits=2]{\SolAa}$.
\end{itemize}
\ResolutionApprochee[Precision=3,Variable=t,Intervalle=2:10]{3*t*exp(-0.5*t+1)=4}[SolB]%
Une valeur approchée, à $10^{-2}$ près d'une solution de $3t\,\text{e}^{-0,5t+1}=4$ est $t_2$ avec :
\begin{itemize}
	\item $t_2 \approx \num[minimum-decimal-digits=2]{\SolBd}$ par défaut ;
	\item $t_2 \approx \num[minimum-decimal-digits=2]{\SolBe}$ par excès ;
	\item $t_2 \approx \num[minimum-decimal-digits=2]{\SolBa}$.
\end{itemize}

\medskip

\hfill\includegraphics[scale=0.45]{./graphics/pl-solve_b}~~
\includegraphics[scale=0.45]{./graphics/pl-solve_c}~~
\includegraphics[scale=0.45]{./graphics/pl-solve_d}\hfill~
\end{codetex}

\newpage

\section{Présentation d'une solution d'équation par balayage}\label{solutiontvi}

\subsection{Idée}

\begin{codeidee}
\cmaj{2.0.4} L'idée est de présenter l'obtention d'une solution approchée d'équation par balayage, dans le cadre du TVI par exemple. Les calculs et tests sont effectués grâce au package \ctex{xinttools}, et le formatage par \ctex{tabularray} et \ctex{sinuitx}.
\end{codeidee}

\begin{codeattention}
Le code ne trouve pas la solution, il met \textit{juste} en forme mais effectue quand même les calculs d'images et les tests.
\end{codeattention}

\begin{codetex}[listing only]
\SolutionTVI[options]{fonction}{valeur}
\end{codetex}

\subsection{Clés et arguments}

\begin{codecles}
Plusieurs \Cle{Clés} sont disponibles pour cette commande, relative donc à une équation du type $f(x)=k$ :

\begin{itemize}
	\item la clé \Cle{NomFct} qui permet de spécifier le nom de la fonction ;\hfill{}défaut \Cle{f}
	\item la clé \Cle{NomSol} qui permet de spécifier le nom de la fonction ;\hfill{}défaut \Cle{\textbackslash{}alpha}
	\item les clés \Cle{va} et \Cle{vb} qui sont les bornes inférieure et supérieure de l'encadrement ;
	\item la clé \Cle{Precision} qui est la précision des calculs pour les images ;\hfill{}défaut \Cle{2}
	\item la clé \Cle{Stretch} qui permet d'espacer les lignes ;\hfill{}défaut \Cle{1.15}
	\item les booléens \Cle{Balayage} ou \Cle{Calculatrice} pour afficher un texte en amont ;\hfill{}défaut \Cle{false}
	%\item le booléen \Cle{Simple} pour une présentation plus \textit{neutre} ;\hfill{}défaut \Cle{false}
	\item le booléen \Cle{Majuscule} qui affiche le texte avant, avec une majuscule au début.\hfill{}défaut \Cle{true}
\end{itemize}

\smallskip

Le premier argument mandataire est la fonction, en syntaxe \ctex{xint} et avec comme variable $x$, et le second la valeur de $k$.
\end{codecles}

\begin{codetex}[]
Pour $f(x)=0$ avec $f(x)=x^2-2$. On obtient \SolutionTVI[va=1.414,vb=1.415,Precision=3]{x**2-2}{0}.
\end{codetex}

\begin{codetex}[]
Avec $\varphi(t)=3t\,\rm{e}^{-0,5t+1}=5$,
\SolutionTVI[Majuscule=false,Calculatrice,va=1.02,vb=1.03,NomFct=\varphi]{3*x*exp(-0.5*x+1)}{5}
\end{codetex}

\begin{codetex}[]
On s'intéresse à $g(x)=\num{1,5}$ avec $g(x)=\ln(x)$.
\SolutionTVI[Balayage,Stretch=1.5,va=4.48,vb=4.49,NomFct=g,Precision=4,NomSol={x_0}]{log(x)}{1.5}.
\end{codetex}

\subsection{Interaction avec la commande de résolution approchée}

\begin{codeidee}
\cmaj{2.1.4} L'idée est de récupérer les valeurs par défaut et par excès pour le TVI grâce à la commande \ctex{\textbackslash ResolutionApprochee}.
\end{codeidee}

\begin{codetex}[]
On s'intéresse à $g(x)=\num{1,5}$ avec $g(x)=\ln(x)$ sur l'intervalle $\left[3;5\right]$.

\ResolutionApprochee[Intervalle=3:5]{log(x)=1.5}[SolLn]
\SolutionTVI[Balayage,Stretch=1.5,va={\SolLnd},vb={\SolLne},NomFct=g,Precision=4,NomSol={x_0}]{log(x)}{1.5}.
\end{codetex}

\begin{codeinfo}
À terme, peut-être que la commande \ctex{\textbackslash ResolutionApprochee} sera intégrée dans la commande \ctex{\textbackslash SolutionTVI} afin d'automatiser encore plus le procédé.
\end{codeinfo}

\newpage

\section{Suites récurrentes simples}\label{calcrecurr}

\subsection{Idées}

\begin{codeidee}
\cmaj{2.0.3} L'idée est de proposer des commandes pour effectuer des calculs avec des suites récurrentes du type $u_{n+1}=f\big(u_n\big)$ :

\begin{itemize}
	\item calcul de termes avec possibilité d'arrondir ;
	\item présentation de la conclusion de la recherche d'un seuil du type $u_n > S$ ou $u_n < S$.
\end{itemize}
\end{codeidee}

\begin{codeattention}
\cmaj{2.1.0} Le code pour le seuil \textbf{trouve} également le rang cherché, il met en forme et effectue les calculs d'images.

\smallskip

\cmaj{2.0.5} Le choix a été fait de faire les calculs en mode \ctex{float} pour éviter les dépassements de capacité de \ctex{xint} liés aux boucles\ldots
\end{codeattention}

\begin{codetex}[listing only]
%commande pour calculer et formater
\CalculTermeRecurrence[options]{fonction associée}

%mise en forme de la conclusion d'un seuil
\SolutionSeuil[options]{fonction associée}{seuil}
\end{codetex}

\subsection{Clés et arguments}

\begin{codecles}
Plusieurs \Cle{Clés} sont disponibles pour la commande du calcul d'un terme :

\begin{itemize}
	\item la clé \Cle{No} qui est le rang initial de la suite ;
	\item la clé \Cle{UNo} qui est le terme initial de la suite ;
	\item la clé \Cle{Precision} qui précise l'arrondi éventuel ;\hfill{}défaut \Cle{3}
	\item la clé \Cle{N} qui est l'indice du terme à calculer.
\end{itemize}

\smallskip

L'argument mandataire est la fonction associée à la suite, en syntaxe \ctex{xint} et avec comme variable $x$.
\end{codecles}

\begin{codetex}[listing only]
Avec $\begin{dcases} u_0 = 50 \\ u_{n+1}=\dfrac{1}{u_n+2} \end{dcases}$.

On obtient $u_{10} \approx \CalculTermeRecurrence[No=0,UNo=50,N=10]{1/(x+2)}$.

On obtient $u_{15} \approx \CalculTermeRecurrence[Precision=4,No=0,UNo=50,N=15]{1/(x+2)}$.

On obtient $u_{20} \approx \CalculTermeRecurrence[Precision=6,No=0,UNo=50,N=20]{1/(x+2)}$.
\end{codetex}

\begin{codesortie}
Avec $u_0 = 50$ et $u_{n+1}=\dfrac{1}{u_n+2}$.

\smallskip

On obtient $u_{10} \approx \CalculTermeRecurrence[No=0,UNo=50,N=10]{1/(x+2)}$ \hfill~sortie par défaut.

\smallskip

On obtient $u_{15} \approx \CalculTermeRecurrence[Precision=4,No=0,UNo=50,N=15]{1/(x+2)}$  \hfill~avec choix de la précision à $10^{-4}$.

\smallskip

On obtient $u_{20} \approx \CalculTermeRecurrence[Precision=6,No=0,UNo=50,N=20]{1/(x+2)}$ \hfill~avec choix de la précision à $10^{-6}$.
\end{codesortie}

\begin{codecles}
Plusieurs \Cle{Clés} sont disponibles pour la commande du seuil :

\begin{itemize}
	\item la clé \Cle{NomSuite} qui est le nom de la suite ;\hfill~défaut \Cle{u}
	\item la clé \Cle{No} qui est le rang initial de la suite ;
	\item la clé \Cle{UNo} qui est le terme initial de la suite ;
	%\item la clé \Cle{SolN} qui est la valeur de l'indice cherché ;
	\item la clé \Cle{Precision} qui précise l'arrondi éventuel ;\hfill{}défaut \Cle{2}
	\item la clé \Cle{Stretch} qui permet d'espacer les lignes ;\hfill{}défaut \Cle{1.15}
	\item les booléens \Cle{Balayage} ou \Cle{Calculatrice} pour afficher un texte en amont ;\hfill{}défaut \Cle{false}
	\item le booléen \Cle{Simple} pour une présentation plus \textit{neutre} ;\hfill{}défaut \Cle{false}
	\item le booléen \Cle{Majuscule} qui affiche le texte avant, avec une majuscule au début ;\hfill{}défaut \Cle{true}
	\item le booléen \Cle{Exact} qui affiche \ctex{=} au lieu de \ctex{\textbackslash approx} ;\hfill{}défaut \Cle{false}
	\item le booléen \Cle{Conclusion} pour afficher la conclusion ou non ;\hfill{}défaut \Cle{true}
	\item la clé \Cle{Sens} parmi \Cle{< / > / <= / >=} pour indiquer le type de seuil.\hfill{}défaut \Cle{>}
\end{itemize}

\smallskip

Le premier argument mandataire est la fonction associée à la suite, en syntaxe \ctex{xint} et avec comme variable $x$, et le second est le seuil à dépasser.
\end{codecles}

\begin{codetex}[]
Avec $\begin{dcases} u_1 = 2 \\ u_{n+1}=1+\dfrac{1+u_n^2}{1+u_n} \end{dcases}$,
on cherche $n$ tel que $u_n > 5$.\\
\SolutionSeuil[Balayage,No=1,UNo=2]{1+(1+x**2)/(1+x)}{5}.
~\SolutionSeuil[Calculatrice,Precision=4,No=1,UNo=2,Conclusion=false]{1+(1+x**2)/(1+x)}{5}.\\
\end{codetex}

\subsection{Exemple d'utilisation}

\begin{codetex}[]
Avec $\begin{dcases} u_1 = 2 \\ u_{n+1}=1+\dfrac{1+u_n^2}{1+u_n} \end{dcases}$,
on obtient le tableau de valeurs suivant : 
\begin{tabular}{c|c}
	$n$ & $u_n$ \\ \hline
	1 & 2 \\
	\xintFor* #1 in {\xintSeq{2}{8}} \do {#1 & \CalculTermeRecurrence[No=1,UNo=2,N=#1]{1+(1+x**2)/(1+x)} \\}
\end{tabular}\\

\SolutionSeuil[Precision=4,No=1,UNo=2,Simple]{1+(1+x**2)/(1+x)}{10} (Ainsi $u_n > 10$ à partir de $n=\the\CompteurSeuil$)
\end{codetex}

\newpage

\part{Outils graphiques, via \TikZ}

\section{Repérage et tracé de courbes, en \TikZ}\label{reperagetikz}

\subsection{Idée}

\begin{codeidee}
\cmaj{2.1.1} L'idée est de proposer des commandes \textit{simplifiées} pour tracer un repère, en \TikZ, avec :

\begin{itemize}
	\item axes et graduations, grille ;
	\item courbe.
\end{itemize}
\end{codeidee}

\begin{codeinfo}
Au niveau du code, il y aura donc plusieurs \textit{aspects} :

\begin{itemize}
	\item le paramétrage de la fenêtre graphique directement dans la déclaration de l'environnement ;
	\item les commandes de tracés avec options et clés.
\end{itemize}
\end{codeinfo}

\begin{codetex}[listing only]
%version basique
\begin{tikzpicture}[paramètres]
	%grille et axes
	\GrilleTikz[options][options grille ppale][options grille second.]
	\AxesTikz[options]
	\AxexTikz[options]{valeurs}
	\AxeyTikz[options]{valeurs}
	%courbe
	\CourbeTikz[options]{fonction}{valxmin:valxmax}
\end{tikzpicture}
\end{codetex}

\begin{codetex}[listing only]
%version simplifiée
\begin{tikzpicture}[<paramètres>]
	%grille et axes
	\FenetreSimpleTikz[opt](opt axes)<opt axe Ox>{liste valx}<opt axe Oy>{liste valy}
	%courbe
	\CourbeTikz[options]{fonction}{valxmin:valxmax}
\end{tikzpicture}
\end{codetex}

\begin{codesortie}
\begin{tikzpicture}%
	[x=0.1cm,y=0.0167cm, %unités
	xmin=0,xmax=60,xgrille=5,xgrilles=5, %axe Ox
	ymin=0,ymax=240,ygrille=30,ygrilles=30] %axe Oy
	\FenetreSimpleTikz<Police=\small>{0,5,...,55}<Police=\small>{0,30,...,210} %repère
	\CourbeTikz[line width=1.25pt,ForestGreen,samples=250]%
		{\x*\x*exp(-0.05*\x)+1}{0:60} %courbe
\end{tikzpicture}
\end{codesortie}

\pagebreak

\subsection{Commandes, clés et options}

\begin{codeinfo}
Les \Cle{paramètres} nécessaires à la bonne utilisation des commandes suivantes sont à déclarer directement dans l'environnement \ctex{tikzpicture}, seules les versions \og x \fg{}  sont présentées ici:

\begin{itemize}
	\item \Cle{xmin}, stockée dans \ctex{\textbackslash{}xmin} ;\hfill{}défaut \Cle{-3}
	\item \Cle{xmax}, stockée dans \ctex{\textbackslash{}xmax} ;\hfill{}défaut \Cle{3}
	\item \Cle{Ox}, stockée dans \ctex{\textbackslash{}axexOx}, origine de l'axe $(Ox)$ ;\hfill{}défaut \Cle{0}
	\item \Cle{xgrille}, stockée dans \ctex{\textbackslash{}xgrille}, graduation principale ;\hfill{}défaut \Cle{1}
	\item \Cle{xgrilles}, stockée dans \ctex{\textbackslash{}xgrilles}, graduation secondaire.\hfill{}défaut \Cle{0.5}
\end{itemize}

La fenêtre d'affichage (de sortie) sera donc \textit{portée} par le rectangle de coins $(\text{xmin}\,;\,\text{ymin})$ et $(\text{xmax}\,;\,\text{ymax})$ ; ce qui correspond en fait à la fenêtre \TikZ{} \textit{portée} par le rectangle de coins $(\text{xmin-Ox}\,;\,\text{ymin-Oy})$ et $(\text{xmax-Ox}\,;\,\text{ymax-Oy})$.

\smallskip

Les commandes ont -- pour certaines -- pas mal de \Cle{clés} pour des réglages fins, mais dans la majorité des cas elles ne sont pas forcément \textit{utiles}.
\end{codeinfo}

\begin{codetex}[listing only]
%...code tikz
\GrilleTikz[options][options grille ppale][options grille second.]
\end{codetex}

\begin{codecles}
Cette commande permet de tracer une grille principale et/ou une grille secondaire :

\begin{itemize}
	\item les premières \Cle{clés} sont les booléens \Cle{Affp} et \Cle{Affs} qui affichent ou non les grilles ;\hfill~défaut \Cle{true}
	\item les options des grilles sont en \TikZ. \hfill~défaut \Cle{thin,lightgray} et \Cle{very thin,lightgray}
\end{itemize}
\end{codecles}

\begin{codetex}[listing only]
\begin{tikzpicture}%
	[x=0.1cm,y=0.0167cm, %unités
	xmin=0,xmax=60,xgrille=5,xgrilles=5, %axe Ox
	ymin=0,ymax=240,ygrille=30,ygrilles=30] %axe Oy
	\GrilleTikz
\end{tikzpicture}
~~
\begin{tikzpicture}%
	[x=0.1cm,y=0.0167cm, %unités
	xmin=0,xmax=60,xgrille=5,xgrilles=5, %axe Ox
	ymin=0,ymax=240,ygrille=30,ygrilles=30] %axe Oy
	\GrilleTikz[Affp=false][][orange,densely dotted]
\end{tikzpicture}
\end{codetex}

\begin{codesortie}
\hfill~
\begin{tikzpicture}%
	[x=0.1cm,y=0.0167cm, %unités
	xmin=0,xmax=60,xgrille=5,xgrilles=5, %axe Ox
	ymin=0,ymax=240,ygrille=30,ygrilles=30] %axe Oy
	\GrilleTikz
\end{tikzpicture}
~~
\begin{tikzpicture}%
	[x=0.1cm,y=0.0167cm, %unités
	xmin=0,xmax=60,xgrille=5,xgrilles=5, %axe Ox
	ymin=0,ymax=240,ygrille=30,ygrilles=30] %axe Oy
	\GrilleTikz[Affp=false][][orange,densely dotted]
\end{tikzpicture}
\hfill~
\end{codesortie}

\begin{codetex}[listing only]
%...code tikz
\AxesTikz[options]
\end{codetex}

\begin{codecles}
Cette commande permet de tracer les axes, avec des \Cle{clés} :

\begin{itemize}
	\item \Cle{Epaisseur} qui est l'épaisseur des axes ; \hfill~défaut \Cle{1pt}
	\item \Cle{Police} qui est le style des labels des axes  ; \hfill~défaut \Cle{\textbackslash{}normalsize\textbackslash{}normalfont}
	\item \cmaj{2.1.2} \Cle{ElargirOx} qui est le \% l'élargissement \Cle{global} ou \Cle{G/D} de l'axe $(Ox)$ ;\hfill~défaut \Cle{0/0.05}
	\item \cmaj{2.1.2} \Cle{ElargirOy} qui est le \% l'élargissement \Cle{global} ou \Cle{B/H} de l'axe $(Oy)$ ;\hfill~défaut \Cle{0/0.05}
	\item \Cle{Labelx} qui est le label de l'axe $(Ox)$ ; \hfill~défaut \Cle{\${}x\$}
	\item \Cle{Labely} qui est le label de l'axe $(Oy)$ ; \hfill~défaut \Cle{\${}y\$}
	\item \Cle{AffLabel} qui est le code pour préciser quels labels afficher, entre \Cle{x}, \Cle{y} ou \Cle{xy} ; \hfill~défaut \Cle{vide}
	\item \Cle{PosLabelx} pour la position du label de $(Ox)$ en bout d'axe ; \hfill~défaut \Cle{right}
	\item \Cle{PosLabely} pour la position du label de $(Oy)$ en bout d'axe ; \hfill~défaut \Cle{above}
	\item \Cle{EchelleFleche} qui est l'échelle de la flèche des axes ; \hfill~défaut \Cle{1}
	\item \Cle{TypeFleche} qui est le type de la flèche des axes.\hfill~défaut \Cle{latex}
\end{itemize}
\end{codecles}

\begin{codetex}[listing only]
%code tikz
\AxesTikz

%code tikz
\AxesTikz%
	[AffLabel=xy,Labelx={Nombre de jours},Labely={Nombre d'individus infectés, en centaines},%
	PosLabelx={above left},PosLabely={above right},%
	Police=\small\sffamily,ElargirOx=0,ElargirOy=0]
\end{codetex}

\begin{codesortie}
\hfill~
\begin{tikzpicture}%
	[x=0.1cm,y=0.0167cm, %unités
	xmin=0,xmax=60,xgrille=5,xgrilles=5, %axe Ox
	ymin=0,ymax=240,ygrille=30,ygrilles=30] %axe Oy
	\AxesTikz
\end{tikzpicture}
~~
\begin{tikzpicture}%
	[x=0.1cm,y=0.0167cm, %unités
	xmin=0,xmax=60,xgrille=5,xgrilles=5, %axe Ox
	ymin=0,ymax=240,ygrille=30,ygrilles=30] %axe Oy
	\AxesTikz%
	[AffLabel=xy,Labelx={Nombre de jours},
	Labely={Nombre d'individus infectés, en centaines},%
	PosLabelx={above left},PosLabely={above right},%
	ElargirOx=0,ElargirOy=0,
	Police=\small\sffamily]
\end{tikzpicture}
\hfill~
\end{codesortie}

%les axes

\begin{codetex}[listing only]
%...code tikz
\AxexTikz[options]{valeurs}
\AxeyTikz[options]{valeurs}
\end{codetex}

\begin{codecles}
Ces commande permet de tracer les graduations des axes, avec des \Cle{clés} identiques pour les deux directions :

\begin{itemize}
	\item \Cle{Epaisseur} qui est l'épaisseur des graduations ; \hfill~défaut \Cle{1pt}
	\item \Cle{Police} qui est le style des labels des graduations ; \hfill~défaut \Cle{\textbackslash{}normalsize\textbackslash{}normalfont}
	\item \Cle{PosGrad} qui est la position des graduations par rapport à l'axe ; \hfill~défaut \Cle{below} et \Cle{left}
	\item \Cle{HautGrad} qui est la position des graduations (sous la forme \Cle{lgt} ou \Cle{lgta/lgtb}) ; \hfill~défaut \Cle{4pt}
	\item le booléen \Cle{AffGrad} pour afficher les valeurs (formatés avec \ctex{num} donc dépendant de \ctex{sisetup}) des graduations  ; \hfill~défaut \Cle{true}
	\item le booléen \Cle{AffOrigine} pour afficher la graduation de l'origine ; \hfill~défaut \Cle{true}
	\item le booléen \Cle{Annee} qui permet de ne pas formater les valeurs des graduations (type \textsf{année}). \hfill~défaut \Cle{false}
\end{itemize}
\end{codecles}

\begin{codetex}[listing only]
%code tikz
\AxexTikz[Police=\small]{0,5,...,55}
\AxeyTikz[Police=\small]{0,30,...,210}

%code tikz
\AxexTikz[Police=\small,HautGrad=0pt/4pt]{0,5,...,55}
\AxeyTikz[AffGrad=false,HautGrad=6pt]{0,30,...,210}

%des axes fictifs (en gris) sont rajoutés pour la lisibilité du code de sortie
\end{codetex}

\begin{codesortie}
\hfill~
\begin{tikzpicture}%
	[x=0.1cm,y=0.0167cm, %unités
	xmin=0,xmax=60,xgrille=5,xgrilles=5, %axe Ox
	ymin=0,ymax=240,ygrille=30,ygrilles=30] %axe Oy
	\draw[gray,line width=1.25pt,->,>=latex] ({\xmin-\axexOx},0) -- ({\xmax-\axexOx},0) ;
	\draw[gray,line width=1.25pt,->,>=latex] (0,{\ymin-\axeyOy}) -- (0,{\ymax-\axeyOy}) ;
	\AxexTikz[Police=\small]{0,5,...,55}
	\AxeyTikz[Police=\small]{0,30,...,210}
\end{tikzpicture}
~~
\begin{tikzpicture}%
	[x=0.1cm,y=0.0167cm, %unités
	xmin=0,xmax=60,xgrille=5,xgrilles=5, %axe Ox
	ymin=0,ymax=240,ygrille=30,ygrilles=30] %axe Oy
	\draw[gray,line width=1.25pt,->,>=latex] ({\xmin-\axexOx},0) -- ({\xmax-\axexOx},0) ;
	\draw[gray,line width=1.25pt,->,>=latex] (0,{\ymin-\axeyOy}) -- (0,{\ymax-\axeyOy}) ;
	\AxexTikz[Police=\small,HautGrad=0pt/4pt]{0,5,...,55}
	\AxeyTikz[AffGrad=false,HautGrad=6pt]{0,30,...,210}
\end{tikzpicture}
\hfill~
\end{codesortie}

\subsection{Commandes annexes}

\begin{codeinfo}
Il existe, de manière marginale, quelques commandes complémentaires qui ne seront pas trop détaillées mais qui sont existent :

\begin{itemize}
	\item \ctex{FenetreTikz} qui restreint les tracés à la fenêtre (utile pour des courbes qui \textit{débordent}) ;
	\item \ctex{FenetreSimpleTikz} qui permet d'automatiser le tracé des grilles/axes/graduations dans leurs versions par défaut, avec peu de paramétrages ;
	\item \ctex{OrigineTikz} pour rajouter le libellé de l'origine si non affiché par les axes.
\end{itemize}
\end{codeinfo}

\begin{codetex}[listing only]
%code tikz
\FenetreTikz                %on restreint les tracés
\FenetreSimpleTikz%
	[options](opt axes)<opt axe Ox>{valeurs Ox}<opt axe Oy>{valeurs Oy}
\end{codetex}

\begin{codeidee}
L'idée est de proposer, en \textit{complément}, une commande simplifiée pour tracer une courbe en \TikZ.
\end{codeidee}

\begin{codetex}[listing only]
%...code tikz
\CourbeTikz[options]{formule}{domaine}
\end{codetex}

\begin{codecles}
Cette commande permet de rajouter une courbe sur le graphique (sans se soucier de la transformation de son expression) avec les arguments :

\begin{itemize}
	\item \Cle{optionnels} qui sont - en \TikZ{} - les paramètres du tracé ;
	\item le premier mandataire, est - en langage \TikZ{} - l'expression de la fonction à tracer, donc avec \ctex{\textbackslash{}x} comme variable ;
	\item le second mandataire est le domaine du tracé , sous la forme \ctex{valxmin:valxmax}.
\end{itemize}
\end{codecles}

\begin{codetex}[listing only]
\begin{tikzpicture}[x=0.1cm,y=0.0167cm, %unités
	xmin=0,xmax=60,xgrille=5,xgrilles=5, %axe Ox
	ymin=0,ymax=240,ygrille=30,ygrilles=30] %axe Oy
	\FenetreSimpleTikz%
		<Police=\small>{0,5,...,60}%
		<Police=\small>{0,30,...,240} %repère
	\CourbeTikz[line width=1.25pt,ForestGreen,samples=250]%
		{\x*\x*exp(-0.05*\x)+1}{0:60} %courbe
\end{tikzpicture}
\end{codetex}

\begin{codesortie}
\begin{tikzpicture}%
	[x=0.1cm,y=0.0167cm, %unités
	xmin=0,xmax=60,xgrille=5,xgrilles=5,ymin=0,ymax=240,ygrille=30,ygrilles=30]
	\FenetreSimpleTikz%
		<Police=\small>{0,5,...,60}<Police=\small>{0,30,...,240} %repère
	\CourbeTikz[line width=1.25pt,ForestGreen,samples=250]%
		{\x*\x*exp(-0.05*\x)+1}{0:60} %courbe
\end{tikzpicture}
\end{codesortie}

\subsection{Repère non centré en O}

\begin{codeidee}
Parfois on est amené à travailler dans des repères qui n'ont pas forcément pour origine $(0\,;\,0)$. De ce fait - pour éviter des erreurs de \ctex{dimension too large} liées à \TikZ{} - il faut \textit{décaler les axes} pour se ramener à une origine en $O$.

\smallskip

L'idée est donc d'utiliser les commandes précédentes, sans se soucier des éventuelles translations à effectuer !
\end{codeidee}

\begin{codetex}[]
\begin{tikzpicture}[x=0.35cm,y=0.07cm,Ox=1992,xmin=1992,xmax=2010,%
	xgrille=2,xgrilles=1,Oy=1640,ymin=1640,ymax=1710,ygrille=10,ygrilles=5]
	\FenetreSimpleTikz<Annee,Police=\small>{1992,1994,...,2008}{1640,1650,...,1700}
	\FenetreTikz
	\CourbeTikz%
		[line width=1.25pt,orange,samples=500]{-(\x-2000)*(\x-2000)+1700}{\xmin:\xmax}
\end{tikzpicture}
\end{codetex}

\pagebreak

\section{L'outil \og SplineTikz \fg}

\subsection{Courbe d'interpolation}

\begin{codeinfo}
On va utiliser les notions suivantes pour paramétrer le tracé \og automatique \fg{} grâce à  \ctex{..controls} :
%
\begin{itemize}
	\item il faut rentrer les \textcolor{purple}{\textsf{points de contrôle}} ;
	\item il faut préciser les \textcolor{ForestGreen}{\textsf{pentes des tangentes}} (pour le moment on travaille avec les mêmes à gauche et à droite\ldots) ;
	\item on peut \og affiner \fg{} les portions de courbe en paramétrant des \textcolor{CadetBlue}{\textsf{coefficients}} (voir un peu plus loin\ldots).
\end{itemize}

\medskip

Pour déclarer les paramètres :
%
\begin{itemize}
	\item liste des points de contrôle (minimum 2 !!) par : \verb|x1/y1/d1§x2/y2/d2§...| avec les points \pverb|(xi;yi)| et \vverb|f'(xi)=di| ;
	\item coefficients de contrôle par \verb|coeffs=...| :
	\begin{itemize}
		\item \averb|coeffs=x| pour mettre tous les coefficients à x ;
		\item \averb|coeffs=C1§C2§...| pour spécifier les coefficients par portion (donc il faut avoir autant de § que pour les points !) ;
		\item \averb|coeffs=C1G/C1D§...| pour spécifier les coefficients par portion et par partie gauche/droite ;
		\item on peut mixer avec \averb|coeffs=C1§C2G/C2D§...|.
	\end{itemize}
\end{itemize}
\end{codeinfo}

\subsection{Code, clés et options}

\begin{codetex}[listing only]
\begin{tikzpicture}
	...
	\SplineTikz[options]{liste}
	...
\end{tikzpicture}
\end{codetex}

\begin{codecles}
Certains paramètres et \Cle{clés} peuvent être gérés directement dans la commande \ctex{splinetikz} :
%
\begin{itemize}
	\item la couleur de la courbe par la {clé} \Cle{Couleur} ;\hfill{}défaut \Cle{red}
	\item l'épaisseur de la courbe par la {clé} \Cle{Epaisseur} ;\hfill{}défaut \Cle{1.25pt}
	\item du style supplémentaire pour la courbe peut être rajouté, grâce à la {clé} \Cle{Style} ;\hfill{}défaut \Cle{vide}
	\item les coefficients de \textit{compensation} gérés par la {clé} \Cle{Coeffs} ;\hfill{}défaut \Cle{3}
	\item les points de contrôle , affichés ou non par la {clé booléenne} \Cle{AffPoints} ;\hfill{}défaut \Cle{false}
	\item la taille des points de contrôle est géré par la {clé} \Cle{TaillePoints}.\hfill{}défaut \Cle{2pt}
\end{itemize}
\end{codecles}

\subsection{Compléments sur les coefficients de \og compensation \fg}

\begin{codeidee}
Le choix a été fait ici, pour \textit{simplifier} le code, le travailler sur des courbes de Bézier.

Pour \textit{simplifier} la gestion des nombres dérivés, les points de contrôle sont gérés par leurs coordonnées \textit{polaires}, les \textsf{coefficients de compensation} servent donc -- grosso modo -- à gérer la position radiale.

\smallskip

Le coefficient \Cle{3} signifie que, pour une courbe de Bézier entre $x=a$ et $x=b$, les points de contrôles seront situés à une distance radiale de $\frac{b-a}{3}$.

Pour \textit{écarter} les points de contrôle, on peut du coup \textit{réduire} le coefficient de compensation !

\medskip

Pour des intervalles \textit{étroits}, la \textit{pente} peut paraître abrupte, et donc le(s) coefficient(s) peuvent être modifiés, de manière fine.

\medskip

Si jamais il existe (un ou) des points \textit{anguleux}, le plus simple est de créer les splines en plusieurs fois.
\end{codeidee}

\subsection{Exemples}

\begin{codetex}[tikz lower]
%code tikz
\def\x{0.9cm}\def\y{0.9cm}
\def\xmin{-1}\def\xmax{11}\def\xgrille{1}\def\xgrilles{0.5}
\def\ymin{-1}\def\ymax{5}\def\ygrille{1}\def\ygrilles{0.5}
%axes et grilles
\draw[xstep=\xgrilles,ystep=\ygrilles,line width=0.6pt,lightgray!50] (\xmin,\ymin) grid (\xmax,\ymax);
\draw[line width=1.5pt,->,gray,>=latex] (\xmin,0)--(\xmax,0) ;
\draw[line width=1.5pt,->,gray,>=latex] (0,\ymin)--(0,\ymax) ;
\foreach \x in {0,1,...,10} {\draw[gray,line width=1.5pt] (\x,4pt) -- (\x,-4pt) ;}
\foreach \y in {0,1,...,4} {\draw[gray,line width=1.5pt] (4pt,\y) -- (-4pt,\y) ;}
\draw[darkgray] (1,-4pt) node[below,font=\sffamily] {1} ;
\draw[darkgray] (-4pt,1) node[left,font=\sffamily] {1} ;
%splines
\def\LISTE{0/1/0§4/3.667/-0.333§7.5/1.75/0§9/2/-0.333§10/0/-10}
\SplineTikz[AffPoints,Coeffs=3,Couleur=red]{\LISTE}
\end{codetex}

\begin{codeinfo}
Avec des explications utiles à la compréhension :

\begin{center}
	\begin{tikzpicture}[x=0.9cm,y=0.9cm,xmin=-1,xmax=11,xgrille=1,xgrilles=0.5,ymin=-1,ymax=7,ygrille=1,ygrilles=0.5]
		\genfenetre
		\SplineTikz[affpoints=true]{0/1/0§4/3.667/-0.333§7.5/1.75/0§9/2/-0.333§10/0/-10}
		\gennotice
		\gentangentes
		\listecoeffs{3}{3}{3}{3}
	\end{tikzpicture}
\end{center}
\end{codeinfo}

\subsection{Avec une gestion plus fine des \og coefficients \fg}

\begin{codeinfo}
Dans la majorité des cas, le \textit{coefficient} \textcircled{3} permet d'obtenir une courbe (ou une portion) très satisfaisante !

Dans certains cas, il se peut que la portion paraisse un peu trop \og abrupte \fg{}.

On peut dans ce cas \textit{jouer} sur les coefficients de cette portion pour \textit{arrondir} un peu tout cela (\textit{ie} diminuer le \textsf{coeff}\ldots)!

%\begin{itemize}
%	\item être donnés (pour utiliser le même partout) sous la forme \Cle{coeffs=C} ;
%	\item être donnés portion par portion, sous la forme \Cle{coeffs=C1§C2§...} ;
%	\item être donné de manière très fine, portion par portion et côté par côté, sous la forme \Cle{coeffs=C1G/C1D§C2G/C2D§...}.
%\end{itemize}

\begin{center}
	\begin{tikzpicture}[x=0.9cm,y=0.9cm,xmin=-1,xmax=11,xgrille=1,xgrilles=0.5,ymin=-1,ymax=7,ygrille=1,ygrilles=0.5]
		\genfenetre
		\draw (1,-4pt) node[below,font=\sffamily] {1} ;
		\draw (-4pt,1) node[left,font=\sffamily] {1} ;
		\def\LISTE{0/1/0§4/3.667/-0.333§7.5/1.75/0§9/2/-0.333§10/0/-10}
		\SplineTikz[AffPoints,Coeffs=3§3§3§2/1]{\LISTE}
		\gennotice
		\listecoeffs{3/3}{3/3}{3/3}{2/1}
	\end{tikzpicture}
\end{center}
\end{codeinfo}

\begin{codetex}[listing only]
...
%splines
\def\LISTE{0/1/0§4/3.667/-0.333§7.5/1.75/0§9/2/-0.333§10/0/-10}
\SplineTikz[AffPoints,Coeffs=3§3§3§2/1]{\LISTE}
...
\end{codetex}

\begin{codesortie}
\begin{center}
	\begin{tikzpicture}[x=0.9cm,y=0.9cm,xmin=-1,xmax=11,xgrille=1,xgrilles=0.5,ymin=-1,ymax=5,ygrille=1,ygrilles=0.5]
		%axes et grilles
		\draw[xstep=\xgrilles,ystep=\ygrilles,line width=0.3pt,lightgray!50] (\xmin,\ymin) grid (\xmax,\ymax);
		\draw[xstep=\xgrilles,ystep=\ygrilles,line width=0.6pt,lightgray!50] (\xmin,\ymin) grid (\xmax,\ymax);
		\draw[line width=1.5pt,->,gray,>=latex] (\xmin,0)--(\xmax,0) ;
		\draw[line width=1.5pt,->,gray,>=latex] (0,\ymin)--(0,\ymax) ;
		\foreach \x in {0,1,...,10} {\draw[gray,line width=1.5pt] (\x,4pt) -- (\x,-4pt) ;}
		\foreach \y in {0,1,...,4} {\draw[gray,line width=1.5pt] (4pt,\y) -- (-4pt,\y) ;}
		\draw[darkgray] (1,-4pt) node[below,font=\sffamily] {1} ;
		\draw[darkgray] (-4pt,1) node[left,font=\sffamily] {1} ;
%		\draw (1,-4pt) node[below,font=\sffamily] {1} ;
%		\draw (-4pt,1) node[left,font=\sffamily] {1} ;
		\def\LISTE{0/1/0§4/3.667/-0.333§7.5/1.75/0§9/2/-0.333§10/0/-10}
		\SplineTikz[AffPoints,Coeffs=3§3§3§2/1]{\LISTE}
	\end{tikzpicture}
\end{center}
\end{codesortie}

\subsection{Conclusion}

\begin{codeinfo}
Le plus \og simple \fg{} est donc:
%
\begin{itemize}
	\item de déclarer la liste des points de contrôle, grâce à \ctex{\textbackslash def\textbackslash LISTE\{x1/y1/d1§x2/y2/d2§...\}} ;
	\item de saisir la commande \ctex{\textbackslash SplineTikz[...]\{\textbackslash LISTE\}} ;
	\item d'ajuster les options et coefficients en fonction du rendu !
\end{itemize}
\end{codeinfo}

\newpage

\section{L'outil \og TangenteTikz \fg{}}

\subsection{Définitions}

\begin{codeidee}
En parallèle de l'outil \ctex{SplineTikz}, il existe l'outil \ctex{TangenteTikz} qui va permettre de tracer des tangentes à l'aide de la liste de points précédemment définie pour l'outil \ctex{SplineTikz}.

\smallskip

NB : il peut fonctionner indépendamment de l'outil \ctex{SplineTikz} puisque la liste des points de travail est gérée de manière autonome !
\end{codeidee}

\begin{codetex}[listing only]
\begin{tikzpicture}
	...
	\TangenteTikz[options]{liste}
	...
\end{tikzpicture}
\end{codetex}

\begin{codecles}
Cela permet de tracer la tangente :
%
\begin{itemize}
	\item au point numéro \Cle{Point} de la liste \Cle{liste}, de coordonnées \textsf{xi/yi} avec la pente \textsf{di} ;
	\item avec une épaisseur de \Cle{Epaisseur}, une couleur \Cle{Couleur} et un style additionnel \Cle{Style} ;
	\item en la traçant à partir de \Cle{xl} avant \textsf{xi} et jusqu'à \Cle{xr} après \textsf{xi}.
\end{itemize}
\end{codecles}

\subsection{Exemple et illustration}

\begin{codetex}[listing only]
\begin{tikzpicture}
	...
	\def\LISTE{0/1.5/0§1/2/-0.333§2/0/-5}
	%spline
	\SplineTikz[AffPoints,Coeffs=3§2,Couleur=red]{\LISTE}
	%tangente
	\TangenteTikz[xl=0,xr=0.5,Couleur=ForestGreen,Style=dashed]{\LISTE}
	\TangenteTikz[xl=0.5,xr=0.75,Couleur=orange,Style=dotted,Point=2]{\LISTE}
	\TangenteTikz[xl=0.33,xr=0,Couleur=blue,Style=densely dashed,Point=3]{\LISTE}
	...
\end{tikzpicture}
\end{codetex}

\begin{codesortie}
On obtient le résultat suivant (avec les éléments rajoutés utiles à la compréhension) :

\begin{center}
	\begin{tikzpicture}[x=3cm,y=2cm,xmin=0,xmax=2,xgrilles=0.25,ymin=0,ymax=2.25,ygrilles=0.25]
		\tikzset{noeudexpl/.style={purple,font=\sffamily\small}}
		\tgrilles
		\draw[line width=1.5pt,->,darkgray,>=latex] (\xmin,0)--(\xmax,0) ;
		\draw[line width=1.5pt,->,darkgray,>=latex] (0,\ymin)--(0,\ymax) ;
		\draw (0,1.5) node[noeudexpl,below] {point 1} ;
		\draw (1,2) node[noeudexpl,below] {point 2} ;
		\draw (2,0) node[noeudexpl,above left] {point 3} ;
		%spline
		\SplineTikz[AffPoints,Coeffs=3§2,Couleur=red]{0/1.5/0§1/2/-0.333§2/0/-5}
		%tangente
		\TangenteTikz[xl=0,xr=0.5,Couleur=ForestGreen,Style=dashed]{0/1.5/0§1/2/-0.333§2/0/-5}
		\TangenteTikz[xl=0.5,xr=0.75,Couleur=orange,Style=dotted,Point=2]{0/1.5/0§1/2/-0.333§2/0/-5}
		\TangenteTikz[xl=0.33,xr=0,Couleur=blue,Style=densely dashed,Point=3]{0/1.5/0§1/2/-0.333§2/0/-5}
		%explications
		\draw[<->,very thick,darkgray] (0.5,2.2)--(1,2.2) node[midway,above,font=\sffamily] {xl} ;
		\draw[<->,very thick,darkgray] (1,2.2)--(1.75,2.2) node[midway,above,font=\sffamily] {xr};
		\draw[thick,darkgray] (1,4pt)--(1,-4pt) node[below,font=\sffamily] {1} ;
		\draw[thick,darkgray] (4pt,1)--(-4pt,1) node[left,font=\sffamily] {1} ;
	\end{tikzpicture}
\end{center}
\end{codesortie}

\subsection{Exemple avec les deux outils, et \og personnalisation \fg}

\begin{codetex}[listing only]
\tikzset{%
	xmin/.store in=\xmin,xmin/.default=-5,xmin=-5,
	xmax/.store in=\xmax,xmax/.default=5,xmax=5,
	ymin/.store in=\ymin,ymin/.default=-5,ymin=-5,
	ymax/.store in=\ymax,ymax/.default=5,ymax=5,
	xgrille/.store in=\xgrille,xgrille/.default=1,xgrille=1,
	xgrilles/.store in=\xgrilles,xgrilles/.default=0.5,xgrilles=0.5,
	ygrille/.store in=\ygrille,ygrille/.default=1,ygrille=1,
	ygrilles/.store in=\ygrilles,ygrilles/.default=0.5,ygrilles=0.5,
	xunit/.store in=\xunit,unit/.default=1,xunit=1,
	yunit/.store in=\yunit,unit/.default=1,yunit=1
}

\begin{tikzpicture}[x=0.5cm,y=0.5cm,xmin=0,xmax=16,xgrilles=1,ymin=0,ymax=16,ygrilles=1]
	\draw[xstep=\xgrilles,ystep=\ygrilles,line width=0.3pt,lightgray] (\xmin,\ymin) grid (\xmax,\ymax) ;
	\draw[line width=1.5pt,->,darkgray,>=latex] (\xmin,0)--(\xmax,0) ;
	\draw[line width=1.5pt,->,darkgray,>=latex] (0,\ymin)--(0,\ymax) ;
	\foreach \x in {0,2,...,14} {\draw[darkgray,line width=1.5pt] (\x,4pt) -- (\x,-4pt) ;}
	\foreach \y in {0,2,...,14} {\draw[darkgray,line width=1.5pt] (4pt,\y) -- (-4pt,\y) ;}
	%la liste pour la courbe d'interpolation
	\def\liste{0/6/3§3/11/0§7/3/0§10/0/0§14/14/6}
	%les tangentes "stylisées"
	\TangenteTikz[xl=0,xr=1,Couleur=blue,Style=dashed]{\liste}
	\TangenteTikz[xl=2,xr=2,Couleur=purple,Style=dotted,Point=2]{\liste}
	\TangenteTikz[xl=2,xr=2,Couleur=orange,Style=<->,Point=3]{\liste}
	\TangenteTikz[xl=2,xr=0,Couleur=ForestGreen,Point=5]{\liste}
	%la courbe en elle-même
	\SplineTikz[AffPoints,Coeffs=3,Couleur=cyan,Style=densely dotted]{\liste}
\end{tikzpicture}
\end{codetex}

\begin{codesortie}
\begin{center}
\begin{tikzpicture}[x=0.5cm,y=0.5cm,xmin=0,xmax=16,xgrilles=1,ymin=0,ymax=16,ygrilles=1]
		\draw[xstep=\xgrilles,ystep=\ygrilles,line width=0.3pt,lightgray] (\xmin,\ymin) grid (\xmax,\ymax) ;
		\draw[line width=1.5pt,->,darkgray,>=latex] (\xmin,0)--(\xmax,0) ;
		\draw[line width=1.5pt,->,darkgray,>=latex] (0,\ymin)--(0,\ymax) ;
		\foreach \x in {0,2,...,14} {\draw[darkgray,line width=1.5pt] (\x,4pt) -- (\x,-4pt) ;}
		\foreach \y in {0,2,...,14} {\draw[darkgray,line width=1.5pt] (4pt,\y) -- (-4pt,\y) ;}
		\draw[darkgray] (2,-4pt) node[below,font=\sffamily] {2} ;
		\draw[darkgray] (-4pt,2) node[left,font=\sffamily] {2} ;
		%la liste pour la courbe d'interpolation
		\def\liste{0/6/3§3/11/0§7/3/0§10/0/0§14/14/6}
		%les tangentes "stylisées"
		\TangenteTikz[xl=0,xr=1,Couleur=blue,Style=dashed]{\liste}
		\TangenteTikz[xl=2,xr=2,Couleur=purple,Style=dotted,Point=2]{\liste}
		\TangenteTikz[xl=2,xr=2,Couleur=orange,Style=<->,Point=3]{\liste}
		\TangenteTikz[xl=2,xr=0,Couleur=ForestGreen,Point=5]{\liste}
		%la courbe en elle-même
		\SplineTikz[AffPoints,Coeffs=3,Couleur=cyan,Style=densely dotted]{\liste}
	\end{tikzpicture}
\end{center}
\end{codesortie}

\newpage



\newpage

\section{Petits schémas pour le signe d'une fonction affine ou d'un trinôme}\label{aidesigne}

\subsection{Idée}

\begin{codeidee}
L'idée est d'obtenir une commande pour tracer (en \TikZ) un petit schéma pour \textit{visualiser} le signe d'une fonction affine ou d'un trinôme.

Le code est très largement inspiré de celui du package \ctex{tnsana} même si la philosophie est légèrement différente.

\smallskip

Comme pour les autres commandes \TikZ, l'idée est de laisser l'utilisateur définir et créer son environnement \TikZ, et d'insérer la commande \ctex{MiniSchemaSignes} pour afficher le schéma.
\end{codeidee}

\begin{codetex}[tikz lower]
%code tikz
\MiniSchemaSignes[clés]
\end{codetex}

\subsection{Commandes}

\begin{codetex}[listing only]
...
\begin{tikzpicture}[<options>]
	...
	\MiniSchemaSignes[clés]
	...
\end{tikzpicture}
\end{codetex}

\begin{codetex}[listing only]
... {\tikz[options] \MiniSchemaSignes[clés]}...
\end{codetex}

\begin{codecles}
Plusieurs \Cle{Clés} sont disponibles pour cette commande :

\begin{itemize}
	\item la clé \Cle{Code} qui permet de définir le type d'expression (voir en-dessous) ;\hfill{}défaut \Cle{da+}
	\item la clé \Cle{Couleur} qui donne la couleur de la représentation ;\hfill{}défaut \Cle{red}
	\item la clé \Cle{Racines} qui définit la ou les racines ;\hfill{}défaut \Cle{2}
	\item la clé \Cle{Largeur} qui est la largeur du schéma ;\hfill{}défaut \Cle{2}
	\item la clé \Cle{Hauteur} qui est la hauteur du schéma ;\hfill{}défaut \Cle{1}
	\item un booléen \Cle{Cadre} qui affiche un cadre autour du schéma.\hfill{}défaut \Cle{true}
\end{itemize}
\end{codecles}

\begin{codecles}
Pour la clé \Cle{code}, il est construit par le type (\textsf{a} pour affine ou \textsf{p} comme parabole) puis les éléments caractéristiques (\textsf{a+} pour $a>0$, \textsf{d0} pour $\Delta=0$, etc) :

\begin{itemize}
	\item \Cle{Code=da+} := une droite croissante ;
	\item \Cle{Code=da-} := une droite décroissante ;
	\item \Cle{Code=pa+d+} := une parabole \textit{souriante} avec deux racines ;
	\item etc
\end{itemize}
\end{codecles}

\pagebreak

\begin{codetex}[listing only]
\begin{center}
	\begin{tikzpicture}
		\MiniSchemaSignes[Code=da+,Racines=-4]
	\end{tikzpicture}
	~~~~
	\begin{tikzpicture}
		\MiniSchemaSignes[Code=da-,Racines={h},Couleur=blue,Largeur=3,Cadre=false]
	\end{tikzpicture}
\end{center}
%
\begin{center}
	\begin{tikzpicture}
		\MiniSchemaSignes[Code=pa+d+,Racines={1/2},Couleur=orange]
	\end{tikzpicture}
	~~~~
	\begin{tikzpicture}
		\MiniSchemaSignes[Code=pa+d-,Couleur=ForestGreen]
	\end{tikzpicture}
	~~~~
	\begin{tikzpicture}
		\MiniSchemaSignes[Code=pa+d0,Racines={5},Couleur=purple]
	\end{tikzpicture}
\end{center}
%
\begin{center}
	\begin{tikzpicture}
		\MiniSchemaSignes[Code=pa-d+,Racines={-3/0},Couleur=yellow]
	\end{tikzpicture}
	~~~~
	\begin{tikzpicture}
		\MiniSchemaSignes[Code=pa-d-,Couleur=cyan]
	\end{tikzpicture}
	~~~~
	\begin{tikzpicture}
		\MiniSchemaSignes[Code=pa-d0,Racines={-1},Couleur=magenta]
	\end{tikzpicture}
\end{center}
\end{codetex}

\begin{codesortie}
\begin{center}
	\begin{tikzpicture}
		\MiniSchemaSignes[Code=da+,Racines=-4]
	\end{tikzpicture}
	~~~~
	\begin{tikzpicture}
		\MiniSchemaSignes[Code=da-,Racines={h},Couleur=blue,Largeur=3,Cadre=false]
	\end{tikzpicture}
\end{center}
%
\begin{center}
	\begin{tikzpicture}
		\MiniSchemaSignes[Code=pa+d+,Racines={1/2},Couleur=orange]
	\end{tikzpicture}
	~~~~
	\begin{tikzpicture}
		\MiniSchemaSignes[Code=pa+d-,Couleur=ForestGreen]
	\end{tikzpicture}
	~~~~
	\begin{tikzpicture}
		\MiniSchemaSignes[Code=pa+d0,Racines={5},Couleur=purple]
	\end{tikzpicture}
\end{center}
%
\begin{center}
	\begin{tikzpicture}
		\MiniSchemaSignes[Code=pa-d+,Racines={-3/0},Couleur=yellow]
	\end{tikzpicture}
	~~~~
	\begin{tikzpicture}
		\MiniSchemaSignes[Code=pa-d-,Couleur=cyan]
	\end{tikzpicture}
	~~~~
	\begin{tikzpicture}
		\MiniSchemaSignes[Code=pa-d0,Racines={-1},Couleur=magenta]
	\end{tikzpicture}
\end{center}
\end{codesortie}

\begin{codetex}[tikz lower]
%code tikz
\MiniSchemaSignes[Largeur=3.5,Hauteur=1.5,Code=da-,Racines=\tfrac{-b}{a},Couleur=Plum]
\end{codetex}

\subsection{Intégration avec tkz-tab}

\begin{codeidee}
Ces schémas peuvent être de plus utilisés, via la commande \ctex{MiniSchemaSignesTkzTab} pour illustrer les signes obtenus dans un tableau de signes présentés grâce au package \ctex{tkz-tab}.

Pour des raisons internes, le fonctionnement de la commande \ctex{aidesignetkztabPL} est légèrement différent et, pour des raisons que j'ignore, le code est légèrement différent en \textit{interne} (avec une \textit{déconnexion} des caractères \textsf{:} et \textsf{\textbackslash}) pour que la librairie \TikZ{} \ctex{calc} puisse fonctionner (mystère pour le moment\ldots)
\end{codeidee}

\begin{codetex}[listing only]
\begin{tikzpicture}
	%commandes tkztab
	\MiniSchemaSignesTkzTab[options]{numligne}[echelle][décalage horizontal]
\end{tikzpicture}
\end{codetex}

\begin{codecles}
Les \Cle{Clés} pour le premier argument optionnel sont les mêmes que pour la version \textit{initiale} de la commande précédente.

En ce qui concerne les autres arguments :

\begin{itemize}
	\item le deuxième argument, mandataire, est le numéro de la ligne à côté de laquelle placer le schéma ;
	\item le troisième argument, optionnel et valant \Cle{0.85} par défaut, est l'échelle à appliquer sur l'ensemble du schéma (à ajuster en fonction de la hauteur de la ligne) ;
	\item le quatrième argument, optionnel et valant \Cle{1.5} par défait, est lié à l'écart horizontal entre le bord de la ligne du tableau et le schéma.
\end{itemize}

À noter que si l'un des arguments optionnels (le n°3 et/ou le n°4) sont utilisés, il vaut mieux préciser les 2 !
\end{codecles}

\begin{codetex}[listing only]
\begin{center}
	\begin{tikzpicture}
		\tkzTabInit[]{$x$/1,$-2x+5$/1,$2x+4$/1,$p(x)$/1}{$-\infty$,$-2$,${2,5}$,$+\infty$}
		\tkzTabLine{,+,t,+,z,-,}
		\tkzTabLine{,-,z,+,t,+,}
		\tkzTabLine{,-,z,+,z,-,}
		\MiniSchemaSignesTkzTab[Code=da-,Racines={2,5},Couleur=blue]{1}
		\MiniSchemaSignesTkzTab[Code=da+,Racines={-2},Couleur=purple]{2}
		\MiniSchemaSignesTkzTab[Code=pa-d+,Racines={-2/2,5},Couleur=orange]{3}[0.85][2]
	\end{tikzpicture}
\end{center}
\end{codetex}

\begin{codesortie}
\begin{center}
	\begin{tikzpicture}
		\tkzTabInit[]{$x$/1,$-2x+5$/1,$2x+4$/1,$p(x)$/1}{$-\infty$,$-2$,${2,5}$,$+\infty$}
		\tkzTabLine{,+,t,+,z,-,}
		\tkzTabLine{,-,z,+,t,+,}
		\tkzTabLine{,-,z,+,z,-,}
		\MiniSchemaSignesTkzTab[Code=da-,Racines={2,5},Couleur=blue]{1}
		\MiniSchemaSignesTkzTab[Code=da+,Racines={-2},Couleur=purple]{2}
		\MiniSchemaSignesTkzTab[Code=pa-d+,Racines={-2/2,5},Couleur=orange]{3}[0.85][2]
	\end{tikzpicture}
\end{center}
\end{codesortie}

\newpage

\section{Suites récurrentes et \og toile \fg}\label{recurr}

\subsection{Idée}

\begin{codeidee}
L'idée est d'obtenir une commande pour tracer (en \TikZ) la \og toile \fg{} permettant d'obtenir -- graphiquement -- les termes d'une suite récurrente définie par une relation $u_{n+1}=f(u_n)$.

\smallskip

Comme pour les autres commandes \TikZ, l'idée est de laisser l'utilisateur définir et créer son environnement \TikZ, et d'insérer la commande \ctex{ToileRecurrence} pour afficher la \og toile \fg.
\end{codeidee}

\subsection{Commandes}

\begin{codetex}[listing only]
...
\begin{tikzpicture}[options]
	...
	\ToileRecurrence[clés][options du tracé][options supplémentaires des termes]
	...
\end{tikzpicture}
\end{codetex}

\begin{codecles}
Plusieurs \Cle{arguments} (optionnels) sont disponibles :

\begin{itemize}
	\item le premier argument optionnel définit les \Cle{Clés} de la commande :
	\begin{itemize}
		\item la clé \Cle{Fct} qui définit la fonction $f$ ;\hfill{}défaut \Cle{vide}
		\item la clé \Cle{Nom} qui est le \textit{nom} de la suite ;\hfill{}défaut \Cle{u}
		\item la clé \Cle{No} qui est l'indice initial ;\hfill{}défaut \Cle{0}
		\item la clé \Cle{Uno} qui est la valeur du terme initial ;\hfill{}défaut \Cle{vide}
		\item la clé \Cle{Nb} qui est le nombre de termes à construire ;\hfill{}défaut \Cle{5}
		\item la clé \Cle{PosLabel} qui correspond au placement des labels par rapport à l'axe des abscisses ;\hfill{}défaut \Cle{below}
		\item la clé \Cle{DecalLabel} qui correspond au décalage des labels par rapport aux abscisses ;\hfill{}défaut \Cle{6pt}
		\item la clé \Cle{TailleLabel} qui correspond à la taille des labels ;\hfill{}défaut \Cle{small}
		\item un booléen \Cle{AffTermes} qui permet d'afficher les termes de la suite sur l'axe $(Ox)$.\hfill{}défaut \Cle{true}
	\end{itemize}
	\item le deuxième argument optionnel concerne les \Cle{options} du tracé de l'\textit{escalier} en \textit{langage \TikZ} ;
	
	\hfill{}défaut \Cle{thick,color=magenta} ;
	\item le troisième argument optionnel concerne les \Cle{options} du tracé des termes en \textit{langage \TikZ}.
	
	\hfill{}défaut \Cle{dotted}.
\end{itemize}
\end{codecles}

\begin{codeinfo}
Il est à noter que le \textsf{code} n'est pas autonome, et doit être intégré dans un environnement \ctex{tikzpicture}.

\smallskip

L'utilisateur est donc libre de définir ses styles pour l'affichage des éléments de son graphique, et il est libre également de rajouter des éléments en plus du tracé de la \textit{toile} !

\smallskip

La macro ne permet -- pour le moment -- ni de tracer la bissectrice, ni de tracer la courbe$\ldots$

En effet, il y aurait trop d'options pour ces deux éléments, et l'idée est quand même de conserver une commande \textit{simple} ! Donc l'utilisateur se chargera de tracer et de personnaliser sa courbe et sa bissectrice !
\end{codeinfo}

\subsection{Exemples}

\begin{codeinfo}
On va tracer la \textit{toile} des 4 premiers termes de la suite récurrente $\begin{dcases} u_1 = 1 \\ u_{n+1} = \sqrt{5u_n}+1 \text{ pour tout entier } n \geqslant 1\end{dcases}$.
\end{codeinfo}

\begin{codetex}[tikz lower]
%code tikz
\def\x{1.5cm}\def\y{1.5cm}
\def\xmin{0}\def\xmax{10}\def\xgrille{1}\def\xgrilles{0.5}
\def\ymin{0}\def\ymax{8}\def\ygrille{1}\def\ygrilles{0.5}
%axes et grilles
\draw[xstep=\xgrilles,ystep=\ygrilles,line width=0.6pt,lightgray!50] (\xmin,\ymin) grid (\xmax,\ymax);
\draw[line width=1.5pt,->,darkgray,>=latex] (\xmin,0)--(\xmax,0) ;
\draw[line width=1.5pt,->,darkgray,>=latex] (0,\ymin)--(0,\ymax) ;
\foreach \x in {0,1,...,9} {\draw[darkgray,line width=1.5pt] (\x,4pt) -- (\x,-4pt) ;}
\foreach \y in {0,1,...,7} {\draw[darkgray,line width=1.5pt] (4pt,\y) -- (-4pt,\y) ;}
%fonction définie et réutilisable
\def\f{sqrt(5*\x)+1}
%toile
\ToileRecurrence[Fct={\f},No=1,Uno=1,Nb=4,DecalLabel=4pt]
%éléments supplémentaires
\draw[very thick,blue,domain=0:8,samples=250] plot (\x,{\f}) ;
\draw[very thick,ForestGreen,domain=0:8,samples=2] plot (\x,\x) ;
\end{codetex}

\begin{codeinfo}
Peut-être que -- ultérieurement -- des options \textit{booléennes} seront disponibles pour un tracé \textit{générique} de la courbe et de la bissectrice, mais pour le moment la \textsf{macro} ne fait \textit{que} l'escalier.
\end{codeinfo}

\subsection{Influence des paramètres}

\begin{codetex}[listing only]
\begin{center}
	\begin{tikzpicture}[x=4cm,y=3cm]
	%axes + grilles + graduations
	...
	%fonction
	\def\f{-0.25*\x*\x+\x}
	%tracés
	\begin{scope}
		\clip (0,0) rectangle (2.5,1.25) ;
		\draw[line width=1.25pt,blue,domain=0:2.5,samples=200] plot (\x,{\f}) ;
	\end{scope}
	\ToileRecurrence[Fct={\f},No=0,Uno=2,Nb=5,PosLabel=above right,DecalLabel=0pt]
\end{tikzpicture}
\end{center}
\end{codetex}

\begin{codesortie}
\begin{center}
	\begin{tikzpicture}[x=4cm,y=3cm]
	\draw[xstep=0.25,ystep=0.25,line width=0.3pt,lightgray!50] (0,0) grid (2.5,1.25);
	\draw[thick,->,>=latex] (0,0)--(2.5,0) ;
	\draw[thick,->,>=latex] (0,0)--(0,1.25) ;
	\foreach \x in {0,1,2}
	\draw[line width=1.25pt] (\x,4pt) -- (\x,-4pt) node[below] {\num{\x}} ;
	\foreach \y in {0,0.5,1.0}
	\draw[line width=1.25pt] (4pt,\y) -- (-4pt,\y) node[left] {\num{\y}} ;
	\draw[line width=1.25pt,red](0,0) -- (1.25,1.25) ;
	%fonction
	\def\f{-0.25*\x*\x+\x}
	%tracés
	\begin{scope}
			\clip (0,0) rectangle (2.5,1.25) ;
			\draw[line width=1.25pt,blue,domain=0:2.5,samples=200] plot (\x,{\f}) ;
		\end{scope}
	\ToileRecurrence[Fct={\f},No=0,Uno=2,Nb=5,PosLabel=above right,DecalLabel=0pt]
\end{tikzpicture}
\end{center}
\end{codesortie}

\begin{codetex}[listing only]
\begin{center}
	\begin{tikzpicture}[x=5cm,y=1.5cm]
			...
			\def\f{1+1/\x}
			\ToileRecurrence%
				[Fct={\f},No=0,Uno=1,Nb=7,PosLabel=above right,DecalLabel=0pt,AffTermes=false]%
				[line width=1.25pt,ForestGreen,densely dashed][]
			\draw[line width=1.25pt,blue,domain=0:2.25,samples=2] plot(\x,{\x});
			\draw[line width=1.25pt,red,domain=0.8:2.5,samples=250] plot(\x,{\f});
		\end{tikzpicture}
\end{center}
\end{codetex}

\begin{codesortie}
\begin{center}
	\begin{tikzpicture}[x=5cm,y=1.5cm]
		%axes et grille
		\draw[xstep=0.5,ystep=0.25,line width=0.3pt,lightgray!50] (0,0) grid (2.5,2.25);
		\draw[thick,->,>=latex] (0,0)--(2.5,0) ;
		\draw[thick,->,>=latex] (0,0)--(0,2.25) ;
		\foreach \x in {0,0.5,...,2}
			\draw[line width=1.25pt] (\x,4pt) -- (\x,-4pt) node[below] {\num{\x}};
		\foreach \y in {0,0.5,...,2}
			\draw[line width=1.25pt] (4pt,\y) -- (-4pt,\y) node[left] {\num{\y}};
		%fonction
		\def\f{1+1/\x}
		%tracés
		\ToileRecurrence%
			[Fct={\f},No=0,Uno=1,Nb=7,PosLabel=above right,DecalLabel=0pt,AffTermes=false]%
			[line width=1.25pt,ForestGreen,densely dashed][]
		\draw[line width=1.25pt,blue,domain=0:2.25,samples=2] plot(\x,{\x});
		\draw[line width=1.25pt,red,domain=0.8:2.5,samples=250] plot(\x,{\f});
	\end{tikzpicture}
\end{center}
\end{codesortie}

\newpage

\part{Présentation de codes}

\section{L'outil \og Calcul Formel \fg}

\subsection{Introduction}

\begin{codeidee}
L'idée des commandes suivantes est de définir, dans un environnement \TikZ, une présentation proche de celle d'un logiciel de calcul formel comme \textsf{XCas} ou \textsf{Geogebra}.

\smallskip

Les sujets d'examens, depuis quelques années, peuvent comporter des \textit{captures d'écran} de logiciel de calcul formel, l'idée est ici de reproduire, de manière autonome, une telle présentation.

\smallskip

À la manière du {package} \ctex{tkz-tab}, l'environnement de référence est un environnement \TikZ, dans lequel les lignes sont créées petit à petit, à l'aide de nœuds qui peuvent être réutilisés à loisir ultérieurement.
\end{codeidee}

\subsection{La commande \og CalculFormelParametres \fg}

\begin{codeinfo}
La première chose à définir est l'ensemble des paramètres \textit{globaux} de la fenêtre de calcul formel, à l'aide de \Cle{Clés}.
\end{codeinfo}

\begin{codetex}[listing only]
...
\begin{tikzpicture}[...]
	\CalculFormelParametres[options]
	...
\end{tikzpicture}
\end{codetex}

\begin{codecles}
Les \Cle{Clés} disponibles sont :
\begin{itemize}
	\item \Cle{Largeur} : largeur de l'environnement ; \hfill{}défaut \Cle{16}
	\item \Cle{EspaceLg} : espacement vertical entre les lignes ;\hfill{}défaut \Cle{2pt}
	\item \Cle{PremCol} \& \Cle{HautPremCol} : largeur et hauteur de la case du \textit{petit numéro} ;\hfill{}défaut \Cle{0.3} \&  \Cle{0.4}
	\item \Cle{Taille} : taille du texte ;\hfill{}défaut \Cle{\textbackslash normalsize}
	\item \Cle{Couleur} : couleur des traits de l'environnement ;\hfill{}défaut \Cle{darkgray}
	\item \Cle{Titre} : booléen pour l'affichage d'un bandeau de titre ;\hfill{}défaut \Cle{false}
	\item \Cle{TailleTitre} : taille du titre ;\hfill{}défaut \Cle{\textbackslash normalsize}
	\item \Cle{PosCmd} : position horizontale de la commande d'entrée ;\hfill{}défaut \Cle{gauche}
	\item \Cle{PosRes} : position horizontale de la commande de sortie ;\hfill{}défaut \Cle{centre}
	\item \Cle{CouleurCmd} : couleur de la commande d'entrée ;\hfill{}défaut \Cle{red}
	\item \Cle{CouleurRes} : couleur de la commande de sortie ;\hfill{}défaut \Cle{blue}
	\item \Cle{Sep} : booléen pour l'affichage du trait de séparation E/S ;\hfill{}défaut \Cle{true}
	\item \Cle{Menu} : booléen pour l'affichage du \textit{bouton} MENU ;\hfill{}défaut \Cle{true}
	\item \Cle{LabelTitre} : libellé du titre.\hfill{}défaut \Cle{Résultats obtenus avec un logiciel de Calcul Formel}
\end{itemize}
\end{codecles}

\subsection{La commande \og CalculFormelLigne \fg}

\begin{codeinfo}
Une fois les paramètres déclarés, il faut créer les différentes lignes, grâce à la \ctex{CalculFormelLigne}.
\end{codeinfo}

\begin{codetex}[listing only]
\begin{tikzpicture}[...]
	\CalculFormelParametres[options]
	\CalculFormelLigne[options]{commande}{résultat}
	...
\end{tikzpicture}
\end{codetex}

\begin{codecles}
Les (quelques) \Cle{Clés} disponibles sont :

\begin{itemize}
	\item \Cle{HautCmd} et \Cle{HautRes}: hauteur de la ligne de commande d'entrée et de sortie ;\hfill{}défaut \Cle{0.75}
	\item deux \textsf{arguments}, celui de la commande d'entrée et celui de la commande de sortie.
\end{itemize}
%
Chaque argument \textsf{COMMANDE} \& \textsf{RÉSULTAT} peut être formaté (niveau police) de manière indépendante.
\end{codecles}

\begin{codetex}[tikz lower]
%code tikz
\CalculFormelParametres[Titre=true,CouleurCmd=olive,CouleurRes=orange]
\CalculFormelLigne{COMMANDE 1}{RÉSULTAT 1}
\CalculFormelLigne[HautCmd=0.75,HautRes=1]{\texttt{(x+1)\CFchap2}}{$\mathtt{x^2+2x+1}$}
%\CFchap := ^ en mathtt
\end{codetex}

\subsection{Visualisation des paramètres}

\begin{codeinfo}
Pour \textit{illustrer} un peu les \Cle{clés}, un petit schéma, avec les différents nœuds crées par les \textsf{macros}.

\begin{center}
	\begin{tikzpicture}[x=0.7cm,y=0.5cm,line width=1pt]
	\CalculFormelParametres[Largeur=12cm,Couleur=lightgray,EspaceLg=12pt,Menu=false]
	\CalculFormelLigne{}{}
	\CalculFormelLigne[HautCmd=1,HautRes=1.25]{}{}
	%explications
	\foreach \noeud in {01,11,21,31,41,51,02,12,22,32,42,52}
		\draw[blue] (A\noeud) node[font=\footnotesize\ttfamily] {A\noeud} ;
\end{tikzpicture}
\end{center}

\begin{center}
	\begin{tikzpicture}[x=0.7cm,y=0.7cm,line width=1pt]
	\CalculFormelParametres[Titre,Largeur=12cm,EspaceLg=10pt,PremCol=0.5,HautPremCol=0.7,Couleur=lightgray]
	\CalculFormelLigne{COMMANDE 1}{RÉSULTAT 1}
	\CalculFormelLigne[HautCmd=0.85,HautRes=1.05]{COMMANDE 2}{RÉSULTAT 2}
	%explications
	\draw[CadetBlue,<->,>=latex] ($(A22) + (0,-12pt)$) -- ($(A52) + (0,-12pt)$) node[midway,below,font=\footnotesize\sffamily] {\Cle{Largeur}} ;
	\draw[CadetBlue,<->,>=latex] ($(A51) + (12pt,0)$) -- ($(A32) + (12pt,0)$) node[midway,right,font=\footnotesize\sffamily] {\Cle{EsapceLg}} ;
	\draw[CadetBlue,<->,>=latex] ($(A02) + (0,2pt)$) -- ($(A02) + (0,2pt) + ({-\CFpremcol},0) $) node[midway,above,font=\footnotesize\sffamily] {\Cle{PremCol}} ;
	\draw[CadetBlue,<->,>=latex] ($(A02) + ({-\CFpremcol},0) + (-2pt,0)$) -- ($(A02) + ({-\CFpremcol},{-\CFhpremcol}) +(-2pt,0)$) node[midway,left,font=\footnotesize\sffamily] {\Cle{HautPremCol}} ;
	\draw[CadetBlue,<->,>=latex] ($(A31) + (12pt,0)$) -- ($(A41) + (12pt,0)$) node[midway,right,font=\footnotesize\sffamily] {\Cle{HautCom}} ;
	\draw[CadetBlue,<->,>=latex] ($(A41) + (12pt,0)$) -- ($(A51) + (12pt,0)$) node[midway,right,font=\footnotesize\sffamily] {\Cle{HautRes}} ;
	\draw[CadetBlue,<->,>=latex] ($(A32) + (12pt,0)$) -- ($(A42) + (12pt,0)$) node[midway,right,font=\footnotesize\sffamily] {\Cle{HautCom}} ;
	\draw[CadetBlue,<->,>=latex] ($(A42) + (12pt,0)$) -- ($(A52) + (12pt,0)$) node[midway,right,font=\footnotesize\sffamily] {\Cle{HautRes}} ;
	\draw[CadetBlue,->,>=latex] ($(A12) + (0,-12pt)$) to[bend left=10] ($(A12) + (0,-12pt) + (-18pt,-12pt)$) node[below left,font=\footnotesize\sffamily] {\Cle{Couleur}} ;
	\draw[CadetBlue,->,>=latex] ($(A52) + (-0.65,0.25)$) to[bend left=10] ($(A52) + (-0.65,0.25) + (-18pt,12pt)$) node[inner sep=0pt,above left=1pt,font=\footnotesize\sffamily] {\Cle{Menu}} ;
	\draw[CadetBlue,->,>=latex] ($(A12) + (16pt,0)$) to[bend left=10] ($(A12) + (16pt,0) + (18pt,-12pt)$) node[inner sep=0pt,below right=1pt,font=\footnotesize\sffamily] {\Cle{Sep}} ;
	\draw[CadetBlue,->,>=latex] ($(A01) + (8pt,2pt) + (0,1em)$) to[bend left=10] ($(A01) + (8pt,2pt) + (0,1em) + (-18pt,12pt)$) node[inner sep=0pt,above=1pt,font=\footnotesize\sffamily] {\Cle{Titre} \& \Cle{TailleTitre} \& \Cle{LabelTitre}} ;
\end{tikzpicture}
\end{center}
\end{codeinfo}

\newpage

\section{Code Python \og simple \fg{} via le package listings}\label{pythonsimple}

\subsection{Introduction}

\begin{codeidee}
Le {package} \ctex{listings} permet d'insérer et de formater du code, notamment du code Python.

En \textit{partenariat} avec \ctex{tcolorbox}, on peut donc présenter \textit{joliment} du code python !
\end{codeidee}

\begin{codeinfo}
Le package \ctex{listings} ne nécessite pas de compilation particulière, au contraire d'autres (comme \ctex{pythontex} ou \ctex{minted} ou \ctex{piton}) qui seront présentés ultérieurement.
\end{codeinfo}

\begin{codeinfo}
Le style utilisé pour formater le code Python n'est pas modifiable. Il donne un rendu proche de celui des packages comme \ctex{pythontex} ou \ctex{minted} ou \ctex{piton}.

\smallskip

Donc, si plusieurs \textit{méthodes} sont utilisées pour insérer du code Python (via les \textit{méthodes} suivantes), le rendu pourra être légèrement différent.
\end{codeinfo}

\subsection{Commande et options}

\begin{codeidee}
L'environnement \ctex{CodePythonLst} permet de présenter du code python, dans une \ctex{tcolorbox} avec un style particulier.
\end{codeidee}

\begin{codetex}[listing only]
\begin{CodePythonLst}(*)[largeur]{commandes tcbox}
...
\end{CodePythonLst}
\end{codetex}

\begin{codecles}
Plusieurs \Cle{arguments} sont disponibles :

\begin{itemize}
	\item la version \textit{étoilée} qui permet de ne pas afficher les numéros de lignes ;
	\item le premier argument (optionnel), concerne la \Cle{largeur} de la \ctex{tcbox} ;\hfill{}défaut \Cle{\textbackslash linewidth}
	\item le second argument (mandataire), concerne des \Cle{options} de la \ctex{tcbox} en \textit{langage tcolorbox}, comme l'alignement.
\end{itemize}
\end{codecles}

\begin{codeattention}
Les environnements \ctex{DeclareTCBListing} créés par \ctex{tcolorbox} et \ctex{listings} ne sont pas compatibles avec les options \Cle{gobble} (pour supprimer les tabulations d'environnement), donc il faut bien penser à \og aligner \fg{} le code à gauche, pour éviter des tabulations non esthétiques !
\end{codeattention}

\subsection{Insertion via un fichier \og externe \fg}

\begin{codeidee}
Pour des raison pratiques, il est parfois intéressant d'avoir le code Python dans un fichier externe au ficher \ctex{tex}, ou bien créé directement par le fichier \ctex{tex} (via \ctex{scontents}, notamment, mais non chargé par \ctex{ProfLycee}).

Dans ce cas, il n'est pas nécessaire d'aligner le code \og à gauche \fg, en utilisant une commande alternative.

\smallskip

Si cette méthode est utilisée, il ne faut oublier de charger le package \ctex{scontents}.
\end{codeidee}

\begin{codetex}[listing only]
\usepackage{scontents} %si script déclaré dans le fichier tex
...
\CodePythonLstFichier(*)[largeur]{commandes tcbox}{script}
\end{codetex}

\subsection{Exemples}

\begin{codetex}[listing only]
\begin{CodePythonLst}{} %les {}, même vides, sont nécessaires (bug avec # sinon !)
#environnement par défaut
nb = int(input("Saisir un entier positif"))
if (nb %7 == 0) :
	print(f"{nb} est bien divisible par 7")
#endif

def f(x) :
	return x**2
\end{CodePythonLst}
\end{codetex}

\begin{codesortie}
\begin{CodePythonLst}{}
#environnement par défaut
nb = int(input("Saisir un entier positif"))
if (nb %7 == 0) :
	print(f"{nb} est bien divisible par 7")
#endif

def f(x) :
	return x**2
\end{CodePythonLst}
\end{codesortie}

\begin{codetex}[listing only]
\begin{CodePythonLst}*[0.5\linewidth]{flush right}
#largeur de 50%, sans numéro, et aligné à droite
nb = int(input("Saisir un entier Python positif"))
if (nb %7 == 0) :
	print(f"{nb} est bien divisible par 7")
#endif

def f(x) :
	return x**2
\end{CodePythonLst}
\end{codetex}

\begin{codesortie}
\begin{CodePythonLst}*[0.5\linewidth]{flush right}
#largeur de 50%, sans numéro, et aligné à droite
nb = int(input("Saisir un entier Python positif"))
if (nb %7 == 0) :
	print(f"{nb} est bien divisible par 7")
#endif

def f(x) :
	return x**2
\end{CodePythonLst}
\end{codesortie}

\begin{codetex}[listing only]
\begin{scontents}[overwrite,write-out=testscript.py]
# Calcul de la factorielle en langage Python
def factorielle(x):
	if x < 2:
		return 1
	else:
		return x * factorielle(x-1)

# rapidité de tracé
import matplotlib.pyplot as plt
import time
def trace_parabole_tableaux():
	depart=time.clock()
	X = [] # Initialisation des listes
	Y = []
	a = -2
	h = 0.001
	while a<2:
		X.append(a) # Ajout des valeurs
		Y.append(a*a) # au "bout" de X et Y
		a = a+h
	# Tracé de l'ensemble du tableau de valeurs
	plt.plot(X,Y,".b")
	fin=time.clock()
	return "Temps : " + str(fin-depart) + " s."
\end{scontents}

%environnement centré, avec numéros, largeur 9cm
\CodePythonLstFichier[9cm]{center}{testscript.py}
\end{codetex}

\begin{codesortie}
\begin{scontents}[overwrite,write-out=testscript.py]
# Calcul de la factorielle en langage Python
def factorielle(x):
	if x < 2:
		return 1
	else:
		return x * factorielle(x-1)

# rapidité de tracé
import matplotlib.pyplot as plt
import time
def trace_parabole_tableaux():
	depart=time.clock()
	X = [] # Initialisation des listes
	Y = []
	a = -2
	h = 0.001
	while a<2:
		X.append(a) # Ajout des valeurs
		Y.append(a*a) # au "bout" de X et Y
		a = a+h
	# Tracé de l'ensemble du tableau de valeurs
	plt.plot(X,Y,".b")
	fin=time.clock()
	return "Temps : " + str(fin-depart) + " s."
\end{scontents}

\CodePythonLstFichier[9cm]{center}{testscript.py}
\end{codesortie}

\newpage

\section{Code Python via le package piton}\label{pythonpiton}

\subsection{Introduction}

\begin{codeinfo}
\cmaj{2.0.0} Le package \ctex{piton} (compatible uniquement avec une compilation en \LuaLaTeX{} !) permet d'insérer du code Python avec une coloration syntaxique en utilisant la bibliothèque \textsf{Lua LPEG}.

\smallskip

En \textit{partenariat} avec \ctex{tcolorbox}, on peut avoir une présentation de code Python !

\smallskip

\cmaj{2.0.2} Depuis la version \ctex{0.95} du package \ctex{piton}, \Cle{left-margin=auto} est disponible et activée dans \ctex{ProfLycee}.

\cmaj{2.1.2} Depuis la version \ctex{0.99} du package \ctex{piton}, \Cle{break-lines} est disponible et activée dans \ctex{ProfLycee}.

\cmaj{2.1.3} Depuis la version \ctex{1.0} du package \ctex{piton}, \Cle{tabs-auto-gobble} est disponible et activée dans \ctex{ProfLycee}.
\end{codeinfo}

\begin{codeattention}
Le package \ctex{piton} nécessite donc obligatoirement l’emploi de \LuaLaTeX{} !

\cmaj{2.0.1} Ce package n'est chargé que si la compilation détectée est en \LuaLaTeX{} !
\end{codeattention}

\subsection{Présentation de code Python}

\begin{codetex}[listing only]
\begin{CodePiton}[options]
...
...
\end{CodePiton}
\end{codetex}

%\begin{codeattention}
%Les environnements créés par \ctex{piton} et \ctex{tcolorbox} ne sont -- a priori -- pas compatibles avec les options de type \Cle{gobble} (pour supprimer les tabulations d'environnement), donc il faut bien penser à \og aligner \fg{} le code à gauche, pour éviter des tabulations non esthétiques !
%\end{codeattention}

\begin{codecles}
Plusieurs \Cle{clés} sont disponibles :

\begin{itemize}
	\item la clé booléenne \Cle{Lignes} pour afficher ou non les numéros de lignes ; \hfill{}défaut \Cle{true}
	\item \cmaj{2.1.3} la clé booléenne \Cle{Gobble} pour activer les options liées au \textsf{gobble} (v1.0 du package !) ; \hfill{}défaut \Cle{true}
	\item la clé \Cle{Largeur} qui correspond à la largeur de la \ctex{tcbox} ; \hfill{}défaut \Cle{\textbackslash linewidth}
	\item la clé \Cle{TaillePolice} pour la taille des caractères ; \hfill{}défaut \Cle{\textbackslash footnotesize}
	\item la clé \Cle{Alignement} qui paramètre l'alignement de la \ctex{tcbox}. \hfill{}défaut \Cle{center}
\end{itemize}
\end{codecles}

\begin{codetex}[listing only]
\begin{CodePiton}
#environnement piton avec numéros de ligne, pleine largeur
def arctan(x,n=10):
	if x < 0:
		return -arctan(-x) #> (appel récursif)
	elif x > 1:
		return pi/2 - arctan(1/x) #> (autre appel récursif)
	else:
		return sum( (-1)**k/(2*k+1)*x**(2*k+1) for k in range(n) )
\end{CodePiton}
\end{codetex}

\begin{codesortie}
\begin{CodePiton}
#environnement piton avec numéros de ligne, pleine largeur
def arctan(x,n=10):
	if x < 0:
		return -arctan(-x) #> (appel récursif)
	elif x > 1:
		return pi/2 - arctan(1/x) #> (autre appel récursif)
	else:
		return sum( (-1)**k/(2*k+1)*x**(2*k+1) for k in range(n) )
\end{CodePiton}
\end{codesortie}

\pagebreak

\begin{codetex}[listing only]
\begin{CodePiton}[Lignes=false,Largeur=15cm]
#sans numéro, de largeur 15cm
def f(x) :
	return x**2
\end{CodePiton}

\begin{CodePiton}[Alignement=flush right,Largeur=13cm]
#avec numéros, de largeur 13cm, aligné à droite
def f(x) :
	return x**2
\end{CodePiton}

\begin{CodePiton}[Alignement=flush left,Largeur=11cm]
#avec numéros, de largeur 11cm, aligné à gauche
def f(x) :
	return x**2
\end{CodePiton}

Avec des indentations d'environnement :

\begin{itemize}
	\item On essaye avec un \texttt{itemize} :
	
	\begin{CodePiton}[Largeur=7cm]
		#avec numéros, de largeur 7cm, centré
		def f(x) :
			return x**2
	\end{CodePiton}
\end{itemize}
\end{codetex}

\begin{codesortie}
\begin{CodePiton}[Lignes=false,Largeur=15cm]
#sans numéro, de largeur 15cm
def f(x) :
	return x**2
\end{CodePiton}

\begin{CodePiton}[Alignement=flush right,Largeur=13cm]
#avec numéros, de largeur 13cm, aligné à droite
def f(x) :
	return x**2
\end{CodePiton}

\begin{CodePiton}[Alignement=flush left,Largeur=11cm]
#avec numéros, de largeur 11cm, aligné à gauche
def f(x) :
	return x**2
\end{CodePiton}

\begin{itemize}
	\item On essaye avec un \texttt{itemize} :
	
	\begin{CodePiton}[Largeur=7cm]
		#avec numéros, de largeur 7cm, centré
		def f(x) :
			return x**2
	\end{CodePiton}
\end{itemize}
\end{codesortie}

\pagebreak

\section{Code \& Console Python, via les packages Pythontex ou Minted}

\subsection{Introduction}

\begin{codeidee}
Le {package} \ctex{pythontex} permet d'insérer et d'exécuter du code Python. On peut :

\begin{itemize}
	\item présenter du code Python ;
	\item exécuter du code Python dans un environnement type \og console \fg{} ;
	\item charger du code Python, et éventuellement l'utiliser dans la console.
\end{itemize}
\end{codeidee}

\begin{codeattention}
\textbf{Attention : }il faut dans ce cas une compilation en plusieurs étapes, comme par exemple \textsf{pdflatex puis pythontex puis pdflatex} !

\cmaj{2.1.0} Il faut de plus penser à charger le package avec l'option \Cle{pythontex}.

Voir par exemple \url{http://lesmathsduyeti.fr/fr/informatique/latex/pythontex/} !
\end{codeattention}

\begin{codeinfo}
Compte tenu de la \textit{relative complexité} pour gérer les options (par paramètres/clés\ldots) des \textit{tcbox} et des \textit{fancyvrb}, le style est \og fixé \fg{} tel quel, et seules la taille et la position de la \textit{tcbox} sont modifiables. Si toutefois vous souhaitez personnaliser davantage, il faudra prendre le code correspondant et appliquer vos modifications !

Cela peut donner -- en tout cas -- des idées de personnalisation en ayant une base \textit{pré}existante !
\end{codeinfo}

\subsection{Présentation de code Python grâce au package pythontex}\label{pythontex}

\begin{codeidee}
L'environnement \ctex{CodePythontex} est donc lié à \ctex{pythontex} (chargé par \ctex{ProfLycee}, avec l'option \textit{autogobble}) permet de présenter du code python, dans une \ctex{tcolorbox} avec un style particulier.
\end{codeidee}

\begin{codetex}[listing only]
\begin{CodePythontex}[options]
...
\end{CodePythontex}
\end{codetex}

\begin{codecles}
Comme précédemment, des \Cle{Clés} qui permettent de \textit{légèrement} modifier le style :

\begin{itemize}
	\item \Cle{Largeur} : largeur de la \textit{tcbox} ;\hfill{}défaut \Cle{\textbackslash linewidth}
	\item \Cle{Centre} : booléen pour centrer ou non la \textit{tcbox} ;\hfill{}défaut \Cle{true}
	\item \Cle{TaillePolice} : taille des caractères ;\hfill{}défaut \Cle{\textbackslash footnotesize}
	\item \Cle{EspacementVertical} : option (\textit{stretch}) pour l'espacement entre les lignes ;\hfill{}défaut \Cle{1}
	\item \Cle{Lignes} : booléen pour afficher ou non les numéros de ligne.\hfill{}défaut \Cle{true}
\end{itemize}
\end{codecles}

\begin{codetex}[listing only]
\begin{CodePythontex}[Largeur=12cm]
	#environnement Python(tex) centré avec numéros de ligne
	def f(x) :
		return x**2
\end{CodePythontex}
\end{codetex}

\begin{codesortie}
\begin{CodePythontex}[Largeur=12cm]
	#environnement Python(tex) centré avec numéros de ligne
	def f(x) :
		return x**2
\end{CodePythontex}
\end{codesortie}

\begin{codetex}[listing only]
\begin{CodePythontex}[Largeur=12cm,Lignes=false,Centre=false]
	#environnement Python(tex) non centré sans numéro de ligne
	def f(x) :
		return x**2
\end{CodePythontex}
\end{codetex}

\begin{codesortie}
\begin{CodePythontex}[Largeur=12cm,Lignes=false,Centre=false]
	#environnement Python(tex) non centré sans numéro de ligne
	def f(x) :
		return x**2
\end{CodePythontex}
\end{codesortie}

\subsection{Présentation de code Python via le package minted}\label{pytminted}

\begin{codeinfo}
Pour celles et ceux qui ne sont pas à l'aise avec le {package} \ctex{pythontex} et notamment sa spécificité pour compiler, il existe le {package} \ctex{minted} qui permet de présenter du code, et notamment Python.
\end{codeinfo}

\begin{codeattention}
Le package \ctex{minted} nécessite quand même une compilation avec l'option \ctex{--shell-escape} ou \ctex{-write18} !
\end{codeattention}

\begin{codetex}[listing only]
\begin{CodePythonMinted}(*)[largeur][options]
...
\end{CodePythonMinted}
\end{codetex}

\begin{codecles}
Plusieurs \Cle{arguments} (optionnels) sont disponibles :

\begin{itemize}
	\item la version \textit{étoilée} qui permet de ne pas afficher les numéros de lignes ;
	\item le premier argument optionnel concerne la \Cle{largeur} de la \ctex{tcbox} ;\hfill{}défaut \Cle{12cm}
	\item le second argument optionnel concerne les \Cle{options} de la \ctex{tcbox} en \textit{langage tcolorbox}.\hfill{}défaut \Cle{vide}
\end{itemize}
\end{codecles}

\begin{codetex}[listing only]
\begin{CodePythonMinted}[12cm][center]
	#environnement Python(minted) centré avec numéros, de largeur 12cm
	def f(x) :
		return x**2
\end{CodePythonMinted}
\end{codetex}

\begin{codesortie}
\begin{CodePythonMinted}[12cm][center]
	#environnement Python(minted) centré avec numéros
	def f(x) :
		return x**2
\end{CodePythonMinted}
\end{codesortie}

\begin{codetex}[listing only]
\begin{CodePythonMinted}*[0.8\linewidth][]
	#environnement Python(minted) sans numéro, de largeur 0.8\linewidth
	def f(x) :
		return x**2
\end{CodePythonMinted}
\end{codetex}

\begin{codesortie}
\begin{CodePythonMinted}*[0.8\linewidth][]
	#environnement Python(minted) sans numéro, de largeur 0.8\linewidth
	def f(x) :
		return x**2
\end{CodePythonMinted}
\end{codesortie}

\subsection{Console d'exécution Python}

\begin{codeidee}
\ctex{pythontex} permet également de \textit{simuler} (en exécutant également !) du code python dans une \textit{console}.

C'est l'environnement \ctex{ConsolePythontex} qui permet de le faire.

\cmaj{2.1.0} Il ne faut donc pas oublier de charger le package \ctex{ProfLycee} avec l'option \Cle{pythontex}.
\end{codeidee}

\begin{codetex}[listing only]
\begin{ConsolePythontex}[options]
...
\end{ConsolePythontex}
\end{codetex}

\begin{codecles}
Les \Cle{Clés} disponibles sont :

\begin{itemize}
	\item \Cle{Largeur} : largeur de la \textit{console} ;\hfill{}défaut \Cle{\textbackslash linewidth}
	\item \Cle{Centre} : booléen pour centrer ou non la \textit{console} ;\hfill{}défaut \Cle{true}
	\item \Cle{TaillePolice} : taille des caractères ;\hfill{}défaut \Cle{\textbackslash footnotesize}
	\item \Cle{EspacementVertical} : option (\textit{stretch}) pour l'espacement entre les lignes ;\hfill{}défaut \Cle{1}
	\item \Cle{Label} : booléen pour afficher ou non le titre.\hfill{}défaut \Cle{true}
\end{itemize}
\end{codecles}

\begin{codetex}[listing only]
\begin{ConsolePythontex}[Largeur=14cm,Centre=false]
	#console Python(tex) non centrée avec label
	from math import sqrt
	1+1
	sqrt(12)
\end{ConsolePythontex}
\end{codetex}

\begin{codesortie}
\smallskip
\begin{ConsolePythontex}[Largeur=14cm,Centre=false]
	#console Python(tex) non centrée avec label
	from math import sqrt
	1+1
	sqrt(12)
\end{ConsolePythontex}
\end{codesortie}

\begin{codetex}[listing only]
\begin{ConsolePythontex}[Largeur=14cm,Label=false]
	#console Python(tex) centrée sans label
	table = [[1,2],[3,4]]
	table[0][0]
	
	from random import randint
	tableau = [[randint(1,20) for j in range(0,6)] for i in range(0,3)]
	tableau
	len(tableau), len(tableau[0])
	tableau[1][4]
\end{ConsolePythontex}
\end{codetex}

\begin{codesortie}
\smallskip
\begin{ConsolePythontex}[Largeur=14cm,Label=false]
	#console Python(tex) centrée sans label
	table = [[1,2],[3,4]]
	table[0][0]
	
	from random import randint
	tableau = [[randint(1,20) for j in range(0,6)] for i in range(0,3)]
	tableau
	len(tableau), len(tableau[0])
	tableau[1][4]
\end{ConsolePythontex}
\end{codesortie}

\begin{codeinfo}
Le package \ctex{pythontex} peut donc servir à présenter du code Python, comme \ctex{minted} ou \ctex{piton}, sa particularité est toutefois de pouvoir \textit{exécuter} du code Python pour une présentation de type \textit{console}.
\end{codeinfo}

\newpage

\section{Pseudo-Code}\label{pseudocode}

\subsection{Introduction}

\begin{codeinfo}
Le {package} \ctex{listings} permet d'insérer et de présenter du code, et avec \ctex{tcolorbox} on peut obtenir une présentation similaire à celle du code Python. Pour le moment la \textit{philosophie} de la commande est un peu différente de celle du code python, avec son système de \Cle{Clés}, car l'environnement \ctex{tcblisting} est un peu différent\ldots
\end{codeinfo}

\subsection{Présentation de Pseudo-Code}

\begin{codeidee}
L'environnement \ctex{PseudoCode} permet de présenter du (pseudo-code) dans une \ctex{tcolorbox}.
\end{codeidee}

\begin{codeattention}
De plus, le package \ctex{listings} avec \ctex{tcolorbox} ne permet pas de gérer le paramètre \textit{autogobble}, donc il faudra être vigilant quant à la position du code (pas de tabulation en fait\ldots)
\end{codeattention}

\begin{codetex}[listing only]
\begin{PseudoCode}(*)[largeur][options]
%attention à l'indentation, gobble ne fonctionne pas...
...
\end{PseudoCode}
\end{codetex}

\begin{codecles}
Plusieurs \Cle{arguments} (optionnels) sont disponibles :

\begin{itemize}
	\item la version \textit{étoilée} qui permet de ne pas afficher les numéros de lignes ;
	\item le premier argument optionnel concerne la \Cle{largeur} de la \ctex{tcbox} ;\hfill{}défaut \Cle{12cm}
	\item le second argument optionnel concerne les \Cle{options} de la \ctex{tcbox} en \textit{langage tcolorbox}.\hfill{}défaut \Cle{vide}
\end{itemize}
\end{codecles}

\begin{codetex}[listing only]
\begin{PseudoCode} %non centré, de largeur par défaut (12cm) avec lignes
List = [...]          # à déclarer au préalable
n = longueur(List)
Pour i allant de 0 à n-1 Faire
	Afficher(List[i])
FinPour
\end{PseudoCode}
\end{codetex}

\begin{codesortie}
\begin{PseudoCode}
List = [...]          # à déclarer au préalable
n = longueur(List)
Pour i allant de 0 à n-1 Faire
	Afficher(List[i])
FinPour
\end{PseudoCode}
\end{codesortie}

\begin{codetex}[listing only]
\begin{PseudoCode}*[15cm][center] %centré, de largeur 15cm sans ligne
List = [...]          # à déclarer au préalable
n = longueur(List)
Pour i allant de 0 à n-1 Faire
	Afficher(List[i])
FinPour
\end{PseudoCode}
\end{codetex}

\begin{codesortie}
\begin{PseudoCode}*[15cm][center]
List = [...]          # à déclarer au préalable
n = longueur(List)
Pour i allant de 0 à n-1 Faire
	Afficher(List[i])
FinPour
\end{PseudoCode}
\end{codesortie}

\subsection{Compléments}

\begin{codeinfo}
À l'instar de packages existants, la \textit{philosophie} ici est de laisser l'utilisateur gérer \textit{son} langage pseudo-code.

J'ai fait le choix de ne pas définir des \textsf{mots clés} à mettre en valeur car cela reviendrait à \textit{imposer} des choix ! Donc ici, pas de coloration syntaxique ou de mise en évidence de mots clés, uniquement un formatage basique de pseudo-code.
\end{codeinfo}

\begin{codeidee}
Évidemment, le code source est récupérable et adaptable à volonté, en utilisant les possibilités du package \ctex{listings}.

\smallskip

Celles et ceux qui sont déjà à l'aise avec les packages \ctex{listings} ou \ctex{minted} doivent déjà avoir leur environnement personnel prêt ! 

Il s'agit ici de présenter une version \og clé en main \fg{}.
\end{codeidee}

\begin{codeinfo}
Le style \ctex{listings} utilisé par la commande a l'option \Cle{mathescape} activée, et accessible grâce aux délimiteurs \Cle{(*...*)}.

Cela permet d'insérer du code \LaTeX{} dans l'environnement \ctex{PseudoCode} (attention au fontes de rendu par contre !).
\end{codeinfo}

\begin{codetex}[listing only]
\begin{PseudoCode}[12cm][]
#Utilisation du mode mathescape
Afficher (*\og*) .........(*\fg*)
m = (*$\tfrac{\texttt{1}}{\texttt{2}}$*)
\end{PseudoCode}
\end{codetex}

\begin{codesortie}
\begin{PseudoCode}[12cm][]
#Utilisation du mode mathescape
Afficher (*\og*) .........(*\fg*)
m = (*$\tfrac{\texttt{1}}{\texttt{2}}$*)
\end{PseudoCode}
\end{codesortie}

\newpage

\section{Terminal Windows/UNiX/OSX}\label{terms}

\subsection{Introduction}

\begin{codeidee}
L'idée des \textsf{commandes} suivantes est de permettre de simuler des fenêtres de \textsf{Terminal}, que ce soit pour Windows, Ubuntu ou OSX.

\smallskip

L'idée de base vient du {package} \ctex{termsim}, mais ici la gestion du \textsf{code} et des \textsf{fenêtres} est légèrement différente.

\smallskip

Le \textsf{contenu} est géré par le package \ctex{listings}, sans langage particulier, et donc sans coloration syntaxique particulière.
\end{codeidee}

\begin{codeattention}
Comme pour le pseudo-code, pas d'\textsf{autogobble}, donc commandes à aligner à gauche !
\end{codeattention}

\subsection{Commandes}

\begin{codetex}[listing only]
\begin{TerminalWin}[largeur]{titre=...}[options]
...
\end{TerminalWin}

\begin{TerminalUnix}[largeur]{titre=...}[options]
...
\end{TerminalUnix}

\begin{TerminalOSX}[largeur]{titre=...}[options]
...
\end{TerminalOSX}
\end{codetex}

\begin{codecles}
Peu d'options pour ces commandes :

\begin{itemize}
	\item le premier, optionnel, est la \Cle{largeur} de la \ctex{tcbox} ;\hfill{}défaut \Cle{\textbackslash linewidth}
	\item le deuxième, mandataire, permet de spécifier le titre par la clé \Cle{titre}.\hfill{}défaut \Cle{Terminal Windows/UNiX/OSX}
	\item le troisième, optionnel, concerne les \Cle{options} de la \ctex{tcbox} en \textit{langage tcolorbox}.\hfill{}défaut \Cle{vide}
\end{itemize}
\end{codecles}

\begin{codeinfo}
Le \textsf{code} n'est pas formaté, ni mis en coloration syntaxique.

De ce fait tous les caractères sont autorisés : même si l'éditeur pourra détecter le \% comme le début d'un commentaire, tout sera intégré dans le code mis en forme !
\end{codeinfo}

\begin{codetex}[listing only]
\begin{TerminalUnix}[12cm]{Titre=Terminal Ubuntu}[center] %12cm, avec titre modifié et centré
test@DESKTOP:~$ ping -c 2 ctan.org
PING ctan.org (5.35.249.60) 56(84) bytes of data.
\end{TerminalUnix}
\end{codetex}

\begin{codesortie}
\begin{TerminalUnix}[12cm]{Titre=Terminal Ubuntu}[center]
test@DESKTOP:~$ ping -c 2 ctan.org
PING ctan.org (5.35.249.60) 56(84) bytes of data.
\end{TerminalUnix}
\end{codesortie}

\begin{codetex}[listing only]
\begin{TerminalWin}[15cm]{} %largeur 15cm avec titre par défaut
Microsoft Windows [version 10.0.22000.493]
(c) Microsoft Corporation. Tous droits réservés.
C:\Users\test>ping ctan.org

Envoi d’une requête 'ping' sur ctan.org [5.35.249.60] avec 32 octets de données :
Réponse de 5.35.249.60 : octets=32 temps=35 ms TTL=51
Réponse de 5.35.249.60 : octets=32 temps=37 ms TTL=51
Réponse de 5.35.249.60 : octets=32 temps=35 ms TTL=51
Réponse de 5.35.249.60 : octets=32 temps=39 ms TTL=51

Statistiques Ping pour 5.35.249.60:
Paquets : envoyés = 4, reçus = 4, perdus = 0 (perte 0%),
Durée approximative des boucles en millisecondes :
Minimum = 35ms, Maximum = 39ms, Moyenne = 36ms
\end{TerminalWin}

\begin{TerminalOSX}[0.5\linewidth]{Titre=Terminal MacOSX}[flush right] %1/2-largeur et titre modifié et droite
[test@server]$ ping -c 2 ctan.org
PING ctan.org (5.35.249.60) 56(84) bytes of data.
\end{TerminalOSX}
\end{codetex}

\begin{codesortie}
\begin{TerminalWin}[15cm]{}
Microsoft Windows [version 10.0.22000.493]
(c) Microsoft Corporation. Tous droits réservés.
C:\Users\test>ping ctan.org

Envoi d’une requête 'ping' sur ctan.org [5.35.249.60] avec 32 octets de données :
Réponse de 5.35.249.60 : octets=32 temps=35 ms TTL=51
Réponse de 5.35.249.60 : octets=32 temps=37 ms TTL=51
Réponse de 5.35.249.60 : octets=32 temps=35 ms TTL=51
Réponse de 5.35.249.60 : octets=32 temps=39 ms TTL=51

Statistiques Ping pour 5.35.249.60:
Paquets : envoyés = 4, reçus = 4, perdus = 0 (perte 0%),
Durée approximative des boucles en millisecondes :
Minimum = 35ms, Maximum = 39ms, Moyenne = 36ms
\end{TerminalWin}

\begin{TerminalUnix}[12cm]{Titre=Terminal Ubuntu}[center]
test@DESKTOP:~$ ping -c 2 ctan.org
PING ctan.org (5.35.249.60) 56(84) bytes of data.
\end{TerminalUnix}

\begin{TerminalOSX}[0.5\linewidth]{Titre=Terminal MacOSX}[flush right]
[test@server]$ ping -c 2 ctan.org
PING ctan.org (5.35.249.60) 56(84) bytes of data.
\end{TerminalOSX}
\end{codesortie}

\newpage

\section{Cartouche Capytale}\label{capytale}

\subsection{Introduction}

\begin{codeidee}
L'idée est d'obtenir des \textsf{cartouches} tels que \textsf{Capytale} les présente, pour partager un code afin d'accéder à une activité \textsf{python}.
\end{codeidee}

\subsection{Commandes}

\begin{codetex}[listing only]
\CartoucheCapytale(*)[options]{code capytale}
\end{codetex}

\begin{codecles}
Peu d'options pour ces commandes :

\begin{itemize}
	\item la version \textit{étoilée} qui permet de  passer de la police \Cle{sffamily} à la police \Cle{ttfamily}, et donc dépendante des fontes du document ;
	\item le deuxième, optionnel, permet de rajouter des caractères après le code (comme un \textsf{espace}) ;\hfill{}défaut \Cle{vide}
	\item le troisième, mandataire, est le \textsf{code capytale} à afficher.
\end{itemize}
\end{codecles}

\begin{codetex}[listing only]
\CartoucheCapytale{abcd-12345}           %lien simple, en sf

\CartoucheCapytale[~]{abcd-12345}        %lien avec ~ à la fin, en sf

\CartoucheCapytale*{abcd-12345}          %lien simple, en tt

\CartoucheCapytale*[~]{abcd-12345}       %lien avec ~ à la fin, en tt
\end{codetex}

\begin{codesortie}
\CartoucheCapytale{abcd-12345}

\CartoucheCapytale[~]{abcd-12345}

\CartoucheCapytale*{abcd-12345}

\CartoucheCapytale*[~]{abcd-12345}
\end{codesortie}

\begin{codeinfo}
Le \textsf{cartouche} peut être \og cliquable \fg{} grâce à \ctex{href}.
\end{codeinfo}

\begin{codetex}[listing only]
\usepackage{hyperref}
\urlstyle{same}
...
\href{https://capytale2.ac-paris.fr/web/c/abcd-12345}{\CartoucheCapytale{abcd-12345}}
\end{codetex}

\begin{codesortie}
\href{https://capytale2.ac-paris.fr/web/c/abcd-12345}{\CartoucheCapytale{abcd-12345}}
\end{codesortie}

\newpage

\section{Présentation de code \LaTeX}\label{prescode}

\subsection{Introduction}

\begin{codeidee}
\cmaj{2.0.6} L'idée est de proposer un environnement pour présenter du code \LaTeX. Ce n'est pas forcément lié à l'enseignement en Lycée mais pourquoi pas !

\smallskip

Il s'agir d'un environnement créé en \ctex{tcolorbox}, et utilisant la présentation \textit{basique} de code via \ctex{listings}.
\end{codeidee}

\subsection{Commandes}

\begin{codetex}[listing only]
\begin{PresentationCode}[Couleur]{options tcbox}
...
\end{PresentationCode}
\end{codetex}

\begin{codecles}
Peu de personnalisations pour ces commandes :

\begin{itemize}
	\item le premier argument, optionnel, permet de préciser la \textit{couleur} de la présentation ;\hfill{}défaut \Cle{ForestGreen}
	\item le second, mandataire, correspond aux éventuelles options liées à la \ctex{tcolorbox}.
\end{itemize}
\end{codecles}

\begin{codeinfo}
Il est à noter que, même dans le cas d'option vide pour la \ctex{tcolorbox}, les \ctex{\{\}} sont nécessaires.

\smallskip

On peut par exemple utiliser l'option \Cle{listing only} pour ne présenter \textit{que} le code source.
\end{codeinfo}

\begin{codetex}[]
\begin{PresentationCode}{}
\xdef\ValAleaA{\fpeval{randint(1,100)}}
\xdef\ValAleaB{\fpeval{randint(1,100)}}

Avec $A=\ValAleaA$ et $B=\ValAleaB$, on a $A\times B=\inteval{\ValAleaA * \ValAleaB}$
\end{PresentationCode}

\begin{PresentationCode}[DarkBlue]{}
On peut faire beaucoup de choses avec \LaTeX{} !
\end{PresentationCode}
\end{codetex}

\pagebreak

\part{Outils pour la géométrie}

\section{Pavé droit \og simple \fg}\label{pave}

\subsection{Introduction}

\begin{codeidee}
L'idée est d'obtenir un pavé droit, dans un environnement \TikZ, avec les nœuds créés et nommés directement pour utilisation ultérieure.
\end{codeidee}

\subsection{Commandes}

\begin{codetex}[listing only]
...
\begin{tikzpicture}[options tikz]
	\PaveTikz[options]
	...
\end{tikzpicture}
\end{codetex}

\begin{codecles}
Quelques \Cle{clés} sont disponibles pour cette commande :

\begin{itemize}
	\item \Cle{Largeur} : largeur du pavé ;\hfill{}défaut \Cle{2}
	\item \Cle{Profondeur} : profondeur du pavé ;\hfill{}défaut \Cle{1}
	\item \Cle{Hauteur} : hauteur du pavé ;\hfill{}défaut \Cle{1.25}
	\item \Cle{Angle} : angle de fuite de la perspective ;\hfill{}défaut \Cle{30}
	\item \Cle{Fuite} : coefficient de fuite de la perspective ;\hfill{}défaut \Cle{0.5}
	\item \Cle{Sommets} : liste des sommets (avec délimiteur § !) ;\hfill{}défaut \Cle{A§B§C§D§E§F§G§H}
	\item \Cle{Epaisseur} : épaisseur des arêtes (en \textit{langage simplifié} \TikZ) ;\hfill{}défaut \Cle{thick}
	\item \Cle{Aff} : booléen pour afficher les noms des sommets ;\hfill{}défaut \Cle{false}
	\item \Cle{Plein} : booléen pour ne pas afficher les arêtes \textit{invisibles} ;\hfill{}défaut \Cle{false}
	\item \Cle{Cube} : booléen pour préciser qu'il s'agit d'un cube (seule la valeur \Cle{Largeur} est util(isé)e).\hfill{}défaut \Cle{false}
\end{itemize}
\end{codecles}

\begin{codetex}[tikz lower]
%code tikz
\PaveTikz
\end{codetex}

\begin{codetex}[tikz lower]
%code tikz
\PaveTikz[Cube,Largeur=2]
\end{codetex}

\begin{codeinfo}
La ligne est de ce fait à insérer dans un environnement \TikZ, avec les options au choix pour cet environnement.

Le code crée les nœuds relatifs aux sommets, et les nomme comme les sommets, ce qui permet de les réutiliser pour éventuellement compléter la figure !
\end{codeinfo}

\subsection{Influence des paramètres}

\begin{codetex}[listing only]
\begin{tikzpicture}[line join=bevel]
	\PaveTikz[Aff,Largeur=4,Profondeur=3,Hauteur=2,Epaisseur={ultra thick}]
\end{tikzpicture}
\end{codetex}

\begin{codesortie}
\begin{tikzpicture}[line join=bevel]
	\PaveTikz[Aff,Largeur=4,Profondeur=3,Hauteur=2,Epaisseur={ultra thick}]
\end{tikzpicture}
\end{codesortie}

\begin{codetex}[listing only]
\begin{center}
	\begin{tikzpicture}[line join=bevel]
		\PaveTikz[Plein,Aff,Largeur=7,Profondeur=3.5,Hauteur=4,Sommets=Q§S§D§F§G§H§J§K]
		\draw[thick,red,densely dotted] (G)--(J) ;
		\draw[thick,blue,densely dotted] (K)--(H) ;
	\end{tikzpicture}
\end{center}
\end{codetex}

\begin{codesortie}
\begin{center}
	\begin{tikzpicture}[line join=bevel]
		\PaveTikz[Plein,Aff,Largeur=7,Profondeur=3.5,Hauteur=4,Sommets=Q§S§D§F§G§H§J§K]
		\draw[thick,red,densely dotted] (G)--(J) ;
		\draw[thick,blue,densely dotted] (K)--(H) ;
	\end{tikzpicture}
\end{center}
\end{codesortie}

\newpage

\section{Tétraèdre \og simple \fg}\label{tetra}

\subsection{Introduction}

\begin{codeidee}
L'idée est d'obtenir un tétraèdre, dans un environnement \TikZ, avec les nœuds créés et nommés directement pour utilisation ultérieure.
\end{codeidee}

\subsection{Commandes}

\begin{codetex}[listing only]
...
\begin{tikzpicture}[options tikz]
	\TetraedreTikz[options]
	...
\end{tikzpicture}
\end{codetex}

\begin{codecles}
Quelques \Cle{clés} sont disponibles pour cette commande :

\begin{itemize}
	\item \Cle{Largeur} : \textit{largeur} du tétraèdre ;\hfill{}défaut \Cle{4}
	\item \Cle{Profondeur} : \textit{profondeur} du tétraèdre ;\hfill{}défaut \Cle{1.25}
	\item \Cle{Hauteur} : \textit{hauteur} du tétraèdre ;\hfill{}défaut \Cle{3}
	\item \Cle{Alpha} : angle \textit{du sommet de devant} ;\hfill{}défaut \Cle{40}
	\item \Cle{Beta} : angle \textit{du sommet du haut} ;\hfill{}défaut \Cle{60}
	\item \Cle{Sommets} : liste des sommets (avec délimiteur § !) ;\hfill{}défaut \Cle{A§B§C§D}
	\item \Cle{Epaisseur} : épaisseur des arêtes (en \textit{langage simplifié} \TikZ) ;\hfill{}défaut \Cle{thick}
	\item \Cle{Aff} : booléen pour afficher les noms des sommets ;\hfill{}défaut \Cle{false}
	\item \Cle{Plein} : booléen pour ne pas afficher l'arête \textit{invisible} .\hfill{}défaut \Cle{false}
\end{itemize}
\end{codecles}

\begin{codetex}[tikz lower]
%code tikz
\TetraedreTikz
\end{codetex}

\begin{codetex}[tikz lower]
%code tikz
\TetraedreTikz[Aff,Largeur=2,Profondeur=0.625,Hauteur=1.5]
\end{codetex}

\begin{codetex}[tikz lower]
%code tikz
\TetraedreTikz[Plein,Aff,Largeur=5,Beta=60]
\end{codetex}

%\begin{codeinfo}
%La ligne est de ce fait à insérer dans un environnement \TikZ, avec les options au choix pour cet environnement.
%
%Le code créé les nœuds relatifs aux sommets, et les nomme comme les sommets, ce qui permet de les réutiliser pour éventuellement compléter la figure !
%\end{codeinfo}

\subsection{Influence des paramètres}

\begin{codeinfo}
Pour \textit{illustrer} un peu les \Cle{clés}, un petit schéma, avec les différents paramètres utiles.

\begin{center}
	\begin{tikzpicture}[x=1.25cm,y=1.25cm,line width=1pt,line join=bevel]
		\TetraedreTikz[Largeur=5,Profondeur=1.95,Hauteur=2.75,Alpha=45,Beta=70]
		\draw[draw=none] (A)--(C) node[midway,sloped,above,font=\small\sffamily,CadetBlue] {Largeur} ;
		\draw[draw=none] (A)--(B) node[midway,sloped,below,font=\small\sffamily,CadetBlue] {Profondeur} ;
		\draw[draw=none] (A)--(D) node[midway,sloped,above,font=\small\sffamily,CadetBlue] {Hauteur} ;
		\draw[purple] (0.5,0) arc (0:-45:0.5) ;
		\draw (-22.5:0.5) node[purple,right] {$\alpha$} ;
		\draw[orange] (0.75,0) arc (0:70:0.75) ;
		\draw (35:0.75) node[orange,right] {$\beta$} ;
	\end{tikzpicture}
\end{center}
\end{codeinfo}

\begin{codetex}[listing only]
\begin{center}
	\begin{tikzpicture}[line join=bevel]
		\TetraedreTikz[Aff,Largeur=7,Profondeur=3,Hauteur=5,Epaisseur={ultra thick},Alpha=20,Beta=30]
		\draw[very thick,ForestGreen,<->,>=latex] ($(A)!0.5!(D)$)--($(B)!0.5!(D)$) ;
	\end{tikzpicture}
\end{center}
\end{codetex}

\begin{codesortie}
\begin{center}
	\begin{tikzpicture}[line join=bevel]
		\TetraedreTikz[Aff,Largeur=7,Profondeur=3,Hauteur=5,Epaisseur={ultra thick},Alpha=20,Beta=30]
		\draw[very thick,ForestGreen,<->,>=latex] ($(A)!0.5!(D)$)--($(B)!0.5!(D)$) ;
	\end{tikzpicture}
\end{center}
\end{codesortie}
%
%\begin{codetex}[listing only]
%	\begin{center}
%		\begin{tikzpicture}[line join=bevel]
%			\pavePL[plein,aff,largeur=7,profondeur=3.5,hauteur=4,sommets=Q§S§D§F§G§H§J§K]
%			\draw[thick,red,densely dotted] (G)--(J) ;
%			\draw[thick,blue,densely dotted] (K)--(H) ;
%		\end{tikzpicture}
%	\end{center}
%\end{codetex}
%
%\medskip
%
%\begin{codesortie}
%	\begin{center}
%		\begin{tikzpicture}[line join=bevel]
%			\pavePL[plein,aff,largeur=7,profondeur=3.5,hauteur=4,sommets=Q§S§D§F§G§H§J§K]
%			\draw[thick,red,densely dotted] (G)--(J) ;
%			\draw[thick,blue,densely dotted] (K)--(H) ;
%		\end{tikzpicture}
%	\end{center}
%\end{codesortie}

\newpage

%\newpage
%
\section{Cercle trigo}\label{cercletrigo}

\subsection{Idée}

\begin{codeidee}
L'idée est d'obtenir une commande pour tracer (en \TikZ) un cercle trigonométrique, avec personnalisation des affichages.

\smallskip

Comme pour les autres commandes \TikZ, l'idée est de laisser l'utilisateur définir et créer son environnement \TikZ, et d'insérer la commande \ctex{CercleTrigo} pour afficher le cercle.
\end{codeidee}

\begin{codetex}[tikz lower]
%code tikz
\CercleTrigo
\end{codetex}

\subsection{Commandes}

\begin{codetex}[listing only]
...
\begin{tikzpicture}[options tikz]
	...
	\CercleTrigo[clés]
	...
\end{tikzpicture}
\end{codetex}

\begin{codecles}
Plusieurs \Cle{Clés} sont disponibles pour cette commande :

\begin{itemize}
	\item la clé \Cle{Rayon} qui définit le rayon du cercle ;\hfill{}défaut \Cle{3}
	\item la clé \Cle{Epaisseur} qui donne l'épaisseur des traits de base ;\hfill{}défaut \Cle{thick}
	\item la clé \Cle{Marge} qui est l'\textit{écartement} de axes  ;\hfill{}défaut \Cle{0.25}
	\item la clé \Cle{TailleValeurs} qui est la taille des valeurs remarquables ;\hfill{}défaut \Cle{scriptsize}
	\item la clé \Cle{TailleAngles} qui est la taille des angles ;\hfill{}défaut \Cle{footnotesize}
	\item la clé \Cle{CouleurFond} qui correspond à la couleur de fond des labels ;\hfill{}défaut \Cle{white}
	\item la clé \Cle{Decal} qui correspond au décalage des labels par rapport au cercle ;\hfill{}défaut \Cle{10pt}
	\item un booléen \Cle{MoinsPi} qui bascule les angles \og -pipi \fg{} à \og zerodeuxpi \fg{} ;\hfill{}défaut \Cle{true}
	\item un booléen \Cle{AffAngles} qui permet d'afficher les angles ;\hfill{}défaut \Cle{true}
	\item un booléen \Cle{AffTraits} qui permet d'afficher les \textit{traits de construction}  ;\hfill{}défaut \Cle{true}
	\item un booléen \Cle{AffValeurs} qui permet d'afficher les valeurs remarquables.\hfill{}défaut \Cle{true}
\end{itemize}
\end{codecles}

\pagebreak

\begin{codetex}[listing only]
\begin{center}
	\begin{tikzpicture}[line join=bevel]
			\CercleTrigo[Rayon=2.5,AffValeurs=false,Decal=8pt]
		\end{tikzpicture}
	~~~~
	\begin{tikzpicture}[line join=bevel]
			\CercleTrigo[Rayon=2.5,AffAngles=false]
		\end{tikzpicture}
	~~~~
	\begin{tikzpicture}[line join=bevel]
			\CercleTrigo[Rayon=2.5,MoinsPi=false,CouleurFond=orange!15]
		\end{tikzpicture}
\end{center}
\end{codetex}

\begin{codesortie}
\begin{center}
	\begin{tikzpicture}[line join=bevel]
			\CercleTrigo[Rayon=2.5,AffValeurs=false,Decal=8pt]
		\end{tikzpicture}
	~~~~
	\begin{tikzpicture}[line join=bevel]
			\CercleTrigo[Rayon=2.5,AffAngles=false]
		\end{tikzpicture}
	~~~~
	\begin{tikzpicture}[line join=bevel]
			\CercleTrigo[Rayon=2.5,MoinsPi=false,CouleurFond=orange!15,TailleValeurs=\tiny]
		\end{tikzpicture}
\end{center}
\end{codesortie}

\subsection{Équations trigos}

\begin{codeinfo}
En plus des \Cle{Clés} précédentes, il existe un complément pour \textit{visualiser} des solutions d'équations simples du type $\cos(x)=\ldots$ ou $\sin(x)=\ldots$.
\end{codeinfo}

\begin{codecles}
Les \Cle{Clés} pour cette possibilité sont :

\begin{itemize}
	\item un booléen \Cle{Equationcos} pour \textit{activer} \og $\cos=$ \fg; \hfill{}défaut \Cle{false}
	\item un booléen \Cle{Equationsin} pour \textit{activer} \og $\sin=$ \fg;\hfill{}défaut \Cle{false}
	\item la clé \Cle{sin} qui est la valeur de l'angle (en degrés) du sin ;\hfill{}défaut \Cle{30}
	\item la clé \Cle{cos} qui est la valeur de l'angle (en degrés) cos ;\hfill{}défaut \Cle{45}
	\item la clé \Cle{CouleurSol} qui est la couleur des \textit{solutions}.\hfill{}défaut \Cle{blue}
\end{itemize}
\end{codecles}

\begin{codetex}[listing only]
\begin{center}
	\begin{tikzpicture}
		\CercleTrigo[%
		AffAngles=false,AffValeurs=false,AffTraits=false,Rayon=2,Equationsin,sin=-30,CouleurSol=red]
	\end{tikzpicture}
	~~~~
	\begin{tikzpicture}
		\CercleTrigo[%
		AffAngles=false,AffValeurs=false,AffTraits=false,Rayon=2,Equationcos,cos=135,CouleurSol=orange]
	\end{tikzpicture}
	
	\medskip
	
	\begin{tikzpicture}
		\CercleTrigo[%
		AffTraits=false,AffAngles=false,Rayon=2.75,Equationcos,cos=60,CouleurSol=purple,TailleVvaleurs=\tiny]
	\end{tikzpicture}
\end{center}
\end{codetex}

\begin{codesortie}
\begin{center}
	\begin{tikzpicture}
		\CercleTrigo[%
		AffAngles=false,AffValeurs=false,AffTraits=false,Rayon=2,Equationsin,sin=-30,CouleurSol=red]
	\end{tikzpicture}
	~~~~
	\begin{tikzpicture}
		\CercleTrigo[%
		AffAngles=false,AffValeurs=false,AffTraits=false,Rayon=2,Equationcos,cos=135,CouleurSol=orange]
	\end{tikzpicture}
	
	\medskip
	
	\begin{tikzpicture}
		\CercleTrigo[%
		AffTraits=false,AffAngles=false,Rayon=2.75,Equationcos,cos=60,CouleurSol=purple,TailleVvaleurs=\tiny]
	\end{tikzpicture}
\end{center}
\end{codesortie}

\newpage

\section{Style \og main levée \fg{} en \TikZ}\label{mainlevee}

\subsection{Idée}

\begin{codeidee}
L'idée est de \textit{proposer} un style \textit{tout prêt} pour simuler un tracé, en \TikZ, à \og main levée \fg.

Il s'agit d'un style \textit{basique} utilisant la librairie \ctex{decorations} avec \textsf{random steps}.
\end{codeidee}

\begin{codetex}[listing only]
\tikzset{%
	mainlevee/.style args={#1et#2}{decorate,decoration={random steps, segment length=#1,amplitude=#2}},
	mainlevee/.default={5mm et 0.6pt}
}
\end{codetex}

\subsection{Utilisation basique}

\begin{codeinfo}
Il s'agit ni plus ni moins d'un style \TikZ{} à intégrer dans les tracés et constructions \TikZ !
\end{codeinfo}

\begin{codecles}
Concernant le style en lui-même, deux paramètres peuvent être précisés via \Cle{mainlevee=\#1 et \#2} :

\begin{itemize}
	\item \Cle{\#1} correspond à l'option \textsf{segment length} (longueur des segments \textit{types}) ;\hfill{}défaut \Cle{5mm}
	\item \Cle{\#2} correspond à l'option \textsf{amplitude} (amplitude maximale de la \textit{déformation}).\hfill{}défaut \Cle{0.6pt}
\end{itemize}

Les valeurs \Cle{mainlevee=5mm et 0.6pt} donnent des résultats -- à mon sens -- satisfaisants, mais l'utilisateur pourra modifier à loisir ces paramètres !
\end{codecles}

\begin{codetex}[listing only]
%la grille a été rajoutée pour la sortie
\begin{tikzpicture}
	\draw[thick,mainlevee] (0,0) --++ (4,0) --++ (0,4) --++ (-4,0) --cycle ;
\end{tikzpicture}

\begin{tikzpicture}
	\draw[thick,mainlevee=5mm et 2pt] (0,0) --++ (4,0) --++ (0,4) --++ (-4,0) --cycle ;
\end{tikzpicture}

\begin{tikzpicture}
	\draw[thick,mainlevee=10mm et 3mm] (0,0) --++ (4,0) --++ (0,4) --++ (-4,0) --cycle ;
\end{tikzpicture}
\end{codetex}

\begin{codesortie}
\hfill~\begin{tikzpicture}
	\draw[xstep=0.5,ystep=0.5,ultra thin,lightgray] (0,0) grid (4,4);
	\draw[thick,mainlevee] (0,0) --++ (4,0) --++ (0,4) --++ (-4,0) --cycle ;
\end{tikzpicture}
\hspace{1.5cm}
\begin{tikzpicture}
	\draw[xstep=0.5,ystep=0.5,ultra thin,lightgray] (0,0) grid (4,4);
	\draw[thick,mainlevee=5mm et 2pt] (0,0) --++ (4,0) --++ (0,4) --++ (-4,0) --cycle ;
\end{tikzpicture}
\hspace{1.5cm}
\begin{tikzpicture}
	\draw[xstep=0.5,ystep=0.5,ultra thin,lightgray] (0,0) grid (4,4);
	\draw[thick,mainlevee=10mm et 3mm] (0,0) --++ (4,0) --++ (0,4) --++ (-4,0) --cycle ;
\end{tikzpicture}
\hfill~
\end{codesortie}

\newpage

\part{Outils pour les statistiques}

\section{Paramètres d'une régression linéaire par la méthode des moindres carrés}\label{reglin}

\subsection{Idée}

\begin{codeidee}
L'idée est d'utiliser une commande qui va permettre de calculer les paramètres principaux d'un régression linéaire par la méthode des moindres carrés.

Le package \ctex{pgfpots} permet de le faire nativement, mais le moteur de calculs de \textsf{pgf} peut poser souci avec de grandes valeurs, donc ici cela passe par \ctex{xfp} qui permet de \textit{gagner} en précision !

\smallskip

L'idée est que cette macro calcule et stocke les paramètres dans des variables (le nom peut être personnalisé !) pour exploitation ultérieure :

\begin{itemize}
	\item en calculs \textit{purs} ;
	\item dans un environnement \TikZ{} via \textsf{pgfplots} ou bien en \textit{natif} ;
	\item dans un environnement \PSTricks{} ;
	\item dans un environnement \METAPOST{} (à vérifier quand même) ;
	\item \ldots
\end{itemize}
\end{codeidee}

\begin{codetex}[listing only]
...
\CalculsRegLin[clés]{listeX}{listeY}  %listes avec éléments séparés par des ,
...
\end{codetex}

\begin{codeinfo}
La commande \ctex{CalculsRegLin} va définir également des \textsf{macros} pour chaque coefficient, qui de ce fait seront réutilisables après !
\end{codeinfo}

\subsection{Commandes}

\begin{codecles}
Quelques \Cle{Clés} sont disponibles pour cette commande, essentiellement pour \textit{renommer} les paramètres :

\begin{itemize}
	\item la clé \Cle{NomCoeffa} qui permet de définir la variable qui contiendra $a$ ;\hfill{}défaut \Cle{COEFFa}
	\item la clé \Cle{NomCoeffb} qui permet de définir la variable qui contiendra $b$ ;\hfill{}défaut \Cle{COEFFb}
	\item la clé \Cle{NomCoeffr} qui permet de définir la variable qui contiendra $r$ ;\hfill{}défaut \Cle{COEFFr}
	\item la clé \Cle{NomCoeffrd} qui permet de définir la variable qui contiendra $r^2$ ;\hfill{}défaut \Cle{COEFFrd}
	\item la clé \Cle{NomXmin} qui permet de définir la variable qui contiendra $x_{\text{min}}$ ;\hfill{}défaut \Cle{LXmin}
	\item la clé \Cle{NomXmax} qui permet de définir la variable qui contiendra $x_{\text{max}}$.\hfill{}défaut \Cle{LXmax}
\end{itemize}
\end{codecles}

\begin{codetex}[listing only]
%les espaces verticaux n'ont pas été écrits ici
\def\LLX{1994,1995,1996,1997,1998,1999,2000,2001,2002,2004,2005,2006,2007,2008,2009,2010}
\def\LLY{1718,1710,1708,1700,1698,1697,1691,1688,1683,1679,1671,1670,1663,1661,1656,1649}
\CalculsRegLin{\LLX}{\LLY}
\end{codetex}

\begin{codetex}[listing only]
%vérif des calculs (noms non modifiables...)
Liste des X := \showitems\LX.
Liste des Y := \showitems\LY.
Somme des X := \LXSomme{} et somme des Y := \LYSomme.
Moyenne des X := \LXmoy{} et moyenne des Y := \LYmoy.
Variance des X := \LXvar{} et variance des Y := \LYvar{}
Covariance des X/Y := \LXYvar.
%les coefficients, avec des noms modifiables !
Min des X := \LXmin{} et Max des X := \LXmax.
Coefficient $a=\COEFFa$.
Coefficient $b=\COEFFb$.
Coefficient $r=\COEFFr$.
Coefficient $r^2=\COEFFrd$.
\end{codetex}

\begin{codesortie}
\def\LLX{1994,1995,1996,1997,1998,1999,2000,2001,2002,2004,2005,2006,2007,2008,2009,2010}
\def\LLY{1718,1710,1708,1700,1698,1697,1691,1688,1683,1679,1671,1670,1663,1661,1656,1649}
\CalculsRegLin{\LLX}{\LLY}

Liste des X := \showitems\LX.

\smallskip

Liste des Y := \showitems\LY.

\smallskip

Somme des X := \LXSomme{} et somme des Y := \LYSomme.

\smallskip

Moyenne des X := \LXmoy{} et moyenne des Y := \LYmoy.

\smallskip

Variance des X := \LXvar{} et variance des Y := \LYvar{}

\smallskip

Covariance des X/Y := \LXYvar.

\smallskip

Min des X := \LXmin{} et Max des X := \LXmax.

\smallskip

Coefficient $a=\COEFFa$.\tabto{0.5\textwidth}Coefficient $b=\COEFFb$.

%\smallskip
%
%Coefficient $b=\COEFFb$.

\smallskip

Coefficient $r=\COEFFr$.\tabto{0.5\textwidth}Coefficient $r^2=\COEFFrd$.

%\smallskip
%
%Coefficient $r^2=\COEFFrd$.
\end{codesortie}

\begin{codeinfo}
\hfill~\includegraphics[height=3cm]{./graphics/pl-doc-stats_a}~~\includegraphics[height=3cm]{./graphics/pl-doc-stats_b}~~\includegraphics[height=3cm]{./graphics/pl-doc-stats_c}~~\includegraphics[height=3cm]{./graphics/pl-doc-stats_c2}\hfill~
\end{codeinfo}

\begin{codeinfo}
Les \textsf{macros} qui contiennent les paramètres de la régression sont donc réutilisables, en tant que nombres réels, donc exploitables par \ctex{siunitx} et \ctex{xfp} pour affichage \textit{fin} ! Ci-dessous un exemple permettant de visualiser tout cela.
\end{codeinfo}

\begin{codetex}[listing only]
%les espaces verticaux n'ont pas été écrits ici
\def\LstX{0,1,3,4,5,6}
\def\LstY{-35,-37.4,-37.7,-39.9,-39,-39.6}
%on lance les calculs et on change le nom des "macros-résultats"
\CalculsRegLin[NomCoeffa=TESTa,NomCoeffb=TESTb,NomCoeffr=TESTr,NomCoeffrd=TESTrd,%
          NomXmin=TESTmin,NomXmax=TESTmax]{\LstX}{\LstY}
%commandes complémentaires
\DeclareDocumentCommand\arrond{ s O{3} m }{% * pour afficher signe / opt = précision / argument = nb
	\IfBooleanTF{#1}{\num[print-implicit-plus]{\fpeval{round(#3,#2)}}}{\num{\fpeval{round(#3,#2)}}}
}
%paramètres
Les valeurs extr. de X sont \TESTmin{} et \TESTmax. Une éq. est $y=\arrond[3]{\TESTa}x \arrond*[3]{\TESTb}$.
Le coeff. de corrélation est $r=\arrond[4]{\TESTr}$, et son carré est $r^2=\arrond[4]{\TESTrd}$.
\end{codetex}

\begin{codesortie}
\def\LstX{0,1,3,4,5,6}\def\LstY{-35,-37.4,-37.7,-39.9,-39,-39.6}
\CalculsRegLin[NomCoeffa=TESTa,NomCoeffb=TESTb,NomCoeffr=TESTr,NomCoeffrd=TESTrd,NomXmin=TESTmin,NomXmax=TESTmax]{\LstX}{\LstY}
\DeclareDocumentCommand\arrond{ s O{3} m }{
	\IfBooleanTF{#1}{\num[print-implicit-plus]{\fpeval{ceil(#3,#2)}}}
		{\num{\fpeval{round(#3,#2)}}}
}

Les valeurs extrêmes de X sont \TESTmin{} et \TESTmax. Une équation de la droite de régression de $y$ en $x$ est $y=\arrond[3]{\TESTa}x \arrond*[3]{\TESTb}$.

\smallskip

Le coefficient de corrélation linéaire est $r=\arrond[4]{\TESTr}$, et son carré est $r^2=\arrond[4]{\TESTrd}$.
\end{codesortie}

\begin{codeinfo}
\hfill~\includegraphics[height=3cm]{./graphics/pl-doc-stats_d}~~\includegraphics[height=3cm]{./graphics/pl-doc-stats_e}\hfill~
\end{codeinfo}

\subsection{Intégration dans un environnement \TikZ}

\begin{codeinfo}
La commande étant \og autonome \fg{}, elle va pouvoir être intégrée dans des environnements graphiques pour permettre un tracé \textit{facile} de la droite de régression.
\end{codeinfo}

\begin{codetex}[listing only]
\begin{tikzpicture}
	\begin{axis}[options des axes, non présentées ici...]
		\addplot[teal, only marks] table{
			X Y
			1994 1718 1995 1710 1996 1708 1997 1700 1998 1698 1999 1697 2000 1691 2001 1688
			2002 1683 2004 1679 2005 1671 2006 1670 2007 1663 2008 1661 2009 1656 2010 1649
		};
		\def\LLX{1994,1995,1996,1997,1998,1999,2000,2001,2002,2004,2005,2006,2007,2008,2009,2010}
		\def\LLY{1718,1710,1708,1700,1698,1697,1691,1688,1683,1679,1671,1670,1663,1661,1656,1649}
		\CalculsRegLin{\LLX}{\LLY}
		\addplot [thick,orange,domain=\LXmin:\LXmax,samples=2]{\COEFFa*x+\COEFFb};
		\addlegendentry{$y = \fpeval{round(\COEFFa,3)}\,x + \fpeval{round(\COEFFb,3)}$};
		\addlegendentry{$R^2=\fpeval{round(\COEFFrd,5)}$};
	\end{axis}
\end{tikzpicture}
\end{codetex}

\begin{codesortie}
\begin{tikzpicture}
	\begin{axis}[
		/pgf/number format/.cd,
		use comma,
		xmin = 1992, xmax = 2012,
		ymin = 1640, ymax = 1730,
		width = 0.7\textwidth,
		height = 0.35\textwidth,
		xtick distance = 2,
		ytick distance = 10,
		grid = both,
		minor tick num = 1,
		major grid style = {lightgray},
		minor grid style = {lightgray!25},
		xlabel = {\small Année ($x$)},
		ylabel = {\small Altitude du glacier (en m) ($y$)},
		x tick label style={/pgf/number format/.cd, set thousands separator={}},
		y tick label style={/pgf/number format/.cd, set thousands separator={}},
		legend cell align = {left},
		legend pos = north east
		]
		\addplot[teal, only marks] table{
			X Y
			1994 1718
			1995 1710
			1996 1708
			1997 1700
			1998 1698
			1999 1697
			2000 1691
			2001 1688
			2002 1683
			2004 1679
			2005 1671
			2006 1670
			2007 1663
			2008 1661
			2009 1656
			2010 1649
		};
		\def\LLX{1994,1995,1996,1997,1998,1999,2000,2001,2002,2004,2005,2006,2007,2008,2009,2010}
		\def\LLY{1718,1710,1708,1700,1698,1697,1691,1688,1683,1679,1671,1670,1663,1661,1656,1649}
		\CalculsRegLin{\LLX}{\LLY}
		\addplot [thick,orange,domain=\LXmin:\LXmax,samples=2]{\COEFFa*x+\COEFFb};
		\addlegendentry{$y = \fpeval{round(\COEFFa,3)}\,x + \fpeval{round(\COEFFb,3)}$};
		\addlegendentry{$R^2=\fpeval{round(\COEFFrd,5)}$};
	\end{axis}
\end{tikzpicture}
\end{codesortie}

\begin{codeinfo}
Il existe également une commande auxiliaire, \ctex{PointsRegLin} pour afficher le nuage de points avec quelques options, dans un environnement \TikZ{} classique (sans \textsf{pgfplot})\ldots
\end{codeinfo}

\begin{codetex}[listing only]
...
\begin{tikzpicture}[<options>]
	...
	\PointsRegLin[clés]{listeX}{listeY}
	...
\end{tikzpicture}
\end{codetex}

\begin{codecles}
Quelques \Cle{Clés} sont disponibles pour cette commande, essentiellement pour la mise en forme du nuage :

\begin{itemize}
	\item la clé \Cle{Couleur} pour la couleur des points du nuage ;\hfill{}défaut \Cle{teal}
	\item la clé \Cle{Taille} pour la taille des points (type \textit{cercle}) ;\hfill{}défaut \Cle{2pt}
	\item la clé \Cle{Ox} pour spécifier la valeur initiale Ox (si changement d'origine) ;\hfill{}défaut \Cle{0}
	\item la clé \Cle{Oy} pour spécifier la valeur initiale Oy (si changement d'origine).\hfill{}défaut \Cle{0}
\end{itemize}
\end{codecles}

\begin{codetex}[listing only]
\begin{tikzpicture}[x=0.5cm,y=0.05cm]
	\draw[xstep=1,ystep=5,lightgray!50,very thin] (0,0) grid (20,100);
	\draw[xstep=2,ystep=10,lightgray,thin] (0,0) grid (20,100);
	\draw[thick,->,>=latex] (0,0)--(20,0) ;
	\draw[thick,->,>=latex] (0,0)--(0,100) ;
	\foreach \x in {1992,1994,...,2010} \draw[thick] ({\x-1992},4pt)--({\x-1992},-4pt) node[below] {$\x$} ;
	\foreach \y in {1640,1650,...,1730} \draw[thick] (4pt,{\y-1640})--(-4pt,{\y-1640}) node[left] {$\y$} ;
	\def\LLX{1994,1995,1996,1997,1998,1999,2000,2001,2002,2004,2005,2006,2007,2008,2009,2010}
	\def\LLY{1718,1710,1708,1700,1698,1697,1691,1688,1683,1679,1671,1670,1663,1661,1656,1649}
	\def\Ox{1992}\def\Oy{1640}
	\CalculsRegLin{\LLX}{\LLY}
	\PointsRegLin[Ox=1992,Oy=1640,Couleur=blue,Taille=3pt]{\LLX}{\LLY}
	\draw[orange,very thick,samples=2,domain=\LXmin:\LXmax] plot ({\x-\Ox},{\COEFFa*(\x)+\COEFFb-\Oy}) ;
	\matrix [draw,fill=white,below left] at (current bounding box.north east) {
		\node {$y = \fpeval{round(\COEFFa,3)}\,x + \fpeval{round(\COEFFb,3)}$} ; \\
		\node {$R^2=\fpeval{round(\COEFFrd,5)}$} ; \\
	};
\end{tikzpicture}
\end{codetex}

\begin{codesortie}
\begin{tikzpicture}[x=0.5cm,y=0.05cm]
	\draw[xstep=1,ystep=5,lightgray!50,very thin] (0,0) grid (20,100);
	\draw[xstep=2,ystep=10,lightgray,thin] (0,0) grid (20,100);
	\draw[thick,->,>=latex] (0,0)--(20,0) ;
	\draw[thick,->,>=latex] (0,0)--(0,100) ;
	\foreach \x in {1992,1994,...,2010} \draw[thick] ({\x-1992},4pt)--({\x-1992},-4pt) node[below] {$\x$} ;
	\foreach \y in {1640,1650,...,1730} \draw[thick] (4pt,{\y-1640})--(-4pt,{\y-1640}) node[left] {$\y$} ;
	\def\LLX{1994,1995,1996,1997,1998,1999,2000,2001,2002,2004,2005,2006,2007,2008,2009,2010}
	\def\LLY{1718,1710,1708,1700,1698,1697,1691,1688,1683,1679,1671,1670,1663,1661,1656,1649}
	\def\Ox{1992}\def\Oy{1640}
	\CalculsRegLin{\LLX}{\LLY}
\PointsRegLin[Ox=1992,Oy=1640,Couleur=blue,Taille=3pt]{\LLX}{\LLY}
	\draw[orange,very thick,samples=2,domain=\LXmin:\LXmax] plot ({\x-\Ox},{\COEFFa*(\x)+\COEFFb-\Oy}) ;
	\matrix [draw,fill=white,below left] at (current bounding box.north east) {
		\node {$y = \fpeval{round(\COEFFa,3)}\,x + \fpeval{round(\COEFFb,3)}$} ; \\
		\node {$R^2=\fpeval{round(\COEFFrd,5)}$} ; \\
	};
\end{tikzpicture}
\end{codesortie}

\newpage

\section{Statistiques à deux variables}\label{statsdeuxvars}

\subsection{Idées}

\begin{codeidee}
L'idée est de \textit{prolonger} le paragraphe précédent pour proposer un environnement \TikZ{} adapté à des situations venant de statistiques à deux variables.

\smallskip

Un des soucis pour ces situations est le fait que le repère dans lequel on travaille n'a pas forcément pour origine $(0\,;\,0)$.

De ce fait -- pour éviter des erreurs de \ctex{dimension too large} liées à \TikZ{} -- il faut \textit{décaler les axes} pour se ramener à une origine en $O$.

\smallskip

Le code, intimement lié à un environnement \ctex{tikzpicture}, va donc :

\begin{itemize}
	\item préciser les informations utiles comme \ctex{xmin}, \ctex{xmax}, \ctex{Ox}, \ctex{xgrille}, etc
	\item proposer des commandes (sans se soucier des \textit{translations} !) pour :
	\begin{itemize}
		\item tracer une grille (principale et/ou secondaire) ;
		\item tracer les axes (avec légendes éventuelles) et éventuellement les graduer ;
	\end{itemize}
\end{itemize}

En utilisant les commandes de \textsf{régression linéaire} du paragraphe précédent, il sera de plus possible (sans calculs !) de :

\begin{itemize}
	\item représenter le nuage de points ;
	\item placer le point moyen ;
	\item tracer la droite d'ajustement (obtenue par \ctex{ProfLycee}) ou une autre courbe.
\end{itemize}
\end{codeidee}

\begin{codeinfo}
Le package \ctex{pgfplots} peut être utilisé pour traiter ce genre de situation, mais ne l'utilisant pas, j'ai préféré préparer des \textsf{macros} permettant de s'affranchir de ce package (est-ce pertinent, ça c'est une autre question\ldots).
\end{codeinfo}

\begin{codetex}[listing only]
%Listes et calculs
\def\LLX{1994,1995,1996,1997,1998,1999,2000,2001,2002,2004,2005,2006,2007,2008,2009,2010}
\def\LLY{1718,1710,1708,1700,1698,1697,1691,1688,1683,1679,1671,1670,1663,1661,1656,1649}
\CalculsRegLin{\LLX}{\LLY}
\end{codetex}

\begin{codetex}[listing only]
%tracé (simple), les options seront présentées juste après
\begin{tikzpicture}%
	[x=0.5cm,y=0.1cm,                                                 %unités
	Ox=1992,xmin=1992,xmax=2012,xgrille=2,xgrilles=1,                 %axe Ox
	Oy=1640,ymin=1640,ymax=1730,ygrille=10,ygrilles=5]                %axe Oy
	\GrilleTikz \AxesTikz                                             %grilles et axes
	\AxexTikz[Annee]{1992,1994,...,2010}                              %axeOx
	\AxeyTikz{1640,1650,...,1720}                                     %axeOy
	\NuagePointsTikz{\LLX}{\LLY}                                      %nuage
	\CourbeTikz[line width=1.25pt,ForestGreen,samples=2]%
		{\COEFFa*\x+\COEFFb}{\LXmin:\LXmax}                           %droite de régression
	\PointMoyenTikz                                                   %point moyen
\end{tikzpicture}
\end{codetex}

\begin{codetex}[listing only]
%tracé avec options fenêtre par défaut
\begin{tikzpicture}%
	[....]                                                              %paramètres
	\FenetreSimpleTikz<Annee>{1992,1994,...,2010}{1640,1650,...,1720}   %fenêtre "simple"
	\NuagePointsTikz{\LLX}{\LLY}                                        %nuage
	\CourbeTikz[line width=1.25pt,ForestGreen,samples=2]%
		{\COEFFa*\x+\COEFFb}{\LXmin:\LXmax}                             %droite de régression
	\PLnuageptmoy                                                       %point moyen
\end{tikzpicture}
\end{codetex}

\begin{codesortie}
\def\LLX{1994,1995,1996,1997,1998,1999,2000,2001,2002,2004,2005,2006,2007,2008,2009,2010}
\def\LLY{1718,1710,1708,1700,1698,1697,1691,1688,1683,1679,1671,1670,1663,1661,1656,1649}
\CalculsRegLin{\LLX}{\LLY}

\begin{tikzpicture}[x=0.5cm,y=0.1cm,Ox=1992,xmin=1992,xmax=2012,xgrille=2,xgrilles=1,Oy=1640,ymin=1640,ymax=1730,ygrille=10,ygrilles=5]
	\GrilleTikz \AxesTikz
	\AxexTikz[Annee]{1992,1994,...,2010}
	\AxeyTikz{1640,1650,...,1720}
	\NuagePointsTikz{\LLX}{\LLY}
	\CourbeTikz[line width=1.25pt,ForestGreen,samples=2]{\COEFFa*\x+\COEFFb}{\LXmin:\LXmax}
	\PointMoyenTikz
\end{tikzpicture}
\end{codesortie}

\subsection{Commandes, clés et options}

\begin{codeinfo}
Les \Cle{paramètres} nécessaires à la bonne utilisation des commandes suivantes sont à déclarer directement dans l'environnement \ctex{tikzpicture}, seules les versions \og x \fg{}  sont présentées ici:

\begin{itemize}
	\item \Cle{xmin}, stockée dans \ctex{\textbackslash{}xmin} ;\hfill{}défaut \Cle{-3}
	\item \Cle{xmax}, stockée dans \ctex{\textbackslash{}xmax} ;\hfill{}défaut \Cle{3}
	\item \Cle{Ox}, stockée dans \ctex{\textbackslash{}axexOx}, origine de l'axe $(Ox)$ ;\hfill{}défaut \Cle{0}
	\item \Cle{xgrille}, stockée dans \ctex{\textbackslash{}xgrille}, graduation principale ;\hfill{}défaut \Cle{1}
	\item \Cle{xgrilles}, stockée dans \ctex{\textbackslash{}xgrilles}, graduation secondaire.\hfill{}défaut \Cle{0.5}
\end{itemize}

La fenêtre d'affichage (de sortie) sera donc \textit{portée} par le rectangle de coins $(\text{xmin}\,;\,\text{ymin})$ et $(\text{xmax}\,;\,\text{ymax})$ ; ce qui correspond en fait à la fenêtre \TikZ{} \textit{portée} par le rectangle de coins $(xmin-Ox\,;\,ymin-Oy)$ et $(\text{xmax-Ox}\,;\,\text{ymax-Oy})$.

\smallskip

Les commandes ont -- pour certaines -- pas mal de \Cle{clés} pour des réglages fins, mais dans la majorité des cas elles ne sont pas forcément \textit{utiles}.
\end{codeinfo}

\begin{codeinfo}
Pour illustrer les commandes et options de ce paragraphe, la base sera le graphique présenté précédemment.
\end{codeinfo}

\begin{codetex}[listing only]
%...code tikz
	\GrilleTikz[options][options grille ppale][options grille second.]
\end{codetex}

\begin{codecles}
Cette commande permet de tracer une grille principale et/ou une grille secondaire :

\begin{itemize}
	\item les premières \Cle{clés} sont les booléens \Cle{Affp} et \Cle{Affs} qui affichent ou non les grilles ;\hfill~défaut \Cle{true}
	\item les options des grilles sont en \TikZ. \hfill~défaut \Cle{thin,lightgray} et \Cle{very thin,lightgray}
\end{itemize}
\end{codecles}

\begin{codetex}[listing only]
\begin{tikzpicture}%
	[x=0.35cm,y=0.07cm,%
	Ox=1992,xmin=1992,xmax=2012,xgrille=2,xgrilles=1,%
	Oy=1640,ymin=1640,ymax=1730,ygrille=10,ygrilles=5]
	\GrilleTikz
\end{tikzpicture}
~~
\begin{tikzpicture}%
	[x=0.35cm,y=0.07cm,%
	Ox=1992,xmin=1992,xmax=2012,xgrille=2,xgrilles=1,%
	Oy=1640,ymin=1640,ymax=1730,ygrille=10,ygrilles=5]
	\GrilleTikz[Affp=false][][orange,densely dotted]
\end{tikzpicture}
\end{codetex}

\begin{codesortie}
\hfill~
\begin{tikzpicture}%
	[x=0.35cm,y=0.07cm,%
	Ox=1992,xmin=1992,xmax=2012,xgrille=2,xgrilles=1,%
	Oy=1640,ymin=1640,ymax=1730,ygrille=10,ygrilles=5]
	\GrilleTikz
\end{tikzpicture}
~~
\begin{tikzpicture}%
	[x=0.35cm,y=0.07cm,%
	Ox=1992,xmin=1992,xmax=2012,xgrille=2,xgrilles=1,%
	Oy=1640,ymin=1640,ymax=1730,ygrille=10,ygrilles=5]
	\GrilleTikz[Affp=false][][orange,densely dotted]
\end{tikzpicture}
\hfill~
\end{codesortie}

\begin{codetex}[listing only]
%...code tikz
	\AxesTikz[options]
\end{codetex}

\begin{codecles}
Cette commande permet de tracer les axes, avec des \Cle{clés} :

\begin{itemize}
	\item \Cle{Epaisseur} qui est l'épaisseur des traits ; \hfill~défaut \Cle{1.25pt}
	\item \Cle{Police} qui est le style des labels des axes  ; \hfill~défaut \Cle{\textbackslash{}normalsize\textbackslash{}normalfont}
	\item \cmaj{2.1.2} \Cle{ElargirOx} qui est le \% l'élargissement \Cle{global} ou \Cle{G/D} de l'axe $(Ox)$ ;\hfill~défaut \Cle{0/0.05}
	\item \cmaj{2.1.2} \Cle{ElargirOy} qui est le \% l'élargissement \Cle{global} ou \Cle{B/H} de l'axe $(Oy)$ ;\hfill~défaut \Cle{0/0.05}
	\item \Cle{Labelx} qui est le label de l'axe $(Ox)$ ; \hfill~défaut \Cle{\${}x\$}
	\item \Cle{Labely} qui est le label de l'axe $(Oy)$ ; \hfill~défaut \Cle{\${}y\$}
	\item \Cle{AffLabel} qui est le code pour préciser quels labels afficher, entre \Cle{x}, \Cle{y} ou \Cle{xy} ; \hfill~défaut \Cle{vide}
	\item \Cle{PosLabelx} pour la position du label de $(Ox)$ en bout d'axe ; \hfill~défaut \Cle{right}
	\item \Cle{PosLabely} pour la position du label de $(Oy)$ en bout d'axe ; \hfill~défaut \Cle{above}
	\item \Cle{EchelleFleche} qui est l'échelle de la flèche des axes ; \hfill~défaut \Cle{1}
	\item \Cle{TypeFleche} qui est le type de la flèche des axes.\hfill~défaut \Cle{latex}
\end{itemize}
\end{codecles}

\begin{codetex}[listing only]
%code tikz
	\AxesTikz

%code tikz
	\AxesTikz%
		[AffLabel=xy,Labelx={Année},Labely={Altitude},%
		PosLabelx={below right},PosLabely={above left},%
		Police=\small\sffamily]
\end{codetex}

\begin{codesortie}
\hfill~
\begin{tikzpicture}%
	[x=0.35cm,y=0.07cm,%
	Ox=1992,xmin=1992,xmax=2012,xgrille=2,xgrilles=1,%
	Oy=1640,ymin=1640,ymax=1730,ygrille=10,ygrilles=5]
	\AxesTikz
\end{tikzpicture}
~~
\begin{tikzpicture}%
	[x=0.35cm,y=0.07cm,%
	Ox=1992,xmin=1992,xmax=2012,xgrille=2,xgrilles=1,%
	Oy=1640,ymin=1640,ymax=1730,ygrille=10,ygrilles=5]
	\AxesTikz%
		[AffLabel=xy,Labelx={Année},Labely={Altitude},%
		PosLabelx={below right},PosLabely={above left},%
		Police=\small\sffamily]
\end{tikzpicture}
\hfill~
\end{codesortie}

%les axes

\begin{codetex}[listing only]
%...code tikz
	\AxexTikz[options]{valeurs}
	\AxeyTikz[options]{valeurs}
\end{codetex}

\begin{codecles}
Ces commande permet de tracer les graduations des axes, avec des \Cle{clés} identiques pour les deux directions :

\begin{itemize}
	\item \Cle{Epaisseur} qui est l'épaisseur des graduations ; \hfill~défaut \Cle{1pt}
	\item \Cle{Police} qui est le style des labels des graduations ; \hfill~défaut \Cle{\textbackslash{}normalsize\textbackslash{}normalfont}
	\item \Cle{PosGrad} qui est la position des graduations par rapport à l'axe ; \hfill~défaut \Cle{below} et \Cle{left}
	\item \Cle{HautGrad} qui est la position des graduations (sous la forme \Cle{lgt} ou \Cle{lgta/lgtb}) ; \hfill~défaut \Cle{4pt}
	\item le booléen \Cle{AffGrad} pour afficher les valeurs (formatés avec \ctex{num} donc dépendant de \ctex{sisetup}) des graduations  ; \hfill~défaut \Cle{true}
	\item le booléen \Cle{AffOrigine} pour afficher la graduation de l'origine ; \hfill~défaut \Cle{true}
	\item le booléen \Cle{Annee} qui permet de ne pas formater les valeurs des graduations (type \textsf{année}). \hfill~défaut \Cle{false}
\end{itemize}
\end{codecles}

\begin{codetex}[listing only]
%code tikz
	\AxexTikz[Police=\small]{1992,1994,...,2010}
	\AxexTikz{1640,1650,...,1720}
	
%code tikz
	\AxeyTikz[Police=\small,Annee,HautGrad=0pt/4pt]{1992,1994,...,2010}
	\AxeyTikz[AffGrad=false,HautGrad=6pt]{1640,1650,...,1720}

%des axes fictifs (en gris) sont rajoutés pour la lisibilité du code de sortie
\end{codetex}

\begin{codesortie}
\hfill~
\begin{tikzpicture}%
	[x=0.35cm,y=0.07cm,%
	Ox=1992,xmin=1992,xmax=2012,xgrille=2,xgrilles=1,%
	Oy=1640,ymin=1640,ymax=1730,ygrille=10,ygrilles=5]
	\draw[gray,line width=1.25pt,->,>=latex] ({\xmin-\axexOx},0) -- ({\xmax-\axexOx},0) ;
	\draw[gray,line width=1.25pt,->,>=latex] (0,{\ymin-\axeyOy}) -- (0,{\ymax-\axeyOy}) ;
	\AxexTikz[Police=\small]{1992,1994,...,2010}
	\AxeyTikz{1640,1650,...,1720}
\end{tikzpicture}
~~
\begin{tikzpicture}%
	[x=0.35cm,y=0.07cm,%
	Ox=1992,xmin=1992,xmax=2012,xgrille=2,xgrilles=1,%
	Oy=1640,ymin=1640,ymax=1730,ygrille=10,ygrilles=5]
	\draw[gray,line width=1.25pt,->,>=latex] ({\xmin-\axexOx},0) -- ({\xmax-\axexOx},0) ;
	\draw[gray,line width=1.25pt,->,>=latex] (0,{\ymin-\axeyOy}) -- (0,{\ymax-\axeyOy}) ;
	\AxexTikz[Police=\small,Annee,HautGrad=0pt/4pt]{1992,1994,...,2010}
	\AxeyTikz[AffGrad=false,HautGrad=6pt]{1640,1650,...,1720}
\end{tikzpicture}
\hfill~
\end{codesortie}

\subsection{Commandes annexes}

\begin{codeinfo}
Il existe, de manière marginale, quelques commandes complémentaires qui ne seront pas trop détaillées mais qui sont présentes dans l'introduction :

\begin{itemize}
	\item \ctex{FenetreTikz} qui restreint les tracés à la fenêtre (utile pour des courbes qui \textit{débordent}) ;
	\item \ctex{FenetreSimpleTikz} qui permet d'automatiser le tracé des grilles/axes/graduations dans leurs versions par défaut, avec peu de paramétrages ;
	\item \ctex{OrigineTikz} pour rajouter le libellé de l'origine si non affiché par les axes.
\end{itemize}
\end{codeinfo}

\begin{codetex}[listing only]
%code tikz
	\FenetreTikz %on restreint les tracés
	\FenetreSimpleTikz[opt](opt axes)<opt axe Ox>{liste valx}<opt axe Oy>{liste valy}
\end{codetex}

%%l'origine
%
%\begin{codetex}[listing only]
%%...code tikz
%	\PLorigine[<options>]
%\end{codetex}

\subsection{Interactions avec PLreglin}

\begin{codetex}[listing only]
%...code tikz
	\NuagePointsTikz[options]{listeX}{listeY}
\end{codetex}

\begin{codecles}
Cette commande, liée à la commande \ctex{CalculsRegLin} permet de représenter le nuage de points associé aux deux listes, avec les \Cle{clés} suivantes :

\begin{itemize}
	\item \Cle{Taille} qui est la taille des points du nuage ; \hfill~défaut \Cle{2pt}
	\item \Cle{Style} parmi \Cle{o} (rond) ou \Cle{x} (croix) ou \Cle{+} (plus) ; \hfill~défaut \Cle{o}
	\item \Cle{Couleur} qui est la couleur (éventuellement \Cle{couleurA/couleurB} pour les ronds). \hfill~défaut \Cle{blue}
\end{itemize}
\end{codecles}

\begin{codetex}[listing only]
\def\LLX{1994,1995,1996,1997,1998,1999,2000,2001,2002,2004,2005,2006,2007,2008,2009,2010}
\def\LLY{1718,1710,1708,1700,1698,1697,1691,1688,1683,1679,1671,1670,1663,1661,1656,1649}

\begin{tikzpicture}[...]
	\NuagePointsTikz[Couleur=blue/red]{\LLX}{\LLY}
\end{tikzpicture}
~~
\begin{tikzpicture}[...]
	\NuagePointsTikz[Couleur=ForestGreen,Style=x,Taille=6pt]{\LLX}{\LLY}
\end{tikzpicture}
\end{codetex}

\begin{codesortie}
\def\LLX{1994,1995,1996,1997,1998,1999,2000,2001,2002,2004,2005,2006,2007,2008,2009,2010}
\def\LLY{1718,1710,1708,1700,1698,1697,1691,1688,1683,1679,1671,1670,1663,1661,1656,1649}
\CalculsRegLin{\LLX}{\LLY}

\begin{tikzpicture}[x=0.35cm,y=0.07cm,Ox=1992,xmin=1992,xmax=2012,xgrille=2,xgrilles=1,Oy=1640,ymin=1640,ymax=1730,ygrille=10,ygrilles=5]
	\GrilleTikz \AxesTikz
	\AxexTikz[Annee,Police=\small]{1992,1994,...,2010}
	\AxeyTikz{1640,1650,...,1720}
	\NuagePointsTikz[Couleur=blue/red]{\LLX}{\LLY}
\end{tikzpicture}
~~
\begin{tikzpicture}[x=0.35cm,y=0.07cm,Ox=1992,xmin=1992,xmax=2012,xgrille=2,xgrilles=1,Oy=1640,ymin=1640,ymax=1730,ygrille=10,ygrilles=5]
	\GrilleTikz \AxesTikz
	\AxexTikz[Annee,Police=\small]{1992,1994,...,2010}
	\AxeyTikz{1640,1650,...,1720}
	\NuagePointsTikz[Couleur=ForestGreen,Style=x,Taille=6pt]{\LLX}{\LLY}
\end{tikzpicture}
\end{codesortie}

%point moyen
\begin{codetex}[listing only]
%...code tikz
	\PointMoyenTikz[options]
\end{codetex}

\begin{codecles}
Cette commande permet de rajouter le point moyen du nuage, calculé par la commande \ctex{CalculsRegLin}, avec les \Cle{clés} :

\begin{itemize}
	\item \Cle{Police}, comme précédemment ; \hfill~défaut \Cle{\textbackslash{}normalsize\textbackslash{}normalfont} ;
	\item \Cle{Taille}, taille du point moyen ; \hfill~défaut \Cle{4pt}
	\item \Cle{Couleur}, couleur du point moyen ; \hfill~défaut \Cle{red}
	\item \Cle{Style} parmi \Cle{o} (rond) ou \Cle{x} (croix) ou \Cle{+} (plus) ; \hfill~défaut \Cle{o}
	\item \Cle{xg}, abscisse du point moyen, récupérable via \ctex{PLRegLin} ; \hfill~défaut \Cle{\textbackslash{}LXmoy}
	\item \Cle{yg}, ordonnée du point moyen, récupérable via \ctex{PLRegLin} ; \hfill~défaut \Cle{\textbackslash{}LYmoy}
	\item \Cle{Nom}, label du point moyen ; \hfill~défaut \Cle{G}
	\item \Cle{Pos} qui est la position du label par rapport au point ; \hfill~défaut \Cle{above}
	\item \Cle{Decal} qui est l'éloignement de la position du label par rapport au point ; \hfill~défaut \Cle{0pt}
	\item la booléen \Cle{AffNom} qui affiche ou non le libellé.\hfill~défaut \Cle{true}
\end{itemize}
\end{codecles}

\begin{codetex}[listing only]
\def\LLX{1994,1995,1996,1997,1998,1999,2000,2001,2002,2004,2005,2006,2007,2008,2009,2010}
\def\LLY{1718,1710,1708,1700,1698,1697,1691,1688,1683,1679,1671,1670,1663,1661,1656,1649}
\CalculsRegLin{\LLX}{\LLY}

\begin{tikzpicture}[...]
	\NuagePointsTikz[Couleur=blue/red]{\LLX}{\LLY}
	\PointMoyenTikz
\end{tikzpicture}
~~
\begin{tikzpicture}[...]
	\NuagePointsTikz[Couleur=ForestGreen,Style=x,Taille=6pt]{\LLX}{\LLY}
	\PointMoyenTikz[Couleur=orange,Taille=8pt,Style=+,Nom={$G_1$},Pos=below]
\end{tikzpicture}
\end{codetex}

\begin{codesortie}
\def\LLX{1994,1995,1996,1997,1998,1999,2000,2001,2002,2004,2005,2006,2007,2008,2009,2010}
\def\LLY{1718,1710,1708,1700,1698,1697,1691,1688,1683,1679,1671,1670,1663,1661,1656,1649}
\CalculsRegLin{\LLX}{\LLY}

\begin{tikzpicture}[x=0.35cm,y=0.07cm,Ox=1992,xmin=1992,xmax=2012,xgrille=2,xgrilles=1,Oy=1640,ymin=1640,ymax=1730,ygrille=10,ygrilles=5]
	\GrilleTikz \AxesTikz
	\AxexTikz[Annee,Police=\small]{1992,1994,...,2010}
	\AxeyTikz{1640,1650,...,1720}
	\NuagePointsTikz[Couleur=blue/red]{\LLX}{\LLY}
	\PointMoyenTikz
\end{tikzpicture}
~~
\begin{tikzpicture}[x=0.35cm,y=0.07cm,Ox=1992,xmin=1992,xmax=2012,xgrille=2,xgrilles=1,Oy=1640,ymin=1640,ymax=1730,ygrille=10,ygrilles=5]
	\GrilleTikz \AxesTikz
	\AxexTikz[Annee,Police=\small]{1992,1994,...,2010}
	\AxeyTikz{1640,1650,...,1720}
	\NuagePointsTikz[Couleur=ForestGreen,Style=x,Taille=6pt]{\LLX}{\LLY}
	\PointMoyenTikz[Couleur=orange,Taille=8pt,Style=+,Nom={$G_1$},Pos=below]
\end{tikzpicture}
\end{codesortie}

%courbe
\begin{codetex}[listing only]
%...code tikz
	\CourbeTikz[options]{formule}{domaine}
\end{codetex}

\begin{codecles}
Cette commande permet de rajouter une courbe sur le graphique (sans se soucier de la transformation de son expression) avec les arguments :

\begin{itemize}
	\item \Cle{optionnels} qui sont -- en \TikZ{} -- les paramètres du tracé ;
	\item le premier mandataire, est -- en langage \TikZ{} -- l'expression de la fonction à tracer, donc avec \ctex{\textbackslash{}x} comme variable ;
	\item le second mandataire est le domaine du tracé , sous la forme \ctex{valxmin:valxmax}.
\end{itemize}
\end{codecles}

\begin{codeinfo}
L'idée principale est de récupérer les variables de la régression linéaire pour tracer la droite d'ajustement \textit{à moindres frais} !
\end{codeinfo}

\begin{codeinfo}
	Toute courbe peut être tracée sur ce principe, par contre il faudra saisir la fonction \textit{à la main}.
\end{codeinfo}

\begin{codetex}[listing only]
\def\LLX{1994,1995,1996,1997,1998,1999,2000,2001,2002,2004,2005,2006,2007,2008,2009,2010}
\def\LLY{1718,1710,1708,1700,1698,1697,1691,1688,1683,1679,1671,1670,1663,1661,1656,1649}
\CalculsRegLin{\LLX}{\LLY}

\begin{tikzpicture}[...]
	\NuagePointsTikz[Couleur=blue/red]{\LLX}{\LLY} \PointMoyenTikz
	\CourbeTikz[line width=1.25pt,ForestGreen,samples=2]{\COEFFa*\x+\COEFFb}{\xmin:\xmax}
\end{tikzpicture}
\end{codetex}

\begin{codesortie}
\def\LLX{1994,1995,1996,1997,1998,1999,2000,2001,2002,2004,2005,2006,2007,2008,2009,2010}
\def\LLY{1718,1710,1708,1700,1698,1697,1691,1688,1683,1679,1671,1670,1663,1661,1656,1649}
\CalculsRegLin{\LLX}{\LLY}

\begin{tikzpicture}[x=0.35cm,y=0.07cm,Ox=1992,xmin=1992,xmax=2012,xgrille=2,xgrilles=1,Oy=1640,ymin=1640,ymax=1730,ygrille=10,ygrilles=5]
	\GrilleTikz \AxesTikz[ElargirOx=0,ElargirOy=0]
	\AxexTikz[Annee,Police=\small]{1992,1994,...,2010}
	\AxeyTikz{1640,1650,...,1720}
	\NuagePointsTikz[Couleur=blue/red]{\LLX}{\LLY} \PointMoyenTikz
	\CourbeTikz[line width=1.25pt,ForestGreen,samples=2]{\COEFFa*\x+\COEFFb}{\xmin:\xmax}
\end{tikzpicture}
\end{codesortie}

\begin{codetex}[listing only]
\def\LLX{1994,1995,1996,1997,1998,1999,2000,2001,2002,2004,2005,2006,2007,2008,2009,2010}
\def\LLY{1718,1710,1708,1700,1698,1697,1691,1688,1683,1679,1671,1670,1663,1661,1656,1649}

\begin{tikzpicture}[...]
	\NuagePointsTikz[Couleur=blue/red]{\LLX}{\LLY} \FenetreTikz %on fixe la fenêtre
	\CourbeTikz[line width=1.25pt,orange,samples=500]{-(\x-2000)*(\x-2000)+1700}{\xmin:\xmax}
\end{tikzpicture}
\end{codetex}

\begin{codesortie}
\def\LLX{1994,1995,1996,1997,1998,1999,2000,2001,2002,2004,2005,2006,2007,2008,2009,2010}
\def\LLY{1718,1710,1708,1700,1698,1697,1691,1688,1683,1679,1671,1670,1663,1661,1656,1649}

\begin{tikzpicture}[x=0.35cm,y=0.07cm,Ox=1992,xmin=1992,xmax=2012,xgrille=2,xgrilles=1,Oy=1640,ymin=1640,ymax=1730,ygrille=10,ygrilles=5]
	\GrilleTikz \AxesTikz[ElargirOx=0,ElargirOy=0]
	\AxexTikz[Annee,Police=\small]{1992,1994,...,2010}
	\AxeyTikz{1640,1650,...,1720}
	\NuagePointsTikz[Couleur=blue/red]{\LLX}{\LLY} \FenetreTikz
	\CourbeTikz[line width=1.25pt,orange,samples=500]{-(\x-2000)*(\x-2000)+1700}{\xmin:\xmax}
\end{tikzpicture}
\end{codesortie}

\newpage

\section{Boîtes à moustaches}\label{boiteamoustaches}

\subsection{Introduction}

\begin{codeidee}
L'idée est de proposer une commande, à intégrer dans un environnement \TikZ, pour tracer une boîte à moustaches grâce aux paramètres, saisis par l'utilisateur.

\smallskip

Le code ne calcule pas les paramètres, il ne fait \textit{que} tracer la boîte à moustaches !
\end{codeidee}

\begin{codetex}[]
\begin{tikzpicture}
	\BoiteMoustaches{10/15/17/19/20}
\end{tikzpicture}
\end{codetex}

\begin{codeinfo}
Étant donnée que la commande est intégrée dans un environnement \TikZ, les unités peuvent/doivent donc être précisées, \textit{comme d'habitude}, si besoin.
\end{codeinfo}

\subsection{Clés et options}

\begin{codecles}
Quelques \Cle{clés} sont disponibles pour cette commande :

\begin{itemize}
	\item la clé \Cle{Couleur} qui est la couleur de la boîte ; \hfill~défaut \Cle{black}
	\item la clé \Cle{Elevation} qui est la position verticale (ordonnée des moustaches) de la boîte ; \hfill~défaut \Cle{1.5}
	\item la clé \Cle{Hauteur} qui est la hauteur de la boîte ; \hfill~défaut \Cle{1}
	\item la clé \Cle{Moyenne} qui est la moyenne (optionnelle) de la série ;
	\item la clé \Cle{Epaisseur} qui est l'épaisseur des traits de la boîte ; \hfill~défaut \Cle{thick}
	\item la clé \Cle{Remplir} qui est la couleur de remplissage de la boîte ; \hfill~défaut \Cle{white}
	\item le booléen \Cle{AffMoyenne} qui permet d'afficher ou non la moyenne (sous forme d'un point) ; \hfill~défaut \Cle{false}
	\item le booléen \Cle{Pointilles} qui permet d'afficher des pointillés au niveau des paramètres ; \hfill~défaut \Cle{false}
	\item le booléen \Cle{Valeurs} qui permet d'afficher les valeurs des paramètres au niveau des abscisses.\hfill~défaut \Cle{false}
\end{itemize}
\end{codecles}

\begin{codetex}[]
\begin{tikzpicture}
	\BoiteMoustaches[Epaisseur=very thick,Moyenne=18.5,Couleur=blue,AffMoyenne,%
	Pointilles,Valeurs,Hauteur=2.25,Elevation=2.75]{10/15/17/19/20}
\end{tikzpicture}
\end{codetex}

\begin{codetex}[listing only]
%une grille a été rajoutée pour visualiser la "position verticale"
\begin{center}
	\begin{tikzpicture}[x=0.1cm]
		\BoiteMoustaches[Epaisseur=ultra thick,Couleur=blue]{100/150/170/190/200}
		\BoiteMoustaches[Epaisseur=thin,Elevation=2.5,Couleur=red]{80/100/110/120/150}
		\BoiteMoustaches[Elevation=4,Couleur=ForestGreen,Remplir=ForestGreen!25]{100/140/145/160/210}
\end{tikzpicture}
\end{center}
\end{codetex}

\begin{codesortie}
\begin{center}
	\begin{tikzpicture}[x=0.1cm]
		\draw[xstep=10,ystep=0.5,very thin,lightgray] (80,0) grid (210,4.5) ;
		\foreach \x in {80,90,...,210} \draw[very thin,lightgray] (\x,3pt)--(\x,-3pt) node[below] {\num{\x}} ;
		\foreach \y in {0,0.5,...,4.5} \draw[very thin,lightgray] ($(210,\y)+(-3pt,0)$)--($(210,\y)+(3pt,0)$) node[right] {\num{\y}} ;
		\BoiteMoustaches[Epaisseur=ultra thick,Couleur=blue]{100/150/170/190/200}
		\BoiteMoustaches[Epaisseur=thin,Elevation=2.5,Couleur=red]{80/100/110/120/150}
		\BoiteMoustaches[Elevation=4,Couleur=ForestGreen,Remplir=ForestGreen!25]{100/140/145/160/210}
	\end{tikzpicture}
\end{center}
\end{codesortie}

\subsection{Commande pour placer un axe horizontal}

\begin{codeidee}
L'idée est de proposer, en parallèle de la commande précédente, une commande pour tracer un axe horizontal \og sous \fg{} les éventuelles boîtes à moustaches.
\end{codeidee}

\begin{codetex}[]
\begin{tikzpicture}
	\BoiteMoustachesAxe[Min=10,Max=20]
	\BoiteMoustaches{10/15/17/19/20}
\end{tikzpicture}
\end{codetex}

\begin{codetex}[]
\begin{tikzpicture}
	\BoiteMoustachesAxe[Min=10,Max=20]
	\BoiteMoustaches[Valeurs,Pointilles]{10/15/17/19/20}
\end{tikzpicture}
\end{codetex}

\begin{codecles}
Quelques \Cle{clés} sont disponibles pour cette commande :

\begin{itemize}
	\item la clé \Cle{Min} qui est la valeur minimale de l'axe horizontal ;
	\item la clé \Cle{Max} qui est la valeur minimale de l'axe horizontal ;
	\item la clé \Cle{Elargir} qui est le pourcentage l'élargissement de l'axe ;\hfill~défaut \Cle{0.1}
	\item la clé \Cle{Epaisseur} qui est l'épaisseur des traits de la boîte ; \hfill~défaut \Cle{thick}
	\item la clé \Cle{Valeurs} qui est la liste (compréhensible en \TikZ) des valeurs à afficher.
\end{itemize}
\end{codecles}

\begin{codetex}[]
\begin{tikzpicture}
	\BoiteMoustachesAxe[Min=8,Max=21,AffValeurs,Valeurs={8,9,...,21},Elargir=0.02]
	\BoiteMoustaches[Moyenne=18.5,Couleur=blue]{10/15/17/19/20}
	\BoiteMoustaches[Elevation=2.5,Couleur=red]{8/10/11/12/15}
	\BoiteMoustaches[Elevation=4,Couleur=ForestGreen,Remplir=ForestGreen!25]{10/14/14.5/16/21}
\end{tikzpicture}
\end{codetex}

\begin{codeinfo}
Le placement des différentes boîtes n'est pas automatique, donc il faut penser à cela avant de se lancer dans le code.

Sachant que la hauteur par défaut est de 1, il est -- a priori -- intéressant de placer les boîtes à des \Cle{élévations} de \num{1} puis \num{2.5} puis \num{4} etc
\end{codeinfo}

\newpage

\part{Outils pour les probabilités}

\section{Calculs de probabilités}\label{calcprobas}

\subsection{Introduction}

\begin{codeidee}
L'idée est de proposer des commandes permettant de calculer des probabilités avec des lois classiques :

\begin{itemize}
	\item binomiale ;
	\item normale ;
	\item exponentielle ;
	\item de Poisson ;
	\item géométrique ;
	\item hypergéométrique.
\end{itemize}
\end{codeidee}

\begin{codeinfo}
Les commandes sont de deux natures :

\begin{itemize}
	\item des commandes pour calculer, grâce au package \ctex{xintexpr} ;
	\item des commandes pour formater le résultat de \ctex{xintexpr}, grâce à \ctex{siunitx}.
\end{itemize}

De ce fait, les options de \ctex{siunitx} de l'utilisateur affecterons les formatages du résultat, la commande va \og forcer \fg{} les arrondis et l'écriture scientifique.
\end{codeinfo}

\subsection{Calculs \og simples \fg}

\begin{codetex}[listing only]
%loi binomiale B(n,p)
\CalcBinomP{n}{p}{k}             %P(X=k)
\CalcBinomC{n}{p}{a}{b}          %P(a<=X<=b)

%loi de Poisson P (l)
\CalcPoissP{l}{k}                %P(X=k)
\CalcPoissC{l}{a}{b}             %P(a<=X<=b)

%loi géométrique G (p)
\CalcGeomP{p}{k}                 %P(X=k)
\CalcGeomC{l}{a}{b}              %P(a<=X<=b)

%loi hypergéométrique H (N,n,m)
\CalcHypergeomP{N}{n}{m}{k}      %P(X=k)
\CalcHypergeomP{N}{n}{m}{a}{b}   %P(a<=X<=b)

%loi normale N(m,s)
\CalcNormC{m}{s}{a}{b}           %P(a<=X<=b)

%loi exponentielle E(l)
\CalcExpoC{l}{a}{b}              %P(a<=X<=b)
\end{codetex}

\begin{codecles}
Les probabilités calculables sont donc -- comme pour beaucoup de modèles de calculatrices -- les probabilités \textbf{P}onctuelles ($P(X=k)$) et \textbf{C}umulées ($P(a\leqslant X\leqslant b)$).

\smallskip

Pour les probabilités cumulées, on peut utiliser le caractère \ctex{*} comme borne ($a$ ou $b$), pour les probabilités du type $P(X\leqslant b)$ et $P(X \geqslant a)$.
\end{codecles}

\begin{codetex}[listing only]
% X -> B(5,0.4)
$P(X=3) \approx \CalcBinomP{5}{0.4}{3}$.
$P(X\leqslant1) \approx \CalcBinomC{5}{0.4}{*}{1}$.

% X -> B(100,0.02)
$P(X=10) \approx \CalcBinomP{100}{0.02}{10}$.
$P(15\leqslant X\leqslant25) \approx \CalcBinomC{100}{0.02}{15}{25}$.

% Y -> P(5)
$P(Y=3) \approx \CalcPoissP{5}{3}$.
$P(Y\geqslant2) \approx \CalcPoissC{5}{2}{*}$.

% T -> G(0.5)
$P(T=100) \approx \CalcPoissP{0.5}{3}$.
$P(T\leqslant5) \approx \CalcPoissC{0.5}{*}{5}$.

% W -> H(50,10,5)
$P(W=4) \approx \CalcHypergeomP{50}{10}{5}{4}$.
$P(1\leqslant W\leqslant3) \approx \CalcHypergeomC{50}{10}{5}{1}{3}$.
\end{codetex}

\begin{codesortie}[listing only]
$\bullet~~~~X \hookrightarrow \mathcal{B}(5\,; 0,4)$ :\\
$P(X=3) \approx \CalcBinomP{5}{0.4}{3}$.\\
$P(X\leqslant1) \approx \CalcBinomC{5}{0.4}{*}{1}$.

\medskip

$\bullet~~~~X \hookrightarrow \mathcal{B}(100\,; 0,02)$ :\\
$P(X=10) \approx \CalcBinomP{100}{0.02}{10}$.\\
$P(15\leqslant X\leqslant25) \approx \CalcBinomC{100}{0.02}{15}{25}$.

\medskip

$\bullet~~~~Y \hookrightarrow \mathcal{P}_5$ :\\
$P(Y=3) \approx \CalcPoissP{5}{3}$.\\
$P(Y\geqslant2) \approx \CalcPoissC{5}{2}{*}$.

\medskip

$\bullet~~~~T \hookrightarrow \mathcal{G}_{0,5}$ :\\
$P(T=3) \approx \CalcGeomP{0.5}{3}$.\\
$P(T\leqslant5) \approx \CalcGeomC{0.5}{*}{5}$.

\medskip

$\bullet~~~~W \hookrightarrow \mathcal{H}(50\,; 10\,; 5)$ :\\
$P(W=4) \approx \CalcHypergeomP{50}{10}{5}{4}$.\\
$P(1\leqslant W\leqslant3) \approx \CalcHypergeomC{50}{10}{5}{1}{3}$.
\end{codesortie}

\begin{codetex}[listing only]
% X -> N(0,1)
$P(X\leqslant1) \approx \CalcNormC{0}{1}{*}{1}$.
$P(-1,96\leqslant Z\leqslant1,96) \approx \CalcNormC{0}{1}{-1.96}{1.96}$.

% X -> N(550,30)
$P(Y\geqslant600) \approx \CalcNormC{550}{30}{600}{*}$.
$P(500\leqslant Y\leqslant600) \approx \CalcNormC{550}{30}{500}{600}$.

% Z -> E(0.001)
$P(Z\geqslant400) \approx \CalcExpoC{0.001}{400}{*}$.
$P(300\leqslant Z\leqslant750) \approx \CalcExpoC{0.001}{300}{750}$.
\end{codetex}

\begin{codesortie}
$\bullet~~~~X \hookrightarrow \mathcal{N}(0\,; 1)$ :\\
$P(X\leqslant1) \approx \CalcNormC{0}{1}{*}{1}$.\\
$P(-1,96\leqslant Z\leqslant1,96) \approx \CalcNormC{0}{1}{-1.96}{1.96}$.

\medskip

$\bullet~~~~Y \hookrightarrow \mathcal{N}(550\,; 30)$ :\\
$P(Y\geqslant600) \approx \CalcNormC{550}{30}{600}{*}$.\\
$P(500\leqslant Y\leqslant600) \approx \CalcNormC{550}{30}{500}{600}$.

\medskip

$\bullet~~~~Z \hookrightarrow \mathcal{E}_{0,001}$ :\\
$P(Z\geqslant400) \approx \CalcExpoC{0.001}{400}{*}$.\\
$P(300\leqslant Z\leqslant750) \approx \CalcExpoC{0.001}{300}{750}$.
\end{codesortie}

\subsection{Complément avec sortie \og formatée \fg}

\begin{codeidee}
L'idée est ensuite de formater le résultat obtenu par \ctex{xintexpr}, pour un affichage homogène.

\smallskip

L'utilisateur peut donc utiliser \og sa \fg{} méthode pour formater les résultats obtenus par \ctex{xintexpr} !
\end{codeidee}

\begin{codetex}[listing only]
%avec un formatage manuel
\num[exponent-mode=scientific]{\CalcBinomP{100}{0.02}{10}}
\end{codetex}

\begin{codesortie}
$\bullet~~~~X \hookrightarrow \mathcal{B}(100\,; 0,02)$ :

$P(X=10) \approx \num[exponent-mode=scientific]{\CalcBinomP{100}{0.02}{10}}$.
\end{codesortie}

\begin{codeidee}
Le package \ctex{ProfLycee} propose -- en complément -- des commandes pour formater, grâce à \ctex{siunitx}, le résultat.

Les commandes ne sont donc, dans ce cas, pas préfixées par \ctex{calc} :

\begin{itemize}
	\item formatage sous forme décimale \textit{pure} : $0,00\ldots$ ;
	\item formatage sous forme scientifique : $n,\ldots\times10^{\ldots}$.
\end{itemize}
\end{codeidee}

\begin{codetex}[listing only]
%loi binomiale B(n,p)
\BinomP(*)[prec]{n}{p}{k}         %P(X=k)
\BinomC(*)[prec]{n}{p}{a}{b}      %P(a<=X<=b)

%loi de Poisson P (l)
\PoissonP(*)[prec]{l}{k}            %P(X=k)
\PoissonC(*)[prec]{l}{a}{b}         %P(a<=X<=b)

%loi géométrique G (p)
\GeomP{p}{k}                      %P(X=k)
\GeomC{l}{a}{b}                   %P(a<=X<=b)

%loi hypergéométrique H (N,n,m)
\HypergeomP{N}{n}{m}{k}           %P(X=k)
\HypergeomC{N}{n}{m}{a}{b}        %P(a<=X<=b)

%loi normale N(m,s)
\NormaleC(*)[prec]{m}{s}{a}{b}       %P(a<=X<=b)

%loi exponentielle E(l)
\ExpoC(*)[prec]{l}{a}{b}          %P(a<=X<=b)
\end{codetex}

\begin{codecles}
Quelques précisions sur les commandes précédentes :

\begin{itemize}
	\item la version étoilée \Cle{*} des commandes formate le résultat en mode scientifique ;
	\item l'argument optionnel (par défaut \Cle{3}) correspond à quant à lui à l'arrondi.
\end{itemize}
\end{codecles}

\begin{codetex}[listing only]
% X -> N(550,30)
$P(Y\geqslant600) \approx \NormaleC[4]{550}{30}{600}{*}$.
$P(500\leqslant Y\leqslant600) \approx \NormaleC[4]{550}{30}{500}{600}$.
% X -> B(100,0.02)
$P(X=10) \approx \BinomP[7]{100}{0.02}{10} \approx \BinomP*[7]{100}{0.02}{10}$.
$P(15\leqslant X\leqslant25) \approx \BinomC[10]{100}{0.02}{15}{25} \approx \BinomC*[10]{100}{0.02}{15}{25}$.
% H -> H(50,10,5)
$P(W=4) \approx \HypergeomP[5]{50}{10}{5}{4}$.
$P(1\leqslant W\leqslant3) \approx \HypergeomC[4]{50}{10}{5}{1}{3}$.
% Z-> E(0,001)$ :
$P(Z\geqslant400) \approx \ExpoC{0.001}{400}{*}$.
$P(300\leqslant Z\leqslant750) \approx \ExpoC{0.001}{300}{750}$.
% T -> P(5)
$P(T=3) \approx \PoissonP{5}{3}$.
$P(T\geqslant2) \approx \PoissonC[4]{5}{2}{*}$.
\end{codetex}

\begin{codesortie}
$\bullet~~~~Y \hookrightarrow \mathcal{N}(550\,; 30)$ :

$P(Y\geqslant600) \approx \NormaleC[4]{550}{30}{600}{*}$.

$P(500\leqslant Y\leqslant600) \approx \NormaleC[4]{550}{30}{500}{600}$.

\medskip

$\bullet~~~~X \hookrightarrow \mathcal{B}(100\,; 0,02)$ :

$P(X=10) \approx \BinomP[7]{100}{0.02}{10} \approx \BinomP*[7]{100}{0.02}{10}$.

$P(15\leqslant X\leqslant25) \approx \BinomC[10]{100}{0.02}{15}{25} \approx \BinomC*[10]{100}{0.02}{15}{25}$.

\medskip

$\bullet~~~~W \hookrightarrow \mathcal{H}(50\,; 10\,; 5)$ :

$P(W=4) \approx \HypergeomP[5]{50}{10}{5}{4}$.

$P(1\leqslant W\leqslant3) \approx \HypergeomC[4]{50}{10}{5}{1}{3}$.

\medskip

$\bullet~~~~Z \hookrightarrow \mathcal{E}_{0,001}$ :

$P(Z\geqslant400) \approx \ExpoC{0.001}{400}{*}$.

$P(300\leqslant Z\leqslant750) \approx \ExpoC{0.001}{300}{750}$.

\medskip

$\bullet~~~~T \hookrightarrow \mathcal{P}_5$ :

$P(T=3) \approx \PoissonP{5}{3}$.

$P(T\geqslant2) \approx \PoissonC[4]{5}{2}{*}$.
\end{codesortie}

\begin{codeinfo}
\hfill~\includegraphics[height=3cm]{./graphics/pl-doc-probas_a}~~\includegraphics[height=3cm]{./graphics/pl-doc-probas_c}~~\includegraphics[height=3cm]{./graphics/pl-doc-probas_e}~~\includegraphics[height=3cm]{./graphics/pl-doc-probas_f}\hfill~
\end{codeinfo}

\newpage

\section{Arbres de probabilités \og classiques \fg}\label{arbresprobas}

\subsection{Introduction}

\begin{codeidee}
L'idée est de proposer des commandes pour créer des arbres de probabilités classiques (et homogènes), en \TikZ, de format :

\begin{itemize}
	\item $2\times2$ ou $2\times3$ ;
	\item $3\times2$ ou $3\times3$.
\end{itemize}

Les (deux) commandes sont donc liées à un environnement \ctex{tikzpicture}, et elles créent les nœuds de l'arbre, pour exploitation ultérieure éventuelle.
\end{codeidee}

\begin{codetex}[listing only]
%commande simple pour tracé de l'arbre
\ArbreProbasTikz[options]{donnees}

%environnement pour tracé et exploitation éventuelle
\begin{EnvArbreProbasTikz}[options]{donnees}
	code tikz supplémentaire
\end{EnvArbreProbasTikz}
\end{codetex}

\subsection{Options et arguments}

\begin{codeinfo}
Les \Cle{donnees} seront à préciser sous forme \ctex{<sommet1>/<proba1>/<position1>,<sommet2>/<proba2>/<position2>,...} avec comme \og sens de lecture \fg{} de la gauche vers la droite puis du haut vers le bas (on balaye les \textit{sous-arbres}), avec comme possibilités :

\begin{itemize}
	\item une donnée \Cle{proba} peut être laissée vide ;
	\item une donnée \Cle{position} peut valoir \Cle{above} (au-dessus), \Cle{below} (en-dessous) ou être laissée \Cle{vide} (sur).
\end{itemize}
\end{codeinfo}

\begin{codecles}
Quelques \Cle{Clés} (communes) pour les deux commandes :

\begin{itemize}
	\item la clé \Cle{Unite} pour préciser l'unité de l'environnement \TikZ{} ; \hfill~défaut \Cle{1cm}
	\item la clé \Cle{EspaceNiveau} pour l'espace (H) entre les étages ; \hfill~défaut \Cle{3.25}
	\item la clé \Cle{EspaceFeuille} pour l'espace (V) entre les feuilles ; \hfill~défaut \Cle{1}
	\item la clé \Cle{Type} pour le format, parmi \Cle{2x2} ou \Cle{2x3} ou \Cle{3x2} ou  \Cle{3x3} ; \hfill~défaut \Cle{2x2}
	\item la clé \Cle{Police} pour la police des nœuds ; \hfill~défaut \Cle{\textbackslash{}normalfont\textbackslash{}normalsize}
	\item la clé \Cle{PoliceProbas} pour la police des probas ; \hfill~défaut \Cle{\textbackslash{}normalfont\textbackslash{}small}
	\item le booléen \Cle{InclineProbas} pour incliner les probas ; \hfill~défaut \Cle{true}
	\item le booléen \Cle{Fleche} pour afficher une flèche sur les branches ; \hfill~défaut \Cle{false}
	\item la clé \Cle{StyleTrait} pour les branches, en langage \TikZ{} ; \hfill~défaut \Cle{vide}
	\item la clé \Cle{EpaisseurTrait} pour l'épaisseur des branches, en langage \TikZ{} ; \hfill~défaut \Cle{semithick}
\end{itemize}
\end{codecles}

\begin{codetex}[listing only]
\def\ArbreDeuxDeux{
	$A$/\num{0.5}/,
		$B$/\num{0.4}/,
		$\overline{B}$/.../,
	$\overline{A}$/.../,
		$B$/.../,
		$\overline{B}$/$\frac{1}{3}$/
}

\ArbreProbasTikz{\ArbreDeuxDeux}

%des éléménts, en gris, ont été rajoutés pour illustrer certaines options
\end{codetex}

\begin{codesortie}
\begin{EnvArbreProbasTikz}{$A$/\num{0.5}/,$B$/\num{0.4}/,$\overline{B}$/.../,$\overline{A}$/.../,$B$/.../,$\overline{B}$/$\frac{1}{3}$/}
	\draw[lightgray] (R) node[left,font=\ttfamily\small] {(R)} ;
	\draw[lightgray] (A11) node[below,font=\ttfamily\small] {(A11)} ;
	\draw[lightgray] (A12) node[below,font=\ttfamily\small] {(A12)} ;
	\draw[lightgray] (A21) node[below,font=\ttfamily\small] {(A21)} ;
	\draw[lightgray] (A22) node[below,font=\ttfamily\small] {(A22)} ;
	\draw[lightgray] (A23) node[below,font=\ttfamily\small] {(A23)} ;
	\draw[lightgray] (A24) node[below,font=\ttfamily\small] {(A24)} ;
	\draw[lightgray,<->,>=latex] (0,-4) -- (3.25,-4) node[midway,below,font=\ttfamily\small] {EspaceNiveau} ;
	\draw[lightgray,<->,>=latex] (3.25,-4) -- (6.5,-4) node[midway,below,font=\ttfamily\small] {EspaceNiveau} ;
	\draw[lightgray,<->,>=latex] (7,0) -- (7,-1) node[midway,right,font=\ttfamily\small] {EspaceFeuille} ;
	\draw[lightgray,<->,>=latex] (7,-1) -- (7,-2) node[midway,right,font=\ttfamily\small] {EspaceFeuille} ;
	\draw[lightgray,<->,>=latex] (7,-2) -- (7,-3) node[midway,right,font=\ttfamily\small] {EspaceFeuille} ;
\end{EnvArbreProbasTikz}
\end{codesortie}

\begin{codeinfo}
Les nœuds crées par les commandes sont :

\begin{itemize}
	\item \ctex{R} pour la racine ;
	\item \ctex{A1x} pour les nœuds du 1\up{er} niveau (de haut en bas) ;
	\item  \ctex{A2x} pour les nœuds du 2\up{d} niveau (de haut en bas).
\end{itemize}
\end{codeinfo}

\subsection{Exemples complémentaires}

\begin{codetex}[listing only]
\def\ArbreTroisDeux{
	$A_1$/\num{0.5}/above,
		$B$/\num{0.4}/above,
		$\overline{B}$/.../below,
	$A_2$/.../above,
		$B$/.../above,
		$\overline{B}$/$\frac{1}{3}$/below,
	$A_3$/.../below,
		$B$/.../above,
		$\overline{B}$/$\frac{4}{15}$/below
}

\begin{EnvArbreProbasTikz}[Type=3x2,Fleche,EspaceNiveau=5,EspaceFeuille=1.25]{\ArbreTroisDeux}
	\draw[ForestGreen,->] (A24)--($(A24)+(2.5,0)$) node[right,font=\sffamily] {code tikz rajouté} ;
\end{EnvArbreProbasTikz}
\end{codetex}

\begin{codesortie}
\begin{EnvArbreProbasTikz}[Type=3x2,Fleche,EspaceNiveau=5,EspaceFeuille=1.25]{$A_1$/\num{0.5}/above,$B$/\num{0.4}/above,$\overline{B}$/.../below,$A_2$/.../above,$B$/.../above,$\overline{B}$/$\frac{1}{3}$/below,$A_3$/.../below,$B$/.../above,$\overline{B}$/$\frac{4}{15}$/below}
	\draw[ForestGreen,->] (A24)--($(A24)+(2.5,0)$) node[right,font=\sffamily] {code tikz rajouté} ;
\end{EnvArbreProbasTikz}
\end{codesortie}

\begin{codetex}[listing only]
\def\ArbreDeuxTrois{
	$A$/\num{0.05}/above,
		$B_1$/\num{0.4}/above,
		$B_2$/\num{0.35}/,
		$B_3$//below,
	$\overline{A}$/.../below,
		$B_1$/$\frac{2}{15}$/above,
		$B_2$/.../,
		$B_3$/$\frac{1}{3}$/below
}
\ArbreProbasTikz[Type=2x3,InclineProbas=false,EspaceFeuille=1.15]{\ArbreDeuxTrois}

\def\ArbreTroisTrois{
	$A_1$/\num{0.05}/,
		$B_1$/{1/3}/,
		$B_2$/{1/3}/,
		$B_3$/{1/3}/,
	$A_2$/\num{0.80}/,
		$B_1$/{1/3}/,
		$B_2$/{1/3}/,
		$B_3$/{1/3}/,
	$A_3$/\num{0.15}/,
		$B_1$/{1/3}/,
		$B_2$/{1/3}/,
		$B_3$/{1/3}/
}

\ArbreProbasTikz[Type=3x3,StyleTrait={densely dashed},EspaceFeuille=0.7,PoliceProbas=\scriptsize,Police=\small]{\ArbreTroisTrois}
\end{codetex}

\begin{codesortie}
\ArbreProbasTikz[Type=2x3,InclineProbas=false,EspaceFeuille=1.15]{$A$/\num{0.05}/above,$B_1$/\num{0.4}/above,$B_2$/\num{0.35}/,$B_3$//below,$\overline{A}$/.../below,$B_1$/$\frac{2}{15}$/above,$B_2$/.../,$B_3$/$\frac{1}{3}$/below}
~~
\ArbreProbasTikz[Type=3x3,StyleTrait={densely dashed},EspaceFeuille=0.7,PoliceProbas=\scriptsize,Police=\small]{$A_1$/\num{0.05}/,$B_1$/{1/3}/,$B_2$/{1/3}/,$B_3$/{1/3}/,$A_2$/\num{0.80}/,$B_1$/{1/3}/,$B_2$/{1/3}/,$B_3$/{1/3}/,$A_3$/\num{0.15}/,$B_1$/{1/3}/,$B_2$/{1/3}/,$B_3$/{1/3}/}
\end{codesortie}

\newpage

\section{Petits schémas pour des probabilités continues}\label{schemasprobas}

\subsection{Idée}

\begin{codeidee}
L'idée est de proposer des commandes pour illustrer, sous forme de schémas en \TikZ, des probabilités avec des lois continues (normales et exponentielles).

\smallskip

Ces \og schémas \fg{} peuvent être insérés en tant que graphique explicatif, ou bien en tant que petite illustration rapide !
\end{codeidee}

\begin{codetex}[listing only]
\LoiNormaleGraphe[options]<options tikz>{m}{s}{a}{b}

\LoiExpoGraphe[options]<options tikz>{l}{a}{b}
\end{codetex}

\begin{codesortie}
\hfill\LoiNormaleGraphe{100}{20}{80}{120}\hspace{3cm}\LoiExpoGraphe{0.001}{250}{1500}\hfill~
\end{codesortie}

\begin{codecles}
Les probabilités \textit{illustrables} sont donc des probabilités \textbf{C}umulées ($P(a\leqslant X\leqslant b)$).

\smallskip

On peut utiliser \ctex{*} comme borne ($a$ ou $b$), pour les probabilités du type $P(X\leqslant b)$ et $P(X \geqslant a)$.
\end{codecles}

\subsection{Commandes et options}

\begin{codecles}
Quelques \Cle{Clés} sont disponibles pour ces commandes :

\begin{itemize}
	\item la clé \Cle{CouleurAire} pour l'aire sous la courbe ; \hfill{}défaut \Cle{LightGray}
	\item la clé \Cle{CouleurCourbe} pour la courbe ; \hfill{}défaut \Cle{red}
	\item la clé \Cle{Largeur} qui sera la largeur (en cm) du graphique ; \hfill{}défaut \Cle{2}
	\item la clé \Cle{Hauteur} qui sera la hauteur (en cm) du graphique ; \hfill{}défaut \Cle{1}
	\item un booléen \Cle{AfficheM} qui affiche la moyenne ; \hfill{}défaut \Cle{true}
	\item un booléen \Cle{AfficheCadre} qui affiche un cadre pour délimiter le schéma. \hfill{}défaut \Cle{true}
\end{itemize}
\end{codecles}

\begin{codeinfo}
Les commandes sont donc des environnements \TikZ, sans possibilité de \og rajouter \fg{} des éléments. Ces petis \textit{schémas} sont donc vraiment dédiés à \textit{montrer} rapidement une probabilité continue, sans fioriture.
\end{codeinfo}

\begin{codetex}
Avec centrage vertical sur l'axe des abscisses :
\LoiNormaleGraphe[AfficheM=false,CouleurCourbe=Blue,CouleurAire=LightBlue]<baseline=0pt>{1000}{100}{950}{*}
\end{codetex}

\begin{codetex}
Avec quelques modifications :

\LoiNormaleGraphe[Largeur=4,Hauteur=2]{150}{12.5}{122}{160}

\medskip

Avec centrage vertical :
\LoiNormaleGraphe[Largeur=5,Hauteur=2.5]<baseline=(current bounding box.center)>{200}{5}{204}{*}

\medskip

Avec centrage vertical sur l'axe des abscisses :
\LoiExpoGraphe[AfficheM=false,CouleurCourbe=Blue,CouleurAire=LightBlue]<baseline=0pt>{0.05}{*}{32}

\medskip

\LoiExpoGraphe[Largeur=4,Hauteur=2]{0.00025}{5000}{*}
\end{codetex}

\subsection{Remarques et compléments}

\begin{codeinfo}
Pour le moment, seules les lois (continues) exponentielles et normales sont disponibles, peut-être que d'autres lois seront ajoutées, mais il ne me semble pas très pertinent de proposer des schémas similaires pour des lois discrètes, qui ont des \textit{représentations} assez variables\ldots
\end{codeinfo}

\newpage

\section{Nombres aléatoires}\label{entiersaleatoires}

\subsection{Idée}

\begin{codeidee}
\cmaj{2.0.9} L'idée est de proposer des commandes pour générer des nombres aléatoires, pour exploitation ultérieure :

\begin{itemize}
	\item un entier ou un nombre décimal ;
	\item des nombres entiers, avec ou sans répétitions.
\end{itemize}
\end{codeidee}

\begin{codeinfo}
Pour chacune des commandes, le ou les résultats sont stockés dans une \textsf{macro} dont le nom est choisi par l'utilisateur.
\end{codeinfo}

\begin{codetex}[listing only]
%entier aléatoire entre a et b
\NbAlea{a}{b}{macro}

%nombre décimal (n chiffres après la virgule) aléatoire entre a et b+1 (exclus)
\NbAlea[n]{a}{b}{macro}

%création d'un nombre aléatoire sous forme d'une macro
\VarNbAlea{macro}{calculs}

%liste d'entiers aléatoires
\TirageAleatoireEntiers[options]{macro}
\end{codetex}

\begin{codetex}[]
%nombre aléatoire entre 1 et 50, stocké dans \PremierNbAlea
Entier entre 1 et 50 : \NbAlea{1}{50}{\PremierNbAlea}\PremierNbAlea

%nombre aléatoire créé à partir du 1er, stocké dans \DeuxiemeNbAlea
Entier à partir du précédent : \VarNbAlea{\DeuxiemeNbAlea}{\PremierNbAlea+randint(0,10)}\DeuxiemeNbAlea

%nombre aléatoire décimal (au millième) entre 0 et 10+1 (exclus), stocké dans \PremierDecAlea
Décimal entre 0 et $10,999\ldots$ : \NbAlea[3]{0}{10}{\PremierDecAlea}\PremierDecAlea

%liste de 6 nombres, sans répétitions, entre 1 et 50
Liste par défaut (6 entre 1 et 50) : \TirageAleatoireEntiers{\PremiereListeAlea}\PremiereListeAlea
\end{codetex}

\begin{codeinfo}
Les listes créées sont exploitables, \textit{a posteriori}, par le package \ctex{listofitems} par exemple !
\end{codeinfo}

\begin{codetex}[]
Liste générée : \TirageAleatoireEntiers{\TestListeA}\TestListeA

Liste traitée : \readlist*\LISTEa{\TestListeA}\showitems{\LISTEa}
\end{codetex}

\pagebreak

\subsection{Clés et options}

\begin{codecles}
Quelques clés sont disponibles pour la commande \ctex{TirageAleatoireEntiers} :

\begin{itemize}
	\item la clé \Cle{ValMin} pour préciser borne inférieure de l'intervalle ;\hfill{}défaut \Cle{1}
	\item la clé \Cle{ValMax} pour préciser borne supérieure de l'intervalle ;\hfill{}défaut \Cle{50}
	\item la clé \Cle{NbVal} qui est le nombre d'entiers à générer ;\hfill{}défaut \Cle{6}
	\item la clé \Cle{Sep} pour spécifier le séparateur d'éléments ;\hfill{}défaut \Cle{,}
	\item la clé \Cle{Tri} parmi \Cle{non/croissant/decroissant} pour trier les valeurs
	;\hfill{}défaut \Cle{non}
	\item le booléen \Cle{Repetition} pour autoriser la répétition d'éléments.\hfill{}défaut \Cle{false}
\end{itemize}
\end{codecles}

\begin{codetex}[]
Une liste de 15 valeurs (différentes), entre 10 et 100, stockée dans la macro MaListeA : \\
Liste : \TirageAleatoireEntiers[ValMin=10,ValMax=100,NbVal=15]{\MaListeA}\MaListeA \\

Une liste de 12 valeurs (différentes), entre 1 et 50, ordre croissant : \\
Liste : \TirageAleatoireEntiers[ValMin=1,ValMax=50,NbVal=12,Tri=croissant]{\MaListeB}\MaListeB \\

Une liste de 12 valeurs (différentes), entre 1 et 50, ordre décroissant : \\
Liste : \TirageAleatoireEntiers[ValMin=1,ValMax=50,NbVal=12,Tri=decroissant]{\MaListeC}\MaListeC \\

15 tirages de dé à 6 faces : \\ \TirageAleatoireEntiers[ValMin=1,ValMax=6,NbVal=15,Repetition]{\TestDes}\TestDes
\end{codetex}

\begin{codetex}[]
Une liste (10) pour le Keno\textcopyright, ordonnée, et séparée par des \texttt{-} :

\TirageAleatoireEntiers[ValMin=1,ValMax=70,NbVal=10,Tri=croissant,Sep={-}]{\ListeKeno}
$\ListeKeno$

\setsepchar{-}\readlist*\KENO{\ListeKeno}\showitems{\KENO}
\end{codetex}

\newpage

\section{Combinatoire}\label{combinatoire}

\subsection{Idée}

\begin{codeidee}
L'idée est de proposer une commande pour calculer un arrangement ou une combinaison, en utilisant les capacités de calcul du package \ctex{xfp}.
\end{codeidee}

\begin{codetex}[listing only]
\Arrangement(*)[option]{p}{n}
\Combinaison(*)[option]{p}{n}
\end{codetex}

\subsection{Utilisation}

\begin{codecles}
Peu de paramétrage pour ces commandes qui permettent de calculer $A_n^p$ et $C_n^p$ :

\begin{itemize}
	\item les versions étoilées ne formatent pas le résultat grâce à \ctex{\textbackslash num} de \ctex{sinuitx} ;
	\item le booléen \Cle{Formule} permet de présenter la formule avant le résultat ; \hfill~défaut \Cle{false}
	\item le premier argument, \textit{mandataire}, est la valeur de $p$ ;
	\item le second argument, \textit{mandataire}, est la valeur de $n$.
\end{itemize}
\end{codecles}

\begin{codetex}[]
On a $A_{20}^3=\Arrangement*{3}{20}$ en non formaté, et $A_{20}^3=\Arrangement{3}{20}$ en formaté.
\end{codetex}

\begin{codetex}[]
On a $C_{20}^3=\Combinaison*{3}{20}$ en non formaté, et $C_{20}^3=\Combinaison{3}{20}$ en formaté.
\end{codetex}

\begin{codetex}[]
On a $A_{20}^3=\Arrangement[Formule]{3}{20}$.
\end{codetex}

\begin{codetex}[]
On a $C_{20}^3=\displaystyle\Combinaison[Formule]{3}{20}$.
\end{codetex}

\newpage

\part{Outils pour l'arithmétique}

\section{Conversions binaire/hexadécimal/décimal}\label{conversions}

\subsection{Idée}

\begin{codeidee}
L'idée est de \textit{compléter} les possibilités offertes par le package \ctex{xintbinhex}, en mettant en forme quelques conversions :

\begin{itemize}
	\item décimal en binaire avec blocs de 4 chiffres en sortie ;
	\item conversion binaire ou hexadécimal en décimal avec écriture polynomiale.
\end{itemize}
\end{codeidee}

\begin{codeinfo}
Le package \ctex{xintbinhex} est la base de ces macros, puisqu'il permet de faire des conversions directes !

\smallskip

Les macros présentées ici ne font que les intégrer dans un environnement adapté à une correction ou une présentation !
\end{codeinfo}

\begin{codetex}[listing only]
\xintDecToHex{100}
\xintDecToBin{51}
\xintHexToDec{A4C}
\xintBinToDec{110011}
\xintBinToHex{11111111}
\xintHexToBin{ACDC}
\xintCHexToBin{3F}
\end{codetex}

\begin{codesortie}
\xintDecToHex{100}

\xintDecToBin{51}

\xintHexToDec{A4C}

\xintBinToDec{110011}

\xintBinToHex{11111111}

\xintHexToBin{ACDC}

\xintCHexToBin{3F}
\end{codesortie}

\subsection{Conversion décimal vers binaire}

\begin{codetex}[listing only]
\ConversionDecBin(*)[clés]{nombre}
\end{codetex}

\begin{codecles}
Concernant la commande en elle même, peu de paramétrage :

\begin{itemize}
	\item la version \textit{étoilée} qui permet de ne pas afficher de zéros avant pour \og compléter \fg{} ;
	\item le booléen \Cle{AffBase} qui permet d'afficher ou non la base des nombres ; \hfill{}défaut \Cle{true}
	\item l'argument, mandataire, est le nombre entier à convertir.
\end{itemize}

Le formatage est géré par \ctex{sinuitx}, le mieux est donc de positionner la commande dans un environnement mathématique.

\smallskip

Les nombres écrits en binaire sont, par défaut, présentés en bloc(s) de 4 chiffres.
\end{codecles}

\begin{codetex}[listing only]
% Conversion avec affichage de la base et par bloc de 4
$\ConversionDecBin{415}$
% Conversion avec affichage de la base et sans forcément des blocs de 4
$\ConversionDecBin*{415}$
% Conversion sans affichage de la base et par bloc de 4
$\ConversionDecBin[AffBase=false]{415}$
% Conversion sans affichage de la base et sans forcément des blocs de 4
$\ConversionDecBin*[AffBase=false]{415}$
\end{codetex}

\begin{codesortie}
$\ConversionDecBin{415}$

\smallskip

$\ConversionDecBin*{415}$

\smallskip

$\ConversionDecBin[AffBase=false]{415}$

\smallskip

$\ConversionDecBin*[AffBase=false]{415}$
\end{codesortie}

\subsection{Conversion binaire vers hexadécimal}

\begin{codeinfo}
L'idée est ici de présenter la conversion, grâce à la conversion \og directe \fg{} par blocs de 4 chiffres :

\begin{itemize}
	\item la macro rajoute éventuellement les zéros pour compléter ;
	\item elle découpe par blocs de 4 chiffres binaires ;
	\item elle présente la conversion de chacun des blocs de 4 chiffres binaires ;
	\item elle affiche la conversion en binaire.
\end{itemize}
\end{codeinfo}

\begin{codetex}[listing only]
\ConversionBinHex[clés]{nombre}
\end{codetex}

\begin{codecles}
Quelques \Cle{clés} sont disponibles pour cette commande :

\begin{itemize}
	\item le booléen \Cle{AffBase} qui permet d'afficher ou non la base des nombres ; \hfill{}défaut \Cle{true}
	\item le booléen \Cle{Details} qui permet d'afficher ou le détail par bloc de 4. \hfill{}défaut \Cle{true}
	%\item la clé \Cle{trait} qui permet de modifier l'épaisseur du crochet. \hfill{}défaut \Cle{0.5pt}
\end{itemize}

Le formatage est géré par le package \ctex{sinuitx}, le mieux est de positionner la commande dans un environnement mathématique.
\end{codecles}

\begin{codetex}[listing only]
%conversion avec détails et affichage de la base
$\ConversionBinHex{110011111}$
%conversion sans détails et affichage de la base
$\ConversionBinHex[Details=false]{110011111}$
%conversion sans détails et sans affichage de la base
$\ConversionBinHex[AffBase=false,Details=false]{110011111}$
\end{codetex}

\begin{codesortie}
$\ConversionBinHex{110011111}$

$\ConversionBinHex[Details=false]{110011111}$

$\ConversionBinHex[AffBase=false,Details=false]{110011111}$
\end{codesortie}

\pagebreak

\subsection{Conversion binaire ou hexadécimal en décimal}

\begin{codeinfo}
L'idée est ici de présenter la conversion, grâce à l'écriture polynômiale :

\begin{itemize}
	\item écrit la somme des puissances ;
	\item convertir si besoin les \textit{chiffres} hexadécimal ;
	\item peut ne pas afficher les monômes de coefficient 0.
\end{itemize}
\end{codeinfo}

\begin{codetex}[listing only]
\ConversionVersDec[clés]{nombre}
\end{codetex}

\begin{codecles}
Quelques \Cle{clés} sont disponibles pour cette commande :

\begin{itemize}
	\item la clé \Cle{BaseDep} qui est la base de départ (2 ou 16 !) ; \hfill{}défaut \Cle{2}
	\item le booléen \Cle{AffBase} qui permet d'afficher ou non la base des nombres ; \hfill{}défaut \Cle{true}
	\item le booléen \Cle{Details} qui permet d'afficher ou le détail par bloc de 4 ; \hfill{}défaut \Cle{true}
	\item le booléen \Cle{Zeros} qui affiche les chiffres 0 dans la somme. \hfill{}défaut \Cle{true}
\end{itemize}

Le formatage est toujours géré par le package \ctex{sinuitx}, le mieux est de positionner la commande dans un environnement mathématique.
\end{codecles}

\begin{codetex}[listing only]
%conversion 16->10 avec détails et affichage de la base et zéros
$\ConversionVersDec[BaseDep=16]{19F}$
%conversion 2->10 avec détails et affichage de la base et zéros
$\ConversionVersDec{110011}$
%conversion 2->10 avec détails et affichage de la base et sans zéros
$\ConversionVersDec[Zeros=false]{110011}$
%conversion 16->10 sans détails et affichage de la base et avec zéros
$\ConversionVersDec[BaseDep=16,Details=false]{AC0DC}$
%conversion 16->10 avec détails et sans affichage de la base et sans zéros
$\ConversionVersDec[Eeros=false,Basedep=16]{AC0DC}$
\end{codetex}

\begin{codesortie}
$\ConversionVersDec[BaseDep=16]{19F}$

$\ConversionVersDec{110011}$

$\ConversionVersDec[Zeros=false]{110011}$

$\ConversionVersDec[BaseDep=16,Details=false]{AC0DC}$

$\ConversionVersDec[Zeros=false,BaseDep=16]{AC0DC}$
\end{codesortie}

\newpage

\section{Conversion \og présentée \fg{} d'un nombre en base décimale}\label{convrestes}

\subsection{Idée}

\begin{codeidee}
L'idée est de proposer une \og présentation \fg{} par divisions euclidiennes pour la conversion d'un entier donné en base 10 dans une base quelconque.

\smallskip

Les commandes de la section précédente donne \textit{juste} les résultats, dans cette section il y a en plus la présentation de la conversion.

\smallskip

La commande utilise -- par défaut -- du code \TikZ{} en mode \ctex{overlay}, donc on pourra déclarer -- si ce n'est pas fait -- dans le préambule, la commande qui suit.
\end{codeidee}

\begin{codetex}[listing only]
...
\tikzstyle{every picture}+=[remember picture]
...
\end{codetex}

\subsection{Code et clés}

\begin{codetex}[]
%conversion basique
\ConversionDepuisBaseDix{78}{2}
\end{codetex}

\begin{codeinfo}
La \og tableau \fg, qui est géré par \ctex{array} est inséré dans un \ctex{ensuremath}, donc les \ctex{\$...\$} ne sont pas utiles.
\end{codeinfo}

\begin{codetex}[listing only]
\ConversionDepuisBaseDix[options]{nombre en base 10}{base d'arrivée}
\end{codetex}

\begin{codecles}
Quelques options pour cette commande :

\begin{itemize}
	\item la clé \Cle{Couleur} pour la couleur du \og rectangle \fg{} des restes ; \hfill{}défaut \Cle{red}
	\item la clé \Cle{DecalH} pour gérer le décalage H du \og rectangle \fg{}, qui peut être donné soit sous la forme \Cle{Esp} ou soit sous la forme \Cle{espgauche/espdroite}; \hfill{}défaut \Cle{2pt}
	\item la clé \Cle{DecalV} pour le décalage vertical du \og rectangle \fg{} ; \hfill{}défaut \Cle{3pt}
	\item la clé \Cle{Noeud} pour le préfixe du nœud du premier et du dernier reste (pour utilisation en \TikZ) ; \hfill{}défaut \Cle{EEE}
	\item le booléen \Cle{Rect} pour afficher ou non le \og rectangle \fg{} des restes ; \hfill{}défaut \Cle{true}
	\item le booléen \Cle{CouleurRes} pour afficher ou non la conversion en couleur (identique au rectangle). \hfill{}défaut \Cle{false}
\end{itemize}
\end{codecles}

\begin{codetex}[listing only]
%conversion avec changement de couleur
\ConversionDepuisBaseDix[Couleur=DarkBlue]{45}{2}

%conversion sans le rectangle
Par divisions euclidiennes successives, \ConversionDepuisBaseDix[Rect=false]{54}{3}.

%conversion avec gestion du decalh pour le placement précis du rectangle
\ConversionDepuisBaseDix[Couleur=Goldenrod,DecalH=6pt/2pt]{1012}{16}

%conversion avec nœud personnalisé et réutilisation
\ConversionDepuisBaseDix[Couleur=ForestGreen,CouleurRes,Noeud=TEST]{100}{9}.
\begin{tikzpicture}
	\draw[overlay,ForestGreen,thick,->] (TEST2.south east) to[bend right] ++ (3cm,-1cm) node[right] {test } ;
\end{tikzpicture}
\end{codetex}

\begin{codesortie}
\ConversionDepuisBaseDix[Couleur=DarkBlue]{45}{2}

\medskip

Par divisions euclidiennes successives, \ConversionDepuisBaseDix[Rect=false]{54}{3}.

\medskip

\ConversionDepuisBaseDix[Couleur=Goldenrod,DecalH=6pt/2pt]{1012}{16}

\medskip

On obtient donc \ConversionDepuisBaseDix[Couleur=ForestGreen,CouleurRes,Noeud=TEST]{100}{9}.
\begin{tikzpicture}
	\draw[overlay,ForestGreen,thick,->] (TEST2.south east) to[bend right] ++ (3cm,-1cm) node[right] {test } ;
\end{tikzpicture}

\vspace{1.5cm}

~
\end{codesortie}

\newpage

\section{Algorithme d'Euclide pour le PGCD}\label{prespgcd}

\subsection{Idée}

\begin{codeidee}
L'idée est de proposer une \og présentation \fg{} de l'algorithme d'Euclide pour le calcul du PGCD de deux entiers.

Le package \ctex{xintgcd} permet déjà de le faire, il s'agit ici de travailler sur la \textit{mise en forme} avec alignement des restes.
\end{codeidee}

\begin{codetex}[listing only]
\PresentationPGCD[options]{a}{b}
\end{codetex}

\begin{codetex}[listing only]
...
\tikzstyle{every picture}+=[remember picture]
...
\PresentationPGCD{150}{27}
\end{codetex}

\begin{codesortie}
\PresentationPGCD{150}{27}
\end{codesortie}

\begin{codeattention}
La mise en valeur du dernier reste non nul est géré par du code \TikZ, en mode \ctex{overlay}, donc il faut bien penser à déclarer dans le préambule :

\hspace{5mm}\ctex{\textbackslash{}tikzstyle\{every picture\}+=[remember picture]}
\end{codeattention}

\subsection{Options et clés}

\begin{codecles}
Quelques options disponibles pour cette commande :

\begin{itemize}
	\item la clé \Cle{Couleur} qui correspond à la couleur pour la mise en valeur ; \hfill{}défaut \Cle{red}
	\item la clé \Cle{DecalRect} qui correspond à l'écartement du rectangle de mise en valeur ; \hfill{}défaut \Cle{2pt}
	\item le booléen \Cle{Rectangle} qui gère l'affichage ou non du rectangle de mise ne valeur ; \hfill{}défaut \Cle{true}
	\item la clé \Cle{Noeud} qui gère le préfixe du nom du nœud \TikZ{} du rectangle (pour exploitation ultérieure) ; \hfill{}défaut \Cle{FFF}
	\item le booléen \Cle{CouleurResultat} pour mettre ou non en couleur de PGCD ; \hfill{}défaut \Cle{false}
	\item le booléen \Cle{AfficheConclusion} pour afficher ou non la conclusion ; \hfill{}défaut \Cle{true}
	\item le booléen \Cle{AfficheDelimiteurs} pour afficher ou non les délimiteurs (accolade gauche et trait droit). \hfill{}défaut \Cle{true}
\end{itemize}

\medskip

Le rectangle de mise en valeur est donc un nœud \TikZ{} qui sera nommé, par défaut \ctex{FFF1}.

\medskip

La présentation est dans un environnement \ctex{ensuremath} donc les \ctex{\$...\$} ne sont pas indispensables.
\end{codecles}

\begin{codetex}[]
\PresentationPGCD[CouleurResultat]{150}{27}
\end{codetex}

\pagebreak

\begin{codetex}[]
\PresentationPGCD[CouleurResultat,Couleur=ForestGreen]{1250}{450}.

\PresentationPGCD[CouleurResultat,Couleur=DarkBlue]{13500}{2500}.

\PresentationPGCD[Rectangle=false]{420}{540}.

\medskip

D'après l'algorithme d'Euclide, on a $\left| \PresentationPGCD[Couleur=LightSkyBlue,AfficheConclusion=false,AfficheDelimiteurs=false]{123456789}{9876} \right.$
\begin{tikzpicture}
	\draw[overlay,LightSkyBlue,thick,<-] (FFF1.east) to[bend right] ++ (2cm,0.75cm) node[right] {dernier reste non nul} ;
\end{tikzpicture}
\end{codetex}

\subsection{Compléments}

\begin{codeinfo}
La présentation des divisions euclidiennes est gérée par un tableau du type \ctex{array}, avec alignement vertical de symboles \ctex{=} et \ctex{+}.

Par défaut, les délimiteurs choisis sont donc l'accolade gauche et le trait droit, mais la clé booléenne \Cle{AfficheDelimiteurs=false} permet de choisir des délimiteurs différents.
\end{codeinfo}

\begin{codetex}[]
$\left[ \PresentationPGCD[AfficheConclusion=false,AfficheDelimiteurs=false]{1234}{5} \right]$
\end{codetex}

\newpage

\part{Écritures, simplifications}

\section{Simplification sous forme d'une fractions}\label{convfrac}

\subsection{Idée}

\begin{codeidee}
L'idée est d'obtenir une commande pour \textit{simplifier} un calcul sous forme de fraction irréductible.
\end{codeidee}

\begin{codetex}[listing only]
\ConversionFraction[option]{argument}
\end{codetex}

\subsection{Commande et options}

\begin{codecles}
Peu d'options pour ces commandes :

\begin{itemize}
\item le premier argument, optionnel, permet de spécifier le mode de sortie de la fraction \textsf{[t]} pour \textsf{tfrac} et \textsf{[d]} pour \textsf{dfrac} ;
\item le second, mandataire, est le \textsf{calcul} ou la \textsf{division} à convertir.
\end{itemize}

À noter que la macro est dans un bloc \ctex{ensuremath} donc les \ctex{\$...\$} ne sont pas nécessaires.
\end{codecles}

\begin{codetex}[listing only]
\ConversionFraction{111/2145}
\ConversionFraction{111/3}
$\frac{111}{2145}=\ConversionFraction{111/2145}$
$\frac{3}{15}=\ConversionFraction[]{3/15}$
$\tfrac{3}{15}=\ConversionFraction[t]{3/15}$                   %formatage en \tfrac
$\dfrac{3}{15}=\ConversionFraction[d]{3/15}$                   %formatage en \dfrac
$\dfrac{0,42}{0,015}=\ConversionFraction[d]{0.42/0.015}$
$\dfrac{0,41}{0,015}=\ConversionFraction[d]{0.41/0.015}$
$\dfrac{1}{7}+\dfrac{3}{8}=\ConversionFraction[d]{1/7+3/8}$
$\ConversionFraction[d]{1+1/2}$
$\ConversionFraction{0.1/0.7+30/80}$
\end{codetex}

\begin{codesortie}
\begin{multicols}{2}
\ConversionFraction{111/2145}

\smallskip

\ConversionFraction{111/3}

\smallskip

$\frac{111}{2145}=\ConversionFraction{111/2145}$

\smallskip

$\frac{3}{15}=\ConversionFraction[]{3/15}$

\smallskip

$\tfrac{3}{15}=\ConversionFraction[t]{3/15}$

\smallskip

$\dfrac{3}{15}=\ConversionFraction[d]{3/15}$

\smallskip

$\dfrac{0,42}{0,015}=\ConversionFraction[d]{0.42/0.015}$

\smallskip

$\dfrac{0,41}{0,015}=\ConversionFraction[d]{0.41/0.015}$

\smallskip

$\dfrac{1}{7}+\dfrac{3}{8}=\ConversionFraction[d]{1/7+3/8}$

\smallskip

$\ConversionFraction[d]{1+1/2}$

\smallskip

$\ConversionFraction{0.1/0.7+30/80}$
\end{multicols}

~
\end{codesortie}

\begin{codeinfo}
A priori le package \ctex{xint} permet de s'en sortir pour des calculs \og simples \fg, je ne garantis pas que tout calcul ou toute division donne un résultat \textit{satisfaisant} !
\end{codeinfo}

\pagebreak

\section{Ensembles}\label{ensembles}

\subsection{Idée}

\begin{codeidee}
L'idée est d'obtenir une commande pour simplifier l'écriture d'un ensemble d'éléments, en laissant gérer les espaces.

Les délimiteurs de l'ensemble créé sont toujours \textsf{\{~~\}}.
\end{codeidee}

\begin{codetex}[listing only]
\EcritureEnsemble[clés]{liste}
\end{codetex}

\subsection{Commande et options}

\begin{codecles}
Peu d'options pour ces commandes :

\begin{itemize}
\item le premier argument, optionnel, permet de spécifier les \Cle{Clés} :
\begin{itemize}
	\item clé \Cle{Sep} qui correspond au délimiteur des éléments de l'ensemble ; \hfill{}défaut \Cle{;}
	\item clé \Cle{Option} qui est un code (par exemple \textsf{strut}\dots) inséré avant les éléments ;\hfill{}défaut \Cle{vide}
	\item un booléen \Cle{Mathpunct} qui permet de préciser si on utilise l'espacement mathématique \textsf{mathpunct};\hfill{}défaut \Cle{true}
\end{itemize}
\item le second, mandataire, est la \textsf{liste} des éléments, séparés par \textsf{/}.
\end{itemize}
\end{codecles}

\begin{codetex}[listing only]
$\EcritureEnsemble{a/b/c/d/e}$
$\EcritureEnsemble[Mathpunct=false]{a/b/c/d/e}$
$\EcritureEnsemble[Sep={,}]{a/b/c/d/e}$
$\EcritureEnsemble[Option={\strut}]{a/b/c/d/e}$                      % \strut pour "augmenter" un peu la hauteur des {}
$\EcritureEnsemble{ \frac{1}{1+\frac{1}{3}} / b / c / d / \frac{1}{2} }$
\end{codetex}

\begin{codesortie}
$\EcritureEnsemble{a/b/c/d/e}$

\smallskip

$\EcritureEnsemble[Mathpunct=false]{a/b/c/d/e}$

\smallskip

$\EcritureEnsemble[Sep={,}]{a/b/c/d/e}$

\smallskip

$\EcritureEnsemble[Option={\strut}]{a/b/c/d/e}$

\smallskip

$\EcritureEnsemble{ \displaystyle\frac{1}{1+\frac{1}{3}} / b / c / d / \displaystyle\frac{1}{2} }$
\end{codesortie}

\begin{codeinfo}
Attention cependant au comportement de la commande avec des éléments en mode \textsf{mathématique}, ceux-ci peuvent générer une erreur si \textsf{displaystyle} n'est pas utilisé\ldots
\end{codeinfo}

\newpage

\section{Écriture d'un trinôme, trinôme aléatoire}\label{trinome}

\subsection{Idée}

\begin{codeidee}
L'idée est de proposer une commande pour écrire, sous forme développée réduite, un trinôme en fonction de ses coefficients $a$, $b$ et $c$ (avec $a\neq0$), avec la gestion des coefficients nuls ou égaux à $\pm1$.

\smallskip

En combinant avec le package \ctex{xfp} et fonction de générateur d'entiers aléatoires, on peut de ce fait proposer une commande pour générer aléatoirement des trinômes à coefficients entiers (pour des fiches d'exercices par exemple).

\smallskip

L'affichage des monômes est géré par le package \ctex{siunitx} et le tout est dans un environnement \ctex{ensuremath}.
\end{codeidee}

\begin{codetex}[listing only]
\EcritureTrinome[options]{a}{b}{c}
\end{codetex}

\begin{codetex}[]
\EcritureTrinome{1}{7}{0}\\
\EcritureTrinome{1.5}{7.3}{2.56}\\
\EcritureTrinome{-1}{0}{12}\\
\EcritureTrinome{-1}{-5}{0}
\end{codetex}

\subsection{Clés et options}

\begin{codecles}
Quelques clés et options sont disponibles :

\begin{itemize}
	\item la clé booléenne \Cle{Alea} pour autoriser les coefficients aléatoires (voir plus bas pour la syntaxe) ;\hfill{}défaut \Cle{false}
	\item la clé booléenne \Cle{Anegatif} pour autoriser $a$ à être négatif.\hfill{}défaut \Cle{true}
\end{itemize}
\end{codecles}

\begin{codeinfo}
La clé \Cle{Alea} va modifier la manière de saisir les coefficients, il suffira dans ce cas de  préciser les bornes, sous la forme \ctex{valmin,valmax}, de chacun des coefficients. C'est ensuite le package \ctex{xfp} qui va se charger de générer les coefficients.
\end{codeinfo}

\begin{codetex}[sidebyside]
Avec $a$ entre 1 et 5 (et signe aléatoire) puis $b$ entre $-2$ et 7 puis $c$ entre $-10$ et 20 :

$f(x)=\EcritureTrinome[Alea]{1,5}{-5,5}{-10,10}$\\
$g(x)=\EcritureTrinome[Alea]{1,5}{-5,5}{-10,10}$\\
$h(x)=\EcritureTrinome[Alea]{1,5}{-5,5}{-10,10}$\\

Avec $a$ entre 1 et 10 (forcément positif) puis $b$ entre $-2$ et 2 puis $c$ entre 0 et 4 :

\EcritureTrinome[Alea,Anegatif=false]{1,10}{-2,2}{0,4}\\
\EcritureTrinome[Alea,Anegatif=false]{1,10}{-2,2}{0,4}\\
\EcritureTrinome[Alea,Anegatif=false]{1,10}{-2,2}{0,4}
\end{codetex}

\newpage

\section{Simplification de racines}\label{simplracine}

\subsection{Idée}

\begin{codeidee}
\cmaj{2.1.0} L'idée est de proposer une commande pour simplifier \textit{automatiquement} une racine carrée, sous la forme $\frac{a\sqrt{b}}{c}$ avec $\frac{a}{c}$ irréductible et $b$ le \frquote{plus petit possible}.
\end{codeidee}

\begin{codetex}[listing only]
\SimplificationRacine{expression ou calcul}
\end{codetex}

\begin{codetex}[]
\SimplificationRacine{48}\\
\SimplificationRacine{100/34}\\
\SimplificationRacine{99999}\\
\SimplificationRacine{1500*0.31*(1-0.31)}\\
\end{codetex}

\begin{codeinfo}
C'est -- comme souvent -- le package \ctex{xint} qui s'occupe en interne des calculs, et qui devrait donner des résultats satisfaisants dans la majorité des cas (attention aux \textit{grands nombres}\ldots)

\smallskip

La commande ne fait pas office de \textit{calculatrice}, elle ne permet \textit{que} de simplifier \textit{une} racine carrée (donc transformer si besoin !).
\end{codeinfo}

\subsection{Exemples}

\begin{codetex}[]
%Simplification d'un module de complexe
$\left| 4+6\text{i}\right| = \sqrt{4^2+6^2} = \sqrt{\xinteval{4**2+6**2}}=\SimplificationRacine{4**2+6**2}$

%Simplification n°1
$\frac{1}{\sqrt{6}}=\left(\sqrt{\frac{1}{6}}\right)=\SimplificationRacine{1/6}$

%Simplification n°2
$\frac{42}{\sqrt{5}}=\left(\sqrt{\frac{42^2}{5}}\right)=\SimplificationRacine{(42*42)/5}$

%Écart-type d'une loi binomiale
$\sqrt{\num{150}\times\num{0.35}\times(1-\num{0.35})}=\displaystyle\SimplificationRacine{150*0.35*(1-0.35)}$
\end{codetex}

\newpage

\section{Mesure principale d'un angle}\label{mesureprincipale}

\subsection{Idée}

\begin{codeidee}
\cmaj{2.1.2} L'idée est de proposer (sur une suggestion de Marylyne Vignal) une commande pour déterminer la mesure principale d'un angle en radian.
\end{codeidee}

\begin{codetex}[listing only]
\MesurePrincipale[booléens]{angle}   %dans un mode mathématique
\end{codetex}

\begin{codeinfo}
La commande est à insérer dans un environnement mathématique, via \ctex{\$...\$} ou \ctex{\textbackslash[...\textbackslash]}.

L'angle peut être donné sous forme \textit{explicite} avec la chaîne \ctex{pi}.
\end{codeinfo}

\subsection{Exemples}

\begin{codecles}
Pour cette commande :

\begin{itemize}
	\item le booléen \Cle{d} permet de forcer l'affichage en \ctex{displaystyle} ;\hfill{}défaut \Cle{false}
	\item le booléen \Cle{Crochets} permet d'afficher le \textit{modulo} entre crochets plutôt qu'entre parenthèses ;\hfill{}défaut \Cle{false}
	\item l'argument mandataire est en écriture \textit{en ligne}.
\end{itemize}
\end{codecles}

\begin{codetex}[listing only]
$\MesurePrincipale[d]{54pi/7}$
$\MesurePrincipale[d]{-128pi/15}$
$\MesurePrincipale{3pi/2}$
$\MesurePrincipale[Crochets]{5pi/2}$
$\MesurePrincipale{-13pi}$
$\MesurePrincipale{28pi}$
$\MesurePrincipale[d]{14pi/4}$
$\MesurePrincipale[Crochets]{14pi/7}$
\end{codetex}

\begin{codesortie}
$\MesurePrincipale[d]{54pi/7}$

\medskip

$\MesurePrincipale{-128pi/15}$

\medskip

$\MesurePrincipale{3pi/2}$

\medskip

$\MesurePrincipale[Crochets]{5pi/2}$

\medskip

$\MesurePrincipale{-13pi}$

\medskip

$\MesurePrincipale{28pi}$

\medskip

$\MesurePrincipale[d]{14pi/4}$

\medskip

$\MesurePrincipale[Crochets]{14pi/7}$
\end{codesortie}

\pagebreak

\part{Jeux et récréations}

\section{PixelART via un fichier csv, en \TikZ}\label{pixelart}

\subsection{Introduction}

\begin{codeidee}
L'idée est de \textit{proposer}, dans un environnement \TikZ, une commande permettant de générer des grilles PixelART.

Les données sont \textit{lues} à partir d'un fichier \textsf{csv}, externe au fichier \textsf{tex} ou déclaré en interne grâce à l'environnement \ctex{filecontents}.
\end{codeidee}

\begin{codeinfo}
Avant toute chose, quelques petites infos sur les données au format \textsf{csv}, surtout dans l'optique de sa lecture et de son traitement par \ctex{ProfLycee} :

\begin{itemize}
	\item le fichier de données \textsf{csv} doit être formaté avec le séparateur décimal \og , \fg ;
	\item des cases vides seront codées par \og \texttt{-} \fg.
\end{itemize}

Le fichier \textsf{csv} peut être déclaré directement dans le fichier \textsf{tex}, grâce à l'environnement \ctex{filecontents} (intégré en natif sur les dernières versions de \LaTeX) :

\begin{Verbatim}[tabsize=2,fontsize=\scriptsize]
\begin{filecontents*}{<nomfichier>.csv}
A,B,C,D
A,B,D,C
B,A,C,D
B,A,D,C
\end{filecontents*}
\end{Verbatim}

À la compilation, le fichier \textsf{<nomfichier>.csv} sera créé automatiquement, et l'option \Cle{[overwrite]} permet (logiquement) de propager les modifications au fichier \textsf{csv}.
\end{codeinfo}

\subsection{Package csvsimple et option}

\begin{codeinfo}
Le package \textit{central} est ici \ctex{csvsimple}, qui permet de lire et traiter le fichier \textsf{csv}.

Il est \og disponible \fg{} en version \LaTeXe{} ou en version \LaTeXIII. Par défaut, \ctex{ProfLycee} le charge en version \LaTeXIII{}, mais une \Cle{option} est disponible pour une \textit{rétro-compatibilité} avec la version \LaTeXe.

\smallskip

L'option \Cle{csvii} permet de passer l'appel au package en version \LaTeXe.
\end{codeinfo}

\begin{codetex}[listing only]
\usepackage{ProfLycee}                     %chargement du package version 3
%qui charge :
%\RequirePackage{expl3}
%\RequirePackage[l3]{csvsimple}

\usepackage[csvii]{ProfLycee}              %chargement du package version 2
%qui charge :
%\RequirePackage[legacy]{csvsimple}
\end{codetex}

\subsection{Exemple simple, clés et options}

\begin{codetex}[listing only]
%déclaration du fichier csv
\begin{filecontents*}[overwrite]{basique.csv}
A,B,C,D
A,B,D,C
B,A,D,C
C,A,B,D
\end{filecontents*}

\begin{tikzpicture}%avec lettres
	\PixelArtTikz[Codes=ABCD,Style=\large\sffamily]{basique.csv}
\end{tikzpicture}
\begin{tikzpicture}%avec chiffres
	\PixelArtTikz[Codes=ABCD,Symboles={45,22,1,7},Symb,Style=\large\sffamily]{basique.csv}
\end{tikzpicture}
\begin{tikzpicture}%avec correction
	\PixelArtTikz[codes=ABCD,Couleurs={Black,Green,Yellow,Red},Correction]{basique.csv}
\end{tikzpicture}
\begin{tikzpicture}%avec correction sans bordure
	\PixelArtTikz[Codes=ABCD,Couleurs={Black,Green,Yellow,Red},Correction,BordCases=false]{basique.csv}
\end{tikzpicture}
\end{codetex}

\begin{codesortie}
\begin{filecontents*}[overwrite]{basique.csv}
A,B,C,D
A,B,D,C
B,A,D,C
C,A,B,D
\end{filecontents*}

\begin{center}
	\begin{tblr}{colspec={*{4}{Q[1.25cm,c,m]}},hlines,vlines,rows={1.15em}}
		\SetCell[c=4]{c} Notice & & & \\
		A & B & C & D \\
		45 & 22 & 1 & 7 \\
		Noir & Vert & Jaune & Rouge \\
	\end{tblr}
\end{center}

\hfill\begin{tikzpicture}[scale=0.9]
	%avec lettres
	\PixelArtTikz[Codes=ABCD,Style=\large\sffamily]{basique.csv}
\end{tikzpicture}
\begin{tikzpicture}[scale=0.9]
	%avec chiffres
	\PixelArtTikz[Codes=ABCD,Symboles={45,22,1,7},Symb,Style=\large\sffamily]{basique.csv}
\end{tikzpicture}
\begin{tikzpicture}[scale=0.9]
	%avec correction
	\PixelArtTikz[Codes=ABCD,Couleurs={Black,Green,Yellow,Red},Correction]{basique.csv}
\end{tikzpicture}
\begin{tikzpicture}[scale=0.9]
	%avec correction
	\PixelArtTikz[Codes=ABCD,Couleurs={Black,Green,Yellow,Red},Correction,BordCases=false]{basique.csv}
\end{tikzpicture}
\hfill~
\end{codesortie}

\begin{codeinfo}
La commande \ctex{PixelArtTikz} nécessite de connaître :

\begin{itemize}
	\item le fichier \textsf{csv} à traiter ;
	\item la liste (en fait sous forme de chaîne) des codes utilisés dans le fichier \textsf{csv} (comme \ctex{234679} ou \ctex{ABCDJK}\ldots);
	\item la liste des symboles (éventuellement !) à afficher dans les cases s'il y a ambiguïté, comme \ctex{25,44,12} ou \ctex{AA,AB,AC};
	\item la liste des couleurs (si la correction est demandée), dans le même ordre que la liste des caractères.
\end{itemize}
\end{codeinfo}

\begin{codetex}[listing only]
%environnement tikz
\PixelArtTikz[clés]{<fichier>.csv}
\end{codetex}

\begin{codecles}
Quelques \Cle{Clés} sont nécessaires au bon fonctionnement de la commande :

\begin{itemize}
	\item la clé \Cle{Codes} contient la \textsf{chaîne} des codes \textit{simples} du  fichier \textsf{csv} ;
	\item la clé \Cle{Couleurs} qui contient la \textsf{liste} des couleurs associées ;
	\item la clé \Cle{Symboles} qui contient la \textsf{liste éventuelles} des caractères alternatifs à afficher dans les cases ;
	\item la clé booléenne \Cle{Correction} qui permet de colorier le PixelART ;\hfill{}défaut \Cle{false}
	\item la clé booléenne \Cle{Symb} qui permet d'afficher les caractères \textit{alternatifs} ;\hfill{}défaut \Cle{false}
	\item la clé booléenne \Cle{BordCases} qui permet d'afficher les bords des cases de la correction ;\hfill{}défaut \Cle{true}
	\item la clé \Cle{Style} qui permet de spécifier le style des caractères. \hfill{}défaut \Cle{scriptsize}
\end{itemize}
\end{codecles}

\begin{codetex}[listing only]
%codes simples et sans ambiguïté
%une case vide sera codée par -

\begin{filecontents*}[overwrite]{perroquet.csv}
-,-,-,-,-,-,4,4,4,4,-,-,-,-,-,-
-,-,-,-,4,4,1,1,1,1,4,4,-,-,-,-
-,-,-,4,1,1,1,1,1,1,1,1,4,-,-,-
-,-,4,1,1,1,1,1,1,1,1,1,1,4,-,-
-,-,4,1,1,1,1,1,1,1,1,1,1,4,-,-
-,4,1,9,9,1,1,1,1,1,1,9,9,1,4,-
-,4,9,9,9,9,4,4,4,4,9,9,9,9,4,-
-,4,9,4,9,9,4,4,4,4,9,4,9,9,4,-
-,4,1,9,9,9,4,4,4,4,9,9,9,1,4,-
-,-,4,1,1,9,4,4,4,4,9,1,1,4,-,-
-,-,4,1,1,1,4,4,4,4,1,1,1,4,-,-
-,-,-,4,1,1,1,4,4,1,1,1,4,-,-,-
-,-,4,3,1,1,1,1,1,1,1,1,3,4,-,-
-,4,6,3,1,1,1,1,1,1,1,1,3,6,4,-
-,4,6,6,1,1,1,1,1,1,1,1,6,6,4,-
-,4,6,6,1,1,1,1,1,1,1,1,6,6,4,-
-,4,6,4,1,1,1,4,4,1,1,1,4,6,4,-
2,2,4,2,4,4,4,2,2,4,4,4,2,4,2,2
2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2
2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2
-,-,-,-,-,4,1,1,1,1,4,-,-,-,-,-
-,-,-,-,-,-,4,1,1,4,-,-,-,-,-,-
-,-,-,-,-,-,-,4,4,-,-,-,-,-,-,-
\end{filecontents*}

\begin{tikzpicture}[x=0.35cm,y=0.35cm]
	\PixelArtTikz[Codes=123469,Style=\ttfamily]{perroquet.csv}
\end{tikzpicture}

\begin{tikzpicture}[x=0.35cm,y=0.35cm]
	\PixelArtTikz[Codes=123469,Couleurs={Red,Brown,Yellow,Black,Blue,White},Correction]{perroquet.csv}
\end{tikzpicture}
\end{codetex}

\subsection{Exemples complémentaires}

\begin{codeinfo}
Les symboles affichés dans les cases sont situés aux nœuds de coordonnées $(c\,;\,-l)$ où $l$ et $c$ sont les numéros de ligne et de colonne correspondants à la position de la donnée dans le fichier \textsf{csv}.
\end{codeinfo}

\begin{codesortie}
\begin{filecontents*}[overwrite]{perroquet.csv}
-,-,-,-,-,-,4,4,4,4,-,-,-,-,-,-
-,-,-,-,4,4,1,1,1,1,4,4,-,-,-,-
-,-,-,4,1,1,1,1,1,1,1,1,4,-,-,-
-,-,4,1,1,1,1,1,1,1,1,1,1,4,-,-
-,-,4,1,1,1,1,1,1,1,1,1,1,4,-,-
-,4,1,9,9,1,1,1,1,1,1,9,9,1,4,-
-,4,9,9,9,9,4,4,4,4,9,9,9,9,4,-
-,4,9,4,9,9,4,4,4,4,9,4,9,9,4,-
-,4,1,9,9,9,4,4,4,4,9,9,9,1,4,-
-,-,4,1,1,9,4,4,4,4,9,1,1,4,-,-
-,-,4,1,1,1,4,4,4,4,1,1,1,4,-,-
-,-,-,4,1,1,1,4,4,1,1,1,4,-,-,-
-,-,4,3,1,1,1,1,1,1,1,1,3,4,-,-
-,4,6,3,1,1,1,1,1,1,1,1,3,6,4,-
-,4,6,6,1,1,1,1,1,1,1,1,6,6,4,-
-,4,6,6,1,1,1,1,1,1,1,1,6,6,4,-
-,4,6,4,1,1,1,4,4,1,1,1,4,6,4,-
2,2,4,2,4,4,4,2,2,4,4,4,2,4,2,2
2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2
2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2
-,-,-,-,-,4,1,1,1,1,4,-,-,-,-,-
-,-,-,-,-,-,4,1,1,4,-,-,-,-,-,-
-,-,-,-,-,-,-,4,4,-,-,-,-,-,-,-
\end{filecontents*}

\begin{center}
	\begin{tblr}{colspec={*{6}{Q[1.25cm,c,m]}},hlines,vlines,rows={1.15em}}
		\SetCell[c=6]{c} Notice & & & & &  \\
		1 & 2 & 3 & 5 & 6 & 9 \\
		Rouge & Marron & Jaune & Noir & Bleu & Blanc \\
	\end{tblr}
%	\renewcommand\arraystretch{1.25}
%	\begin{tabular}{|c|c|c|c|c|c|}
%		\hline
%		\multicolumn{6}{|c|}{Notice} \\ \hline
%		1 & 2 & 3 & 5 & 6 & 9 \\ \hline
%		Rouge & Marron & Jaune & Noir & Bleu & Blanc \\ \hline
%	\end{tabular}
\end{center}

\begin{center}
	\begin{tikzpicture}[x=0.35cm,y=0.35cm]
		\PixelArtTikz[Codes=123469,Style=\ttfamily]{perroquet.csv}
	\end{tikzpicture}
	\begin{tikzpicture}[x=0.35cm,y=0.35cm]
		\PixelArtTikz[Codes=123469,Couleurs={Red,Brown,Yellow,Black,Blue,White},Correction]{perroquet.csv}
	\end{tikzpicture}
\end{center}

\begin{center}
	\begin{tikzpicture}[x=0.35cm,y=0.35cm]
		\draw[very thin,gray,xstep=1,ystep=1] (0,0) grid (17,-24) ;
		\foreach \x in {0,1,...,17} \draw[very thin,gray] (\x,-3pt)--(\x,3pt) node[above,font=\scriptsize\sffamily] {\x} ;
		\foreach \y in {0,-1,...,-24} \draw[very thin,gray] (3pt,\y)--(-3pt,\y) node[left,font=\scriptsize\sffamily] {\y} ;
		\PixelArtTikz[Codes=123469,Couleurs={Red,Brown,Yellow,Black,Blue,White},Correction]{perroquet.csv}
		\filldraw[Blue] (14,-1) circle[radius=1] ;
		\filldraw[Yellow] (14,-1) circle[radius=0.8] ;
		\draw[ForestGreen,very thick,<-,>=latex] (15,-1) to[bend left=30] (18,-2) node[right,font=\scriptsize\sffamily] {rajouté en \TikZ} ;
	\end{tikzpicture}
\end{center}
\end{codesortie}

\begin{codetex}[listing only]
%code tikz et pixelart
\filldraw[Blue] (14,-1) circle[radius=1] ;
\filldraw[Yellow] (14,-1) circle[radius=0.8] ;
\draw[ForestGreen,very thick,<-,>=latex] (15,-1) to[bend left=30] (18,-2)
	node[right,font=\scriptsize\sffamily] {rajouté en \TikZ} ;
\end{codetex}

\pagebreak

\begin{codetex}[listing only]
%codes avec ambiguïté

\begin{filecontents*}[overwrite]{cap.csv}
-,-,-,-,-,-,-,-,D,-,D,-,D,-,-,-,-,-,-,-,-,-
-,D,D,-,-,-,-,D,D,D,D,D,D,-,-,D,D,D,D,-,-,-
D,-,-,D,-,D,D,F,F,F,F,F,F,D,D,-,-,-,-,D,-,-
-,D,-,-,D,F,F,F,-,-,F,F,F,F,F,D,-,D,D,-,-,-
-,-,D,D,F,F,F,-,F,F,-,F,F,F,F,F,D,D,-,-,-,-
-,-,-,D,F,F,F,F,F,F,F,F,F,F,F,F,D,-,-,-,-,-
-,-,-,D,F,J,J,J,J,J,J,J,F,F,F,F,D,-,-,-,-,-
-,-,-,D,J,-,-,-,J,-,-,-,J,J,F,F,D,-,-,-,-,-
-,-,-,D,J,-,D,-,J,-,D,-,J,J,B,B,D,-,-,-,-,-
-,-,-,D,J,-,-,-,J,-,-,-,J,J,B,B,D,-,-,-,-,-
-,-,-,D,C,J,J,J,J,J,J,J,J,C,C,C,D,-,-,-,-,-
-,-,-,D,C,C,C,C,C,C,C,C,C,C,C,D,D,D,-,-,-,-
-,-,-,D,C,C,C,D,D,D,D,D,D,C,D,A,A,A,D,-,-,-
-,-,-,D,F,C,C,C,C,C,C,C,C,D,A,-,-,-,A,D,-,-
-,-,-,D,F,C,F,C,C,C,C,F,D,A,-,A,A,A,-,A,D,-
-,-,D,C,F,F,F,F,C,C,F,D,A,-,A,F,F,F,A,-,A,D
-,-,D,C,F,F,F,F,F,F,F,D,A,-,A,F,-,F,A,-,A,D
-,-,D,A,D,-,A,-,A,-,A,D,A,-,A,F,F,F,A,-,A,D
-,-,-,D,D,-,A,-,A,-,A,-,D,A,-,A,A,A,-,A,D,-
-,-,-,-,-,D,D,F,D,D,D,D,F,D,A,-,-,-,A,D,-,-
-,-,-,-,-,-,D,A,D,-,-,D,-,-,D,A,A,A,D,-,-,-
-,-,-,-,-,-,D,D,D,-,-,D,D,D,D,D,D,D,-,-,-,-
\end{filecontents*}

\begin{tikzpicture}[x=0.35cm,y=0.35cm]
	\PixelArtTikz[Codes=ABCDFJ,Symboles={1,2,3,4,6,10},Symb,Style=\tiny\sffamily]{cap.csv}
\end{tikzpicture}

\begin{tikzpicture}[x=0.35cm,y=0.35cm]
	\PixelArtTikz[Codes=ABCDFJ,Couleurs={Red,Brown,Yellow,Black,Blue,Gray},Correction]{cap.csv}
\end{tikzpicture}
\end{codetex}

\begin{codesortie}
\begin{filecontents*}[overwrite]{cap.csv}
-,-,-,-,-,-,-,-,D,-,D,-,D,-,-,-,-,-,-,-,-,-
-,D,D,-,-,-,-,D,D,D,D,D,D,-,-,D,D,D,D,-,-,-
D,-,-,D,-,D,D,F,F,F,F,F,F,D,D,-,-,-,-,D,-,-
-,D,-,-,D,F,F,F,-,-,F,F,F,F,F,D,-,D,D,-,-,-
-,-,D,D,F,F,F,-,F,F,-,F,F,F,F,F,D,D,-,-,-,-
-,-,-,D,F,F,F,F,F,F,F,F,F,F,F,F,D,-,-,-,-,-
-,-,-,D,F,J,J,J,J,J,J,J,F,F,F,F,D,-,-,-,-,-
-,-,-,D,J,-,-,-,J,-,-,-,J,J,F,F,D,-,-,-,-,-
-,-,-,D,J,-,D,-,J,-,D,-,J,J,B,B,D,-,-,-,-,-
-,-,-,D,J,-,-,-,J,-,-,-,J,J,B,B,D,-,-,-,-,-
-,-,-,D,C,J,J,J,J,J,J,J,J,C,C,C,D,-,-,-,-,-
-,-,-,D,C,C,C,C,C,C,C,C,C,C,C,D,D,D,-,-,-,-
-,-,-,D,C,C,C,D,D,D,D,D,D,C,D,A,A,A,D,-,-,-
-,-,-,D,F,C,C,C,C,C,C,C,C,D,A,-,-,-,A,D,-,-
-,-,-,D,F,C,F,C,C,C,C,F,D,A,-,A,A,A,-,A,D,-
-,-,D,C,F,F,F,F,C,C,F,D,A,-,A,F,F,F,A,-,A,D
-,-,D,C,F,F,F,F,F,F,F,D,A,-,A,F,-,F,A,-,A,D
-,-,D,A,D,-,A,-,A,-,A,D,A,-,A,F,F,F,A,-,A,D
-,-,-,D,D,-,A,-,A,-,A,-,D,A,-,A,A,A,-,A,D,-
-,-,-,-,-,D,D,F,D,D,D,D,F,D,A,-,-,-,A,D,-,-
-,-,-,-,-,-,D,A,D,-,-,D,-,-,D,A,A,A,D,-,-,-
-,-,-,-,-,-,D,D,D,-,-,D,D,D,D,D,D,D,-,-,-,-
\end{filecontents*}

\begin{center}
	\begin{tikzpicture}[x=0.35cm,y=0.35cm]
		\PixelArtTikz[Codes=ABCDFJ,Symboles={1,2,3,4,6,10},Symb,Style=\tiny\sffamily]{cap.csv}
	\end{tikzpicture}
	~~
	\begin{tikzpicture}[x=0.35cm,y=0.35cm]
		\PixelArtTikz[Codes=ABCDFJ,Couleurs={Red,Brown,Yellow,Black,Blue,Gray},Correction]{cap.csv}
	\end{tikzpicture}
\end{center}
\end{codesortie}

\newpage

\section{SudoMaths, en \TikZ}\label{sudomaths}

\subsection{Introduction}

\begin{codeidee}
L'idée est de \textit{proposer} un environnement \TikZ, une commande permettant de tracer des grilles de SudoMaths.

L'environnement créé, lié à \TikZ, trace la grille de SudoMaths (avec les blocs démarqués), et peut la remplir avec une liste d'éléments.
\end{codeidee}

\begin{codetex}[listing only]
%grille classique non remplie, avec légendes H et V
%les {} non nécessaires pour préciser que les cases seront "vides"
\SudoMaths{}
\end{codetex}

\begin{codesortie}
\SudoMaths{}
\end{codesortie}

\begin{codeinfo}
La commande \ctex{SudoMaths} crée donc la grille (remplie ou non), dans un environnement \TikZ, c'est \textit{c'est tout} ! 

\smallskip

Si on veut exploiter le tracé de la grille, on peut utiliser l'\textit{environnement} \ctex{EnvSudoMaths} dans lequel on peut rajouter toute commande en \TikZ{} !
\end{codeinfo}

\begin{codetex}[listing only]
%grille "toute seule"
\SudoMaths[options]{liste}

%grille avec ajout de code
\begin{EnvSudoMaths}[options]{grille}
	commandes tikz
\end{EnvSudoMaths}
\end{codetex}

\pagebreak

\subsection{Clés et options}

\begin{codecles}
Quelques \Cle{clés} sont disponibles pour cette commande :

\begin{itemize}
	\item la clé \Cle{Epaisseurg} pour gérer l'épaisseur des traits épais ; \hfill~défaut \Cle{1.5pt}
	\item la clé \Cle{Epaisseur} pour gérer l'épaisseur des traits fins ; \hfill~défaut \Cle{0.5pt}
	\item la clé \Cle{Unite} qui est l'unité graphique de la figure ; \hfill~défaut \Cle{1cm}
	\item la clé \Cle{CouleurCase} pour la couleur (éventuelles) des cases ; \hfill~défaut \Cle{LightBlue!50}
	\item la clé \Cle{CouleurTexte} pour gérer la couleur du label des cases ; \hfill~défaut \Cle{blue}
	\item la clé \Cle{NbCol} qui est le nombre de colonnes ; \hfill~défaut \Cle{9}
	\item la clé \Cle{NbSubCol} qui est le nombre de sous-colonnes ; \hfill~défaut \Cle{3}
	\item la clé \Cle{NbLig} qui est le nombre de lignes ; \hfill~défaut \Cle{9}
	\item la clé \Cle{NbSubLig} qui est le nombre de sous-colonnes ; \hfill~défaut \Cle{3}
	\item la clé \Cle{Police} qui formatte le label des cases ; \hfill~défaut \Cle{\textbackslash{}normalfont\textbackslash{}normalsize}
	\item le booléen \Cle{Legendes} qui affiche ou non les légendes (H et V) des cases ; \hfill~défaut \Cle{true}
	\item la clé \Cle{PoliceLeg} qui formatte le label des légendes ; \hfill~défaut \Cle{\textbackslash{}normalfont\textbackslash{}normalsize}
	\item la clé \Cle{ListeLegV} qui est la liste de la légende verticale ; \hfill~défaut \Cle{ABCD...WXYZ}
	\item la clé \Cle{ListeLegH} qui est la liste de la légende horizontale ; \hfill~défaut \Cle{abcd...wxyz}
	\item la clé \Cle{DecalLegende} qui est le décalage de la légende par rapport à la grille. \hfill~défaut \Cle{0.45}
\end{itemize}
\end{codecles}

\begin{codeinfo}
La liste éventuelle des éléments à rentrer dans le tableau est traitée par le package \ctex{listofitems}, et se présente sous la forme suivante : \ctex{ / / / ... / / § / / / ... / / § ... § / / / ... / / }

\smallskip

Il peut donc être intéressant de \textit{déclarer} la liste au préalable pour simplifier la saisie de la commande !
\end{codeinfo}

\begin{codeinfo}
La \Cle{CouleurCase} est gérée -- en interne -- par le caractère \ctex{*} qui permet de préciser qu'on veut que la case soit coloriée.
\end{codeinfo}

\begin{codetex}[listing only]
%grille 6x6 avec blocs 2x3, avec coloration de cases (présentée sous forme de "cases")
\def\grilleSuMa{%
	(a)* / (b)* /      /      / (c)* / (d)* §%
	(e)* /      /      / (f)* / (g)* / (h)* §%
	     /      / (i)* /      /      / (j)* §%
	     /      / (k)* /      / (l)* / (m)* §%
	(n)* /      / (o)* /      /      / (p)* §%
	     /      /      / (q)* /      /      §%
}

\PLsudomaths[unite=0.75cm,nbcol=6,nbsubcol=2,nblig=6,nbsublig=3,police=\small\bfseries\ttfamily,%
	couleurtexte=red,couleurcase=yellow!50,legendes=false]{\grilleSuMa}
\end{codetex}

\begin{codesortie}
\def\grilleSuMa{%
	(a)* / (b)* /      /      / (c)* / (d)* §%
	(e)* /      /      / (f)* / (g)* / (h)* §%
	/      / (i)* /      /      / (j)* §%
	/      / (k)* /      / (l)* / (m)* §%
	(n)* /      / (o)* /      /      / (p)* §%
	/      /      / (q)* /      /      §%
}

\SudoMaths[Unite=0.75cm,NbCol=6,NbSubCol=2,NbLig=6,NbSubLig=3,Police=\small\bfseries\ttfamily,CouleurTexte=red,CouleurCase=yellow!50,Legendes=false]{\grilleSuMa}
\end{codesortie}

\pagebreak

\begin{codeinfo}
La grille, créée en \TikZ, est portée par le rectangle de \og coins \fg{} $(0\,;\,0)$ et $(\text{nbcol}\,;\,-\text{nblig})$, de sorte que les labels des cases sont situés au nœuds de coordonnées $(x,5\,;\,-y,5)$.
\end{codeinfo}

\begin{codetex}[listing only]
%grille classique avec coloration de cases et commande tikz
%graduations rajoutées pour la lecture des coordonnées
\def\grilleSuMaB{%
	*/////4///§%
	/*///3////§%
	//*//////§%
	///*/////§%
	////*////§%
	/////*///§%
	//5*/////*/§%
	/////B///*§%
	*///9////Q/§%
}

\begin{EnvSudoMaths}[%
		Unite=0.66cm,Police=\footnotesize\bfseries\ttfamily,CouleurCase=ForestGreen!50,%
		ListeLegV=QSDFGHJKL,ListeLegH=poiuytrez]{\grilleSuMaB}
	\draw[red,very thick,<-,>=latex] (7.5,-4.5) to[bend right] ++ (4,-1) node[right] {code rajouté...} ;
\end{EnvSudoMaths}
\end{codetex}

\begin{codesortie}
\def\grilleSuMaB{%
	*/////4///§%
	/*///3////§%
	//*//////§%
	///*/////§%
	////*////§%
	/////*///§%
	//5*/////*/§%
	/////B///*§%
	*///9////Q/§%
}

\begin{EnvSudoMaths}[%
		Unite=0.66cm,Police=\footnotesize\bfseries\ttfamily,CouleurCase=ForestGreen!50,%
		ListeLegV=QSDFGHJKL,ListeLegH=poiuytrez]{\grilleSuMaB}
	\draw[red,very thick,<-,>=latex] (7.5,-4.5) to[bend right] ++ (4,-1) node[right] {code rajouté pour montrer la case \textsf{Ge}} ;
	\foreach \x in {0,1,...,9} \draw[lightgray] (\x,-9) node[below,font=\scriptsize\ttfamily] {\x} ;
	\foreach \y in {-1,-2,...,-9} \draw[lightgray] (9,\y) node[right,font=\scriptsize\ttfamily] {\y} ;
	\draw[lightgray] (9,0) node[right,font=\scriptsize\ttfamily] {~0} ;
\end{EnvSudoMaths}
\end{codesortie}

\newpage

\part{Historique}

{\small \bverb|v 2.1.6|~:~~~~Correction d'un bug lié au chargement de \textsf{hvlogos}, remplacé par \textsf{hologo}

{\small \bverb|v 2.1.5|~:~~~~Combinatoire avec arrangements et combinaisons (page \pageref{combinatoire})

{\small \bverb|v 2.1.4|~:~~~~Résolution approchée d'équations $f(x)=k$ (page \pageref{resolapprox})

{\small \bverb|v 2.1.3|~:~~~~Améliorations dans les présentations \textsf{Piton} (page \pageref{pythonpiton})
	
{\small \bverb|v 2.1.2|~:~~~~Ajout d'une commande pour la mesure principale d'un angle (page \pageref{mesureprincipale})

{\small \bverb|v 2.1.1|~:~~~~Ajout d'une section pour des repères en \TikZ{} (page \pageref{reperagetikz})

{\small \bverb|v 2.1.0|~:~~~~Calcul du seuil, en interne désormais (page \pageref{calcrecurr})

{\small \bverb|       |~:~~~~Commande pour simplifier une racine carrée (page \pageref{simplracine})

{\small \bverb|       |~:~~~~Option \textsf{[pythontex]} pour charger le nécessaire pour \textsf{pythontex}
	
{\small \bverb|v 2.0.9|~:~~~~Nombres aléatoires, tirages aléatoires d'entiers (page \pageref{entiersaleatoires})

{\small \bverb|v 2.0.8|~:~~~~Ajout d'un environnement pour présenter du code \LaTeX{} (page \pageref{prescode})

{\small \bverb|v 2.0.7|~:~~~~Ajout d'options pour stretch et fonte env python(s) (pas tous...)

{\small \bverb|v 2.0.6|~:~~~~Changement de taille de la police des codes Python (page \pageref{pythonsimple})

{\small \bverb|v 2.0.5|~:~~~~Correction d'un bug avec les calculs de suites récurrentes (page \pageref{calcrecurr})

{\small \bverb|v 2.0.4|~:~~~~Ajout d'une commande pour une présentation de solution par TVI (page \pageref{solutiontvi})

{\small \bverb|v 2.0.3|~:~~~~Commandes pour des suites récurrentes \textit{simples} (page \pageref{calcrecurr})

{\small \bverb|v 2.0.2|~:~~~~Option \textsf{left-margin=auto} pour le package \textsf{piton} (page \pageref{pythonpiton})

{\small \bverb|v 2.0.1|~:~~~~Chargement du package \textsf{piton} uniquement si compilation en \LuaLaTeX{} (page \pageref{pythonpiton})

{\small \bverb|v 2.0.0|~:~~~~Refonte du code source avec modification des commandes, et de la documentation}

\hrulefill

{\small \bverb|v 1.3.7|~:~~~~Commandes pour du code python via piton, en compilation \LuaLaTeX{} (page \pageref{pythonpiton})

{\small \bverb|       |~:~~~~Corrections et modifications mineures de la documentation

{\small \bverb|v 1.3.6|~:~~~~Présentation de l'algorithme d'Euclide pour le PGCD (page \pageref{prespgcd})

{\small \bverb|       |~:~~~~Affichage d'un trinôme par coefficients, aléatoires ou non (page \pageref{trinome})

{\small \bverb|v 1.3.5|~:~~~~Correction d'un bug avec la loi géométrique (page \pageref{calcprobas})
	
{\small \bverb|v 1.3.4|~:~~~~Ajout de petits schémas, en \TikZ{}, de lois normales et exponentielles (page \pageref{schemasprobas})

{\small \bverb|       |~:~~~~Calculs de probas avec les lois géométriques et hypergéométriques (page \pageref{calcprobas})
	
{\small \bverb|v 1.3.3|~:~~~~Ajout d'un environnement pour des arbres de probas classiques, en \TikZ{} (page \pageref{arbresprobas})
	
{\small \bverb|v 1.3.2|~:~~~~Correction d'un bug sur les conversions bintohex avec lualatex (page \pageref{conversions})

{\small \bverb|v 1.3.1|~:~~~~Ajout d'une option pour ne pas afficher les bordures des corrections de pixelart (page \pageref{pixelart})

{\small \bverb|v 1.3.0|~:~~~~Commande pour présenter une conversion depuis la base 10 (page \pageref{convrestes})

{\small \bverb|v 1.2.9|~:~~~~Correction des commandes avec \textsf{simplekv}

{\small \bverb|v 1.2.7|~:~~~~Ajout de commandes pour des calculs de probabilités (page \pageref{calcprobas})

{\small \bverb|v 1.2.6|~:~~~~Ajout d'un environnement pour des SudoMaths (page \pageref{sudomaths})

{\small \bverb|v 1.2.5|~:~~~~Ajout de commandes pour des boîtes à moustaches (page \pageref{boiteamoustaches})

{\small \bverb|v 1.2.4|~:~~~~Correction de quelques bugs mineurs, et mise à jour de la doc

{\small \bverb|v 1.2.3|~:~~~~Commandes pour du code python "simple", sans compilation particulière (page \pageref{pythonsimple})

{\small \bverb|v 1.2.2|~:~~~~Commandes pour travailler sur des stats à 2 variables (page \pageref{statsdeuxvars})

{\small \bverb|v 1.2.1|~:~~~~Amélioration de la gestion du csv pour Pixelart

{\small \bverb|v 1.1.9|~:~~~~Pixelart en \TikZ{} (page \pageref{pixelart})

{\small \bverb|v 1.1.8|~:~~~~Style "Mainlevée" basique pour \TikZ (page \pageref{mainlevee})

{\small \bverb|v 1.1.7|~:~~~~Conversions bin/hex/dec (basées sur \textsf{xintbinhex}) avec quelques détails (page \pageref{conversions})

{\small \bverb|v 1.1.6|~:~~~~Ajout d'une commande pour déterminer les paramètres d'une régression linéaire par moindres carrés (page \pageref{reglin})

{\small \bverb|v 1.1.5|~:~~~~Ajout de deux commandes pour, en \TikZ, créer des petits schémas \og de signe \fg{} (page \pageref{aidesigne})

{\small \bverb|v 1.1.4|~:~~~~Ajout d'une commande pour, en \TikZ, créer facilement un cercle trigo avec \textit{options} (page \pageref{cercletrigo})

{\small \bverb|v 1.1.3|~:~~~~Ajout des commandes pour fractions, ensembles et récurrence (pages \pageref{convfrac}, \pageref{ensembles} et \pageref{recurr})

{\small \bverb|v 1.1.1|~:~~~~Modification mineure de l'environnement calcul formel, avec prise de charge de la taille du texte

{\small \bverb|v 1.1.0|~:~~~~Ajout d'une commande pour créer des tétraèdres (avec nœuds) en \TikZ{} (page \pageref{tetra})

{\small \bverb|v 1.0.9|~:~~~~Ajout d'une commande pour créer des pavés droits (avec nœuds) en \TikZ{} (page \pageref{pave})

{\small \bverb|v 1.0.8|~:~~~~Ajout d'une commande pour créer des cartouches de lien "comme capytale" (page \pageref{capytale})

{\small \bverb|v 1.0.7|~:~~~~Ajout d'une option \textsf{build} pour placer certains fichiers auxiliaires dans un répertoire externe

{\small \bverb|v 1.0.6|~:~~~~Ajout d'une option \textsf{nominted} pour ne pas charger (pas besoin de compiler avec \textsf{shell-escape})

{\small \bverb|v 1.0.5|~:~~~~Ajout d'un environnement pour Python (\textsf{minted}) (page \pageref{pytminted})

{\small \bverb|v 1.0.4|~:~~~~Ajout des environnements pour Terminal (win, osx, unix) (page \pageref{terms})

{\small \bverb|v 1.0.3|~:~~~~Ajout des environnements pour PseudoCode (page \pageref{pseudocode})

{\small \bverb|v 1.0.2|~:~~~~Ajout des environnements pour Python (\textsf{pythontex}) (page \pageref{pythontex})

{\small \bverb|v 1.0  |~:~~~~Version initiale}

\end{document}