summaryrefslogtreecommitdiff
path: root/Master/texmf-dist/source/latex/expl3/l3int.dtx
diff options
context:
space:
mode:
Diffstat (limited to 'Master/texmf-dist/source/latex/expl3/l3int.dtx')
-rw-r--r--Master/texmf-dist/source/latex/expl3/l3int.dtx2453
1 files changed, 0 insertions, 2453 deletions
diff --git a/Master/texmf-dist/source/latex/expl3/l3int.dtx b/Master/texmf-dist/source/latex/expl3/l3int.dtx
deleted file mode 100644
index 4bb794a4b82..00000000000
--- a/Master/texmf-dist/source/latex/expl3/l3int.dtx
+++ /dev/null
@@ -1,2453 +0,0 @@
-% \iffalse
-%% File: l3int.dtx Copyright (C) 1990-2011 LaTeX3 project
-%%
-%% It may be distributed and/or modified under the conditions of the
-%% LaTeX Project Public License (LPPL), either version 1.3c of this
-%% license or (at your option) any later version. The latest version
-%% of this license is in the file
-%%
-%% http://www.latex-project.org/lppl.txt
-%%
-%% This file is part of the ``expl3 bundle'' (The Work in LPPL)
-%% and all files in that bundle must be distributed together.
-%%
-%% The released version of this bundle is available from CTAN.
-%%
-%% -----------------------------------------------------------------------
-%%
-%% The development version of the bundle can be found at
-%%
-%% http://www.latex-project.org/svnroot/experimental/trunk/
-%%
-%% for those people who are interested.
-%%
-%%%%%%%%%%%
-%% NOTE: %%
-%%%%%%%%%%%
-%%
-%% Snapshots taken from the repository represent work in progress and may
-%% not work or may contain conflicting material! We therefore ask
-%% people _not_ to put them into distributions, archives, etc. without
-%% prior consultation with the LaTeX Project Team.
-%%
-%% -----------------------------------------------------------------------
-%
-%<*driver|package>
-\RequirePackage{l3names}
-%</driver|package>
-%\fi
-\GetIdInfo$Id: l3int.dtx 2229 2011-04-11 17:37:05Z joseph $
- {L3 Experimental Integer module}
-%\iffalse
-%<*driver>
-%\fi
-\ProvidesFile{\filename.\filenameext}
- [\filedate\space v\fileversion\space\filedescription]
-%\iffalse
-\documentclass[full]{l3doc}
-\begin{document}
-\DocInput{l3int.dtx}
-\end{document}
-%</driver>
-% \fi
-%
-%
-% \title{The \textsf{l3int} package\thanks{This file
-% has version number \fileversion, last
-% revised \filedate.}\\
-% Integers/counters}
-% \author{\Team}
-% \date{\filedate}
-% \maketitle
-%
-% \begin{documentation}
-%
-%\section{Integer values}
-%
-%
-% Calculation and comparison of integer values can be carried out
-% using literal numbers, \texttt{int} registers, constants and
-% integers stored in token list variables. The standard operators
-% \texttt{+}, \texttt{-}, \texttt{/} and \texttt{*} and
-% parentheses can be used within such expressions to carry
-% arithmetic operations. This module carries out these functions
-% on \emph{integer expressions} (`\texttt{int expr}').
-%
-%\subsection{Integer expressions}
-%
-%\begin{function}{
-% \int_eval:n / (EXP) |
-%}
-% \begin{syntax}
-% \cs{int_eval:n} \Arg{integer expression}
-% \end{syntax}
-% Evaluates the \meta{integer expression}, expanding any
-% integer and token list variables within the \meta{expression}
-% to their content (without requiring \cs{int_use:N}/\cs{tl_use:N})
-% and applying the standard mathematical rules. For example both
-% \begin{verbatim}
-% \int_eval:n { 5 + 4 * 3 - ( 3 + 4 * 5 ) }
-% \end{verbatim}
-% and
-% \begin{verbatim}
-% \tl_new:N \l_my_tl
-% \tl_set:Nn \l_my_tl { 5 }
-% \int_new:N \l_my_int
-% \int\set:Nn \l_my_int { 4 }
-% \int_eval:n { \l_my_tl + \l_my_int * 3 - ( 3 + 4 * 5 ) }
-% \end{verbatim}
-% both evaluate to \( -6 \). The \Arg{integer expression} may
-% contain the operators \texttt{+}, \texttt{-}, \texttt{*} and
-% \texttt{/}, along with parenthesis \texttt{(} and \texttt{)}.
-% After two expansions, \cs{int_eval:n} yields a
-% \meta{integer donation} which is left in the input stream. This is
-% \emph{not} an \meta{internal integer}, and therefore requires
-% suitable termination if used in a \TeX-style integer assignment.
-%\end{function}
-%
-%\begin{function}{
-% \int_abs:n / (EXP) |
-%}
-% \begin{syntax}
-% \cs{int_abs:n} \Arg{integer expression}
-% \end{syntax}
-% Evaluates the \meta{integer expression} as described for
-% \cs{int_eval:n} and leaves the absolute value of the result in
-% the input stream as an \meta{integer denotation} after two
-% expansions.
-%\end{function}
-%
-%\begin{function}{ \int_div_round:nn / (EXP) }
-% \begin{syntax}
-% \cs{int_div_round:nn} \Arg{intexpr1} \Arg{intexpr2}
-% \end{syntax}
-% Evaluates the two \meta{integer expressions} as described earlier,
-% then calculates the result of dividing the first value by the
-% second, rounding any remainder. Note that division using "/"
-% is identical to this function. The result is left in the input
-% stream as a \meta{integer denotation} after two expansions.
-%\end{function}
-%
-%\begin{function}{
-% \int_div_truncate:nn / (EXP) |
-%}
-% \begin{syntax}
-% \cs{int_div_truncate:nn} \Arg{intexpr1} \Arg{intexpr2}
-% \end{syntax}
-% Evaluates the two \meta{integer expressions} as described earlier,
-% then calculates the result of dividing the first value by the
-% second, truncating any remainder. Note that division using "/"
-% rounds the result. The result is left in the input stream as a
-% \meta{integer denotation} after two expansions.
-%\end{function}
-%
-%\begin{function}{
-% \int_max:nn / (EXP) |
-% \int_min:nn / (EXP) |
-%}
-% \begin{syntax}
-% \cs{int_max:nn} \Arg{intexpr1} \Arg{intexpr2}
-% \cs{int_min:nn} \Arg{intexpr1} \Arg{intexpr2}
-% \end{syntax}
-% Evaluates the \meta{integer expressions} as described for
-% \cs{int_eval:n} and leaves either the larger or smaller value
-% in the input stream as an \meta{integer denotation} after two
-% expansions.
-%\end{function}
-%
-%\begin{function}{
-% \int_mod:nn / (EXP) |
-%}
-% \begin{syntax}
-% \cs{int_mod:nn} \Arg{intexpr1} \Arg{intexpr2}
-% \end{syntax}
-% Evaluates the two \meta{integer expressions} as described earlier,
-% then calculates the integer remainder of dividing the first
-% expression by the second. This is left in the input stream as an
-% \meta{integer denotation} after two expansions.
-%\end{function}
-%
-%\subsection{Integer variables}
-%
-%\begin{function}{
-% \int_new:N |
-% \int_new:c |
-%}
-% \begin{syntax}
-% \cs{int_new:N} \meta{integer}
-% \end{syntax}
-% Creates a new \meta{inter} or raises an error if the name is
-% already taken. The declaration is global. The \meta{integer} will
-% initially be equal to \( 0 \).
-%\end{function}
-%
-%\begin{function}{
-% \int_set_eq:NN |
-% \int_set_eq:cN |
-% \int_set_eq:Nc |
-% \int_set_eq:cc |
-%}
-% \begin{syntax}
-% \cs{int_set_eq:NN} \meta{integer1} \meta{integer 2}
-% \end{syntax}
-% Sets the content of \meta{integer1} equal to that of
-% \meta{integer 2}. This assignment is restricted to the current
-% \TeX\ group level.
-%\end{function}
-%
-%\begin{function}{
-% \int_gset_eq:NN |
-% \int_gset_eq:cN |
-% \int_gset_eq:Nc |
-% \int_gset_eq:cc |
-%}
-% \begin{syntax}
-% \cs{int_gset_eq:NN} \meta{integer1} \meta{integer2}
-% \end{syntax}
-% Sets the content of \meta{integer1} equal to that of \meta{integer2}.
-% This assignment is global and so is not limited by the current
-% \TeX\ group level.
-%\end{function}
-%
-%\begin{function}{
-% \int_add:Nn |
-% \int_add:cn |
-%}
-% \begin{syntax}
-% \cs{int_add:Nn} \meta{integer} \Arg{integer expression}
-% \end{syntax}
-% Adds the result of the \meta{integer expression} to the current
-% content of the \meta{integer}. This assignment is local.
-%\end{function}
-%
-%\begin{function}{
-% \int_gadd:Nn |
-% \int_gadd:cn |
-%}
-% \begin{syntax}
-% \cs{int_gadd:Nn} \meta{integer} \Arg{integer expression}
-% \end{syntax}
-% Adds the result of the \meta{integer expression} to the current
-% content of the \meta{integer}. This assignment is global.
-%\end{function}
-%
-%\begin{function}{
-% \int_decr:N |
-% \int_decr:c |
-%}
-% \begin{syntax}
-% \cs{int_decr:N} \meta{integer}
-% \end{syntax}
-% Decreases the value stored in \meta{integer} by \( 1 \) within
-% the scope of the current \TeX\ group.
-%\end{function}
-%
-%\begin{function}{
-% \int_gdecr:N |
-% \int_gdecr:c |
-%}
-% \begin{syntax}
-% \cs{int_incr:N} \meta{integer}
-% \end{syntax}
-% Decreases the value stored in \meta{integer} by \( 1 \) globally
-% (\emph{i.e}.~not limited by the current group level).
-%\end{function}
-%
-%\begin{function}{
-% \int_incr:N |
-% \int_incr:c |
-%}
-% \begin{syntax}
-% \cs{int_incr:N} \meta{integer}
-% \end{syntax}
-% Increases the value stored in \meta{integer} by \( 1 \) within
-% the scope of the current \TeX\ group.
-%\end{function}
-%
-%\begin{function}{
-% \int_gincr:N |
-% \int_gincr:c |
-%}
-% \begin{syntax}
-% \cs{int_incr:N} \meta{integer}
-% \end{syntax}
-% Increases the value stored in \meta{integer} by \( 1 \) globally
-% (\emph{i.e}.~not limited by the current group level).
-%\end{function}
-%
-%\begin{function}{
-% \int_set:Nn |
-% \int_set:cn |
-%}
-% \begin{syntax}
-% \cs{int_set:Nn} \meta{integer} \Arg{integer expression}
-% \end{syntax}
-% Sets \meta{integer} to the value of \meta{integer expression},
-% which must evaluate to an integer (as described for
-% \cs{int_eval:n}). This assignment is restricted to the
-% current \TeX\ group.
-%\end{function}
-%
-%\begin{function}{
-% \int_gset:Nn |
-% \int_gset:cn |
-%}
-% \begin{syntax}
-% \cs{int_gset:Nn} \meta{integer} \Arg{integer expression}
-% \end{syntax}
-% Sets \meta{integer} to the value of \meta{integer expression},
-% which must evaluate to an integer (as described for
-% \cs{int_eval:n}). This assignment is global and is not limited
-% to the current \TeX\ group level.
-%\end{function}
-%
-%\begin{function}{
-% \int_sub:Nn |
-% \int_sub:cn |
-%}
-% \begin{syntax}
-% \cs{int_sub:Nn} \meta{integer} \Arg{integer expression}
-% \end{syntax}
-% Subtracts the result of the \meta{integer expression} to the
-% current content of the \meta{integer}. This assignment is local.
-%\end{function}
-%
-%\begin{function}{
-% \int_gsub:Nn |
-% \int_gsub:cn |
-%}
-% \begin{syntax}
-% \cs{int_gsub:Nn} \meta{integer} \Arg{integer expression}
-% \end{syntax}
-% Subtracts the result of the \meta{integer expression} to the
-% current content of the \meta{integer}. This assignment is global.
-%\end{function}
-%
-%\begin{function}{
-% \int_zero:N |
-% \int_zero:c |
-%}
-% \begin{syntax}
-% \cs{int_zero:N} \meta{integer}
-% \end{syntax}
-% Sets \meta{integer} to \( 0 \) within the scope of the current
-% \TeX\ group.
-%\end{function}
-%
-%\begin{function}{
-% \int_gzero:N |
-% \int_gzero:c |
-%}
-% \begin{syntax}
-% \cs{int_gzero:N} \meta{integer}
-% \end{syntax}
-% Sets \meta{integer} to \( 0 \) globally, \emph{i.e}.~not
-% restricted by the current \TeX\ group level.
-%\end{function}
-%
-%\begin{function}{
-% \int_show:N |
-% \int_show:c |
-%}
-% \begin{syntax}
-% \cs{int_show:N} \meta{integer}
-% \end{syntax}
-% Displays the value of the \meta{integer} on the terminal.
-%\end{function}
-%
-%\begin{function}{
-% \int_use:N / (EXP) |
-% \int_use:c / (EXP) |
-%}
-% \begin{syntax}
-% \cs{int_use:N} \meta{integer}
-% \end{syntax}
-% Recovers the content of a \meta{integer} and places it directly
-% in the input stream. An error will be raised if the variable does
-% not exist or if it is invalid. Can be omitted in places where a
-% \meta{integer} is required (such as in the first and third arguments
-% of \cs{int_compare:nNnTF}).
-%\end{function}
-%
-%\subsection{Comparing integer expressions}
-%
-%\begin{function}{
-% \int_compare:nNn / (EXP) (pTF) |
-%}
-% \begin{syntax}
-% \cs{int_compare_p:nNn}
-% ~~\Arg{intexpr1} \meta{relation} \Arg{intexpr2}
-% \cs{int_compare:nNnTF}
-% ~~\Arg{intexpr1} \meta{relation} \Arg{intexpr2}
-% ~~\Arg{true code} \Arg{false code}
-% \end{syntax}
-% This function first evaluates each of the \meta{integer expressions}
-% as described for \cs{int_eval:n}. The two results are then
-% compared using the \meta{relation}:
-% \begin{center}
-% \begin{tabular}{ll}
-% Equal & "=" \\
-% Greater than & ">" \\
-% Less than & "<" \\
-% \end{tabular}
-% \end{center}
-% The branching versions then leave either \meta{true code} or
-% \meta{false code} in the input stream, as appropriate to the truth
-% of the test and the variant of the function chosen. The logical
-% truth of the test is left in the input stream by the predicate
-% version.
-%\end{function}
-%
-%\begin{function}{
-% \int_compare:n / (EXP) (pTF) |
-%}
-% \begin{syntax}
-% \cs{int_compare_p:n}
-% ~~\{ \meta{intexpr1} \meta{relation} \meta{intexpr2} \}
-% \cs{int_compare:nTF}
-% ~~\{ \meta{intexpr1} \meta{relation} \meta{intexpr2} \}
-% ~~\Arg{true code} \Arg{false code}
-% \end{syntax}
-% This function first evaluates each of the \meta{integer expressions}
-% as described for \cs{int_eval:n}. The two results are then
-% compared using the \meta{relation}:
-% \begin{center}
-% \begin{tabular}{ll}
-% Equal & "=" or "==" \\
-% Greater than or equal to & "=>" \\
-% Greater than & ">" \\
-% Less than or equal to & "=<" \\
-% Less than & "<" \\
-% Not equal & "!=" \\
-% \end{tabular}
-% \end{center}
-% The branching versions then leave either \meta{true code} or
-% \meta{false code} in the input stream, as appropriate to the truth
-% of the test and the variant of the function chosen. The logical
-% truth of the test is left in the input stream by the predicate
-% version.
-%\end{function}
-%
-%\begin{function}{
-% \int_if_even:n / (EXP) (pTF) |
-% \int_if_odd:n / (EXP) (pTF) |
-%}
-% \begin{syntax}
-% \cs{int_if_odd_p:n} \Arg{integer expression}
-% \cs{int_if_odd:nTF} \Arg{integer expression}
-% ~~\Arg{true code} \Arg{false code}
-% \end{syntax}
-% This function first evaluates the \meta{integer expression}
-% as described for \cs{int_eval:n}. It then evaluates if this
-% is odd or even, as appropriate. The branching versions then leave
-% either \meta{true code} or \meta{false code} in the input stream,
-% as appropriate to the truth of the test and the variant of the
-% function chosen. The logical truth of the test is left in the input
-% stream by the predicate version.
-%\end{function}
-%
-%\begin{function}{ \int_do_while:nNnn / (EXP) }
-% \begin{syntax}
-% \cs{int_do_while:nNnn}
-% ~~\Arg{intexpr1} \meta{relation} \Arg{intexpr2} \Arg{code}
-% \end{syntax}
-% Evaluates the relationship between the two \meta{integer expressions}
-% as described for \cs{int_compare:nNnTF}, and then places the
-% \meta{code} in the input stream if the \meta{relation} is
-% \texttt{true}. After the \meta{code} has been processed by \TeX\ the
-% test will be repeated, and a loop will occur until the test is
-% \texttt{false}.
-% \end{function}
-%
-%\begin{function}{ \int_do_until:nNnn / (EXP) }
-% \begin{syntax}
-% \cs{int_do_until:nNnn}
-% ~~\Arg{intexpr1} \meta{relation} \Arg{intexpr2} \Arg{code}
-% \end{syntax}
-% Evaluates the relationship between the two \meta{integer expressions}
-% as described for \cs{int_compare:nNnTF}, and then places the
-% \meta{code} in the input stream if the \meta{relation} is
-% \texttt{false}. After the \meta{code} has been processed by \TeX\ the
-% test will be repeated, and a loop will occur until the test is
-% \texttt{true}.
-% \end{function}
-%
-%\begin{function}{ \int_until_do:nNnn / (EXP) }
-% \begin{syntax}
-% \cs{int_until_do:nNnn}
-% ~~\Arg{intexpr1} \meta{relation} \Arg{intexpr2} \Arg{code}
-% \end{syntax}
-% Places the \meta{code} in the input stream for \TeX\ to process, and
-% then evaluates the relationship between the two
-% \meta{integer expressions} as described for \cs{int_compare:nNnTF}.
-% If the test is \texttt{false} then the \meta{code} will be inserted
-% into the input stream again and a loop will occur until the
-% \meta{relation} is \texttt{true}.
-% \end{function}
-%
-%\begin{function}{ \int_while_do:nNnn / (EXP) }
-% \begin{syntax}
-% \cs{int_while_do:nNnn} \
-% ~~\Arg{intexpr1} \meta{relation} \Arg{intexpr2} \Arg{code}
-% \end{syntax}
-% Places the \meta{code} in the input stream for \TeX\ to process, and
-% then evaluates the relationship between the two
-% \meta{integer expressions} as described for \cs{int_compare:nNnTF}.
-% If the test is \texttt{true} then the \meta{code} will be inserted
-% into the input stream again and a loop will occur until the
-% \meta{relation} is \texttt{false}.
-% \end{function}
-%
-%\begin{function}{ \int_do_while:nn / (EXP) }
-% \begin{syntax}
-% \cs{int_do_while:nNnn}
-% ~~\{ \meta{intexpr1} \meta{relation} \meta{intexpr2} \} \Arg{code}
-% \end{syntax}
-% Evaluates the relationship between the two \meta{integer expressions}
-% as described for \cs{int_compare:nTF}, and then places the
-% \meta{code} in the input stream if the \meta{relation} is
-% \texttt{true}. After the \meta{code} has been processed by \TeX\ the
-% test will be repeated, and a loop will occur until the test is
-% \texttt{false}.
-% \end{function}
-%
-%\begin{function}{ \int_do_until:nn / (EXP) }
-% \begin{syntax}
-% \cs{int_do_until:nn}
-% ~~\{ \meta{intexpr1} \meta{relation} \meta{intexpr2} \} \Arg{code}
-% \end{syntax}
-% Evaluates the relationship between the two \meta{integer expressions}
-% as described for \cs{int_compare:nTF}, and then places the
-% \meta{code} in the input stream if the \meta{relation} is
-% \texttt{false}. After the \meta{code} has been processed by \TeX\ the
-% test will be repeated, and a loop will occur until the test is
-% \texttt{true}.
-% \end{function}
-%
-%\begin{function}{ \int_until_do:nn / (EXP) }
-% \begin{syntax}
-% \cs{int_until_do:nn}
-% ~~\{ \meta{intexpr1} \meta{relation} \meta{intexpr2} \} \Arg{code}
-% \end{syntax}
-% Places the \meta{code} in the input stream for \TeX\ to process, and
-% then evaluates the relationship between the two
-% \meta{integer expressions} as described for \cs{int_compare:nTF}.
-% If the test is \texttt{false} then the \meta{code} will be inserted
-% into the input stream again and a loop will occur until the
-% \meta{relation} is \texttt{true}.
-% \end{function}
-%
-%\begin{function}{ \int_while_do:nn / (EXP) }
-% \begin{syntax}
-% \cs{int_while_do:nn} \
-% ~~\{ \meta{intexpr1} \meta{relation} \meta{intexpr2} \} \Arg{code}
-% \end{syntax}
-% Places the \meta{code} in the input stream for \TeX\ to process, and
-% then evaluates the relationship between the two
-% \meta{integer expressions} as described for \cs{int_compare:nTF}.
-% If the test is \texttt{true} then the \meta{code} will be inserted
-% into the input stream again and a loop will occur until the
-% \meta{relation} is \texttt{false}.
-% \end{function}
-%
-%\subsection{Formatting integers}
-%
-% Integers can be placed into the output stream with formatting. These
-% conversions apply to any integer expressions.
-%
-%\begin{function}{ \int_to_arabic:n / (EXP) }
-% \begin{syntax}
-% \cs{int_to_arabic:n} \Arg{integer expression}
-% \end{syntax}
-% Places the value of the \meta{integer expression} in the input
-% stream as digits, with category code \( 12 \) (other).
-%\end{function}
-%
-%\begin{function}{
-% \int_to_alph:n / (EXP) |
-% \int_to_Alph:n / (EXP) |
-%}
-% \begin{syntax}
-% \cs{int_to_alph:n} \Arg{integer expression}
-% \end{syntax}
-% Evaluates the \meta{integer expression} and converts the result
-% into a series of letters, which are then left in the input stream.
-% The conversion rule uses the \( 26 \) letters of the English
-% alphabet, in order. Thus
-% \begin{verbatim}
-% \int_to_alph:n { 1 }
-% \end{verbatim}
-% places "a" in the input stream,
-% \begin{verbatim}
-% \int_to_alph:n { 26 }
-% \end{verbatim}
-% is represented as "z" and
-% \begin{verbatim}
-% \int_to_alph:n { 27 }
-% \end{verbatim}
-% is converted to `aa'. For conversions using other alphabets, use
-% \cs{int_convert_to_symbols:nnn} to define an alphabet-specific
-% function. The basic \cs{int_to_alph:n} and \cs{int_to_Alph:n}
-% functions should not be modified.
-%\end{function}
-%
-%\begin{function}{ \int_to_binary:n / (EXP) }
-% \begin{syntax}
-% \cs{int_to_binary:n} \Arg{integer expression}
-% \end{syntax}
-% Calculates the value of the \meta{integer expression} and places
-% the binary representation of the result in the input stream.
-%\end{function}
-%
-%\begin{function}{ \int_to_hexadecimal:n / (EXP) }
-% \begin{syntax}
-% \cs{int_to_binary:n} \Arg{integer expression}
-% \end{syntax}
-% Calculates the value of the \meta{integer expression} and places
-% the hexadecimal (base~\( 16 \)) representation of the result in the
-% input stream. Upper case letters are used for digits beyond \( 9 \).
-%\end{function}
-%
-%\begin{function}{ \int_to_octal:n / (EXP) }
-% \begin{syntax}
-% \cs{int_to_octal:n} \Arg{integer expression}
-% \end{syntax}
-% Calculates the value of the \meta{integer expression} and places
-% the octal (base~\( 8 \)) representation of the result in the input
-% stream.
-%\end{function}
-%
-%\begin{function}{
-% \int_to_roman:n / (EXP) |
-% \int_to_Roman:n / (EXP) |
-%}
-% \begin{syntax}
-% \cs{int_to_roman:n} \Arg{integer expression}
-% \end{syntax}
-% Places the value of the \meta{integer expression} in the input
-% stream as Roman numerals, either lower case (\cs{int_to_roman:n})
-% or upper case (\cs{int_to_Roman:n}). The numerals are letters
-% with category code \( 11 \) (letter).
-%\end{function}
-%
-%\begin{function}{ \int_to_symbol:n / (EXP) }
-% \begin{syntax}
-% \cs{int_to_symbol:n} \Arg{integer expression}
-% \end{syntax}
-% Calculates the value of the \meta{integer expression} and places
-% the symbol representation of the result in the input stream. The
-% list of symbols used is equivalent to \LaTeXe's \cs{@fnsymbol}
-% set.
-%\end{function}
-%
-%\subsection{Converting from other formats}
-%
-%\begin{function}{ \int_from_alph:n / (EXP) }
-% \begin{syntax}
-% \cs{int_from_alpa:n} \Arg{letters}
-% \end{syntax}
-% Converts the \meta{letters} into the integer (base~\( 10 \))
-% representation and leaves this in the input stream. The
-% \meta{letters} are treated using the English alphabet only, with
-% `a' equal to \( 1 \) through to `z' equal to \( 26 \). Either lower
-% or upper case letters may be used. This is the inverse function of
-% \cs{int_to_alph:n}.
-%\end{function}
-%
-%\begin{function}{ \int_from_binary:n / (EXP) }
-% \begin{syntax}
-% \cs{int_from_binary:n} \Arg{binary number}
-% \end{syntax}
-% Converts the \meta{binary number} into the integer (base~\( 10 \))
-% representation and leaves this in the input stream.
-%\end{function}
-%
-%\begin{function}{ \int_from_hexadecimal:n / (EXP) }
-% \begin{syntax}
-% \cs{int_from_binary:n} \Arg{hexadecimal number}
-% \end{syntax}
-% Converts the \meta{hexadecimal number} into the integer
-% (base~\( 10 \)) representation and leaves this in the input stream.
-% Digits greater than \( 9 \) may be represented in the
-% \meta{hexadecimal number} by upper or lower case letters.
-%\end{function}
-%
-%\begin{function}{ \int_from_octal:n / (EXP) }
-% \begin{syntax}
-% \cs{int_from_octal:n} \Arg{octal number}
-% \end{syntax}
-% Converts the \meta{octal number} into the integer (base~\( 10 \))
-% representation and leaves this in the input stream.
-%\end{function}
-%
-%\begin{function}{ \int_from_roman:n / (EXP) }
-% \begin{syntax}
-% \cs{int_from_roman:n} \Arg{roman numeral}
-% \end{syntax}
-% Converts the \meta{roman numeral} into the integer (base~\( 10 \))
-% representation and leaves this in the input stream. The
-% \meta{roman numeral} may be in upper or lower case; if the numeral
-% is not valid then the resulting value will be \( -1 \).
-%\end{function}
-%
-%\subsection{Low-level conversion functions}
-%
-% As well as the higher-level functions already documented, there
-% are a series of lower-level functions which can be used to carry out
-% generic conversions. These are used to create the higher-level
-% versions documented above.
-%
-%\begin{function}{ \int_convert_from_base_ten:nn / (EXP) }
-% \begin{syntax}
-% \cs{int_convert_from_base_ten:nn} \Arg{integer expression}
-% ~~\Arg{base}
-% \end{syntax}
-% Calculates the value of the \meta{integer expression} and
-% converts it into the appropriate representation in the \meta{base};
-% the later may be given as an integer expression. For bases greater
-% than \( 10 \) the higher `digits' are represented by the upper case
-% letters from the English alphabet (with normal category codes). The
-% maximum \meta{base} value is \( 36 \).
-%\end{function}
-%
-%\begin{function}{ \int_convert_to_base_ten:nn / (EXP) }
-% \begin{syntax}
-% \cs{int_convert_to_base_ten:nn} \Arg{number}
-% ~~\Arg{base}
-% \end{syntax}
-% Converts the \meta{number} in \meta{base} into the appropriate
-% value in base \( 10 \). The \meta{number} should consist of
-% digits and letters (either lower or upper case), plus optionally
-% a leading sign. The maximum \meta{base} value is \( 36 \).
-%\end{function}
-%
-%\begin{function}{ \int_convert_to_symbols:nnn / (EXP) }
-% \begin{syntax}
-% \cs{int_convert_to_symbols:nnn}
-% ~~\Arg{integer expression} \Arg{total symbols}
-% ~~\meta{value to symbol mapping}
-% \end{syntax}
-% This is the low-level function for conversion of an
-% \meta{integer expression} into a symbolic form (which will often
-% be letters). The \meta{total symbols} available should be given
-% as an integer expression. Values are actually converted to symbols
-% according to the \meta{value to symbol mapping}. This should be given
-% as \meta{total symbols} pairs of entries, a number and the
-% appropriate symbol. Thus the \cs{int_to_alph:n} function is defined
-% as
-% \begin{verbatim}
-% \cs_new:Npn \int_to_alph:n #1 {
-% \int_convert_to_sybols:nnn {#1} { 26 }
-% {
-% { 1 } { a }
-% { 2 } { b }
-% { 3 } { c }
-% { 4 } { d }
-% { 5 } { e }
-% { 6 } { f }
-% { 7 } { g }
-% { 8 } { h }
-% { 9 } { i }
-% { 10 } { j }
-% { 11 } { k }
-% { 12 } { l }
-% { 13 } { m }
-% { 14 } { n }
-% { 15 } { o }
-% { 16 } { p }
-% { 17 } { q }
-% { 18 } { r }
-% { 19 } { s }
-% { 20 } { t }
-% { 21 } { u }
-% { 22 } { v }
-% { 23 } { w }
-% { 24 } { x }
-% { 25 } { y }
-% { 26 } { z }
-% }
-% }
-% \end{verbatim}
-%\end{function}
-%
-%\section{Variables and constants}
-%
-% \begin{variable}{%
-% \l_tmpa_int |
-% \l_tmpb_int |
-% \l_tmpc_int |
-% \g_tmpa_int |
-% \g_tmpb_int |
-% }
-% Scratch register for immediate use. They are not used by conditionals
-% or predicate functions.
-% \end{variable}
-%
-%\begin{function}{
-% \int_const:Nn |
-% \int_const:cn |
-%}
-% \begin{syntax}
-% \cs{int_const:Nn} \meta{integer} \Arg{integer expression}
-% \end{syntax}
-% Creates a new constant \meta{integer} or raises an error if the name
-% is already taken. The value of the \meta{integer} will be set
-% globally to the \meta{integer expression}.
-%\end{function}
-%
-%\begin{variable}{ \c_max_int }
-% The maximum value that can be stored as an integer.
-%\end{variable}
-%
-%\begin{variable}{
-% \c_minus_one |
-% \c_zero |
-% \c_one |
-% \c_two |
-% \c_three |
-% \c_four |
-% \c_five |
-% \c_six |
-% \c_seven |
-% \c_eight |
-% \c_nine |
-% \c_ten |
-% \c_eleven |
-% \c_twelve |
-% \c_thirteen |
-% \c_fourteen |
-% \c_fifteen |
-% \c_sixteen |
-% \c_thirty_two |
-% \c_hundred_one |
-% \c_twohundred_fifty_five |
-% \c_twohundred_fifty_six |
-% \c_thousand |
-% \c_ten_thousand |
-% \c_ten_thousand_one |
-% \c_ten_thousand_two |
-% \c_ten_thousand_three |
-% \c_ten_thousand_four |
-% \c_twenty_thousand |
-%}
-% Integer values used with primitive tests and assignments:
-% self-terminating nature makes these more convenient and faster than
-% literal numbers.
-%\end{variable}
-%
-% \begin{variable}{\c_max_register_int}
-% Maximum number of registers.
-% \end{variable}
-%
-%\subsection{Internal functions}
-%
-% \begin{function}{\int_to_roman:w / (EXP)}
-% \begin{syntax}
-% "\int_to_roman:w" <integer> <space> \textit{or} <non-expandable token>
-% \end{syntax}
-% Converts <integer> to it lowercase roman representation. Note that
-% it produces a string of letters with catcode 12.
-% \begin{texnote}
-% This is the \TeX{} primitive \tn{romannumeral} renamed.
-% \end{texnote}
-% \end{function}
-%
-% \begin{function}{
-% \int_roman_lcuc_mapping:Nnn |
-% \int_to_roman_lcuc:NN |
-% }
-% \begin{syntax}
-% "\int_roman_lcuc_mapping:Nnn" <roman_char> \Arg{licr} \Arg{LICR}
-% "\int_to_roman_lcuc:NN" <roman_char> <char>
-% \end{syntax}
-% "\int_roman_lcuc_mapping:Nnn" specifies how the roman
-% numeral <roman\_ char> (i, v, x, l, c, d, or m) should be
-% interpreted when converting the number. <licr> is the lower case and
-% <LICR> is the uppercase mapping. "\int_to_roman_lcuc:NN" is a
-% recursive function converting the roman numerals.
-% \end{function}
-%
-%
-% \begin{function}{
-% \int_convert_number_with_rule:nnN |
-% \int_symbol_math_conversion_rule:n |
-% \int_symbol_text_conversion_rule:n |
-% }
-% \begin{syntax}
-% "\int_convert_number_with_rule:nnN" \Arg{int1} \Arg{int2} <function>
-% \end{syntax}
-% "\int_convert_number_with_rule:nnN" converts <int1> into letters,
-% symbols, whatever as defined by <function>. <int2> denotes the base
-% number for the conversion.
-% \end{function}
-%
-%\begin{function}{
-% \if_num:w / (EXP) |
-% \if_int_compare:w / (EXP)
-%}
-% \begin{syntax}
-% "\if_num:w" <number1> <rel> <number2> <true> "\else:" <false> "\fi:"
-% \end{syntax}
-% Compare two integers using <rel>, which must be one of
-% \texttt{=}, "<" or ">" with category code \(12\).
-% The \cs{else:} branch is optional.
-% \begin{texnote}
-% These are both names for the \TeX\ primitive \cs{ifnum}.
-% \end{texnote}
-%\end{function}
-%
-%\begin{function}{
-% \if_case:w / (EXP) |
-% \or: / (EXP)
-%}
-% \begin{syntax}
-% "\if_case:w" <number> <case0> "\or:" <case1> "\or:" "..." "\else:"
-% <default> "\fi:"
-% \end{syntax}
-% Selects a case to execute based on the value of <number>. The first
-% case (<case0>) is executed if <number> is \(0\), the second
-% (<case1>) if the <number> is \(1\), \emph{etc}. The
-% <number> may be a literal, a constant or an integer
-% expression (\emph{e.g}.~using \cs{int_eval:n}).
-% \begin{texnote}
-% These are the \TeX\ primitives \cs{ifcase} and \cs{or}.
-% \end{texnote}
-%\end{function}
-%
-%\begin{function}{\int_value:w / (EXP)}
-% \begin{syntax}
-% "\int_value:w" <integer>
-% "\int_value:w" <tokens> <optional space>
-% \end{syntax}
-% Expands <tokens> until an <integer> is formed. One space may be
-% gobbled in the process.
-% \begin{texnote}
-% This is the \TeX\ primitive \tn{number}.
-% \end{texnote}
-%\end{function}
-%
-%\begin{function}{
-% \int_eval:w / (EXP) |
-% \int_eval_end:
-%}
-% \begin{syntax}
-% "\int_eval:w" <int expr> "\int_eval_end:"
-% \end{syntax}
-% Evaluates <integer expression> as described for \cs{int_eval:n}.
-% The evalution stops when an unexpandable token with category code
-% other than \(12\) is read or when \cs{int_eval_end:} is
-% reached. The latter is gobbled by the scanner mechanism:
-% \cs{int_eval_end:} itself is unexpandable but used correctly
-% the entire construct is expandable.
-% \begin{texnote}
-% This is the \eTeX\ primitive \cs{numexpr}.
-% \end{texnote}
-%\end{function}
-%
-%\begin{function}{\if_int_odd:w / (EXP)}
-% \begin{syntax}
-% "\if_int_odd:w" <tokens> <true> "\else:" <false> "\fi:"
-% "\if_int_odd:w" <number> <true> "\else:" <false> "\fi:"
-% \end{syntax}
-% Expands <tokens> until a non-numeric tokens is found, and
-% tests whether the resulting <number> is odd. If so, <true code>
-% is executed. The \cs{else:} branch is optional.
-% \begin{texnote}
-% This is the \TeX\ primitive \cs{ifodd}.
-% \end{texnote}
-%\end{function}
-%
-% \end{documentation}
-%
-% \begin{implementation}
-%
-% \section{\pkg{l3int} implementation}
-%
-% \TestFiles{m3int001.lvt,m3int002.lvt,m3int03.lvt}
-%
-% \subsection{Internal functions and variables}
-%
-% \begin{function}{\int_advance:w}
-% \begin{syntax}
-% "\int_advance:w" <int register> <optional `\texttt{by}'> <number> <space>
-% \end{syntax}
-% Increments the count register by the specified amount.
-% \begin{texnote}
-% This is \TeX's \tn{advance}.
-% \end{texnote}
-% \end{function}
-%
-%
-% \begin{function}{\int_convert_number_to_letter:n / (EXP)}
-% \begin{syntax}
-% "\int_convert_number_to_letter:n" \Arg{integer expression}
-% \end{syntax}
-% Internal function for turning a number for a different base into a letter or digit.
-% \end{function}
-%
-% \begin{function}{\int_pre_eval_one_arg:Nn | \int_pre_eval_two_args:Nnn}
-% \begin{syntax}
-% "\int_pre_eval_one_arg:Nn" <function> \Arg{integer expression}
-% "\int_pre_eval_one_arg:Nnn" <function> \Arg{int~expr~1} \Arg{int~expr~2}
-% \end{syntax}
-% These are expansion helpers; they evaluate their integer expressions
-% before handing them off to the specified <function>.
-% \end{function}
-%
-% \begin{function}{ \int_get_sign_and_digits:n / (EXP) |
-% \int_get_sign:n / (EXP ) |
-% \int_get_digits:n / (EXP) }
-% \begin{syntax}
-% "\int_get_sign_and_digits:n" \Arg{number}
-% \end{syntax}
-% From an argument that may or may not include a "+" or "-" sign, these
-% functions expand to the respective components of the number.
-% \end{function}
-%
-% \subsection{Module loading and primitives definitions}
-%
-% We start by ensuring that the required packages are loaded.
-% \begin{macrocode}
-%<*package>
-\ProvidesExplPackage
- {\filename}{\filedate}{\fileversion}{\filedescription}
-\package_check_loaded_expl:
-%</package>
-%<*initex|package>
-% \end{macrocode}
-%
-% \begin{macro}{\int_value:w}
-% \begin{macro}{\int_eval:n,\int_eval:w,\int_eval_end:}
-% \begin{macro}{\if_int_compare:w}
-% \begin{macro}{\if_int_odd:w}
-% \begin{macro}{\if_num:w}
-% \begin{macro}{\if_case:w}
-% \begin{macro}{\int_to_roman:w}
-% \begin{macro}{\int_advance:w}
-% Here are the remaining primitives for number comparisons and
-% expressions.
-% \begin{macrocode}
-\cs_set_eq:NN \int_value:w \tex_number:D
-\cs_set_eq:NN \int_eval:w \etex_numexpr:D
-\cs_set_protected:Npn \int_eval_end: {\tex_relax:D}
-\cs_set_eq:NN \if_int_compare:w \tex_ifnum:D
-\cs_new_eq:NN \if_num:w \tex_ifnum:D
-\cs_set_eq:NN \if_int_odd:w \tex_ifodd:D
-\cs_new_eq:NN \if_case:w \tex_ifcase:D
-\cs_new_eq:NN \int_to_roman:w \tex_romannumeral:D
-\cs_new_eq:NN \int_advance:w \tex_advance:D
-% \end{macrocode}
-% \end{macro}
-% \end{macro}
-% \end{macro}
-% \end{macro}
-% \end{macro}
-% \end{macro}
-% \end{macro}
-% \end{macro}
-%
-%
-% \begin{macro}{\int_eval:n}
-% Wrapper for \cs{int_eval:w}. Can be used in an integer expression
-% or directly in the input stream.
-% \begin{macrocode}
-\cs_set:Npn \int_eval:n #1{
- \int_value:w \int_eval:w #1\int_eval_end:
-}
-% \end{macrocode}
-% \end{macro}
-%
-%
-%
-% \subsection{Allocation and setting}
-%
-% \begin{macro}{\int_new:N,\int_new:c}
-% \UnitTested
-% For the \LaTeX3 format:
-% \begin{macrocode}
-%<*initex>
-\alloc_new:nnnN {int} {11} {\c_max_register_int} \tex_countdef:D
-%</initex>
-% \end{macrocode}
-% For `l3in2e':
-% \begin{macrocode}
-%<*package>
-\cs_new_protected_nopar:Npn \int_new:N #1 {
- \chk_if_free_cs:N #1
- \newcount #1
-}
-%</package>
-% \end{macrocode}
-% \begin{macrocode}
-\cs_generate_variant:Nn \int_new:N {c}
-% \end{macrocode}
-% \end{macro}
-%
-%
-% \begin{macro}{\int_set:Nn, \int_set:cn}
-% \UnitTested
-% \begin{macro}{\int_gset:Nn,\int_gset:cn}
-% \UnitTested
-% Setting counters is again something that I would like to make
-% uniform at the moment to get a better overview.
-% \begin{macrocode}
-\cs_new_protected_nopar:Npn \int_set:Nn #1#2{#1 \int_eval:w #2\int_eval_end:
-%<*check>
-\chk_local_or_pref_global:N #1
-%</check>
-}
-\cs_new_protected_nopar:Npn \int_gset:Nn {
-%<*check>
- \pref_global_chk:
-%</check>
-%<-check> \pref_global:D
- \int_set:Nn }
-\cs_generate_variant:Nn\int_set:Nn {cn}
-\cs_generate_variant:Nn\int_gset:Nn {cn}
-% \end{macrocode}
-% \end{macro}
-% \end{macro}
-%
-%
-%
-%
-%\begin{macro}{\int_set_eq:NN,\int_set_eq:cN,
-% \int_set_eq:Nc,\int_set_eq:cc}
-% \UnitTested
-%\begin{macro}{\int_gset_eq:NN,\int_gset_eq:cN,
-% \int_gset_eq:Nc,\int_gset_eq:cc}
-% \UnitTested
-% Setting equal means using one integer inside the set function of
-% another.
-% \begin{macrocode}
-\cs_new_protected_nopar:Npn \int_set_eq:NN #1#2 {
- \int_set:Nn #1 {#2}
-}
-\cs_generate_variant:Nn \int_set_eq:NN { c }
-\cs_generate_variant:Nn \int_set_eq:NN { Nc }
-\cs_generate_variant:Nn \int_set_eq:NN { cc }
-\cs_new_protected_nopar:Npn \int_gset_eq:NN #1#2 {
- \int_gset:Nn #1 {#2}
-}
-\cs_generate_variant:Nn \int_gset_eq:NN { c }
-\cs_generate_variant:Nn \int_gset_eq:NN { Nc }
-\cs_generate_variant:Nn \int_gset_eq:NN { cc }
-% \end{macrocode}
-%\end{macro}
-%\end{macro}
-%
-%
-%
-%
-% \begin{macro}{\int_incr:N,\int_incr:c}
-% \UnitTested
-% \begin{macro}{\int_decr:N,\int_decr:c}
-% \UnitTested
-% \begin{macro}{\int_gincr:N,\int_gincr:c}
-% \UnitTested
-% \begin{macro}{\int_gdecr:N,\int_gdecr:c}
-% \UnitTested
-% Incrementing and decrementing of integer registers is done with
-% the following functions.
-% \begin{macrocode}
-\cs_new_protected_nopar:Npn \int_incr:N #1{\int_advance:w#1\c_one
-%<*check>
- \chk_local_or_pref_global:N #1
-%</check>
-}
-\cs_new_protected_nopar:Npn \int_decr:N #1{\int_advance:w#1\c_minus_one
-%<*check>
- \chk_local_or_pref_global:N #1
-%</check>
-}
-\cs_new_protected_nopar:Npn \int_gincr:N {
-% \end{macrocode}
-% We make sure that a local variable is not updated globally by
-% changing the internal test (i.e.\ |\chk_local_or_pref_global:N|) before
-% making the assignment. This is done by |\pref_global_chk:| which also
-% issues the necessary |\pref_global:D|. This is not very efficient, but
-% this code will be only included for debugging purposes. Using
-% |\pref_global:D| in front of the local function is better in the
-% production versions.
-% \begin{macrocode}
-%<*check>
- \pref_global_chk:
-%</check>
-%<-check> \pref_global:D
- \int_incr:N}
-\cs_new_protected_nopar:Npn \int_gdecr:N {
-%<*check>
- \pref_global_chk:
-%</check>
-%<-check> \pref_global:D
- \int_decr:N}
-% \end{macrocode}
-% With the |\int_add:Nn| functions we can shorten the above code.
-% If this makes it too slow \ldots
-% \begin{macrocode}
-\cs_set_protected_nopar:Npn \int_incr:N #1{\int_add:Nn#1\c_one}
-\cs_set_protected_nopar:Npn \int_decr:N #1{\int_add:Nn#1\c_minus_one}
-\cs_set_protected_nopar:Npn \int_gincr:N #1{\int_gadd:Nn#1\c_one}
-\cs_set_protected_nopar:Npn \int_gdecr:N #1{\int_gadd:Nn#1\c_minus_one}
-% \end{macrocode}
-%
-% \begin{macrocode}
-\cs_generate_variant:Nn \int_incr:N {c}
-\cs_generate_variant:Nn \int_decr:N {c}
-\cs_generate_variant:Nn \int_gincr:N {c}
-\cs_generate_variant:Nn \int_gdecr:N {c}
-% \end{macrocode}
-% \end{macro}
-% \end{macro}
-% \end{macro}
-% \end{macro}
-%
-%
-% \begin{macro}{\int_zero:N,\int_zero:c}
-% \UnitTested
-% \begin{macro}{\int_gzero:N,\int_gzero:c}
-% \UnitTested
-% Functions that reset an \m{int} register to zero.
-% \begin{macrocode}
-\cs_new_protected_nopar:Npn \int_zero:N #1 {#1=\c_zero}
-\cs_generate_variant:Nn \int_zero:N {c}
-% \end{macrocode}
-%
-% \begin{macrocode}
-\cs_new_protected_nopar:Npn \int_gzero:N #1 {\pref_global:D #1=\c_zero}
-\cs_generate_variant:Nn \int_gzero:N {c}
-% \end{macrocode}
-% \end{macro}
-% \end{macro}
-%
-% \begin{macro}{\int_add:Nn,\int_add:cn}
-% \UnitTested
-% \begin{macro}{\int_gadd:Nn,\int_gadd:cn}
-% \UnitTested
-% \begin{macro}{\int_sub:Nn,\int_sub:cn}
-% \UnitTested
-% \begin{macro}{\int_gsub:Nn,\int_gsub:cn}
-% \UnitTested
-% Adding and substracting to and from a counter \ldots
-% We should think of using these functions
-% \begin{macrocode}
-\cs_new_protected_nopar:Npn \int_add:Nn #1#2{
-% \end{macrocode}
-% We need to say |by| in case the first argument is a register
-% accessed by its number, e.g., |\count23|. Not that it should
-% ever happen but\dots
-% \begin{macrocode}
- \int_advance:w #1 by \int_eval:w #2\int_eval_end:
-%<*check>
- \chk_local_or_pref_global:N #1
-%</check>
-}
-\cs_new_nopar:Npn \int_sub:Nn #1#2{
- \int_advance:w #1-\int_eval:w #2\int_eval_end:
-%<*check>
-\chk_local_or_pref_global:N #1
-%</check>
-}
-\cs_new_protected_nopar:Npn \int_gadd:Nn {
-%<*check>
- \pref_global_chk:
-%</check>
-%<-check> \pref_global:D
- \int_add:Nn }
-\cs_new_protected_nopar:Npn \int_gsub:Nn {
-%<*check>
- \pref_global_chk:
-%</check>
-%<-check> \pref_global:D
- \int_sub:Nn }
-\cs_generate_variant:Nn \int_add:Nn {cn}
-\cs_generate_variant:Nn \int_gadd:Nn {cn}
-\cs_generate_variant:Nn \int_sub:Nn {cn}
-\cs_generate_variant:Nn \int_gsub:Nn {cn}
-% \end{macrocode}
-% \end{macro}
-% \end{macro}
-% \end{macro}
-% \end{macro}
-%
-%
-% \begin{macro}{\int_use:N,\int_use:c}
-% \UnitTested
-% Here is how counters are accessed:
-% \begin{macrocode}
-\cs_new_eq:NN \int_use:N \tex_the:D
-\cs_new_nopar:Npn \int_use:c #1{\int_use:N \cs:w#1\cs_end:}
-% \end{macrocode}
-% \end{macro}
-%
-%
-% \begin{macro}{\int_show:N,\int_show:c}
-% \UnitTested
-% \begin{macrocode}
-\cs_new_eq:NN \int_show:N \kernel_register_show:N
-\cs_new_eq:NN \int_show:c \kernel_register_show:c
-% \end{macrocode}
-% \end{macro}
-%
-%
-%
-%
-% \begin{macro}{\int_to_arabic:n}
-% \UnitTested
-% Nothing exciting here.
-% \begin{macrocode}
-\cs_new_nopar:Npn \int_to_arabic:n #1{ \int_eval:n{#1}}
-% \end{macrocode}
-% \end{macro}
-%
-%
-%
-% \begin{macro}[aux]{\int_roman_lcuc_mapping:Nnn}
-% Using \TeX's built-in feature for producing roman numerals has some
-% surprising features. One is the the characters resulting from
-% |\int_to_roman:w| have category code~12 so they may fail in
-% certain comparison tests. Therefore we use a mapping from the
-% character \TeX{} produces to the character we actually want which
-% will give us letters with category code~11.%
-% \begin{macrocode}
-\cs_new_protected_nopar:Npn \int_roman_lcuc_mapping:Nnn #1#2#3{
- \cs_set_nopar:cpn {int_to_lc_roman_#1:}{#2}
- \cs_set_nopar:cpn {int_to_uc_roman_#1:}{#3}
-}
-% \end{macrocode}
-% \end{macro}
-%
-%
-% Here are the default mappings. I haven't found any examples of say
-% Turkish doing the mapping |i \i I| but at least there is a
-% possibility for it if needed. Note: I have now asked a Turkish
-% person and he tells me they do the |i I| mapping.
-% \begin{macrocode}
-\int_roman_lcuc_mapping:Nnn i i I
-\int_roman_lcuc_mapping:Nnn v v V
-\int_roman_lcuc_mapping:Nnn x x X
-\int_roman_lcuc_mapping:Nnn l l L
-\int_roman_lcuc_mapping:Nnn c c C
-\int_roman_lcuc_mapping:Nnn d d D
-\int_roman_lcuc_mapping:Nnn m m M
-% \end{macrocode}
-% For the delimiter we cheat and let it gobble its arguments instead.
-% \begin{macrocode}
-\int_roman_lcuc_mapping:Nnn Q \use_none:nn \use_none:nn
-% \end{macrocode}
-%
-% \begin{macro}{\int_to_roman:n, \int_to_Roman:n}
-% \UnitTested
-% \TestMissing{output is catcode 11}
-% \begin{macro}[aux]{\int_to_roman_lcuc:NN}
-% The commands for producing the lower and upper case roman numerals
-% run a loop on one character at a time and also carries some
-% information for upper or lower case with it. We put it through
-% |\int_eval:n| first which is safer and more flexible.
-% \begin{macrocode}
-\cs_new_nopar:Npn \int_to_roman:n #1 {
- \exp_after:wN \int_to_roman_lcuc:NN \exp_after:wN l
- \int_to_roman:w \int_eval:n {#1} Q
-}
-\cs_new_nopar:Npn \int_to_Roman:n #1 {
- \exp_after:wN \int_to_roman_lcuc:NN \exp_after:wN u
- \int_to_roman:w \int_eval:n {#1} Q
-}
-\cs_new_nopar:Npn \int_to_roman_lcuc:NN #1#2{
- \use:c {int_to_#1c_roman_#2:}
- \int_to_roman_lcuc:NN #1
-}
-% \end{macrocode}
-% \end{macro}
-% \end{macro}
-%
-%
-%\begin{macro}{\int_convert_to_symbols:nnn}
-%\UnitTested
-% For conversion of integers to arbitrary symbols the method is in
-% general as follows. The input number ("#1") is compared to the total
-% number of symbols available at each place ("#2"). If the input is larger
-% than the total number of symbols available then the modulus is needed,
-% with one added so that the positions don't have to number from
-% zero. Using an \texttt{f}-type expansion, this is done so that the system
-% is recursive. The actual conversion function therefore gets a `nice'
-% number at each stage. Of course, if the initial input was small enough
-% then there is no problem and everything is easy. This is more or less the
-% same as \cs{int_convert_number_with_rule:nnN} but `pre-packaged'.
-% \begin{macrocode}
-\cs_new_nopar:Npn \int_convert_to_symbols:nnn #1#2#3 {
- \int_compare:nNnTF {#1} > {#2}
- {
- \exp_args:Nf \int_convert_to_symbols:nnn
- { \int_div_truncate:nn { #1 - 1 } {#2} } {#2} {#3}
- \exp_args:Nf \prg_case_int:nnn
- { \int_eval:n { 1 + \int_mod:nn { #1 - 1 } {#2} } }
- {#3} { }
- }
- { \exp_args:Nf \prg_case_int:nnn { \int_eval:n {#1} } {#3} { } }
-}
-% \end{macrocode}
-%\end{macro}
-%
-%
-%
-% \begin{macro}{\int_convert_number_with_rule:nnN}
-% This is our major workhorse for conversions. |#1| is the number we
-% want converted, |#2| is the base number, and |#3| is the function
-% converting the number. This function expects to receive a
-% non-negative integer and as such is ideal for something using
-% |\if_case:w| internally.
-%
-% The basic example is this: We want to convert the number 50 (|#1|)
-% into an alphabetic equivalent |ax|. For the English language our
-% list contains 26 elements so this is our argument |#2| while the
-% function |#3| just turns |1| into |a|, |2| into |b|, etc. Hence our
-% goal is to turn 50 into the sequence |#3{1}#1{24}| so what we do is
-% to first divide 50 by 26 and truncating the result returning 1.
-% Then before we execute this we call the function again but this time
-% on the result of the remainder of the division. This goes on until
-% the remainder is less than or equal to the base number where we just
-% call the function |#3| directly on the number.
-%
-% We do a little pre-expansion of the arguments below as they
-% otherwise have a tendency to grow quite large.
-% \begin{macrocode}
-\cs_set_nopar:Npn \int_convert_number_with_rule:nnN #1#2#3{
- \int_compare:nNnTF {#1}>{#2}
- {
- \exp_args:Nf \int_convert_number_with_rule:nnN
- { \int_div_truncate:nn {#1-1}{#2} }{#2}
- #3
-% \end{macrocode}
-% Note that we have to nudge our modulus function so it won't
-% return~$0$ as that wouldn't work with |\if_case:w| when that
-% expects a positive number to produce a letter.
-% \begin{macrocode}
- \exp_args:Nf #3 { \int_eval:n{1+\int_mod:nn {#1-1}{#2}} }
- }
- { \exp_args:Nf #3{ \int_eval:n{#1} } }
-}
-% \end{macrocode}
-% As can be seen it is even simpler to convert to number systems
-% that contain 0, since then we don't have to add or subtract 1
-% here and there.
-% \end{macro}
-%
-%
-%\begin{macro}{\int_to_alph:n,\int_to_Alph:n}
-%\UnitTested
-% These both use the above function with input functions that make sense
-% for the alphabet in English.
-% \begin{macrocode}
-\cs_new_nopar:Npn \int_to_alph:n #1 {
- \int_convert_to_symbols:nnn {#1} { 26 }
- {
- { 1 } { a }
- { 2 } { b }
- { 3 } { c }
- { 4 } { d }
- { 5 } { e }
- { 6 } { f }
- { 7 } { g }
- { 8 } { h }
- { 9 } { i }
- { 10 } { j }
- { 11 } { k }
- { 12 } { l }
- { 13 } { m }
- { 14 } { n }
- { 15 } { o }
- { 16 } { p }
- { 17 } { q }
- { 18 } { r }
- { 19 } { s }
- { 20 } { t }
- { 21 } { u }
- { 22 } { v }
- { 23 } { w }
- { 24 } { x }
- { 25 } { y }
- { 26 } { z }
- }
-}
-\cs_new_nopar:Npn \int_to_Alph:n #1 {
- \int_convert_to_symbols:nnn {#1} { 26 }
- {
- { 1 } { A }
- { 2 } { B }
- { 3 } { C }
- { 4 } { D }
- { 5 } { E }
- { 6 } { F }
- { 7 } { G }
- { 8 } { H }
- { 9 } { I }
- { 10 } { J }
- { 11 } { K }
- { 12 } { L }
- { 13 } { M }
- { 14 } { N }
- { 15 } { O }
- { 16 } { P }
- { 17 } { Q }
- { 18 } { R }
- { 19 } { S }
- { 20 } { T }
- { 21 } { U }
- { 22 } { V }
- { 23 } { W }
- { 24 } { X }
- { 25 } { Y }
- { 26 } { Z }
- }
-}
-% \end{macrocode}
-%\end{macro}
-%
-%
-% \begin{macro}{\int_to_symbol:n}
-% \UnitTested
-% Turning a number into a symbol is also easy enough.
-% \begin{macrocode}
-\cs_new_nopar:Npn \int_to_symbol:n #1{
- \mode_if_math:TF
- {
- \int_convert_number_with_rule:nnN {#1}{9}
- \int_symbol_math_conversion_rule:n
- }
- {
- \int_convert_number_with_rule:nnN {#1}{9}
- \int_symbol_text_conversion_rule:n
- }
-}
-% \end{macrocode}
-% \end{macro}
-%
-%
-%
-% \begin{macro}{\int_symbol_math_conversion_rule:n}
-% \begin{macro}{\int_symbol_text_conversion_rule:n}
-% Nothing spectacular here.
-% \begin{macrocode}
-\cs_new_nopar:Npn \int_symbol_math_conversion_rule:n #1 {
- \if_case:w #1
- \or: *
- \or: \dagger
- \or: \ddagger
- \or: \mathsection
- \or: \mathparagraph
- \or: \|
- \or: **
- \or: \dagger\dagger
- \or: \ddagger\ddagger
- \fi:
-}
-\cs_new_nopar:Npn \int_symbol_text_conversion_rule:n #1 {
- \if_case:w #1
- \or: \textasteriskcentered
- \or: \textdagger
- \or: \textdaggerdbl
- \or: \textsection
- \or: \textparagraph
- \or: \textbardbl
- \or: \textasteriskcentered\textasteriskcentered
- \or: \textdagger\textdagger
- \or: \textdaggerdbl\textdaggerdbl
- \fi:
-}
-% \end{macrocode}
-% \end{macro}
-% \end{macro}
-%
-% \begin{macro}[aux]{\l_tmpa_int}
-% \begin{macro}[aux]{\l_tmpb_int}
-% \begin{macro}[aux]{\l_tmpc_int}
-% \begin{macro}[aux]{\g_tmpa_int}
-% \begin{macro}[aux]{\g_tmpb_int}
-% We provide four local and two global scratch counters, maybe we
-% need more or less.
-% \begin{macrocode}
-\int_new:N \l_tmpa_int
-\int_new:N \l_tmpb_int
-\int_new:N \l_tmpc_int
-\int_new:N \g_tmpa_int
-\int_new:N \g_tmpb_int
-% \end{macrocode}
-% \end{macro}
-% \end{macro}
-% \end{macro}
-% \end{macro}
-% \end{macro}
-%
-%
-%
-%
-% \begin{macro}{\int_pre_eval_one_arg:Nn}
-% \begin{macro}{\int_pre_eval_two_args:Nnn}
-% These are handy when handing down values to other
-% functions. All they do is evaluate the number in advance.
-% \begin{macrocode}
-\cs_set_nopar:Npn \int_pre_eval_one_arg:Nn #1#2{
- \exp_args:Nf#1{\int_eval:n{#2}}}
-\cs_set_nopar:Npn \int_pre_eval_two_args:Nnn #1#2#3{
- \exp_args:Nff#1{\int_eval:n{#2}}{\int_eval:n{#3}}
-}
-% \end{macrocode}
-% \end{macro}
-% \end{macro}
-%
-%
-%
-%
-%
-%
-% \subsection{Scanning and conversion}
-%
-%
-% \begin{macro}{\int_from_roman:n}
-% \UnitTested
-% \TestMissing{boundary cases / wrong input?}
-%\begin{macro}[aux]{\int_from_roman_aux:NN}
-%\begin{macro}[aux]{\int_from_roman_end:w}
-%\begin{macro}[aux]{\int_from_roman_clean_up:w}
-% The method here is to iterate through the input, finding the
-% appropriate value for each letter and building up a sum. This is
-% then evaluated by \TeX.
-% \begin{macrocode}
-\cs_new_nopar:Npn \int_from_roman:n #1 {
- \tl_if_blank:nF {#1}
- {
- \tex_expandafter:D \int_from_roman_end:w
- \tex_number:D \etex_numexpr:D
- \int_from_roman_aux:NN #1 Q \q_stop
- }
-}
-\cs_new_nopar:Npn \int_from_roman_aux:NN #1#2 {
- \str_if_eq:nnTF {#1} { Q }
- {#1#2}
- {
- \str_if_eq:nnTF {#2} { Q }
- {
- \cs_if_exist:cF { c_int_from_roman_ #1 _int }
- { \int_from_roman_clean_up:w }
- +
- \use:c { c_int_from_roman_ #1 _int }
- #2
- }
- {
- \cs_if_exist:cF { c_int_from_roman_ #1 _int }
- { \int_from_roman_clean_up:w }
- \cs_if_exist:cF { c_int_from_roman_ #2 _int }
- { \int_from_roman_clean_up:w }
- \int_compare:nNnTF
- { \use:c { c_int_from_roman_ #1 _int } }
- <
- { \use:c { c_int_from_roman_ #2 _int } }
- {
- + \use:c { c_int_from_roman_ #2 _int }
- - \use:c { c_int_from_roman_ #1 _int }
- \int_from_roman_aux:NN
- }
- {
- + \use:c { c_int_from_roman_ #1 _int }
- \int_from_roman_aux:NN #2
- }
- }
- }
-}
-\cs_new_nopar:Npn \int_from_roman_end:w #1 Q #2 \q_stop {
- \tl_if_empty:nTF {#2} {#1} {#2}
-}
-\cs_new_nopar:Npn \int_from_roman_clean_up:w #1 Q { + 0 Q -1 }
-% \end{macrocode}
-%\end{macro}
-%\end{macro}
-%\end{macro}
-%\end{macro}
-%
-%
-%
-%
-%\begin{macro}{\int_convert_from_base_ten:nn}
-% \UnitTested
-%\begin{macro}[aux]{\int_convert_from_base_ten_aux:nnn}
-%\begin{macro}{\int_convert_number_to_letter:n}
-% \UnitTested
-% Converting from base ten ("#1") to a second base ("#2") starts with
-% a simple sign check. As the input is base \( 10 \) \TeX\ can then
-% do the actual work with the sign itself.
-% \begin{macrocode}
-\cs_new:Npn \int_convert_from_base_ten:nn #1#2 {
- \int_compare:nNnTF {#1} < { 0 }
- {
- -
- \exp_args:Nnf \int_convert_from_base_ten_aux:nnn
- { } { \int_eval:n { 0 - ( #1 ) } } {#2}
- }
- {
- \exp_args:Nnf \int_convert_from_base_ten_aux:nnn
- { } { \int_eval:n {#1} } {#2}
- }
-}
-% \end{macrocode}
-% Here, the idea is to provide a recursive system to deal with the
-% input. The output is build up as argument "#1", which is why it
-% starts off empty in the above. At each pass, the value in "#2" is
-% checked to see if it is less than the new base ("#3"). If it is
-% the it is converted directly and the rest of the output is added in.
-% On the other hand, if the value to convert is greater than or equal
-% to the new base then the modulus and remainder values are found. The
-% modulus is converted to a symbol and the remainder is carried forward
-% to the next round.S
-% \begin{macrocode}
-\cs_new:Npn \int_convert_from_base_ten_aux:nnn #1#2#3 {
- \int_compare:nNnTF {#2} < {#3}
- {
- \int_convert_number_to_letter:n {#2}
- #1
- }
- {
- \exp_args:Nff \int_convert_from_base_ten_aux:nnn
- {
- \int_convert_number_to_letter:n
- { \int_mod:nn {#2} {#3} }
- #1
- }
- { \int_div_truncate:nn {#2} {#3} }
- {#3}
- }
-}
-% \end{macrocode}
-% Convert to a letter only if necessary, otherwise simply return the
-% value unchanged.
-% \begin{macrocode}
-\cs_new:Npn \int_convert_number_to_letter:n #1 {
- \prg_case_int:nnn { #1 - 9 }
- {
- { 1 } { A }
- { 2 } { B }
- { 3 } { C }
- { 4 } { D }
- { 5 } { E }
- { 6 } { F }
- { 7 } { G }
- { 8 } { H }
- { 9 } { I }
- { 10 } { J }
- { 11 } { K }
- { 12 } { L }
- { 13 } { M }
- { 14 } { N }
- { 15 } { O }
- { 16 } { P }
- { 17 } { Q }
- { 18 } { R }
- { 19 } { S }
- { 20 } { T }
- { 21 } { U }
- { 22 } { V }
- { 23 } { W }
- { 24 } { X }
- { 25 } { Y }
- { 26 } { Z }
- }
- {#1}
-}
-% \end{macrocode}
-%\end{macro}
-%\end{macro}
-%\end{macro}
-%
-%\begin{macro}{\int_convert_to_base_ten:nn}
-% \UnitTested
-%\begin{macro}[aux]{\int_convert_to_base_ten_aux:nn}
-%\begin{macro}[aux]{\int_convert_to_base_ten_aux:nnN}
-%\begin{macro}[aux]{\int_convert_to_base_ten_aux:N}
-%\begin{macro}{\int_get_sign_and_digits:n}
-%\begin{macro}{\int_get_sign:n}
-%\begin{macro}{\int_get_digits:n}
-%\begin{macro}[aux]{\int_get_sign_and_digits_aux:nNNN}
-%\begin{macro}[aux]{\int_get_sign_and_digits_aux:oNNN}
-% Conversion to base ten means stripping off the sign then iterating
-% through the input one token at a time. The total number is then added
-% up as the code loops.
-% \begin{macrocode}
-\cs_new:Npn \int_convert_to_base_ten:nn #1#2 {
- \int_eval:n
- {
- \int_get_sign:n {#1}
- \exp_args:Nf \int_convert_to_base_ten_aux:nn
- { \int_get_digits:n {#1} } {#2}
- }
-}
-\cs_new:Npn \int_convert_to_base_ten_aux:nn #1#2 {
- \int_convert_to_base_ten_aux:nnN { 0 } { #2 } #1 \q_nil
-}
-\cs_new:Npn \int_convert_to_base_ten_aux:nnN #1#2#3 {
- \quark_if_nil:NTF #3
- {#1}
- {
- \exp_args:Nf \int_convert_to_base_ten_aux:nnN
- { \int_eval:n { #1 * #2 + \int_convert_to_base_ten_aux:N #3 } }
- {#2}
- }
-}
-% \end{macrocode}
-% The conversion here will take lower or upper case letters and turn
-% them into the appropriate number, hence the two-part nature of the
-% function.
-% \begin{macrocode}
-\cs_new:Npn \int_convert_to_base_ten_aux:N #1 {
- \int_compare:nNnTF { `#1 } < { 58 }
- {#1}
- {
- \int_eval:n
- { `#1 - \int_compare:nNnTF { `#1 } < { 91 } { 55 } { 87 } }
- }
-}
-% \end{macrocode}
-% Finding a number and its sign requires dealing with an arbitrary
-% list of "+" and "-" symbols. This is done by working through token
-% by token until there is something else at the start of the input.
-% The sign of the input is tracked by the first Boolean used by the
-% auxiliary function.
-% \begin{macrocode}
-\cs_new:Npn \int_get_sign_and_digits:n #1 {
- \int_get_sign_and_digits_aux:nNNN {#1}
- \c_true_bool \c_true_bool \c_true_bool
-}
-\cs_new:Npn \int_get_sign:n #1 {
- \int_get_sign_and_digits_aux:nNNN {#1}
- \c_true_bool \c_true_bool \c_false_bool
-}
-\cs_new:Npn \int_get_digits:n #1 {
- \int_get_sign_and_digits_aux:nNNN {#1}
- \c_true_bool \c_false_bool \c_true_bool
-}
-% \end{macrocode}
-% The auxiliary loops through, finding sign tokens and removing them.
-% The sign itself is carried through as a flag.
-% \begin{macrocode}
-\cs_new:Npn \int_get_sign_and_digits_aux:nNNN #1#2#3#4 {
- \tl_if_head_eq_charcode:fNTF {#1} -
- {
- \bool_if:NTF #2
- {
- \int_get_sign_and_digits_aux:oNNN
- { \use_none:n #1 } \c_false_bool #3#4
- }
- {
- \int_get_sign_and_digits_aux:oNNN
- { \use_none:n #1 } \c_true_bool #3#4
- }
- }
- {
- \tl_if_head_eq_charcode:fNTF {#1} +
- { \int_get_sign_and_digits_aux:oNNN { \use_none:n #1 } #2#3#4 }
- {
- \bool_if:NT #3 { \bool_if:NF #2 - }
- \bool_if:NT #4 {#1}
- }
- }
-}
-\cs_generate_variant:Nn \int_get_sign_and_digits_aux:nNNN { o }
-% \end{macrocode}
-%\end{macro}
-%\end{macro}
-%\end{macro}
-%\end{macro}
-%\end{macro}
-%\end{macro}
-%\end{macro}
-%\end{macro}
-%\end{macro}
-%
-%\begin{macro}{\int_from_binary:n,\int_from_hexadecimal:n,\int_from_octal:n}
-% \UnitTested
-%\begin{macro}{\int_to_binary:n,\int_to_hexadecimal:n,\int_to_octal:n}
-% \UnitTested
-% Wrappers around the generic function.
-% \begin{macrocode}
-\cs_new:Npn \int_from_binary:n #1 {
- \int_convert_to_base_ten:nn {#1} { 2 }
-}
-\cs_new:Npn \int_from_hexadecimal:n #1 {
- \int_convert_to_base_ten:nn {#1} { 16 }
-}
-\cs_new:Npn \int_from_octal:n #1 {
- \int_convert_to_base_ten:nn {#1} { 8 }
-}
-\cs_new:Npn \int_to_binary:n #1 {
- \int_convert_from_base_ten:nn {#1} { 2 }
-}
-\cs_new:Npn \int_to_hexadecimal:n #1 {
- \int_convert_from_base_ten:nn {#1} { 16 }
-}
-\cs_new:Npn \int_to_octal:n #1 {
- \int_convert_from_base_ten:nn {#1} { 8 }
-}
-% \end{macrocode}
-%\end{macro}
-%\end{macro}
-%
-%
-%
-%\begin{macro}{\int_from_alph:n}
-% \UnitTested
-%\begin{macro}[aux]{\int_from_alph_aux:n}
-%\begin{macro}[aux]{\int_from_alph_aux:nN}
-%\begin{macro}[aux]{\int_from_alph_aux:N}
-% The aim here is to iterate through the input, converting one letter at
-% a time to a number. The same approach is also used for base
-% conversion, but this needs a different final auxiliary.
-% \begin{macrocode}
-\cs_new:Npn \int_from_alph:n #1 {
- \int_eval:n
- {
- \int_get_sign:n {#1}
- \exp_args:Nf \int_from_alph_aux:n
- { \int_get_digits:n {#1} }
- }
-}
-\cs_new:Npn \int_from_alph_aux:n #1 {
- \int_from_alph_aux:nN { 0 } #1 \q_nil
-}
-\cs_new:Npn \int_from_alph_aux:nN #1#2 {
- \quark_if_nil:NTF #2
- {#1}
- {
- \exp_args:Nf \int_from_alph_aux:nN
- { \int_eval:n { #1 * 26 + \int_from_alph_aux:N #2 } }
- }
-}
-\cs_new:Npn \int_from_alph_aux:N #1 {
- \int_eval:n
- { `#1 - \int_compare:nNnTF { `#1 } < { 91 } { 64 } { 96 } }
-}
-% \end{macrocode}
-%\end{macro}
-%\end{macro}
-%\end{macro}
-%\end{macro}
-%
-%
-% \begin{macro}[pTF]{\int_compare:n}
-% Comparison tests using a simple syntax where only one set of braces
-% is required and additional operators such as "!=" and ">=" are
-% supported. First some notes on the idea behind this. We wish to
-% support writing code like
-% \begin{verbatim}
-% \int_compare_p:n { 5 + \l_tmpa_int != 4 - \l_tmpb_int }
-% \end{verbatim}
-% In other words, we want to somehow add the missing "\int_eval:w"
-% where required. We can start evaluating from the left using
-% "\int_eval:w", and we know that since the relation symbols "<", ">",
-% "=" and "!" are not allowed in such expressions, they will terminate
-% the expression. Therefore, we first let \TeX\ evaluate this left
-% hand side of the (in)equality.
-% \begin{macrocode}
-\prg_set_conditional:Npnn \int_compare:n #1{p,TF,T,F}{
- \exp_after:wN \int_compare_auxi:w \int_value:w
- \int_eval:w #1\q_stop
-}
-% \end{macrocode}
-% Then the next step is to figure out which relation we should use, so
-% we have to somehow get rid of the first evaluation so that we can
-% see what stopped it. "\tex_romannumeral:D" is handy here since its
-% expansion given a non-positive number is \m{null}. We therefore
-% simply check if the first token of the left hand side evaluation is
-% a minus. If not, we insert it and issue "\tex_romannumeral:D",
-% thereby ridding us of the left hand side evaluation. We do however
-% save it for later.
-% \begin{macrocode}
-\cs_set:Npn \int_compare_auxi:w #1#2\q_stop{
- \exp_after:wN \int_compare_auxii:w \tex_romannumeral:D
- \if:w #1- \else: -\fi: #1#2 \q_mark #1#2 \q_stop
-}
-% \end{macrocode}
-% This leaves the first relation symbol in front and assuming the
-% right hand side has been input, at least one other token as well. We
-% support the following forms: |=|, |<|, |>| and the extended |!=|,
-% |==|, |<=| and |>=|. All the extended forms have an extra |=| so we
-% check if that is present as well. Then use specific function to
-% perform the test.
-% \begin{macrocode}
-\cs_set:Npn \int_compare_auxii:w #1#2#3\q_mark{
- \use:c{
- int_compare_
- #1 \if_meaning:w =#2 = \fi:
- :w}
-}
-% \end{macrocode}
-% The actual comparisons are then simple function calls, using the
-% relation as delimiter for a delimited argument.
-% Equality is easy:
-% \begin{macrocode}
-\cs_set:cpn {int_compare_=:w} #1=#2\q_stop{
- \if_int_compare:w #1=\int_eval:w #2 \int_eval_end:
- \prg_return_true: \else: \prg_return_false: \fi:
-}
-% \end{macrocode}
-% So is the one using |==| -- we just have to use |==| in the
-% parameter text.
-% \begin{macrocode}
-\cs_set:cpn {int_compare_==:w} #1==#2\q_stop{
- \if_int_compare:w #1=\int_eval:w #2 \int_eval_end:
- \prg_return_true: \else: \prg_return_false: \fi:
-}
-% \end{macrocode}
-% Not equal is just about reversing the truth value.
-% \begin{macrocode}
-\cs_set:cpn {int_compare_!=:w} #1!=#2\q_stop{
- \if_int_compare:w #1=\int_eval:w #2 \int_eval_end:
- \prg_return_false: \else: \prg_return_true: \fi:
-}
-% \end{macrocode}
-% Less than and greater than are also straight forward.
-% \begin{macrocode}
-\cs_set:cpn {int_compare_<:w} #1<#2\q_stop{
- \if_int_compare:w #1<\int_eval:w #2 \int_eval_end:
- \prg_return_true: \else: \prg_return_false: \fi:
-}
-\cs_set:cpn {int_compare_>:w} #1>#2\q_stop{
- \if_int_compare:w #1>\int_eval:w #2 \int_eval_end:
- \prg_return_true: \else: \prg_return_false: \fi:
-}
-% \end{macrocode}
-% The less than or equal operation is just the opposite of the greater
-% than operation. Vice versa for less than or equal.
-% \begin{macrocode}
-\cs_set:cpn {int_compare_<=:w} #1<=#2\q_stop{
- \if_int_compare:w #1>\int_eval:w #2 \int_eval_end:
- \prg_return_false: \else: \prg_return_true: \fi:
-}
-\cs_set:cpn {int_compare_>=:w} #1>=#2\q_stop{
- \if_int_compare:w #1<\int_eval:w #2 \int_eval_end:
- \prg_return_false: \else: \prg_return_true: \fi:
-}
-% \end{macrocode}
-% \end{macro}
-%
-%
-% \begin{macro}[pTF]{\int_compare:nNn}
-% \UnitTested
-% More efficient but less natural in typing.
-% \begin{macrocode}
-\prg_set_conditional:Npnn \int_compare:nNn #1#2#3{p}{
- \if_int_compare:w \int_eval:w #1 #2 \int_eval:w #3
- \int_eval_end:
- \prg_return_true: \else: \prg_return_false: \fi:
-}
-\cs_set_nopar:Npn \int_compare:nNnT #1#2#3 {
- \tex_ifnum:D \etex_numexpr:D #1 #2 \etex_numexpr:D #3 \scan_stop:
- \tex_expandafter:D \use:n
- \tex_else:D
- \tex_expandafter:D \use_none:n
- \tex_fi:D
-}
-\cs_set_nopar:Npn \int_compare:nNnF #1#2#3 {
- \tex_ifnum:D \etex_numexpr:D #1 #2 \etex_numexpr:D #3 \scan_stop:
- \tex_expandafter:D \use_none:n
- \tex_else:D
- \tex_expandafter:D \use:n
- \tex_fi:D
-}
-\cs_set_nopar:Npn \int_compare:nNnTF #1#2#3 {
- \tex_ifnum:D \etex_numexpr:D #1 #2 \etex_numexpr:D #3 \scan_stop:
- \tex_expandafter:D \use_i:nn
- \tex_else:D
- \tex_expandafter:D \use_ii:nn
- \tex_fi:D
-}
-% \end{macrocode}
-% \end{macro}
-%
-%
-% \begin{macro}{\int_max:nn}
-% \UnitTested
-% \begin{macro}{\int_min:nn}
-% \UnitTested
-% \begin{macro}{\int_abs:n}
-% \UnitTested
-% Functions for $\min$, $\max$, and absolute value.
-% \begin{macrocode}
-\cs_set:Npn \int_abs:n #1{
- \int_value:w
- \if_int_compare:w \int_eval:w #1<\c_zero
- -
- \fi:
- \int_eval:w #1\int_eval_end:
-}
-\cs_set:Npn \int_max:nn #1#2{
- \int_value:w \int_eval:w
- \if_int_compare:w
- \int_eval:w #1>\int_eval:w #2\int_eval_end:
- #1
- \else:
- #2
- \fi:
- \int_eval_end:
-}
-\cs_set:Npn \int_min:nn #1#2{
- \int_value:w \int_eval:w
- \if_int_compare:w
- \int_eval:w #1<\int_eval:w #2\int_eval_end:
- #1
- \else:
- #2
- \fi:
- \int_eval_end:
-}
-% \end{macrocode}
-% \end{macro}
-% \end{macro}
-% \end{macro}
-%
-%
-% \begin{macro}{\int_div_truncate:nn}
-% \UnitTested
-% \begin{macro}{\int_div_round:nn}
-% \UnitTested
-% \begin{macro}{\int_mod:nn}
-% \UnitTested
-% As "\int_eval:w" rounds the result of a division we also
-% provide a version that truncates the result.
-% \begin{macrocode}
-% \end{macrocode}
-% Initial version didn't work correctly with e\TeX's implementation.
-% \begin{macrocode}
-%\cs_set:Npn \int_div_truncate_raw:nn #1#2 {
-% \int_eval:n{ (2*#1 - #2) / (2* #2) }
-%}
-% \end{macrocode}
-% New version by Heiko:
-% \begin{macrocode}
-\cs_set:Npn \int_div_truncate:nn #1#2 {
- \int_value:w \int_eval:w
- \if_int_compare:w \int_eval:w #1 = \c_zero
- 0
- \else:
- (#1
- \if_int_compare:w \int_eval:w #1 < \c_zero
- \if_int_compare:w \int_eval:w #2 < \c_zero
- -( #2 +
- \else:
- +( #2 -
- \fi:
- \else:
- \if_int_compare:w \int_eval:w #2 < \c_zero
- +( #2 +
- \else:
- -( #2 -
- \fi:
- \fi:
- 1)/2)
- \fi:
- /(#2)
- \int_eval_end:
-}
-% \end{macrocode}
-% For the sake of completeness:
-% \begin{macrocode}
-\cs_set:Npn \int_div_round:nn #1#2 {\int_eval:n{(#1)/(#2)}}
-% \end{macrocode}
-% Finally there's the modulus operation.
-% \begin{macrocode}
-\cs_set:Npn \int_mod:nn #1#2 {
- \int_value:w
- \int_eval:w
- #1 - \int_div_truncate:nn {#1}{#2} * (#2)
- \int_eval_end:
-}
-% \end{macrocode}
-% \end{macro}
-% \end{macro}
-% \end{macro}
-%
-%
-% \begin{macro}[pTF]{\int_if_odd:n}
-% \UnitTested
-% \begin{macro}[pTF]{\int_if_even:n}
-% \UnitTested
-% A predicate function.
-% \begin{macrocode}
-\prg_set_conditional:Npnn \int_if_odd:n #1 {p,TF,T,F} {
- \if_int_odd:w \int_eval:w #1\int_eval_end:
- \prg_return_true: \else: \prg_return_false: \fi:
-}
-\prg_set_conditional:Npnn \int_if_even:n #1 {p,TF,T,F} {
- \if_int_odd:w \int_eval:w #1\int_eval_end:
- \prg_return_false: \else: \prg_return_true: \fi:
-}
-% \end{macrocode}
-% \end{macro}
-% \end{macro}
-%
-%
-% \begin{macro}{\int_while_do:nn}
-% \UnitTested
-% \TestMissing{Boundary cases}
-% \begin{macro}{\int_until_do:nn}
-% \UnitTested
-% \TestMissing{Boundary cases}
-% \begin{macro}{\int_do_while:nn}
-% \UnitTested
-% \TestMissing{Boundary cases}
-% \begin{macro}{\int_do_until:nn}
-% \UnitTested
-% \TestMissing{Boundary cases}
-% These are quite easy given the above functions. The "while" versions
-% test first and then execute the body. The "do_while" does it the
-% other way round.
-% \begin{macrocode}
-\cs_set:Npn \int_while_do:nn #1#2{
- \int_compare:nT {#1}{#2 \int_while_do:nn {#1}{#2}}
-}
-\cs_set:Npn \int_until_do:nn #1#2{
- \int_compare:nF {#1}{#2 \int_until_do:nn {#1}{#2}}
-}
-\cs_set:Npn \int_do_while:nn #1#2{
- #2 \int_compare:nT {#1}{\int_do_while:nNnn {#1}{#2}}
-}
-\cs_set:Npn \int_do_until:nn #1#2{
- #2 \int_compare:nF {#1}{\int_do_until:nn {#1}{#2}}
-}
-% \end{macrocode}
-% \end{macro}
-% \end{macro}
-% \end{macro}
-% \end{macro}
-%
-%
-% \begin{macro}{\int_while_do:nNnn}
-% \begin{macro}{\int_until_do:nNnn}
-% \begin{macro}{\int_do_while:nNnn}
-% \begin{macro}{\int_do_until:nNnn}
-% As above but not using the more natural syntax.
-% \begin{macrocode}
-\cs_set:Npn \int_while_do:nNnn #1#2#3#4{
- \int_compare:nNnT {#1}#2{#3}{#4 \int_while_do:nNnn {#1}#2{#3}{#4}}
-}
-\cs_set:Npn \int_until_do:nNnn #1#2#3#4{
- \int_compare:nNnF {#1}#2{#3}{#4 \int_until_do:nNnn {#1}#2{#3}{#4}}
-}
-\cs_set:Npn \int_do_while:nNnn #1#2#3#4{
- #4 \int_compare:nNnT {#1}#2{#3}{\int_do_while:nNnn {#1}#2{#3}{#4}}
-}
-\cs_set:Npn \int_do_until:nNnn #1#2#3#4{
- #4 \int_compare:nNnF {#1}#2{#3}{\int_do_until:nNnn {#1}#2{#3}{#4}}
-}
-% \end{macrocode}
-% \end{macro}
-% \end{macro}
-% \end{macro}
-% \end{macro}
-%
-%
-% \subsection{Defining constants}
-%
-% \begin{macro}{\int_const:Nn, \int_const:cn}
-% \UnitTested
-% As stated, most constants can be defined as |\tex_chardef:D| or
-% |\tex_mathchardef:D| but that's engine dependent.
-% \begin{macrocode}
-\cs_new_protected_nopar:Npn \int_const:Nn #1#2 {
- \int_compare:nTF { #2 > \c_minus_one }
- {
- \int_compare:nTF { #2 > \c_max_register_int }
- {
- \int_new:N #1
- \int_gset:Nn #1 {#2}
- }
- {
- \chk_if_free_cs:N #1
- \tex_global:D \tex_mathchardef:D #1 =
- \etex_numexpr:D #2 \scan_stop:
- }
- }
- {
- \int_new:N #1
- \int_gset:Nn #1 {#2}
- }
-}
-\cs_generate_variant:Nn \int_const:Nn { c }
-% \end{macrocode}
-% \end{macro}
-%
-%
-% \begin{macro}{\c_minus_one,
-% \c_zero, \c_one, \c_two, \c_three, \c_four, \c_five, \c_six,
-% \c_seven, \c_eight, \c_nine, \c_ten,
-% \c_eleven, \c_twelve, \c_thirteen, \c_fourteen, \c_fifteen,
-% \c_sixteen, \c_thirty_two,
-% \c_hundred_one,
-% \c_twohundred_fifty_five, \c_twohundred_fifty_six,
-% \c_thousand,
-% \c_ten_thousand,
-% \c_ten_thousand_one, \c_ten_thousand_two,
-% \c_ten_thousand_three, \c_ten_thousand_four,
-% \c_twenty_thousand}
-% \TestMissing{Too simple for tests, but they aren't aux, so perhaps we should
-% add a test that they actually represent their numbers after
-% all}
-% \UnitTested
-% And the usual constants, others are still missing. Please, make
-% every constant a real constant at least for the moment. We can
-% easily convert things in the end when we have found what
-% constants are used in critical places and what not.
-% \begin{macrocode}
- %% \tex_countdef:D \c_minus_one = 10 \scan_stop:
- %% \c_minus_one = -1 \scan_stop: %% in l3basics
-%\int_const:Nn \c_zero {0} %% in l3basics
-\int_const:Nn \c_one {1}
-\int_const:Nn \c_two {2}
-\int_const:Nn \c_three {3}
-\int_const:Nn \c_four {4}
-\int_const:Nn \c_five {5}
-%\int_const:Nn \c_six {6} %% in l3basics
-%\int_const:Nn \c_seven {7} %% in l3basics
-\int_const:Nn \c_eight {8}
-\int_const:Nn \c_nine {9}
-\int_const:Nn \c_ten {10}
-\int_const:Nn \c_eleven {11}
-%\int_const:Nn \c_twelve {12} %% in l3basics
-\int_const:Nn \c_thirteen {13}
-\int_const:Nn \c_fourteen {14}
-\int_const:Nn \c_fifteen {15}
- %% \tex_chardef:D \c_sixteen = 16\scan_stop: %% in l3basics
-\int_const:Nn \c_thirty_two {32}
-% \end{macrocode}
-% The next one may seem a little odd (obviously!) but is useful when
-% dealing with logical operators.
-% \begin{macrocode}
-\int_const:Nn \c_hundred_one {101}
-\int_const:Nn \c_twohundred_fifty_five{255}
-\int_const:Nn \c_twohundred_fifty_six {256}
-\int_const:Nn \c_thousand {1000}
-\int_const:Nn \c_ten_thousand {10000}
-\int_const:Nn \c_ten_thousand_one {10001}
-\int_const:Nn \c_ten_thousand_two {10002}
-\int_const:Nn \c_ten_thousand_three {10003}
-\int_const:Nn \c_ten_thousand_four {10004}
-\int_const:Nn \c_twenty_thousand {20000}
-% \end{macrocode}
-% \end{macro}
-%
-% \begin{macro}{\c_max_int}
-% The largest number allowed is $2^{31}-1$
-% \begin{macrocode}
-\int_const:Nn \c_max_int {2147483647}
-% \end{macrocode}
-% \end{macro}
-%
-%\begin{macro}[aux]{\c_int_from_roman_i_int}
-%\begin{macro}[aux]{\c_int_from_roman_v_int}
-%\begin{macro}[aux]{\c_int_from_roman_x_int}
-%\begin{macro}[aux]{\l_int_from_roman_l_int}
-%\begin{macro}[aux]{\c_int_from_roman_c_int}
-%\begin{macro}[aux]{\c_int_from_roman_d_int}
-%\begin{macro}[aux]{\c_int_from_roman_m_int}
-%\begin{macro}[aux]{\c_int_from_roman_I_int}
-%\begin{macro}[aux]{\c_int_from_roman_V_int}
-%\begin{macro}[aux]{\c_int_from_roman_X_int}
-%\begin{macro}[aux]{\c_int_from_roman_L_int}
-%\begin{macro}[aux]{\c_int_from_roman_C_int}
-%\begin{macro}[aux]{\c_int_from_roman_D_int}
-%\begin{macro}[aux]{\c_int_from_roman_M_int}
-% Delayed from earlier.
-% \begin{macrocode}
-\int_const:cn { c_int_from_roman_i_int } { 1 }
-\int_const:cn { c_int_from_roman_v_int } { 5 }
-\int_const:cn { c_int_from_roman_x_int } { 10 }
-\int_const:cn { c_int_from_roman_l_int } { 50 }
-\int_const:cn { c_int_from_roman_c_int } { 100 }
-\int_const:cn { c_int_from_roman_d_int } { 500 }
-\int_const:cn { c_int_from_roman_m_int } { 1000 }
-\int_const:cn { c_int_from_roman_I_int } { 1 }
-\int_const:cn { c_int_from_roman_V_int } { 5 }
-\int_const:cn { c_int_from_roman_X_int } { 10 }
-\int_const:cn { c_int_from_roman_L_int } { 50 }
-\int_const:cn { c_int_from_roman_C_int } { 100 }
-\int_const:cn { c_int_from_roman_D_int } { 500 }
-\int_const:cn { c_int_from_roman_M_int } { 1000 }
-% \end{macrocode}
-%\end{macro}
-%\end{macro}
-%\end{macro}
-%\end{macro}
-%\end{macro}
-%\end{macro}
-%\end{macro}
-%\end{macro}
-%\end{macro}
-%\end{macro}
-%\end{macro}
-%\end{macro}
-%\end{macro}
-%\end{macro}
-%
-% Needed from other modules:
-% \begin{macrocode}
-\int_new:N \g_tl_inline_level_int
-\int_new:N\g_prg_inline_level_int
-% \end{macrocode}
-%
-% \subsection{Backwards compatibility}
-% \begin{macrocode}
-\cs_set_eq:NN \intexpr_value:w \int_value:w
-\cs_set_eq:NN \intexpr_eval:w \int_eval:w
-\cs_set_eq:NN \intexpr_eval_end: \int_eval_end:
-\cs_set_eq:NN \if_intexpr_compare:w \if_int_compare:w
-\cs_set_eq:NN \if_intexpr_odd:w \if_int_odd:w
-\cs_set_eq:NN \if_intexpr_case:w \if_case:w
-\cs_set_eq:NN \intexpr_eval:n \int_eval:n
-
-\cs_set_eq:NN \intexpr_compare_p:n \int_compare_p:n
-\cs_set_eq:NN \intexpr_compare:nTF \int_compare:nTF
-\cs_set_eq:NN \intexpr_compare:nT \int_compare:nT
-\cs_set_eq:NN \intexpr_compare:nF \int_compare:nF
-
-\cs_set_eq:NN \intexpr_compare_p:nNn \int_compare_p:nNn
-\cs_set_eq:NN \intexpr_compare:nNnTF \int_compare:nNnTF
-\cs_set_eq:NN \intexpr_compare:nNnT \int_compare:nNnT
-\cs_set_eq:NN \intexpr_compare:nNnF \int_compare:nNnF
-
-\cs_set_eq:NN \intexpr_abs:n \int_abs:n
-\cs_set_eq:NN \intexpr_max:nn \int_max:nn
-\cs_set_eq:NN \intexpr_min:nn \int_min:nn
-
-\cs_set_eq:NN \intexpr_div_truncate:nn \int_div_truncate:nn
-\cs_set_eq:NN \intexpr_div_round:nn \int_div_round:nn
-\cs_set_eq:NN \intexpr_mod:nn \int_mod:nn
-
-\cs_set_eq:NN \intexpr_if_odd_p:n \int_if_odd_p:n
-\cs_set_eq:NN \intexpr_if_odd:nTF \int_if_odd:nTF
-\cs_set_eq:NN \intexpr_if_odd:nT \int_if_odd:nT
-\cs_set_eq:NN \intexpr_if_odd:nF \int_if_odd:nF
-
-\cs_set_eq:NN \intexpr_if_even_p:n \int_if_even_p:n
-\cs_set_eq:NN \intexpr_if_even:nTF \int_if_even:nTF
-\cs_set_eq:NN \intexpr_if_even:nT \int_if_even:nT
-\cs_set_eq:NN \intexpr_if_even:nF \int_if_even:nF
-
-\cs_set_eq:NN \intexpr_while_do:nn \int_while_do:nn
-\cs_set_eq:NN \intexpr_until_do:nn \int_until_do:nn
-\cs_set_eq:NN \intexpr_do_while:nn \int_do_while:nn
-\cs_set_eq:NN \intexpr_do_until:nn \int_do_until:nn
-
-\cs_set_eq:NN \intexpr_while_do:nNnn \int_while_do:nNnn
-\cs_set_eq:NN \intexpr_until_do:nNnn \int_until_do:nNnn
-\cs_set_eq:NN \intexpr_do_while:nNnn \int_do_while:nNnn
-\cs_set_eq:NN \intexpr_do_until:nNnn \int_do_until:nNnn
-% \end{macrocode}
-%
-% \begin{macrocode}
-%</initex|package>
-% \end{macrocode}
-%
-%
-% \end{implementation}
-% \PrintIndex
-%
-%
-% \endinput
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-16 15:31:14 +0000