summaryrefslogtreecommitdiff
path: root/Master/texmf-dist/doc/generic
diff options
context:
space:
mode:
authorKarl Berry <karl@freefriends.org>2024-11-17 21:20:12 +0000
committerKarl Berry <karl@freefriends.org>2024-11-17 21:20:12 +0000
commit5b34dbf3b3a1ac5246f292bb4d6be2d9a8f5da11 (patch)
treed2a8489a167da35a5dc31e6ddef057ebc4980d40 /Master/texmf-dist/doc/generic
parent7575a0c6b103b16320d4eda152a2ae641fa9a497 (diff)
tuple (17nov24)
git-svn-id: svn://tug.org/texlive/trunk@72878 c570f23f-e606-0410-a88d-b1316a301751
Diffstat (limited to 'Master/texmf-dist/doc/generic')
-rw-r--r--Master/texmf-dist/doc/generic/tuple/README43
-rw-r--r--Master/texmf-dist/doc/generic/tuple/tuple-doc-en.pdfbin0 -> 147030 bytes
-rw-r--r--Master/texmf-dist/doc/generic/tuple/tuple-doc-en.tex541
-rw-r--r--Master/texmf-dist/doc/generic/tuple/tuple-doc-fr.pdfbin0 -> 148764 bytes
-rw-r--r--Master/texmf-dist/doc/generic/tuple/tuple-doc-fr.tex541
5 files changed, 1125 insertions, 0 deletions
diff --git a/Master/texmf-dist/doc/generic/tuple/README b/Master/texmf-dist/doc/generic/tuple/README
new file mode 100644
index 00000000000..d445c863635
--- /dev/null
+++ b/Master/texmf-dist/doc/generic/tuple/README
@@ -0,0 +1,43 @@
+___________________________________
+
+ tuple
+
+ v0.1
+
+ 2024/11/16
+___________________________________
+
+Maintainer: Christian Tellechea
+E-mail : unbonpetit@netc.fr
+ Comments, bug reports and suggestions are welcome.
+Licence : Released under the LaTeX Project Public License v1.3c or
+ later, see http://www.latex-project.org/lppl.txt
+
+-----------------------------------------------------------------------
+
+This package provides expandable operations for tuples of numbers:
+
+ * len, sum, min, max, mean, med, quantile, standard deviation,
+ get item, position of item
+ * sort, add or set(*) items, filter, operations, composition(*),
+ split(*), formatting and display
+
+All with a concise syntax that's easy and intuitive to use :
+ "object.method1.method2..."
+
+(*): no expandable method
+
+-----------------------------------------------------------------------
+
+Cette extension met à disposition des opérations développables pour les
+tuples de nombres :
+
+ - len, sum, min, max, mean, med, quantile, écart type, get item,
+ position d'un élément
+ - tri, ajout ou modification(*) d'éléments, filtre, opérations,
+ composition(*), coupure(*), formattage et affichage
+
+Le tout avec une syntaxe concise et d'un usage facile et intuitif :
+ " object.methode1.methode2... "
+
+(*) : méthode non développable
diff --git a/Master/texmf-dist/doc/generic/tuple/tuple-doc-en.pdf b/Master/texmf-dist/doc/generic/tuple/tuple-doc-en.pdf
new file mode 100644
index 00000000000..9b7d15cb011
--- /dev/null
+++ b/Master/texmf-dist/doc/generic/tuple/tuple-doc-en.pdf
Binary files differ
diff --git a/Master/texmf-dist/doc/generic/tuple/tuple-doc-en.tex b/Master/texmf-dist/doc/generic/tuple/tuple-doc-en.tex
new file mode 100644
index 00000000000..e3fb9c76125
--- /dev/null
+++ b/Master/texmf-dist/doc/generic/tuple/tuple-doc-en.tex
@@ -0,0 +1,541 @@
+% !TeX TS-program = lualatex
+\documentclass[english,a4paper]{article}
+\usepackage[no-math]{fontspec}
+\usepackage[libertine]{newtxmath}
+\usepackage{libertineRoman}
+\DeclareSymbolFont{operators}{\encodingdefault}{\familydefault}{m}{n}
+\usepackage[scaled=0.8]{GoMono}
+\usepackage{babel,xcolor,enumitem,tuple}
+\usepackage[pdfborder={0 0 0.5}]{hyperref}
+%\frenchsetup{og=",fg=",AutoSpaceFootnotes=false,AutoSpacePunctuation=true}
+\usepackage[bottom]{footmisc}
+\usepackage[margin=2cm]{geometry}
+\makeatletter
+\long\def\defactive#1#2{\catcode`#1=13 \begingroup\lccode`\~`#1 \lowercase{\endgroup\long\def~{#2}}}
+\newcommand\disable@lig[1]{\defactive#1{\leavevmode\kern\z@\string#1}}
+\def\code{\expandafter\code@i\string}
+\def\code@i#1{%
+ \begingroup
+ \par\nobreak\smallskip\parindent0pt
+ \leftskip.1\linewidth
+ \rightskip\leftskip
+ \defactive\^^I{\leavevmode\space\space\space\space}%
+ \defactive\<{\begingroup$\langle$\itshape}%
+ \defactive\>{$\rangle$\endgroup}%
+ \let\do\@makeother \dospecials
+ \ttfamily\small
+ \obeylines\obeyspaces
+ \def\code@ii##1#1{##1\par\smallbreak\endgroup}%
+ \code@ii
+}
+\long\def\grab@toks#1\relax{\gdef\right@content{#1}}
+
+\newcommand\exemple[1][60]{%
+ \par\nobreak\vskip2.5pt \noindent
+ \def\part@coeff{#1}%
+ \relax\leavevmode\null
+ \begingroup
+ \let\do\@makeother\dospecials
+ \defactive\ {\space}%
+ \defactive\^^M{\par\leavevmode}%
+ \defactive\^^I{\leavevmode\space\space\space\space}%
+ \@makeother:\disable@lig,\disable@lig-%
+ \exemple@@
+}
+
+\newcommand\exemple@@[1]{%
+ \def\@tempa##1#1{%
+ \xdef\left@content{##1}%
+ \endgroup
+ \begingroup
+ \fboxsep1pt \fboxrule 0.5pt
+ \fbox{%
+ \parbox[c]{\dimexpr0.\part@coeff\linewidth-\fboxsep-\fboxrule}{%
+ \vskip5pt
+ \ttfamily\footnotesize\left@content
+ \vskip5pt
+ }%
+ \parbox[c]{\dimexpr\linewidth-0.\part@coeff\linewidth-\fboxsep-\fboxrule}{%
+ \vskip5pt
+ \normalfont\footnotesize\noindent\newlinechar`\^^M \everyeof{\noexpand}%
+ \scantokens{##1}%
+ \vskip2.5pt
+ }%
+ }%
+ \vskip7.5pt\relax
+ \endgroup
+ }%
+ \@tempa
+}
+
+\begingroup
+\catcode`\<13 \catcode`\>13
+\gdef\verb{\relax\ifmmode\hbox\else\leavevmode\null\fi
+ \bgroup
+ \verb@eol@error \let\do\@makeother \dospecials
+ \verbatim@font\@noligs
+ \catcode`\<13 \catcode`\>13 \def<{\begingroup$\langle$\itshape}\def>{\/$\rangle$\endgroup}%
+ \@ifstar\@sverb\@verb}
+\endgroup
+%\def\longfrtpldate@i#1/#2/#3.{}
+%\edef\longfrtpldate{\tpldate}
+\makeatother
+\setlist[enumerate]{topsep=1pt minus 0.75pt, partopsep=0.75pt plus0.5pt minus0.5pt, itemsep=0.5pt minus0.25pt }
+\setlist [itemize]{topsep=1pt minus 0.75pt, partopsep=0.75pt plus0.5pt minus0.5pt, itemsep=0.5pt minus0.25pt }
+\def\tpl{\textsf\tplname}
+\begin{document}
+\parskip=5ptplus0.5ptminus0.75pt\relax
+\parindent=0pt
+\thispagestyle{empty}
+\begin{titlepage}
+ \renewcommand\thefootnote{\fnsymbol{footnote}}
+ \begingroup
+ \centering
+ \null\vskip.25\vsize
+ {\large\bfseries The package for \TeX{} and \LaTeX\par \Huge \tplname\par}
+ \bigbreak
+ v\tplversion
+ \smallbreak
+ \tpldate
+ \vskip1.5cm
+ {Christian \textsc{Tellechea}\footnote{\href{mailto:unbonpetit@netc.fr}{unbonpetit@netc.fr}}}
+ \par
+ \endgroup
+ \vskip2cm
+ \leftskip=.2\linewidth \rightskip=.2\linewidth \small
+ This extension provides common operations for tuples of numbers, in a expandable way, with a concise and easy-to-use "\verb|object.method|" syntax.
+\end{titlepage}
+
+\section{Preview}
+We consider the list of numbers (which we will now call a "tuple"):
+\code|12.7, 6.3, 11.7, 2.9, 5.5, 8.1, 4.3, 9.4, 13.6, 2.9, 6.9, 11.2, 5.1, 7.7, 10.1, 3, 4.1|
+
+We can define an "object", which we name for example "\verb|nn|" with the instruction:
+\code|\newtuple{nn}{12.7, 6.3, 11.7, 2.9, 5.5, 8.1, 4.3, 9.4,13.6, 2.9, 6.9, 11.2, 5.1, 7.7, 10.1, 3, 4.1}|
+
+This tuple "\texttt{nn}" will be used throughout this documentation and recalled in comments in all the codes where it occurs.%
+\newtuple{nn}{12.7, 6.3, 11.7, 2.9, 5.5, 8.1, 4.3, 9.4,13.6, 2.9, 6.9, 11.2, 5.1, 7.7, 10.1, 3, 4.1}
+
+Here is its maximal value:
+\exemple/1) \tplexe{nn.max} \par
+2) \edef\foo{\tplexe{nn.max}}\meaning\foo/
+
+We can also calculate the median of the 5 smallest values, which supposes:
+\begin{enumerate}
+\item to sort the tuple (method \texttt{sorted});
+\item to retain only the values whith index 0 to 4 (method \texttt{filter});
+\item to find the median of the 5 numbers retained (method \texttt{med}).
+\end{enumerate}
+\exemple/%\newtuple{nn}{12.7, 6.3, 11.7, 2.9, 5.5, 8.1, 4.3, 9.4,
+% 13.6, 2.9, 6.9, 11.2, 5.1, 7.7, 10.1, 3, 4.1}
+1) \tplexe{nn.sorted.filter{idx<5}.med} \par
+2) \edef\foo{\tplexe{nn.sorted.filter{idx<5}.med}}\meaning\foo/
+
+Without \LaTeX{}, this package is loaded with
+\code|\input tuple.tex|
+and under \LaTeX{} with
+\code|\usepackage{tuple}|
+
+This package does not rely on any other except the \LaTeX3 module "\texttt{l3fp}", which is now part of the \LaTeX{} kernel, in particular to take advantage of its powerful macro \verb|\fpeval|.
+
+If we do not use \LaTeX{}, \tpl{} will load the file \texttt{expl3-generic.tex} in order to have the \texttt{l3fp} module.
+
+\section{Declaring a tuple object}
+The macro \verb|\newtuple{<name>}{<list of numbers>}| allows to construct a tuple "object" that is then accessed by its \verb|<name>|:
+\begin{itemize}
+ \item the \verb|<name>| accepts all alphanumeric characters \texttt{[az][AZ][09]}, spaces and punctuation. Spaces preceding or following it are removed. A macro is also allowed\footnote{The macro will never be modified by the package \texttt{tuple}: internally, this macro is detokenized to build a more complex name of a macro.}.
+ \item the numbers composing the \verb|<list of numbers>| are understood in the sense of the \texttt{l3fp} module: they cover a much wider range and have a much higher precision than the decimal numbers (in the sense of dimensions) of \TeX{} (see the \href{http://mirrors.ctan.org/macros/latex/required/l3kernel/interface3.pdf}{documentation} of \LaTeX3{}, chapter \texttt{l3fp});
+ \item the \verb|<list of numbers>| is fully expanded and then detokenized before being used by the constructor of the tuple object. Empty elements are ignored.
+\end{itemize}
+
+It is possible to define an empty tuple (i.e. one that does not contain any numbers), but many methods will return an error if they are executed on an empty list.
+
+On the other hand, it's impossible to redefine an existing tuple (this requires the \texttt{store} method).
+
+\section{Methods}
+Here is the syntaxe to execute methods on a tuple:
+\code|\tplexe{<tuple name>.<method 1>.<method 2>...<method n>}|
+No spaces are allowed between the “\verb-.-” and the name of a method. It is therefore illegal to write “\verb*|. sorted|”.
+
+There are 3 types of datas for the \tpl{} package:
+\begin{enumerate}
+ \item numbers (and displayable datas);
+ \item "tuple" objects;
+ \item the "storage" type which characterizes non-expandable methods performing assignments.
+ \end{enumerate}
+
+All methods in this package take a tuple as input (which is the result of the previous methods) and return a result whose type determines which group the method belongs to:
+\begin{itemize}
+ \item group 1 "\texttt{tuple} $\longrightarrow$ \texttt{number}";
+ \item group 2 "\texttt{tuple} $\longrightarrow$ \texttt{tuple}". The methods in this group \emph{do not modify} the initial tuple\footnote{They cannot do so, otherwise they would not be expandable!}, they act on a temporary tuple that it is obviously possible to save with a method in the group below;
+ \item group 3 "\texttt{tuple} $\longrightarrow$ \texttt{storage}";
+\end{itemize}
+
+The macro \verb|\tplexe| and its argument are expandable, provided that the methods invoked are not in the group "\texttt{tuple} $\longrightarrow$ \texttt{storage}".
+
+If no method is specified, an expandable, implicit and generic method of the group "\texttt{tuple} $\longrightarrow$ \texttt{number}", is executed and returns the tuple.
+\exemple/%\newtuple{nn}{12.7, 6.3, 11.7, 2.9, 5.5, 8.1, 4.3, 9.4,
+% 13.6, 2.9, 6.9, 11.2, 5.1, 7.7, 10.1, 3, 4.1}%
+\tplexe{nn}/
+
+\section{Methods of the group \texttt{tuple} $\longrightarrow$ \texttt{number}}
+\subsection{Methods \texttt{len}, \texttt{sum}, \texttt{min}, \texttt{max}, \texttt{mean}, \texttt{med} and \texttt{stdev}}
+All these methods do not accept any argument and return respectively the number of elements, their sum, the minimum, the maximum, the mean, the median and the standard deviation.
+
+\exemple/%\newtuple{nn}{12.7, 6.3, 11.7, 2.9, 5.5, 8.1, 4.3, 9.4,
+% 13.6, 2.9, 6.9, 11.2, 5.1, 7.7, 10.1, 3, 4.1}%
+1) len = \tplexe{nn.len}\par
+2) sum = \tplexe{nn.sum}\par
+3) min = \tplexe{nn.min}\par
+4) max = \tplexe{nn.max}\par
+5) mean = \tplexe{nn.mean}\par
+5) med = \tplexe{nn.med}\par
+6) stdev = \tplexe{nn.stdev}/
+
+\subsection{Method \texttt{quantile}}
+This method has the syntax
+\code|quantile{<p>}|
+where \verb|<p>| must be a number between 0 and 1. The method returns the quantile according to the argument \verb|<p>|. The method used is the average method\footnote{If $p$ is the argument of the method, we define $h=(n-1)p+1$ where $n$ is the length of the tuple.\par The method returns the number equal to $x_{\lfloor h\rfloor}+(h-\lfloor h\rfloor)(x_{\lfloor h\rfloor}+x_{\lceil h\rceil})$, where $x_k$ is the $k^{\hbox{\tiny th}}$ number of the sorted tuple.}; this is interpolation scheme “R7” described in this \href{https://en.wikipedia.org/wiki/Quantile}{article}.
+
+\exemple/%\newtuple{nn}{12.7, 6.3, 11.7, 2.9, 5.5, 8.1, 4.3, 9.4,
+% 13.6, 2.9, 6.9, 11.2, 5.1, 7.7, 10.1, 3, 4.1}%
+1) \tplexe{nn.quantile{0.25}}\par
+2) \tplexe{nn.quantile{0.5}}\par
+2) \tplexe{nn.quantile{0.75}}\par/
+
+Note that \verb|quantile{0.5}| is equivalent to \verb|med|.
+\medbreak
+It's important to note that spaces before and after method arguments are ignored. It is therefore possible to write \verb*|.quantile {0.5} |.
+
+\subsection{Method \texttt{get}}
+This method has the syntax
+\code|get{<index>}|
+
+The first index is 0 and the last is $n-1$ where $n$ is the number of elements in the tuple. Therefore, the argument of \texttt{get} must be between 0 and $n-1$ otherwise a compilation error will be returned.
+
+\exemple|%\newtuple{nn}{12.7, 6.3, 11.7, 2.9, 5.5, 8.1, 4.3, 9.4,
+% 13.6, 2.9, 6.9, 11.2, 5.1, 7.7, 10.1, 3, 4.1}%
+1st number : \tplexe{nn.get{0}}\par
+13th number : \tplexe{nn.get{12}}\par
+last number : \tplexe{nn.get{\tplexe{nn.len}-1}}|
+
+The argument of \texttt{get} is evaluated before being used: it is therefore possible to put the expandable macro \verb|\tplexe| with a final method returning an integer.
+
+\subsection{Method \texttt{pos}}
+This method has the syntax
+\code|pos{<number>}|
+and returns the index of the first occurrence of the \verb|<number>| in the tuple. If the tuple does not contain the \verb|<number>|, \verb|-1| is returned.
+
+\exemple|%\newtuple{nn}{12.7, 6.3, 11.7, 2.9, 5.5, 8.1, 4.3, 9.4,
+% 13.6, 2.9, 6.9, 11.2, 5.1, 7.7, 10.1, 3, 4.1}%
+index of 12.7: \tplexe{nn.pos{12.7}}\par
+index of 2.9 : \tplexe{nn.pos{2.9}}\par
+index of 31.8: \tplexe{nn.pos{31.8}}|
+
+\subsection{Method \texttt{show}}
+This method does not accept any arguments and is intended to convert a tuple object into a displayable result. To do this:
+\begin{itemize}
+ \item for each element, the macro \verb|\tplformat|, requiring 2 mandatory arguments, is executed. The first argument passed is the index of the element and the 2nd{} argument is the element itself;
+ \item each result from the macro \verb|\tplformat| is separated from the next by the content of the macro \verb|\tplsep|.
+\end{itemize}
+
+By default, these two macros have the following code:
+\begin{verbatim}
+\def\tplformat#1#2{#2}% #1=current index #2=current item
+\def\tplsep{, }
+\end{verbatim}
+
+The default behavior is therefore exactly the same as the implicit method that is executed last, and in particular, the method is expandable.
+
+\exemple/%\newtuple{nn}{12.7, 6.3, 11.7, 2.9, 5.5, 8.1, 4.3, 9.4,
+% 13.6, 2.9, 6.9, 11.2, 5.1, 7.7, 10.1, 3, 4.1}%
+\tplexe{nn.show}/
+
+These 2 macros can be reprogrammed to create more advanced formatting. Here we use the \verb|\tplfpcompare| macro, which is an alias of the \verb|\fp_compare:nNnTF| macro of the \texttt{l3fp} module, to compare an element with a given value. In the 2 examples given below, the method is no longer expandable due to the use of the \verb|\fbox| and \verb|\textcolor| macros.
+
+Boxing the first 10 elements:
+\exemple/%\newtuple{nn}{12.7, 6.3, 11.7, 2.9, 5.5, 8.1, 4.3, 9.4,
+% 13.6, 2.9, 6.9, 11.2, 5.1, 7.7, 10.1, 3, 4.1}%
+\def\tplformat#1#2{\ifnum#1<10 \fbox{#2}\else#2\fi}
+\tplexe{nn.show}/
+
+Below-average items highlighted in red:
+\exemple/%\newtuple{nn}{12.7, 6.3, 11.7, 2.9, 5.5, 8.1, 4.3, 9.4,
+% 13.6, 2.9, 6.9, 11.2, 5.1, 7.7, 10.1, 3, 4.1}%
+\edef\nnmean{\tplexe{nn.mean}}%
+\def\tplformat#1#2{\tplfpcompare{#2}<{\nnmean}
+ {\textcolor{red}{#2}}
+ {#2}%
+}%
+\def\tplsep{~; }%
+\tplexe{nn.show}/
+
+\section{Methods of the group \texttt{tuple} $\longrightarrow$ \texttt{tuple}}
+Each time a tuple is generated or modified, the \texttt{len}, \texttt{sum}, \texttt{min}, \texttt{max}, \texttt{mean}, \texttt{med}, \texttt{stdev} and \texttt{sorted} methods are updated.
+\subsection{Method \texttt{sorted}}
+This method does not accept any arguments and returns a tuple object with its elements sorted in ascending order.
+
+\exemple|%\newtuple{nn}{12.7, 6.3, 11.7, 2.9, 5.5, 8.1, 4.3, 9.4,
+% 13.6, 2.9, 6.9, 11.2, 5.1, 7.7, 10.1, 3, 4.1}%
+\tplexe{nn.sorted}|
+
+\subsection{Method \texttt{set}}
+The syntax of this method is
+\code|set{<index1>:<number1>,<index2>:<number2>,...}|
+In the tuple resulting from the previous methods, replaces the number at \verb|<index1>| with \verb|<number1>| and so on if several assignments are specified in a comma-separated list.
+
+Each \verb|<index>| must be between 0 and $n-1$, where $n$ is the number of elements in the tuple passed as input to the method.
+
+\exemple|%\newtuple{nn}{12.7, 6.3, 11.7, 2.9, 5.5, 8.1, 4.3, 9.4,
+% 13.6, 2.9, 6.9, 11.2, 5.1, 7.7, 10.1, 3, 4.1}%
+\tplexe{nn.set{1:10,5:50}}|
+
+\subsection{Method \texttt{add}}
+This method, which adds a \verb|<insertion>| at one or more specified indexes, has the syntax
+\code|add{<index1>:<insertion1>,<index2>:<insertion2>,...}|
+
+It should be noted that in this syntax, a \verb|<insertion>| can be
+\begin{itemize}
+ \item a single number "\verb|add{<index>:<number>}|"
+ \item a csv list of numbers that \emph{must} be enclosed in braces "\verb|add{<index>:{n1,n2,n3...}}|"
+ \item a tuple accessed by \verb|\tplexe|: "\verb|add{<index>:{\tplexe{<tuple name>}}}|".
+\end{itemize}
+
+Concerning the \verb|<index>|:
+\begin{itemize}
+ \item if a \verb|<index>| is less than 0, it is taken as 0;
+ \item if a \verb|<index>| is "\verb|*|" or greater than $n-1$, the \verb|<insertion>| is placed at the end of the input tuple;
+ \item the \verb|<index>| \emph{are not} recalculated after each \verb|<insertion>|, but only after the last one. It is therefore not equivalent to write "\verb|.add{1:10,5:50}|" and "\verb|.add{1:10}.add{5:50}|". Indeed, 5 will be at index 6 in the first case while it will be at index 5 in the second.
+\end{itemize}
+
+\exemple|%\newtuple{nn}{12.7, 6.3, 11.7, 2.9, 5.5, 8.1, 4.3, 9.4,
+% 13.6, 2.9, 6.9, 11.2, 5.1, 7.7, 10.1, 3, 4.1}%
+1) add at first pos : \tplexe{nn.add{0:{666,667}}}\par
+2) add index 16 : \tplexe{nn.add{16:{666,667}}}\par
+3) add at last pos last: \tplexe{nn.add{*:{666,667}}}|
+
+\exemple|\newtuple{X}{10,20,30,40,50,60}%
+\newtuple{Y}{1,2,3,4}%
+1) \tplexe{X.add{-3:{\tplexe{Y}}}}\par
+2) \tplexe{X.add{1:1000,3:{\tplexe{Y}}}}\par
+3) \tplexe{X.add{1:1000}.add{3:{\tplexe{Y}}}}|
+
+\subsection{Method \texttt{op}}
+This method, which performs an \verb|<operation>| on all elements of the tuple, has the syntax
+\code|op{<operation>}|
+
+The \verb|<operation>| is an expression not containing braces, evaluable by \verb|\fpeval| once all occurrences of "\texttt{val}" have been replaced by the value of each element, and all occurrences of "\texttt{idx}" by its index.
+
+\exemple|\newtuple{X}{10,20,30,40,50,60}%
+1) \tplexe{X.op{val+5}}\par
+2) \tplexe{X.op{val*val}}\par
+3) \tplexe{X.op{val+idx}}\par
+4) \tplexe{X.op{idx<4 ? val-1 : val+1 }}|
+
+\subsection{Method \texttt{filter}}
+This method, which selects elements according to one or more criteria, has the syntax
+\code|filter{<test>}|
+and where \verb|<test>| is a boolean not containing braces, evaluable by \verb|\fpeval| once all occurrences of "\texttt{val}" have been replaced by the value of each element, and all occurrences of "\texttt{idx}" by its index.
+
+\exemple/%\newtuple{nn}{12.7, 6.3, 11.7, 2.9, 5.5, 8.1, 4.3, 9.4,
+% 13.6, 2.9, 6.9, 11.2, 5.1, 7.7, 10.1, 3, 4.1}%
+1) \tplexe{nn.filter{val<10}}\par
+2) \tplexe{nn.filter{val>5 && val<10}}\par
+3) \tplexe{nn.filter{idx<3 || idx>13}}\par
+4) \tplexe{nn.filter{val!=6.3 && val!=2.9 && val!=4.1}}/
+
+\subsection{Method \texttt{comp}}
+This method composes two tuples of the same length with an operation that the user specifies. Its syntax is
+\code|comp{<operation>}{<tuple name>}|
+where the tuple whose name is passed as the second argument \emph{must} have the same length as the tuple passed as input to the method.
+
+The \verb|<operation>| is an expression not containing braces, evaluable by \verb|\fpeval| once all occurrences of "\texttt{xa}" have been replaced by the value of each element of the input tuple, and all occurrences of "\texttt{xb}" by that of the tuple specified in the 2nd argument.
+
+Product of 2 tuples and their "\texttt{sumprod}":
+\exemple/\newtuple{A}{2,-4,3,7,-1}%
+\newtuple{B}{-9,0,4,6,-2}%
+product \tplexe{A.comp{xa*xb}{B}}\par
+sumprod: \tplexe{A.comp{xa*xb}{B}.sum}/
+
+Calculation of the smallest distance to point A(2.5 ; -0.5) knowing the list of abscissas and the list of ordinates of a trajectory (here elliptical):
+\exemple/\newtuple{ListX}{4,2,0.5,1,3,6.5}%
+\newtuple{ListY}{2,1.5,0,-1.5,-2,0.5}%
+\tplexe{ListX.comp{sqrt((xa-2.5)**2+(xb+0.5)**2)}{ListY}.min}/
+
+\section{Methods in the group \texttt{tuple} $\longrightarrow$ \texttt{storage}}
+As these methods don't return a result because they perform an assignment, they are not expandable, and must be placed in the last position. If this is not the case, all methods following them will be ignored.
+
+\subsection{Method \texttt{split}}
+This method cuts the tuple passed as input to the method after the specified index. The syntax is
+\code|split{<index>}{<tuple1>}{<tuple2>}|
+The tuple passed as input to the method is split after the \verb|<index>|: the part before the split is assigned, via \verb||newtuple| to the tuple with name “\texttt{tuple1}” and the remaining part to the tuple with name “\texttt{tuple2}”. No check is made on the existence of the 2 tuples, so existing tuples can be silently replaced.
+
+The \verb|<index>| must lie between 0 and $n-2$, where $n$ is the number of elements in the tuple passed as input.
+
+\exemple/%\newtuple{nn}{12.7, 6.3, 11.7, 2.9, 5.5, 8.1, 4.3, 9.4,
+% 13.6, 2.9, 6.9, 11.2, 5.1, 7.7, 10.1, 3, 4.1}%
+\tplexe{nn.split{5}{n1}{n2}}%
+tuple before: \tplexe{n1}\par
+tuple after : \tplexe{n2}/
+
+\subsection{Method \texttt{store}}
+This macro is used to store the result of the last method. If this result is a tuple, the syntax is
+\code|store{<tuple name>}|
+and if the result is a number or a displayable data from the \texttt{show} method:
+\code|store{<macro>}|
+
+No check is made on the existence of the tuple or macro. It is therefore possible to silently replace an existing tuple or macro.
+
+\exemple|%\newtuple{nn}{12.7, 6.3, 11.7, 2.9, 5.5, 8.1, 4.3, 9.4,
+% 13.6, 2.9, 6.9, 11.2, 5.1, 7.7, 10.1, 3, 4.1}%
+1) \tplexe{nn.sorted.filter{val>11}.store{nn1}}%
+ \tplexe{nn1}\par
+2) \tplexe{nn1.len.store\nnlen}%
+ \meaning\nnlen\par
+3) \def\tplformat#1#2{\fbox{#2}}\def\tplsep{ }%
+ \tplexe{nn1.show.store\nnshow}%
+ \meaning\nnshow\par
+4) \edef\nndisp{\tplexe{nn1}}%
+ \meaning\nndisp% generic method
+|
+
+To store the result of the generic method, you have to use \verb|\edef| because \verb|\tplexe{<tuple>.store<macro>}| is incorrect since in this case, the \texttt{store} method applies to a tuple.
+
+\section{Tuple generation}
+To generate a tuple, we can use the expandable macro \verb|\gentuple| which is intended to be called in the 2nd argument of \verb|\newtuple|. Its syntax is
+\code/\gentuple{<initial values>},\genrule<generation rule>;\while||\until<condition>}/
+where:
+\begin{itemize}
+ \item the \verb|<initial values>| are optional. If present, they \emph{must} be followed by a comma. The macro \verb|\gentuple| determines their number $i$ by counting ($i$ must be at most equal to 9). These initial values will be copied at the beginning of the tuple and subsequently, are intended to be used in the \verb|<generation rule>| for recurrence purposes;
+ \item the \verb|<generation rule>| is an expression not containing braces, evaluable by \verb|\fpeval| once in the previous $i$ values, all occurrences of \verb|\1| have been replaced by the first value, \verb|\2| by the second value, etc. In addition, each occurrence of \verb|\i| is replaced by the value of the current index.
+ \item the \verb|<condition>| is a boolean not containing braces, evaluable by \verb|\fpeval| once all occurrences of "\texttt{val}" have been replaced by the value of the computed element, and all occurrences of "\verb|\i|" by its index. If the keyword after \verb|;| is \verb|\while|, the loop is of the type \verb|while<condition>...endwhile| whereas if this keyword is \verb|\until|, it is a \verb|repeat...until<condition>| loop.
+\end{itemize}
+
+Generating the first 10 even integers:
+\exemple|\gentuple{\genrule (\i+1)*2 ; \until \i=9 }\par
+or\par
+\gentuple{\genrule (\i+1)*2 ; \while \i<10 }|
+
+Generation of 15 random integers between 1 and 10:
+\exemple|\gentuple{\genrule randint(1,10) ; \until \i=14 }|
+
+Generate squares of integers up to 500:
+\exemple|\gentuple{\genrule\i*\i; \while val<500 }|
+
+Generation of the first 10 terms of the Fibonacci sequence:
+\exemple|\gentuple{1,1,\genrule\1+\2; \until \i=9 }|
+
+Generation of the first 10 terms of $u_0=1$ ; $u_1=1$ ; $u_2=-1$ and $u_{n}=u_{n-3}u_{n-1}-u^2_{n-2}$:
+\exemple|\gentuple{1,1,-1,\genrule\1*\3-\2*\2; \until \i=10}|
+
+Generation of the Syracuse sequence (aka the “$3n+1$ sequence”) of 15:
+\exemple|\edef\syr{%
+ \gentuple{15,\genrule \1/2=trunc(\1/2) ? \1/2 : 3*\1+1 ; \until val=1}%
+}%
+\meaning\syr|
+
+Maximum altitude and length of the Syracuse sequence of 27:
+\exemple|\newtuple{syr27}
+ {\gentuple{27,\genrule \1/2=trunc(\1/2) ? \1/2 : 3*\1+1 ; \until val=1}}%
+length = \tplexe{syr27.len}\par
+max alt = \tplexe{syr27.max}|
+
+\section{Conclusion}
+\subsection{Motivation}
+Somewhat surprisingly, very little exists to manipulate and operate on lists of numbers\footnote{There is one package, \texttt{commalists-tools}, but it's clearly too limited. Like all its author's packages that flood CTAN, it simply aligns, linearly and without any real programmation, the high-level macros of the packages \texttt{tikz}, \texttt{listofitems}, \texttt{xstring}, \texttt{xint} and \texttt{simplekv}.% What advice would you give this author? Quality over quantity? Progress in programming and not remain at this basic, distressing and uninteresting level forever? Think about what would happen (spoiler: CTAN would explode!) if all \LaTeX{} users started writing a package every time they managed to combine macros from other packages?
+}.
+
+The main challenge was to provide expandable macros and also an original syntax in the world of \TeX{} of the type \verb|<object>.<method 1>.<method 2>...<method n>|, where you can chain methods executed on an “object” which is a tuple of numbers. I don't know if any packages offer this kind of syntax, but it's actually quite intuitive. As I'm fairly unfamiliar with programming expandable macros, I almost gave up many times. But I've finally found a mouse-hole that makes it all work pretty much, except for the numerous bugs that are probably lurking everywhere.
+
+I'd like to thank anyone who finds one for pointing it out to me by e-mail, or even suggesting new features.
+
+\subsection{Execution speed}
+When you get into optimizing execution speed, especially for expandable macros, you don't get out! It's a pit of questions about macro arguments, about little ---~or big~--- tricks that save time, and a headache about how to juggle with delimited arguments and find them later!
+
+I hope I didn't fall into this trap, because I've barely entered it. In any case, \TeX{} is not made for massive calculations, since it is first and foremost a typesetting software. For calculations, powerful tools that beat \TeX{} hands down exist in abundance.
+
+In any case, "expandable macro" goes a bit against "execution speed". For information, I put below the compilation times, in seconds, of the creation of tuples containing $n$ random integers. It depends on the computer used, of course, but the orders of magnitude are quite revealing. We can clearly see that it is illusory to exceed a thousand numbers because the time to create a tuple then increases rapidly\footnote{Not to mention that, in addition to that, the tuple is immediately recreated and recalculated after being modified by the methods \texttt{set}, \texttt{add}, \texttt{op}, \texttt{filter}, \texttt{split} and \texttt{comp}}. That said, who would use \TeX{} for calculations on so many numbers?
+\begin{center}
+\begin{tabular}{|c|c|}\hline
+ Number of elements $n$ & Execution time of \verb|\newtuple| in s\\\hline
+ 50 & 0.011\\\hline
+ 100 & 0.026\\\hline
+ 500 & 0.224\\\hline
+ 1000 & 0.703\\\hline
+ 1500 & 1.727\\\hline
+ 2000 & 2.876\\\hline
+ 5000 & 22.907\\\hline
+\end{tabular}
+\end{center}
+
+\subsection{Example: state population}
+The tuple \verb|\Wpop| contains the population of each state in the world, in millions of inhabitants\footnote{The data comes from \href{https://www.unfpa.org/data/world-population-dashboard}{https://www.unfpa.org/data/world-population-dashboard}} :
+\exemple/\newtuple\Wpop{%
+43.4, 2.8, 46.3, 37.8, 0.1, 46.1, 2.8, 0.1, 26.7, 9.0, 10.5, 0.4, 1.5,%
+174.7, 0.3, 9.5, 11.7, 0.4, 14.1, 0.8, 12.6, 3.2, 2.7, 217.6, 0.5, 6.6,%
+23.8, 13.6, 0.6, 17.1, 29.4, 39.1, 5.9, 18.8, 19.7, 1425.2, 7.5, 0.7,%
+52.3, 0.9, 6.2, 5.2, 29.6, 4.0, 11.2, 0.2, 1.3, 10.5, 26.2, 105.6, 5.9,%
+1.2, 0.1, 11.4, 18.4, 114.5, 6.4, 1.8, 3.8, 1.3, 1.2, 129.7, 0.9, 5.5,%
+64.9, 0.3, 0.3, 2.5, 2.8, 3.7, 83.3, 34.8, 10.3, 0.1, 0.4, 0.2, 18.4,%
+14.5, 2.2, 0.8, 11.9, 10.8, 10.0, 0.4, 1441.7, 279.8, 89.8, 46.5, 5.1,%
+9.3, 58.7, 2.8, 122.6, 11.4, 19.8, 56.2, 0.1, 4.3, 6.8, 7.7, 1.8, 5.2,%
+2.4, 5.5, 7.0, 2.7, 0.7, 31.1, 21.5, 34.7, 0.5, 24.0, 0.5, 0.4, 5.0,%
+1.3,129.4, 0.1, 3.5, 0.6, 38.2, 34.9, 55.0, 2.6, 31.2, 17.7, 0.3, 5.3,%
+7.1,28.2, 229.2, 2.1, 5.5, 4.7, 245.2, 4.5, 10.5, 6.9, 34.7, 119.1,%
+40.2,10.2, 3.3, 2.7, 51.7, 3.3, 1.0, 19.6, 144.0, 14.4, 0.0, 0.2, 0.1,%
+0.2,0.03, 0.2, 37.5, 18.2, 7.1, 0.1, 9.0, 6.1, 0.0, 5.7, 2.1, 0.8, 18.7,%
+61.0,11.3, 47.5, 21.9, 5.5, 49.4, 0.6, 10.7, 8.9, 24.3, 10.3, 71.9, 1.4,%
+9.3,0.1, 1.5, 12.6, 86.3, 6.6, 0.0, 0.0, 49.9, 37.9, 9.6, 68.0, 69.4,%
+341.8,0.1, 3.4, 35.7, 0.3, 29.4, 99.5, 0.6, 35.2, 21.1, 17.0}%
+Number of state: \tplexe{\Wpop.len}\par
+Mean: \tplexe{\Wpop.mean}\par
+Median: \tplexe{\Wpop.med}\par
+Standard deviation: \tplexe{\Wpop.stdev}\par
+Quintile \#1 : \tplexe{\Wpop.quantile{0.2}}\par
+Quintile \#4 : \tplexe{\Wpop.quantile{0.8}}/
+\newtuple\Wpop{%
+43.4, 2.8, 46.3, 37.8, 0.1, 46.1, 2.8, 0.1, 26.7, 9.0, 10.5, 0.4, 1.5,%
+174.7, 0.3, 9.5, 11.7, 0.4, 14.1, 0.8, 12.6, 3.2, 2.7, 217.6, 0.5, 6.6,%
+23.8, 13.6, 0.6, 17.1, 29.4, 39.1, 5.9, 18.8, 19.7, 1425.2, 7.5, 0.7,%
+52.3, 0.9, 6.2, 5.2, 29.6, 4.0, 11.2, 0.2, 1.3, 10.5, 26.2, 105.6, 5.9,%
+1.2, 0.1, 11.4, 18.4, 114.5, 6.4, 1.8, 3.8, 1.3, 1.2, 129.7, 0.9, 5.5,%
+64.9, 0.3, 0.3, 2.5, 2.8, 3.7, 83.3, 34.8, 10.3, 0.1, 0.4, 0.2, 18.4,%
+14.5, 2.2, 0.8, 11.9, 10.8, 10.0, 0.4, 1441.7, 279.8, 89.8, 46.5, 5.1,%
+9.3, 58.7, 2.8, 122.6, 11.4, 19.8, 56.2, 0.1, 4.3, 6.8, 7.7, 1.8, 5.2,%
+2.4, 5.5, 7.0, 2.7, 0.7, 31.1, 21.5, 34.7, 0.5, 24.0, 0.5, 0.4, 5.0,%
+1.3,129.4, 0.1, 3.5, 0.6, 38.2, 34.9, 55.0, 2.6, 31.2, 17.7, 0.3, 5.3,%
+7.1,28.2, 229.2, 2.1, 5.5, 4.7, 245.2, 4.5, 10.5, 6.9, 34.7, 119.1,%
+40.2,10.2, 3.3, 2.7, 51.7, 3.3, 1.0, 19.6, 144.0, 14.4, 0.0, 0.2, 0.1,%
+0.2,0.03, 0.2, 37.5, 18.2, 7.1, 0.1, 9.0, 6.1, 0.0, 5.7, 2.1, 0.8, 18.7,%
+61.0,11.3, 47.5, 21.9, 5.5, 49.4, 0.6, 10.7, 8.9, 24.3, 10.3, 71.9, 1.4,%
+9.3,0.1, 1.5, 12.6, 86.3, 6.6, 0.0, 0.0, 49.9, 37.9, 9.6, 68.0, 69.4,%
+341.8,0.1, 3.4, 35.7, 0.3, 29.4, 99.5, 0.6, 35.2, 21.1, 17.0}%
+
+We modify the tuple \verb|\Wpop|, retaining only “moderately” populated states. We arbitrarily consider their population between 10 and 100 millions:
+\exemple/\tplexe{\Wpop.filter{val>=10 && val<=100}.store\Wpop}%
+Number: \tplexe{\Wpop.len}\par
+Mean: \tplexe{\Wpop.mean}\par
+Median: \tplexe{\Wpop.med}\par
+Standard deviation: \tplexe{\Wpop.stdev}\par
+Quintile \#1 : \tplexe{\Wpop.quantile{0.2}}\par
+Quintile \#4 : \tplexe{\Wpop.quantile{0.8}}
+
+Distribution over 6 equal intervals:\par
+\begin{tabular}{lc}\\\hline
+ From 10 to 25 & \tplexe{\Wpop.filter{val<25}.len}\\
+ From 25 to 40 & \tplexe{\Wpop.filter{val>=25 && val<40}.len}\\
+ From 40 to 55 & \tplexe{\Wpop.filter{val>=40 && val<55}.len}\\
+ From 55 to 70 & \tplexe{\Wpop.filter{val>=55 && val<70}.len}\\
+ From 70 to 85 & \tplexe{\Wpop.filter{val>=70 && val<85}.len}\\
+ From 85 to 100& \tplexe{\Wpop.filter{val>=85}.len}\\\hline
+\end{tabular}/
+
+\subsection{TODO list}
+To be implemented more or less quickly:
+\begin{enumerate}
+ \item allow the user to choose \texttt{l3fp} or \texttt{xint} as the calculation engine;
+ \item insertion sorting to sort almost-sorted tuples obtained using the \texttt{add}, \texttt{set}, \texttt{op} methods (risky as it depends on the operation!).
+ \item merge sorting to add one tuple to another;
+ \item other speed optimization?
+\end{enumerate}
+\end{document} \ No newline at end of file
diff --git a/Master/texmf-dist/doc/generic/tuple/tuple-doc-fr.pdf b/Master/texmf-dist/doc/generic/tuple/tuple-doc-fr.pdf
new file mode 100644
index 00000000000..6ea0d990967
--- /dev/null
+++ b/Master/texmf-dist/doc/generic/tuple/tuple-doc-fr.pdf
Binary files differ
diff --git a/Master/texmf-dist/doc/generic/tuple/tuple-doc-fr.tex b/Master/texmf-dist/doc/generic/tuple/tuple-doc-fr.tex
new file mode 100644
index 00000000000..76ec899178b
--- /dev/null
+++ b/Master/texmf-dist/doc/generic/tuple/tuple-doc-fr.tex
@@ -0,0 +1,541 @@
+% !TeX TS-program = lualatex
+\documentclass[french,a4paper]{article}
+\usepackage[no-math]{fontspec}
+\usepackage[libertine]{newtxmath}
+\usepackage{libertineRoman}
+\DeclareSymbolFont{operators}{\encodingdefault}{\familydefault}{m}{n}
+\usepackage[scaled=0.8]{GoMono}
+\usepackage{babel,xcolor,enumitem,tuple}
+\usepackage[pdfborder={0 0 0.5}]{hyperref}
+\frenchsetup{og=«,fg=»,AutoSpaceFootnotes=false,AutoSpacePunctuation=true}
+\usepackage[bottom]{footmisc}
+\usepackage[margin=2cm]{geometry}
+\makeatletter
+\long\def\defactive#1#2{\catcode`#1=13 \begingroup\lccode`\~`#1 \lowercase{\endgroup\long\def~{#2}}}
+\newcommand\disable@lig[1]{\defactive#1{\leavevmode\kern\z@\string#1}}
+\def\code{\expandafter\code@i\string}
+\def\code@i#1{%
+ \begingroup
+ \par\nobreak\smallskip\parindent0pt
+ \leftskip.1\linewidth
+ \rightskip\leftskip
+ \defactive\^^I{\leavevmode\space\space\space\space}%
+ \defactive\<{\begingroup$\langle$\itshape}%
+ \defactive\>{$\rangle$\endgroup}%
+ \let\do\@makeother \dospecials
+ \ttfamily\small
+ \obeylines\obeyspaces
+ \def\code@ii##1#1{##1\par\smallbreak\endgroup}%
+ \code@ii
+}
+\long\def\grab@toks#1\relax{\gdef\right@content{#1}}
+
+\newcommand\exemple[1][60]{%
+ \par\nobreak\vskip2.5pt \noindent
+ \def\part@coeff{#1}%
+ \relax\leavevmode\null
+ \begingroup
+ \let\do\@makeother\dospecials
+ \defactive\ {\space}%
+ \defactive\^^M{\par\leavevmode}%
+ \defactive\^^I{\leavevmode\space\space\space\space}%
+ \@makeother:\disable@lig,\disable@lig-%
+ \exemple@@
+}
+
+\newcommand\exemple@@[1]{%
+ \def\@tempa##1#1{%
+ \xdef\left@content{##1}%
+ \endgroup
+ \begingroup
+ \fboxsep1pt \fboxrule 0.5pt
+ \fbox{%
+ \parbox[c]{\dimexpr0.\part@coeff\linewidth-\fboxsep-\fboxrule}{%
+ \vskip5pt
+ \ttfamily\footnotesize\left@content
+ \vskip5pt
+ }%
+ \parbox[c]{\dimexpr\linewidth-0.\part@coeff\linewidth-\fboxsep-\fboxrule}{%
+ \vskip5pt
+ \normalfont\footnotesize\noindent\newlinechar`\^^M \everyeof{\noexpand}%
+ \scantokens{##1}%
+ \vskip2.5pt
+ }%
+ }%
+ \vskip7.5pt\relax
+ \endgroup
+ }%
+ \@tempa
+}
+
+\begingroup
+\catcode`\<13 \catcode`\>13
+\gdef\verb{\relax\ifmmode\hbox\else\leavevmode\null\fi
+ \bgroup
+ \verb@eol@error \let\do\@makeother \dospecials
+ \verbatim@font\@noligs
+ \catcode`\<13 \catcode`\>13 \def<{\begingroup$\langle$\itshape}\def>{\/$\rangle$\endgroup}%
+ \@ifstar\@sverb\@verb}
+\endgroup
+\def\longfrtpldate@i#1/#2/#3.{\number#3\relax\space\ifcase #2 \or janvier\or février\or mars\or avril\or mai\or juin\or juillet\or aout\or septembre\or octobre\or novembre\or décembre\fi\space#1}
+\edef\longfrtpldate{\expandafter\longfrtpldate@i\tpldate.}
+\makeatother
+\setlist[enumerate]{topsep=1pt minus 0.75pt, partopsep=0.75pt plus0.5pt minus0.5pt, itemsep=0.5pt minus0.25pt }
+\setlist [itemize]{topsep=1pt minus 0.75pt, partopsep=0.75pt plus0.5pt minus0.5pt, itemsep=0.5pt minus0.25pt }
+\def\tpl{\textsf\tplname}
+\begin{document}
+\parskip=5ptplus0.5ptminus0.75pt\relax
+\parindent=0pt
+\thispagestyle{empty}
+\begin{titlepage}
+ \renewcommand\thefootnote{\fnsymbol{footnote}}
+ \begingroup
+ \centering
+ \null\vskip.25\vsize
+ {\large\bfseries L'extension pour \TeX{} et \LaTeX\par \Huge \tplname\par}
+ \bigbreak
+ v\tplversion
+ \smallbreak
+ \longfrtpldate
+ \vskip1.5cm
+ {Christian \bsc{Tellechea}\footnote{\href{mailto:unbonpetit@netc.fr}{unbonpetit@netc.fr}}}
+ \par
+ \endgroup
+ \vskip2cm
+ \leftskip=.2\linewidth \rightskip=.2\linewidth \small
+ Cette extension met à disposition des opérations courantes pour les tuples de nombres, de façon développable, avec une syntaxe «\verb|objet.méthode|» concise et facile à utiliser.
+\end{titlepage}
+
+\section{Aperçu}
+On considère la liste de nombres (que l'on appellera désormais « tuple ») :
+\code|12.7, 6.3, 11.7, 2.9, 5.5, 8.1, 4.3, 9.4, 13.6, 2.9, 6.9, 11.2, 5.1, 7.7, 10.1, 3, 4.1|
+
+On peut définir un « objet » de type tuple, que l'on nomme par exemple «\verb|nn|» avec l'instruction :
+\code|\newtuple{nn}{12.7, 6.3, 11.7, 2.9, 5.5, 8.1, 4.3, 9.4,13.6, 2.9, 6.9, 11.2, 5.1, 7.7, 10.1, 3, 4.1}|
+
+Ce tuple « \texttt{nn} » sera utilisé tout au long de cette documentation et rappelé en commentaire dans tous les codes où il intervient.%
+\newtuple{nn}{12.7, 6.3, 11.7, 2.9, 5.5, 8.1, 4.3, 9.4,13.6, 2.9, 6.9, 11.2, 5.1, 7.7, 10.1, 3, 4.1}
+
+On peut en extraire son maximum :
+\exemple/1) \tplexe{nn.max} \par
+2) \edef\foo{\tplexe{nn.max}}\meaning\foo/
+
+On peut également calculer la médiane des 5 plus petites valeurs, ce qui suppose :
+\begin{enumerate}
+ \item d'ordonner le tuple (méthode \texttt{sorted}) ;
+ \item de ne retenir que les valeurs dont l'index est 0 à 4 (méthode \texttt{filter});
+ \item de trouver la médiane des 5 nombres retenus (méthode \texttt{med}).
+\end{enumerate}
+\exemple/%\newtuple{nn}{12.7, 6.3, 11.7, 2.9, 5.5, 8.1, 4.3, 9.4,
+% 13.6, 2.9, 6.9, 11.2, 5.1, 7.7, 10.1, 3, 4.1}
+1) \tplexe{nn.sorted.filter{idx<5}.med} \par
+2) \edef\foo{\tplexe{nn.sorted.filter{idx<5}.med}}\meaning\foo/
+
+On charge ce package hors \LaTeX{} par
+\code|\input tuple.tex|
+et sous \LaTeX{} par
+\code|\usepackage{tuple}|
+
+Ce package ne s'appuie sur aucun autre si ce n'est le module de \LaTeX3 «\texttt{l3fp}», qui fait désormais partie du noyau \LaTeX{}, pour notamment tirer parti de sa puissante macro \verb|\fpeval|.
+
+Si l'on n'utilise pas \LaTeX{}, \tpl{} va charger le fichier \texttt{expl3-generic.tex} afin de disposer du module \texttt{l3fp}.
+
+\section{Déclarer un objet tuple}
+La macro \verb|\newtuple{<nom>}{<liste de nombres>}| permet de construire un «objet» tuple auquel on accède ensuite par son \verb|<nom>|:
+\begin{itemize}
+ \item le \verb|<nom>| admet tous les caractères alphanumériques \texttt{[az][AZ][09]}, espaces et ponctuations. Les espaces qui le précèdent ou le suivent sont supprimés. Il est également possible de mettre une macro\footnote{La macro ne sera jamais modifiée par le package \texttt{tuple} : en interne cette macro est détokenisée pour construire le nom plus complexe d'une macro.}.
+ \item les nombres composant la \verb|<liste de nombres>| s'entendent au sens du module \texttt{l3fp}, c'est-à-dire qu'ils couvrent une plage beaucoup plus étendue et disposent d'une précision très supérieure aux nombres décimaux (pris au sens de dimensions) de \TeX{} (voir la \href{http://mirrors.ctan.org/macros/latex/required/l3kernel/interface3.pdf}{documentation} de \LaTeX3{}, chapitre \texttt{l3fp}) ;
+ \item la \verb|<liste de nombres>| est développée au maximum puis détokénisée avant d'être exploitée par le constructeur de l'objet tuple. Les éléments vides sont ignorés.
+\end{itemize}
+
+Il est possible de définir un tuple vide (c'est-à-dire ne contenant donc aucun nombre), mais beaucoup de méthodes renverront une erreur si elles sont exécutées sur une liste vide.
+
+Il est en revanche impossible de redéfinir un tuple déjà existant (il faut pour cela passer par la méthode \texttt{store}).
+
+\section{Les méthodes}
+Pour exécuter des méthodes sur un tuple, on doit utiliser la syntaxe
+\code|\tplexe{<nom du tuple>.<méthode 1>.<méthode 2>...<méthode n>}|
+Aucun espace entre le «\verb-.-» et le nom d'une méthode n'est admis. Il est donc illicite d'écrire «\verb*|. sorted|».
+
+Il existe 3 types de donnés pour le package \tpl{} :
+\begin{enumerate}
+ \item les nombres (et les données affichables) ;
+ \item les objets « tuples »;
+ \item le type « stockage » qui caractérise des méthodes non développables effectuant des assignations.
+\end{enumerate}
+
+Toutes les méthodes de ce package admettent en entrée un tuple (qui est le résultat des méthodes précédentes) et renvoient un résultat dont le type détermine à quel groupe appartient la méthode :
+\begin{itemize}
+ \item groupe 1 «\texttt{tuple} $\longrightarrow$ \texttt{nombre}»;
+ \item groupe 2 «\texttt{tuple} $\longrightarrow$ \texttt{tuple}». Les méthodes de ce groupe \emph{ne modifient pas} le tuple initial\footnote{Elles ne le peuvent pas sinon, elles perdraient leur caractère développable !}, elles agissent sur un tuple temporaire qu'il est évidemment possible de sauvegarder avec une méthode du groupe ci-dessous;
+ \item groupe 3 «\texttt{tuple} $\longrightarrow$ \texttt{stockage}»;
+\end{itemize}
+
+La macro \verb|\tplexe| et son argument forment un tout purement développable, sous réserve que les méthodes invoquées ne soient pas dans le groupe «\texttt{tuple} $\longrightarrow$ \texttt{stockage}».
+
+Si aucune méthode n'est spécifiée, une méthode générique implicite du groupe «\texttt{tuple} $\longrightarrow$ \texttt{nombre}», est exécutée et renvoie le tuple sous forme affichable.
+\exemple/%\newtuple{nn}{12.7, 6.3, 11.7, 2.9, 5.5, 8.1, 4.3, 9.4,
+% 13.6, 2.9, 6.9, 11.2, 5.1, 7.7, 10.1, 3, 4.1}%
+\tplexe{nn}/
+
+\section{Les méthodes du groupe \texttt{tuple} $\longrightarrow$ \texttt{nombre}}
+\subsection{Les méthodes \texttt{len}, \texttt{sum}, \texttt{min}, \texttt{max}, \texttt{mean}, \texttt{med} et \texttt{stdev}}
+Toutes ces méthodes n'admettent pas d'argument et renvoient respectivement le nombre d'éléments, leur somme, le minimum, le maximum, la moyenne, la médiane et l'écart-type.
+
+\exemple/%\newtuple{nn}{12.7, 6.3, 11.7, 2.9, 5.5, 8.1, 4.3, 9.4,
+% 13.6, 2.9, 6.9, 11.2, 5.1, 7.7, 10.1, 3, 4.1}%
+1) len = \tplexe{nn.len}\par
+2) sum = \tplexe{nn.sum}\par
+3) min = \tplexe{nn.min}\par
+4) max = \tplexe{nn.max}\par
+5) mean = \tplexe{nn.mean}\par
+5) med = \tplexe{nn.med}\par
+6) stdev = \tplexe{nn.stdev}/
+
+\subsection{La méthode \texttt{quantile}}
+Cette méthode a pour syntaxe
+\code|quantile{<p>}|
+où \verb|<p>| doit être un nombre compris entre 0 et 1. La méthode renvoie le quantile correspondant à l'argument \verb|<p>|. La méthode utilisée est celle de la moyenne pondérée\footnote{Si $p$ est l'argument de la méthode, on définit $h=(n-1)p+1$ où $n$ est la longueur du tuple.\par La méthode renvoie le nombre égal à $x_{\lfloor h\rfloor}+(h-\lfloor h\rfloor)(x_{\lfloor h\rfloor}+x_{\lceil h\rceil})$, où $x_k$ est le $k$\ieme{} nombre du tuple ordonné.} ; il s'agit de l'interpolation linéaire du type «R7» décrite dans l'article de \href{https://en.wikipedia.org/wiki/Quantile}{wikipedia}.
+
+\exemple/%\newtuple{nn}{12.7, 6.3, 11.7, 2.9, 5.5, 8.1, 4.3, 9.4,
+% 13.6, 2.9, 6.9, 11.2, 5.1, 7.7, 10.1, 3, 4.1}%
+1) \tplexe{nn.quantile{0.25}}\par
+2) \tplexe{nn.quantile{0.5}}\par
+2) \tplexe{nn.quantile{0.75}}\par/
+
+La méthode \verb|quantile{0.5}| est équivalente à la méthode \verb|med|.
+\medbreak
+Il est important de noter que les espaces avant/après les arguments d'une méthode sont ignorés. Il est donc licite d'écrire \verb*|.quantile {0.5} |.
+
+\subsection{La méthode \texttt{get}}
+Cette méthode a pour syntaxe
+\code|get{<index>}|
+
+Le premier index est 0 et le dernier est $n-1$ où $n$ est le nombre d'éléments du tuple. Par conséquent, l'argument de \texttt{get} doit être entre 0 et $n-1$ sans quoi une erreur de compilation sera renvoyée.
+
+\exemple|%\newtuple{nn}{12.7, 6.3, 11.7, 2.9, 5.5, 8.1, 4.3, 9.4,
+% 13.6, 2.9, 6.9, 11.2, 5.1, 7.7, 10.1, 3, 4.1}%
+1er élément : \tplexe{nn.get{0}}\par
+13e élément : \tplexe{nn.get{12}}\par
+dernier élément : \tplexe{nn.get{\tplexe{nn.len}-1}}|
+
+L'argument de \texttt{get} est évalué avant d'être exploité : il est donc possible d'y mettre la macro purement développable \verb|\tplexe| avec une méthode finale renvoyant un nombre entier.
+
+\subsection{La méthode \texttt{pos}}
+Cette méthode a pour syntaxe
+\code|pos{<nombre>}|
+et renvoie l'index de la première occurrence du \verb|<nombre>| dans le tuple. Si le tuple ne contient pas le \verb|<nombre>|, \verb|-1| est renvoyé.
+
+\exemple|%\newtuple{nn}{12.7, 6.3, 11.7, 2.9, 5.5, 8.1, 4.3, 9.4,
+% 13.6, 2.9, 6.9, 11.2, 5.1, 7.7, 10.1, 3, 4.1}%
+index de 12.7 : \tplexe{nn.pos{12.7}}\par
+index de 2.9 : \tplexe{nn.pos{2.9}}\par
+index de 31.8 : \tplexe{nn.pos{31.8}}|
+
+\subsection{La méthode \texttt{show}}
+Cette méthode n'admet pas d'argument et a pour but de convertir un objet tuple en résultat affichable. Pour ce faire :
+\begin{itemize}
+ \item pour chaque élément, la macro publique \verb|\tplformat|, admettant 2 arguments obligatoires, est exécutée. Le premier argument transmis est l'index de l'élément et le 2\ieme{} argument est l'élément lui-même ;
+ \item chaque résultat issu de la macro \verb|\tplformat| est séparé du suivant par le contenu de la macro \verb|\tplsep|.
+\end{itemize}
+
+Par défaut, ces deux macros ont le code suivant :
+\begin{verbatim}
+\def\tplformat#1#2{#2}% #1=index en cours #2=item en cours
+\def\tplsep{, }
+\end{verbatim}
+
+Le comportement par défaut est donc exactement le même que la méthode implicite qui est exécutée en dernier, et en particulier, la méthode est purement développable.
+
+\exemple/%\newtuple{nn}{12.7, 6.3, 11.7, 2.9, 5.5, 8.1, 4.3, 9.4,
+% 13.6, 2.9, 6.9, 11.2, 5.1, 7.7, 10.1, 3, 4.1}%
+\tplexe{nn.show}/
+
+On peut reprogrammer ces 2 macros pour créer une mise en forme plus évoluée. On utilise ici la macro \verb|\tplfpcompare| qui est alias de la macro \verb|\fp_compare:nNnTF| du module \texttt{l3fp}, pour comparer un élément à une valeur donnée. Dans les 2 exemples donnés ci-dessous, la méthode n'est plus purement développable à cause de l'utilisation des macros \verb|\fbox| et \verb|\textcolor|.
+
+Mise dans une boite des 10 premiers éléments :
+\exemple/%\newtuple{nn}{12.7, 6.3, 11.7, 2.9, 5.5, 8.1, 4.3, 9.4,
+% 13.6, 2.9, 6.9, 11.2, 5.1, 7.7, 10.1, 3, 4.1}%
+\def\tplformat#1#2{\ifnum#1<10 \fbox{#2}\else#2\fi}
+\tplexe{nn.show}/
+
+Mise en rouge des éléments inférieurs à la moyenne :
+\exemple/%\newtuple{nn}{12.7, 6.3, 11.7, 2.9, 5.5, 8.1, 4.3, 9.4,
+% 13.6, 2.9, 6.9, 11.2, 5.1, 7.7, 10.1, 3, 4.1}%
+\edef\nnmean{\tplexe{nn.mean}}%
+\def\tplformat#1#2{\tplfpcompare{#2}<{\nnmean}
+ {\textcolor{red}{#2}}
+ {#2}%
+}%
+\def\tplsep{~; }%
+\tplexe{nn.show}/
+
+\section{Les méthodes du groupe \texttt{tuple} $\longrightarrow$ \texttt{tuple}}
+Chaque fois qu'un tuple est généré ou modifié, ses méthodes \texttt{len}, \texttt{sum}, \texttt{min}, \texttt{max}, \texttt{mean}, \texttt{med}, \texttt{stdev} et \texttt{sorted} sont mises à jour.
+\subsection{La méthode \texttt{sorted}}
+Cette méthode n'admet pas d'argument et retourne un objet tuple avec ses éléments rangés dans l'ordre croissant.
+
+\exemple|%\newtuple{nn}{12.7, 6.3, 11.7, 2.9, 5.5, 8.1, 4.3, 9.4,
+% 13.6, 2.9, 6.9, 11.2, 5.1, 7.7, 10.1, 3, 4.1}%
+\tplexe{nn.sorted}|
+
+\subsection{La méthode \texttt{set}}
+Cette méthode a pour syntaxe
+\code|set{<index1>:<nombre1>,<index2>:<nombre2>,...}|
+Dans le tuple issu des méthodes précédentes, remplace le nombre à l'\verb|<index1>| par \verb|<nombre1>| et ainsi de suite si plusieurs assignations sont spécifiées dans une liste séparée par des virgules.
+
+Chaque \verb|<index>| doit être compris entre 0 et $n-1$, où $n$ est le nombre d'élément du tuple passé en entrée de la méthode.
+
+\exemple|%\newtuple{nn}{12.7, 6.3, 11.7, 2.9, 5.5, 8.1, 4.3, 9.4,
+% 13.6, 2.9, 6.9, 11.2, 5.1, 7.7, 10.1, 3, 4.1}%
+\tplexe{nn.set{1:10,5:50}}|
+
+\subsection{La méthode \texttt{add}}
+Cette méthode, qui ajoute une \verb|<insertion>| à un ou plusieurs index spécifiés, a pour syntaxe
+\code|add{<index1>:<insertion1>,<index2>:<insertion2>,...}|
+
+Il faut noter que dans cette syntaxe, une \verb|<insertion>| peut être
+\begin{itemize}
+ \item un nombre seul «\verb|add{<index>:<nombre>}|»
+ \item une liste csv de nombres qui \emph{doit} être entre accolades «\verb|add{<index>:{n1,n2,n3...}}|»
+ \item un tuple auquel on accède par \verb|\tplexe| : «\verb|add{<index>:{\tplexe{<nom tuple>}}}|».
+\end{itemize}
+
+En ce qui concerne les \verb|<index>| :
+\begin{itemize}
+ \item si un \verb|<index>| est inférieur à 0, il est compris comme étant 0 ;
+ \item si un \verb|<index>| est «\verb|*|» ou supérieur à $n-1$, l'\verb|<insertion>| est placée à la fin du tuple passé en entrée ;
+ \item les \verb|<index>| \emph{ne sont pas} recalculés après chaque \verb|<insertion>|, mais seulement après la dernière. Il n'est donc pas équivalent d'écrire «\verb|.add{1:10,5:50}|» et «\verb|.add{1:10}.add{5:50}|. En effet, 5 sera à l'index 6 dans le premier cas alors qu'il sera à l'index 5 dans le second.
+\end{itemize}
+
+\exemple|%\newtuple{nn}{12.7, 6.3, 11.7, 2.9, 5.5, 8.1, 4.3, 9.4,
+% 13.6, 2.9, 6.9, 11.2, 5.1, 7.7, 10.1, 3, 4.1}%
+1) ajout en 1er : \tplexe{nn.add{0:{666,667}}}\par
+2) ajout index 16 : \tplexe{nn.add{16:{666,667}}}\par
+3) ajout en dernier : \tplexe{nn.add{*:{666,667}}}|
+
+\exemple|\newtuple{X}{10,20,30,40,50,60}%
+\newtuple{Y}{1,2,3,4}%
+1) \tplexe{X.add{-3:{\tplexe{Y}}}}\par
+2) \tplexe{X.add{1:1000,3:{\tplexe{Y}}}}\par
+3) \tplexe{X.add{1:1000}.add{3:{\tplexe{Y}}}}|
+
+\subsection{La méthode \texttt{op}}
+Cette méthode, qui effectue une \verb|<opération>| sur tous les éléments du tuple, a pour syntaxe
+\code|op{<opération>}|
+
+L'\verb|<opération>| est une expression ne contenant pas d'accolades, évaluable par \verb|\fpeval| une fois que toutes les occurrences de «\texttt{val}» aient été remplacées par la valeur de chaque élément, et toutes les occurrences de «\texttt{idx}» par son index.
+
+\exemple|\newtuple{X}{10,20,30,40,50,60}%
+1) \tplexe{X.op{val+5}}\par
+2) \tplexe{X.op{val*val}}\par
+3) \tplexe{X.op{val+idx}}\par
+4) \tplexe{X.op{idx<4 ? val-1 : val+1 }}|
+
+\subsection{La méthode \texttt{filter}}
+Cette méthode, qui sélectionne certains éléments selon un ou plusieurs critères, a pour syntaxe
+\code|filter{<test>}|
+et où \verb|<test>| est un booléen ne contenant pas d'accolades, évaluable par \verb|\fpeval| une fois que toutes les occurrences de «\texttt{val}» aient été remplacées par la valeur de chaque élément, et toutes les occurrences de «\texttt{idx}» par son index.
+
+\exemple/%\newtuple{nn}{12.7, 6.3, 11.7, 2.9, 5.5, 8.1, 4.3, 9.4,
+% 13.6, 2.9, 6.9, 11.2, 5.1, 7.7, 10.1, 3, 4.1}%
+1) \tplexe{nn.filter{val<10}}\par
+2) \tplexe{nn.filter{val>5 && val<10}}\par
+3) \tplexe{nn.filter{idx<3 || idx>13}}\par
+4) \tplexe{nn.filter{val!=6.3 && val!=2.9 && val!=4.1}}/
+
+\subsection{La méthode \texttt{comp}}
+Cette méthode compose deux tuples de même longueur avec une opération que l'utilisateur spécifie. Sa syntaxe est
+\code|comp{<opération>}{<nom tuple>}|
+où le tuple dont le nom est passé en deuxième argument \emph{doit} avoir la même longueur que le tuple passé en entrée de la méthode.
+
+L'\verb|<opération>| est une expression ne contenant pas d'accolades, évaluable par \verb|\fpeval| une fois que toutes les occurrences de «\texttt{xa}» aient été remplacées par la valeur de chaque élément du tuple d'entrée, et toutes les occurrences de «\texttt{xb}» par celle du tuple spécifié en 2\ieme{} argument.
+
+Produit de 2 tuples et leur «\texttt{somprod}» :
+\exemple/\newtuple{A}{2,-4,3,7,-1}%
+\newtuple{B}{-9,0,4,6,-2}%
+produit : \tplexe{A.comp{xa*xb}{B}}\par
+somprod : \tplexe{A.comp{xa*xb}{B}.sum}/
+
+Calcul de la plus petite distance au point A(2.5 ; -0.5) connaissant la liste des abscisses et la liste des ordonnées d'une trajectoire (ici elliptique) :
+\exemple/\newtuple{ListX}{4,2,0.5,1,3,6.5}%
+\newtuple{ListY}{2,1.5,0,-1.5,-2,0.5}%
+\tplexe{ListX.comp{sqrt((xa-2.5)**2+(xb+0.5)**2)}{ListY}.min}/
+
+\section{Les méthodes du groupe \texttt{tuple} $\longrightarrow$ \texttt{stockage}}
+Comme ces méthodes ne renvoient pas un résultat puisqu'elles effectuent une assignation, elle ne sont pas développables, et \emph{doivent} se trouver en dernière position. Si ce n'est pas le cas, toutes les méthodes qui les suivent seront ignorées.
+
+\subsection{La méthode \texttt{split}}
+Cette méthode coupe le tuple passé en entré à la méthode après l'index spécifié. La syntaxe est
+\code|split{<index>}{<tuple1>}{<tuple2>}|
+Le tuple passé en entrée de la méthode est coupé après l'\verb|<index>| : la partie avant la coupure est assignée, via \verb|\newtuple| au tuple de nom «\texttt{tuple1}» et la partie restant au tuple de nom «\texttt{tuple2}». Aucune vérification n'est faite sur l'existence des 2 tuples ; il est donc possible de remplacer silencieusement des tuples existants.
+
+L'\verb|<index>| doit se trouver entre 0 et $n-2$ où $n$ est le nombre d'éléments du tuple passé en entré.
+
+\exemple/%\newtuple{nn}{12.7, 6.3, 11.7, 2.9, 5.5, 8.1, 4.3, 9.4,
+% 13.6, 2.9, 6.9, 11.2, 5.1, 7.7, 10.1, 3, 4.1}%
+\tplexe{nn.split{5}{n1}{n2}}%
+tuple avant : \tplexe{n1}\par
+tuple après : \tplexe{n2}/
+
+\subsection{La méthode \texttt{store}}
+Cette macro a pour but de stocker le résultat de la dernière méthode. Si ce résultat est un tuple, la syntaxe est
+\code|store{<nom tuple>}|
+et si le résultat est un nombre ou une donnée affichable venant de la méthode \texttt{show} :
+\code|store{<macro>}|
+
+Aucune vérification n'est faite sur l'existence du tuple ou de la macro. Il est donc possible de remplacer silencieusement un tuple déjà créé ou une macro existante.
+
+\exemple|%\newtuple{nn}{12.7, 6.3, 11.7, 2.9, 5.5, 8.1, 4.3, 9.4,
+% 13.6, 2.9, 6.9, 11.2, 5.1, 7.7, 10.1, 3, 4.1}%
+1) \tplexe{nn.sorted.filter{val>11}.store{nn1}}%
+ \tplexe{nn1}\par
+2) \tplexe{nn1.len.store\nnlen}%
+ \meaning\nnlen\par
+3) \def\tplformat#1#2{\fbox{#2}}\def\tplsep{ }%
+ \tplexe{nn1.show.store\nnshow}%
+ \meaning\nnshow\par
+4) \edef\nndisp{\tplexe{nn1}}%
+ \meaning\nndisp% méthode générique
+|
+
+Pour stocker le résultat de la méthode générique, il faut utiliser \verb|\edef| car \verb|\tplexe{<tuple>.store<macro>}| est incorrect puisque dans ce cas, la méthode \texttt{store} s'applique à un tuple.
+
+\section{Génération de tuples}
+Pour générer un tuple, on peut utiliser la macro développable \verb|\gentuple| qui est destinée à être appelée dans le 2\ieme{} argument de \verb|\newtuple|. Sa syntaxe est
+\code/\gentuple{<valeurs initiales>},\genrule<règle de génération>;\while||\until<condition>}/
+où :
+\begin{itemize}
+ \item les \verb|<valeurs initiales>| sont facultatives. Si elles sont présentes, elles \emph{doivent} être suivies d'une virgule. La macro \verb|\gentuple| détermine leur nombre $i$ par comptage ($i$ devant être au plus égal à 9). Ces valeurs initiales seront recopiées en début de tuple et par la suite, ont vocation à être utilisées dans la \verb|<règle de génération>| à des fins de récurrence;
+ \item la \verb|<règle de génération>| est une expression ne contenant pas d'accolades, évaluable par \verb|\fpeval| une fois que dans les $i$ valeurs précédentes, toutes les occurrences de \verb|\1| aient été remplacées par la valeur n°1, \verb|\2| par la valeur n°2, etc. De plus, chaque occurrence de \verb|\i| est remplacée par la valeur de l'index en cours.
+ \item la \verb|<condition>| est un booléen ne contenant pas d'accolades, évaluable par \verb|\fpeval| une fois que toutes les occurrences de «\texttt{val}» aient été remplacées par la valeur de l'élément calculé, et toutes les occurrences de «\verb|\i| par son index. Si le mot-clé après \verb|;| est \verb|\while|, la boucle est du type \verb|while<condition>...endwhile| alors que si ce mot-clé est \verb|\until|, il s'agit d'une boucle \verb|repeat...until<condition>|.
+\end{itemize}
+
+Génération des 10 premiers entiers pairs :
+\exemple|\gentuple{\genrule (\i+1)*2 ; \until \i=9 }\par
+ou\par
+\gentuple{\genrule (\i+1)*2 ; \while \i<10 }|
+
+Génération de 15 entiers aléatoires entre 1 et 10 :
+\exemple|\gentuple{\genrule randint(1,10) ; \until \i=14 }|
+
+Génération des carrés d'entiers jusqu'à 500 :
+\exemple|\gentuple{\genrule\i*\i; \while val<500 }|
+
+Génération des 10 premiers termes la suite de Fibonacci :
+\exemple|\gentuple{1,1,\genrule\1+\2; \until \i=9 }|
+
+Génération des 10 premiers termes de $u_0=1$ ; $u_1=1$ ; $u_2=-1$ et $u_{n}=u_{n-3}u_{n-1}-u^2_{n-2}$ :
+\exemple|\gentuple{1,1,-1,\genrule\1*\3-\2*\2; \until \i=10}|
+
+Génération de la suite de Syracuse (connue aussi comme «suite $3n+1$») de 15 :
+\exemple|\edef\syr{%
+ \gentuple{15,\genrule \1/2=trunc(\1/2) ? \1/2 : 3*\1+1 ; \until val=1}%
+}%
+\meaning\syr|
+
+Altitude maximale et longueur de la suite de Syracuse de 27 :
+\exemple|\newtuple{syr27}
+ {\gentuple{27,\genrule \1/2=trunc(\1/2) ? \1/2 : 3*\1+1 ; \until val=1}}%
+longueur = \tplexe{syr27.len}\par
+alt max = \tplexe{syr27.max}|
+
+\section{Conclusion}
+\subsection{Motivation}
+D'une façon un peu étonnante, assez peu de choses existent pour manipuler et opérer sur des listes de nombres\footnote{Il y a bien un package \texttt{commalists-tools}, mais il est clairement trop limité. Comme tous les packages de son auteur qui floode le CTAN, il ne fait qu'aligner \emph{ad nauseam}, linéairement et sans véritable programmation, les macros de haut niveau des packages \texttt{tikz}, \texttt{listofitems}, \texttt{xstring}, \texttt{xint} et \texttt{simplekv}.% Que pourrait-on conseiller à cet auteur ? De privilégier la qualité à la quantité ? Progresser en programmation et ne pas rester at vitam eternam à ce niveau basique affligeant et sans grand intérêt ? De penser à ce qu'il adviendrait (spoiler : le CTAN exploserait !) si tous les utilisteurs de \LaTeX{} se mettaient à pondre un package compulsivement chaque fois qu'ils ont réussi à combiner entre-elles des macros d'autres packages ?
+}.
+
+Le principal défi a surtout été d'offrir des macros développables et aussi une syntaxe originale dans le monde de \TeX{} du type \verb|<objet>.<méthode 1>.<méthode 2>...<méthode n>|, où l'on peut enchainer les méthodes exécutées sur un «objet» qui est un tuple de nombres. J'ignore si des packages proposent ce genre de syntaxe, mais elle est finalement assez intuitive. Comme je suis assez peu familier avec la programmation de macros purement développables, j'ai voulu de nombreuses fois renoncer. Mais j'ai fini par trouver un trou de souris qui permet que le tout fonctionne à peu près, à l'exception des nombreux bugs qui doivent encore se cacher un peu partout.
+
+Je remercie ceux qui en trouvent de me le signaler par email, voire même de proposer de nouvelles fonctionnalités.
+
+\subsection{Vitesse d'exécution}
+Lorsqu'on met un pied dans l'optimisation de la vitesse d'exécution, surtout de macros purement développables, on n'en ressort pas ! C'est un puits sans fond de questionnements sur les arguments des macros, sur des petites ---~ou grosses~--- astuces qui font gagner du temps, et un casse tête sur la façon de jongler avec les arguments délimités et les retrouver ensuite !
+
+J'espère ne pas être tombé dans ce piège, car j'y suis à peine entré. De toutes façons, \TeX{} n'est pas fait pour du calcul massif, car c'est avant tout un logiciel de composition. Pour le calcul, des outils performants qui battent \TeX{} à plate couture existent à foison.
+
+Quoiqu'il en soit, «macro développable» va un peu à l'encontre de «vitesse d'exécution». À titre d'information, je mets ci-dessous les temps de compilation, en secondes, de la création de tuples contenant $n$ entiers aléatoires. Cela dépend de l'ordinateur utilisé, bien sûr, mais les ordres de grandeur sont bien révélateurs. On voit clairement qu'il est illusoire de dépasser le millier de nombres car le temps de création d'un tuple croit ensuite rapidement\footnote{Sans compter que le tuple est immédiatement recréé et recalculé après avoir été modifié par les méthodes \texttt{set}, \texttt{add}, \texttt{op}, \texttt{filter}, \texttt{split} et \texttt{comp}}. Ceci dit, qui utiliserait \TeX{} pour des calculs sur autant de nombres ?
+\begin{center}
+\begin{tabular}{|c|c|}\hline
+ Nombre d'éléments $n$ & Durée de \verb|\newtuple| en s\\\hline
+ 50 & 0,011\\\hline
+ 100 & 0,026\\\hline
+ 500 & 0,224\\\hline
+ 1000 & 0,703\\\hline
+ 1500 & 1,727\\\hline
+ 2000 & 2,876\\\hline
+ 5000 & 22,907\\\hline
+\end{tabular}
+\end{center}
+
+\subsection{Exemple : population des états}
+Le tuple \verb|\Wpop| contient la population de chaque état dans le monde, en millions d'habitants\footnote{Les données proviennent de \href{https://www.unfpa.org/data/world-population-dashboard}{https://www.unfpa.org/data/world-population-dashboard}} :
+\exemple/\newtuple\Wpop{
+43.4, 2.8, 46.3, 37.8, 0.1, 46.1, 2.8, 0.1, 26.7, 9.0, 10.5, 0.4, 1.5,
+174.7, 0.3, 9.5, 11.7, 0.4, 14.1, 0.8, 12.6, 3.2, 2.7, 217.6, 0.5, 6.6,
+23.8, 13.6, 0.6, 17.1, 29.4, 39.1, 5.9, 18.8, 19.7, 1425.2, 7.5, 0.7,
+52.3, 0.9, 6.2, 5.2, 29.6, 4.0, 11.2, 0.2, 1.3, 10.5, 26.2, 105.6, 5.9,
+1.2, 0.1, 11.4, 18.4, 114.5, 6.4, 1.8, 3.8, 1.3, 1.2, 129.7, 0.9, 5.5,
+64.9, 0.3, 0.3, 2.5, 2.8, 3.7, 83.3, 34.8, 10.3, 0.1, 0.4, 0.2, 18.4,
+14.5, 2.2, 0.8, 11.9, 10.8, 10.0, 0.4, 1441.7, 279.8, 89.8, 46.5, 5.1,
+9.3, 58.7, 2.8, 122.6, 11.4, 19.8, 56.2, 0.1, 4.3, 6.8, 7.7, 1.8, 5.2,
+2.4, 5.5, 7.0, 2.7, 0.7, 31.1, 21.5, 34.7, 0.5, 24.0, 0.5, 0.4, 5.0,
+1.3,129.4, 0.1, 3.5, 0.6, 38.2, 34.9, 55.0, 2.6, 31.2, 17.7, 0.3, 5.3,
+7.1,28.2, 229.2, 2.1, 5.5, 4.7, 245.2, 4.5, 10.5, 6.9, 34.7, 119.1,
+40.2,10.2, 3.3, 2.7, 51.7, 3.3, 1.0, 19.6, 144.0, 14.4, 0.0, 0.2, 0.1,
+0.2,0.03, 0.2, 37.5, 18.2, 7.1, 0.1, 9.0, 6.1, 0.0, 5.7, 2.1, 0.8, 18.7,
+61.0,11.3, 47.5, 21.9, 5.5, 49.4, 0.6, 10.7, 8.9, 24.3, 10.3, 71.9, 1.4,
+9.3,0.1, 1.5, 12.6, 86.3, 6.6, 0.0, 0.0, 49.9, 37.9, 9.6, 68.0, 69.4,
+341.8,0.1, 3.4, 35.7, 0.3, 29.4, 99.5, 0.6, 35.2, 21.1, 17.0}
+Nombre : \tplexe{\Wpop.len}\par
+Moyenne : \tplexe{\Wpop.mean}\par
+Médiane : \tplexe{\Wpop.med}\par
+Écart type : \tplexe{\Wpop.stdev}\par
+Quintile \#1 : \tplexe{\Wpop.quantile{0.2}}\par
+Quintile \#4 : \tplexe{\Wpop.quantile{0.8}}/
+\newtuple\Wpop{
+43.4, 2.8, 46.3, 37.8, 0.1, 46.1, 2.8, 0.1, 26.7, 9.0, 10.5, 0.4, 1.5,
+174.7, 0.3, 9.5, 11.7, 0.4, 14.1, 0.8, 12.6, 3.2, 2.7, 217.6, 0.5, 6.6,
+23.8, 13.6, 0.6, 17.1, 29.4, 39.1, 5.9, 18.8, 19.7, 1425.2, 7.5, 0.7,
+52.3, 0.9, 6.2, 5.2, 29.6, 4.0, 11.2, 0.2, 1.3, 10.5, 26.2, 105.6, 5.9,
+1.2, 0.1, 11.4, 18.4, 114.5, 6.4, 1.8, 3.8, 1.3, 1.2, 129.7, 0.9, 5.5,
+64.9, 0.3, 0.3, 2.5, 2.8, 3.7, 83.3, 34.8, 10.3, 0.1, 0.4, 0.2, 18.4,
+14.5, 2.2, 0.8, 11.9, 10.8, 10.0, 0.4, 1441.7, 279.8, 89.8, 46.5, 5.1,
+9.3, 58.7, 2.8, 122.6, 11.4, 19.8, 56.2, 0.1, 4.3, 6.8, 7.7, 1.8, 5.2,
+2.4, 5.5, 7.0, 2.7, 0.7, 31.1, 21.5, 34.7, 0.5, 24.0, 0.5, 0.4, 5.0,
+1.3,129.4, 0.1, 3.5, 0.6, 38.2, 34.9, 55.0, 2.6, 31.2, 17.7, 0.3, 5.3,
+7.1,28.2, 229.2, 2.1, 5.5, 4.7, 245.2, 4.5, 10.5, 6.9, 34.7, 119.1,
+40.2,10.2, 3.3, 2.7, 51.7, 3.3, 1.0, 19.6, 144.0, 14.4, 0.0, 0.2, 0.1,
+0.2,0.03, 0.2, 37.5, 18.2, 7.1, 0.1, 9.0, 6.1, 0.0, 5.7, 2.1, 0.8, 18.7,
+61.0,11.3, 47.5, 21.9, 5.5, 49.4, 0.6, 10.7, 8.9, 24.3, 10.3, 71.9, 1.4,
+9.3,0.1, 1.5, 12.6, 86.3, 6.6, 0.0, 0.0, 49.9, 37.9, 9.6, 68.0, 69.4,
+341.8,0.1, 3.4, 35.7, 0.3, 29.4, 99.5, 0.6, 35.2, 21.1, 17.0}
+
+On modifie \verb|\Wpop|, en ne retenant que les états «moyennement» peuplés. On considère arbitrairement leur population entre 10 et 100 millions d'habitants :
+\exemple/\tplexe{\Wpop.filter{val>=10 && val<=100}.store\Wpop}%
+Nombre : \tplexe{\Wpop.len}\par
+Moyenne : \tplexe{\Wpop.mean}\par
+Médiane : \tplexe{\Wpop.med}\par
+Écart type : \tplexe{\Wpop.stdev}\par
+Quintile \#1 : \tplexe{\Wpop.quantile{0.2}}\par
+Quintile \#4 : \tplexe{\Wpop.quantile{0.8}}
+
+Répartition sur 6 intervalles égaux :\par
+\begin{tabular}{lc}\\\hline
+ De 10 à 25 & \tplexe{\Wpop.filter{val<25}.len}\\
+ De 25 à 40 & \tplexe{\Wpop.filter{val>=25 && val<40}.len}\\
+ De 40 à 55 & \tplexe{\Wpop.filter{val>=40 && val<55}.len}\\
+ De 55 à 70 & \tplexe{\Wpop.filter{val>=55 && val<70}.len}\\
+ De 70 à 85 & \tplexe{\Wpop.filter{val>=70 && val<85}.len}\\
+ De 85 à 100& \tplexe{\Wpop.filter{val>=85}.len}\\\hline
+\end{tabular}/
+
+\subsection{TODO list}
+À implémenter plus ou moins rapidement :
+\begin{enumerate}
+ \item permettre à l'utilisateur de choisir \texttt{l3fp} ou \texttt{xint} comme moteur de calcul ;
+ \item utiliser le tri par insertion pour trier les tuples presque triés obtenus suite aux méthodes \texttt{add}, \texttt{set}, \texttt{op} (risqué car dépend de l'opération !)
+ \item utiliser le tri fusion pour ajouter un tuple à un autre ;
+ \item autres optimisation de la rapidité ?
+\end{enumerate}
+\end{document} \ No newline at end of file