}
% would crash. Not a very serious limitation, I believe.
%\end{lverb}
% \begin{macrocode}
\def\xintCntoCs {\romannumeral0\xintcntocs }%
\def\xintcntocs #1%
{%
\expandafter\XINT_cntcs\expandafter {\the\numexpr #1}%
}%
\def\XINT_cntcs #1#2%
{%
\ifnum #1<0
\xint_afterfi { }% 1.09i: a 0/1[0] was here, now the macro returns nothing
\else
\xint_afterfi {\expandafter\XINT_cntcs_loop\expandafter
{\the\numexpr #1-\xint_c_i\expandafter}\expandafter
{\romannumeral`&&@#2{#1}}{#2}}% produced coeff not braced
\fi
}%
\def\XINT_cntcs_loop #1#2#3%
{%
\ifnum #1>-\xint_c_i \else \XINT_cntcs_exit \fi
\expandafter\XINT_cntcs_loop\expandafter
{\the\numexpr #1-\xint_c_i\expandafter}\expandafter
{\romannumeral`&&@#3{#1}, #2}{#3}% space added, 1.09m
}%
\def\XINT_cntcs_exit \fi
\expandafter\XINT_cntcs_loop\expandafter
#1\expandafter #2#3%
{%
\fi\XINT_cntcs_exit_b #2%
}%
\def\XINT_cntcs_exit_b #1,{}% romannumeral stopping space already there
% \end{macrocode}
% \subsection{\csh{xintCntoGC}}
%\begin{lverb}
% Modified in 1.06 to give the N first to a \numexpr rather than expanding
% twice. I just use \the\numexpr and maintain the previous code after that.
%
% 1.09m maintains the braces, as the coeff are allowed to be fraction and the
% slash can not be naked in the GC format, contrarily to what happens in
% \xintCntoCs. Also the separators given to \xintGCtoGCx may then fetch the
% coefficients as argument, as they are braced.
%\end{lverb}
% \begin{macrocode}
\def\xintCntoGC {\romannumeral0\xintcntogc }%
\def\xintcntogc #1%
{%
\expandafter\XINT_cntgc\expandafter {\the\numexpr #1}%
}%
\def\XINT_cntgc #1#2%
{%
\ifnum #1<0
\xint_afterfi { }% 1.09i there was as strange 0/1[0] here, removed
\else
\xint_afterfi {\expandafter\XINT_cntgc_loop\expandafter
{\the\numexpr #1-\xint_c_i\expandafter}\expandafter
{\expandafter{\romannumeral`&&@#2{#1}}}{#2}}%
\fi
}%
\def\XINT_cntgc_loop #1#2#3%
{%
\ifnum #1>-\xint_c_i \else \XINT_cntgc_exit \fi
\expandafter\XINT_cntgc_loop\expandafter
{\the\numexpr #1-\xint_c_i\expandafter }\expandafter
{\expandafter{\romannumeral`&&@#3{#1}}+1/#2}{#3}%
}%
\def\XINT_cntgc_exit \fi
\expandafter\XINT_cntgc_loop\expandafter
#1\expandafter #2#3%
{%
\fi\XINT_cntgc_exit_b #2%
}%
\def\XINT_cntgc_exit_b #1+1/{ }%
% \end{macrocode}
% \subsection{\csh{xintGCntoGC}}
%\begin{lverb}
% Modified in 1.06 to give the N first to a \numexpr rather than expanding
% twice. I just use \the\numexpr and maintain the previous code after that.
%\end{lverb}
% \begin{macrocode}
\def\xintGCntoGC {\romannumeral0\xintgcntogc }%
\def\xintgcntogc #1%
{%
\expandafter\XINT_gcntgc\expandafter {\the\numexpr #1}%
}%
\def\XINT_gcntgc #1#2#3%
{%
\ifnum #1<0
\xint_afterfi { }% 1.09i now returns nothing
\else
\xint_afterfi {\expandafter\XINT_gcntgc_loop\expandafter
{\the\numexpr #1-\xint_c_i\expandafter}\expandafter
{\expandafter{\romannumeral`&&@#2{#1}}}{#2}{#3}}%
\fi
}%
\def\XINT_gcntgc_loop #1#2#3#4%
{%
\ifnum #1>-\xint_c_i \else \XINT_gcntgc_exit \fi
\expandafter\XINT_gcntgc_loop_b\expandafter
{\expandafter{\romannumeral`&&@#4{#1}}/#2}{#3{#1}}{#1}{#3}{#4}%
}%
\def\XINT_gcntgc_loop_b #1#2#3%
{%
\expandafter\XINT_gcntgc_loop\expandafter
{\the\numexpr #3-\xint_c_i \expandafter}\expandafter
{\expandafter{\romannumeral`&&@#2}+#1}%
}%
\def\XINT_gcntgc_exit \fi
\expandafter\XINT_gcntgc_loop_b\expandafter #1#2#3#4#5%
{%
\fi\XINT_gcntgc_exit_b #1%
}%
\def\XINT_gcntgc_exit_b #1/{ }%
% \end{macrocode}
% \subsection{\csh{xintCstoGC}}
% \begin{macrocode}
\def\xintCstoGC {\romannumeral0\xintcstogc }%
\def\xintcstogc #1%
{%
\expandafter\XINT_cstc_prep \romannumeral`&&@#1,!,%
}%
\def\XINT_cstc_prep #1,{\XINT_cstc_loop_a {{#1}}}%
\def\XINT_cstc_loop_a #1#2,%
{%
\xint_gob_til_exclam #2\XINT_cstc_end!%
\XINT_cstc_loop_b {#1}{#2}%
}%
\def\XINT_cstc_loop_b #1#2{\XINT_cstc_loop_a {#1+1/{#2}}}%
\def\XINT_cstc_end!\XINT_cstc_loop_b #1#2{ #1}%
% \end{macrocode}
% \subsection{\csh{xintGCtoGC}}
% \begin{macrocode}
\def\xintGCtoGC {\romannumeral0\xintgctogc }%
\def\xintgctogc #1%
{%
\expandafter\XINT_gctgc_start \romannumeral`&&@#1+!/%
}%
\def\XINT_gctgc_start {\XINT_gctgc_loop_a {}}%
\def\XINT_gctgc_loop_a #1#2+#3/%
{%
\xint_gob_til_exclam #3\XINT_gctgc_end!%
\expandafter\XINT_gctgc_loop_b\expandafter
{\romannumeral`&&@#2}{#3}{#1}%
}%
\def\XINT_gctgc_loop_b #1#2%
{%
\expandafter\XINT_gctgc_loop_c\expandafter
{\romannumeral`&&@#2}{#1}%
}%
\def\XINT_gctgc_loop_c #1#2#3%
{%
\XINT_gctgc_loop_a {#3{#2}+{#1}/}%
}%
\def\XINT_gctgc_end!\expandafter\XINT_gctgc_loop_b
{%
\expandafter\XINT_gctgc_end_b
}%
\def\XINT_gctgc_end_b #1#2#3{ #3{#1}}%
\XINTrestorecatcodesendinput%
% \end{macrocode}
% \StoreCodelineNo {xintcfrac}
% \cleardoublepage\let\xintcfracnameUp\undefined
%\gardesactifs
%\let\relax
%\let<*xintexpr>\gardesinactifs
%^^A--------------------------------------------------
%<*xintexpr>^^A---------------------------------------------------
%^^A -*- coding: utf-8; mode: doctex; fill-column: 78; sentence-end-double-space: t; eval: (auto-fill-mode -1)
% \clearpage\csname xintexprnameUp\endcsname
% \let\MakePrivateLetters\xintexprMakePrivateLetters
% \section{Package \xintexprnameimp implementation}
% \RaisedLabel{sec:exprimp}
% \addedcalx{2.0a1}
%
% \localtableofcontents
%
% xintexpr.sty: **WIP**
% Currently an empty wrapper loading calx.sty and xintfrac.sty.
% In future |\xinteval| will be defined by this file not by calx.sty.
%
%
% \subsection{Catcodes, \protect\eTeX{} and reload detection}
% \begin{macrocode}
\begingroup\catcode61\catcode48\catcode32=10\relax%
\catcode13=5 % ^^M
\endlinechar=13 %
\catcode123=1 % {
\catcode125=2 % }
\catcode64=11 % @
\catcode44=12 % ,
\catcode46=12 % .
\catcode58=12 % :
\catcode94=7 % ^
\catcode35=6 % #
\def\odef#1{\expandafter\def\expandafter#1\expandafter}%
\def\empty{}\def\space{ }\newlinechar10
\def\z{\endgroup}%
\expandafter\let\expandafter\x\csname ver@xintexpr.sty\endcsname
\expandafter\let\expandafter\f\csname ver@xintfrac.sty\endcsname
\expandafter\let\expandafter\c\csname ver@calx.sty\endcsname
% I assume engines do not exist providing \expanded but not \numexpr
\expandafter\ifx\csname expanded\endcsname\relax
\expandafter\ifx\csname PackageWarningNoLine\endcsname\relax
\immediate\write128{^^JPackage xintexpr Warning:^^J%
\space\space\space\space
\expanded not available, aborting input.^^J}%
\else
\PackageWarningNoLine{xintexpr}{\expanded not available, aborting input}%
\fi
\def\z{\endgroup\endinput}%
\else
\ifx\x\relax % not LaTeX (perhaps Plain+miniltx), first loading of xintexpr.sty
\ifx\c\relax % but calx.sty not yet loaded.
\odef\z{\z\input calx.sty\relax}%
\fi
\ifx\f\relax % but xintfrac.sty not yet loaded (made miniltx robust 2022/06/09)
\odef\z{\z\input xintfrac.sty\relax}%
\fi
\else
\ifx\x\empty % LaTeX, first loading,
% variable is initialized, but \ProvidesPackage not yet seen
\ifx\c\relax % calx not yet loaded.
\odef\z{\z\RequirePackage{calx}}%
\fi
\ifx\f\relax % xintfrac not yet loaded.
\odef\z{\z\RequirePackage{xintfrac}}%
\fi
\else
\def\z{\endgroup\endinput}% xintexpr already loaded.
\fi
\fi
\fi
\z%
\XINTsetupcatcodes%
% \end{macrocode}
% \subsection{Package identification}
% \begin{macrocode}
\XINT_providespackage
\ProvidesPackage{xintexpr}%
[2026/11/01 v2.0a1 Expandable fp, bigint and fraction expression parsers (JFB)]%
\catcode`! 11
% \end{macrocode}
% \subsection{\csh{XINTinFloatdigits}, \csh{XINTinFloatSdigits}}
% \begin{macrocode}
\def\XINTinFloatdigits {\XINTinFloat [\XINTdigits]}%
\def\XINTinFloatSdigits{\XINTinFloatS[\XINTdigits]}%
% \end{macrocode}
% \subsection{Top level user \TeX{} interface: \cshnolabel{xinteval}}
% \localtableofcontents
% \subsubsection{\csh{xintexpr}, \csh{xintiexpr}}
%\begin{lverb}
%
% \xintiexpr has an optional argument since 1.1.
%
% ATTENTION! 1.3d renamed $string$xinteval$space to \xintexpro etc...
% (thus this old $string$xinteval$space isn't our current \xinteval).
%
%
% Usage of \xintiRound{0} for \xintiexpr without optional [D] means that
% \xintiexpr ... \relax wrapper can be used to insert rounded-to-integers
% values in \xintiiexpr context: no post-fix [0] which would break it.
% ^^^^^^ REVISE THE ABOVE BECAUSE NOW WE HAVE [0] ^^^^^
%
% 1.4a add support for the optional argument [D] for \xintiexpr being negative
% D, with same meaning as the 1.4a modified \xintRound from xintfrac.sty.
%
% \xintiexpr mechanism was refactored at 1.4e so that rounding due to [D]
% optional argument uses raw format, not fixed point format on output,
% delegating fixed point conversion to an \XINTiexprprint now separated from
% \XINTexprprint.
%
% In case of negative [D], \xintiexpr [D]...\relax internally has the [0]
% post-fix so it can not be inserted as sub-expression in \xintiiexpr without
% a num() or \xintiexpr ...\relax (extra) wrapper.
%
%\end{lverb}
%
% \changed{1.4o}
% \begin{macrocode}
\def\xintexpr {\romannumeral0\xintexpro }%
\def\xintiexpr {\romannumeral0\xintiexpro }%
\def\xintexpro {\csname XINT_expr_wrap\expandafter\endcsname
\romannumeral0\xintbareeval }%
\def\xintiexpro #1%
{%
\ifx [#1\expandafter\XINT_iexpr_withopt\else\expandafter\XINT_iexpr_noopt
\fi #1%
}%
\def\XINT_iexpr_noopt
{%
\csname XINT_iexpr_iiround\expandafter\endcsname\romannumeral0\xintbareeval
}%
\def\XINT_iexpr_iiround
{%
\expandafter\XINT_expr_wrap
\expanded
\XINT:NEhook:x:mapwithin\XINT:expr:mapwithin{\XINTiRoundzero_braced}%
}%
% \end{macrocode}
% FIX THIS (for calx 2.0a1)
% \begin{macrocode}
\def\XINTiRoundzero_braced#1{{\xintiRound{0}{#1}}}%
\def\XINT_iexpr_withopt [#1]%
{%
\csname XINT_iexpr_round\expandafter\endcsname
\the\numexpr \xint_zapspaces #1 \xint_gobble_i\expandafter.%
\romannumeral0\xintbareeval
}%
\def\XINT_iexpr_round #1.%
{%
\ifnum#1=\xint_c_\xint_dothis{\XINT_iexpr_iiround}\fi
\xint_orthat{\XINT_iexpr_round_a #1.}%
}%
\def\XINT_iexpr_round_a #1.%
{%
\expandafter\XINT_iexpr_wrap
\expanded
\XINT:NEhook:x:mapwithin\XINT:expr:mapwithin{\XINTiRound_braced{#1}}%
}%
\def\XINTiRound_braced#1#2%
{{\xintiRound{#1}{#2}[\the\numexpr\ifnum#1<\xint_c_i0\else-#1\fi]}}%
% \end{macrocode}
% \subsubsection{\csh{XINT_expr_wrap},
% \csh{XINT_iexpr_wrap}}
%\begin{lverb}
% 1.3e removes some leading space tokens which served nothing.
%
% 1.4e has \XINT_iexpr_wrap separated from \XINT_expr_wrap, thus simplifying
% internal matters as output printer for \xintexpr will not have to handle
% fixed point input but only extended-raw type input (i.e. A, A/B, A[N] or A/B[N]).
%\end{lverb}
% \begin{macrocode}
\def\XINT_expr_wrap {\XINTfstop\XINTexprprint.}%
\def\XINT_iexpr_wrap {\XINTfstop\XINTiexprprint.}%
% \end{macrocode}
% \subsubsection{\csh{XINTexprprint}, \csh{XINTiexprprint}}
% \label{\xintimplabelprefix xintexprPrintOne}
% \label{\xintimplabelprefix xintiexprPrintOne}
% See comments in \calxnameimp.
% \begin{macrocode}
\protected\def\XINTexprprint.%
{\XINT:NEhook:x:toblist\XINT:expr:toblistwith\xintexprPrintOne}%
\protected\def\XINTiexprprint.%
{\XINT:NEhook:x:toblist\XINT:expr:toblistwith\xintiexprPrintOne}%
\let\xintiexprPrintOne\xintDecToString
\protected\def\XINTboolexprprint.%
{\XINT:NEhook:x:toblist\XINT:expr:toblistwith\xintboolexprPrintOne}%
\def\xintboolexprPrintOne#1{\calxifNotZero{#1}{true}{false}}%
% \end{macrocode}
% \subsubsection{\csh{xinttheexpr}, \csh{xinttheiexpr}}
% See comments in \calxnameimp.
%
% \begin{macrocode}
\def\xinttheexpr
{\expanded\csname XINTexprprint\expandafter\endcsname
\expandafter.\romannumeral0\xintbareeval}%
\def\xinttheiexpr{\expanded\expandafter\xint_gobble_i\romannumeral0\xintiexpro}%
% \end{macrocode}
% \subsubsection{\csh{xintbareeval}}
% See comments in \calxnameimp.
% \begin{macrocode}
\def\xintbareeval {\XINT_expr_start }%
% \end{macrocode}
% \subsubsection{\csh{xintthebareeval}}
% See comments in \calxnameimp.
% \begin{macrocode}
\def\xintthebareeval{%
\romannumeral0\csname xint_firstofone\expandafter\endcsname
\romannumeral0\xintbareeval
}%
% \end{macrocode}
% \subsubsection{\csh{xinteval}, \csh{xintieval}}
% See comments in \calxnameimp.
% \begin{macrocode}
\def\xinteval #1{%
\expanded\csname XINTexprprint\expandafter\endcsname
\expandafter.\romannumeral0\xintbareeval#1\relax
}%
% \end{macrocode}
% Should I use |#{| rather delimited argument? (as for \csbxint{iieval} at |1.4n|).
% \begin{macrocode}
\def\xintieval{\expanded\expandafter\xint_ieval_chkopt\string}%
\def\xint_ieval_chkopt #1%
{%
\ifx [#1\expandafter\xint_ieval_opt
\else\expandafter\xint_ieval_noopt
\fi #1%
}%
% \end{macrocode}
% \changed{1.4p} Here too I don't know why I had been using
% |\romannumeral`&&@\xintiexpr|. Replaced with |\romannumeral0\xintiexpro|.
% And I couldn't resist the temptation to immediately jump to |_withopt|.
% I did resist replacing |_withopt| with its expansion... this expansion
% will inject the |\csname| for Babel.
% \begin{macrocode}
\def\xint_ieval_opt [#1]#2{%
\expandafter\xint_gobble_i\romannumeral0\XINT_iexpr_withopt[#1]#2\relax
}%
\def\xint_ieval_noopt #1{\expandafter\xint_ieval\expandafter{\iffalse}\fi}%
% \end{macrocode}
% Attention that here the optional argument can come from the expression itself
% (legacy syntax).
% \begin{macrocode}
\def\xint_ieval#1{%
\expandafter\xint_gobble_i\romannumeral0\xintiexpro#1\relax
}%
% \end{macrocode}
% \subsubsection{\csh{xintboolexpr}, \csh{XINT_boolexpr_print}, \csh{xinttheboolexpr}}
%\begin{lverb}
% Attention, the conversion to 1 or 0 is done only by the print macro.
% Perhaps I should force it also inside raw result.
%\end{lverb}
% \begin{macrocode}
\def\xintboolexpr{%
\romannumeral0\expandafter\XINT_boolexpr_done\romannumeral0\xintexpro
}%
\def\XINT_boolexpr_done #1.{\XINTfstop\XINTboolexprprint.}%
% \end{macrocode}
% \changed{1.4o} A |\csname| for |\xinttheboolexpr| for Babel.
% \begin{macrocode}
\def\xinttheboolexpr{%
\expanded\csname XINTboolexprprint\expandafter\endcsname
\expandafter.\romannumeral0\xintbareeval
}%
% \end{macrocode}
% \subsubsection{\csh{xintifboolexpr}}
% See comments in \calxnameimp.
% FIXME CHECK STATUS OF |\xintiiifnotzero| WHOSE USAGE HERE WAS AN ABUSE
% ORIGINALLY
% \begin{macrocode}
\def\xintifboolexpr #1{%
\romannumeral0\expandafter\CALX_ifnz
\romannumeral0\csname xint_firstofone\expandafter\endcsname
\romannumeral0\xintbareeval #1\relax
}%
% \end{macrocode}
% \subsubsection{\csh{xintifsgnexpr}}
% \begin{macrocode}
\def\xintifsgnexpr #1{%
\romannumeral0\expandafter\CALX_ifsgn
\romannumeral0\csname xint_firstofone\expandafter\endcsname
\romannumeral0\xintbareeval #1\relax
}%
% \end{macrocode}
% \subsubsection{\csh{xint_FracToSci_x}}
% \added{1.4}
% TODO CLEAN UP COMMENTS WHICH HAVE MULTIPLE OBSOLETE COMPONENTS
% Under the name of |\xintFracToSci| and defined in \xintfracnameimp.
% \changed{1.4e}
%\begin{lverb}
% Refactored and much simplified
%
% It only needs to be x-expandable, and indeed the implementation here is only
% x-expandable.
%\end{lverb}
%\begin{lverb}
%
% Finally for 1.4e release I modify. This is breaking change for all
% \xinteval output in case of scientific notation: it will not be with an
% integer mantissa, but with regular scientific notation, using the same rules
% as \xintPFloat.
%
% Of course no float rounding! Also, as [0] will always or almost always be
% present from an \xinteval, we want then to use integer not scientific
% notation. But expression contained decimal fixed point input, or uses
% scientific functions, then probably the N will not be zero and this will
% trigger usage of scientific notation in output.
%
% Implementing these changes sort of ruin our previous efforts to minimize
% grabbing the argument, but well. So the rules now are
%
%( Input: A, A/B, A[N], A/B[N]
%: Output: A, A/B, A if N=0, A/B if N=0
%: If N is not zero, scientific notation like \xintPFloat,&
% i.e. behaviour like \xintfloateval apart from the rounding&
% to significands of width Digits.&
% At 1.4k, trimming of zeros from A is always done, i.e.&
% the \xintPFloatMinTrimmed is ignored to keep behaviour.&
% unchanged. Trailing zeros of B are kept as is.
%: The zero gives 0, except in A[N] and A/B[N] cases, it may give&
% 0.0
%)
%\end{lverb}
% \changed{1.4k}
% Moved from \xintfracnameimp to \xintexprnameimp.
% \changed{1.4l}
%\begin{lverb}
% Renamed to \xint_FracToSci_x to make it private and provide in
% $xintfracnameimp another \xintFracToSci with same output but which behaves
% like other macros there: f-expandable and accepting the whole range of
% inputs accepted by the xintfrac public macros.
%
% The private x-expandable macro here will have an empty output for an empty
% input but is never used for an empty input (see \xintexprEmptyItem).
%\end{lverb}
% \begin{macrocode}
\def\xint_FracToSci_x #1%
{\expandafter\CALX_fts\romannumeral`&&@#1/\W[\R}%
\def\XINT_FracToSci_x #1/#2#3[#4%
{%
\xint_gob_til_W #2\XINT_FracToSci_x_noslash\W
\xint_gob_til_R #4\XINT_FracToSci_x_slash_noN\R
\XINT_FracToSci_x_slash_N #1/#2#3[#4%
}%
\def\XINT_FracToSci_x_noslash#1\XINT_FracToSci_x_slash_N #2[#3%
{%
\xint_gob_til_R #3\XINT_FracToSci_x_noslash_noN\R
\XINT_FracToSci_x_noslash_N #2[#3%
}%
\def\XINT_FracToSci_x_noslash_noN\R\XINT_FracToSci_x_noslash_N #1/\W[\R{#1}%
\def\XINT_FracToSci_x_noslash_N #1[#2]/\W[\R%
{%
\ifnum#2=\xint_c_ #1\else
\romannumeral0\expandafter\XINT_pfloat_a_fork\romannumeral0\xintrez{#1[#2]}%
\fi
}%
\def\XINT_FracToSci_x_slash_noN\R\XINT_FracToSci_x_slash_N #1#2/#3/\W[\R%
{%
#1\xint_gob_til_zero#1\expandafter\iffalse\xint_gobble_ii0\iftrue
#2\if\XINT_isOne{#3}1\else/#3\fi\fi
}%
\def\XINT_FracToSci_x_slash_N #1#2/#3[#4]/\W[\R%
{%
\ifnum#4=\xint_c_ #1#2\else
\romannumeral0\expandafter\XINT_pfloat_a_fork\romannumeral0\xintrez{#1#2[#4]}%
\fi
\if\XINT_isOne{#3}1\else\if#10\else/#3\fi\fi
}%
% \end{macrocode}
%\begin{lverb}
% \xint_FracToSci_x also prints the native values of calx which reach
% \xinteval (nested \xintfloatexpr or \xintiiexpr, float or ii variables
% and functions): \CALX_fts tests the first token, a tag has character
% code above `9. I+, I-, I? are printed as they are; an M value is
% converted by calxint's \CALX_mtoraw (all digits), an F value by calxfp's
% \CALX_ftoraw (A[N]), then printed by \XINT_FracToSci_x.
%\end{lverb}
% \begin{macrocode}
\def\CALX_fts #1%
{\ifnum`#1>57 \expandafter\CALX_fts_t\fi\XINT_FracToSci_x #1}%
\def\CALX_fts_t\XINT_FracToSci_x #1#2/\W[\R
{\if I#1\xint_dothis{#1#2}\fi
\if M#1\xint_dothis{\expandafter\XINT_FracToSci_x
\romannumeral0\CALX_mtoraw{#1#2}/\W[\R}\fi
\xint_orthat{\expandafter\XINT_FracToSci_x
\romannumeral0\CALX_ftoraw{#1#2}/\W[\R}}%
\let\xintexprPrintOne\xint_FracToSci_x
% \end{macrocode}
% See \calxnameimp.
% \begin{macrocode}
\def\XINT_tmpa #1#2#3{%
\def #1##1%
{%
\csname
XINT_\ifcsname XINT_#3_func_##1\endcsname
#3_func_##1\expandafter\endcsname\romannumeral`&&@\expandafter#2%
\romannumeral\else
\ifcsname XINT_#3_onliteral_##1\endcsname
#3_onliteral_##1\expandafter\endcsname\romannumeral
\else
\ifcsname XINT_expr_var*_##1\endcsname
expr_var*_##1\expandafter\endcsname\romannumeral
\else
#3_func_\XINT_expr_unknown_function {##1}%
\expandafter\endcsname\romannumeral`&&@\expandafter#2%
\romannumeral
\fi\fi\fi\xint_c_
}%
}%
\expandafter\XINT_tmpa
\csname XINT_expr_op_`\endcsname
\XINT_expr_oparen
{expr}%
% \end{macrocode}
% \subsection{Raw input of the float operations}
%\begin{lverb}
% Syntax (as in calxfp, where \CALX_fr_x is the raw input branch of
% \CALX_fround):
%(
% \CALX_fr_x .\xint:
%: -> Y\xint: (Y: X rounded to P digits, native float)
%)
% calxfp accepts as raw values only A[N], A/B[N] (integers A, B without
% leading zeros, B > 0). With xintexpr.sty, X is any xintfrac
% input, as in xint 1.4: the arguments of macros made by \xintNewExpr and
% similar, the argument of qfloat() and the arguments of the \calxFp
% macros are not parsed by the expression parser. xintfrac's \XINTinFloat
% rounds X to P digits (its A[N] branch does not look for a decimal mark
% or an exponent), \CALX_ffromraw converts the A[N] result, and calxfp's
% \CALX_fr_f finishes as for a native input.
%\end{lverb}
% \begin{macrocode}
\def\CALX_fr_x #1.#2\xint:%
{\expandafter\CALX_fr_f\the\numexpr#1\expandafter.%
\romannumeral`&&@\CALX_ffromraw{\XINTinFloat[#1]{#2}}\xint:}%
% \end{macrocode}
% \subsection{Expansion spanning; opening and closing parentheses}
% See comments in \calxnameimp.
% \begin{macrocode}
\catcode`) 11
\expandafter\XINT_def_start_and_check
\csname XINT_expr_start\expandafter\endcsname
\csname XINT_expr_check\expandafter\endcsname
\csname XINT_expr_checkp\expandafter\endcsname
\csname XINT_expr_op_-xii\expandafter\endcsname
\csname XINT_expr_extra_)\endcsname
{expr}%
\expandafter\XINT_defop_oparen
\csname XINT_expr_op_(\expandafter\endcsname
\csname XINT_expr_op_)\expandafter\endcsname
\csname XINT_expr_oparen\expandafter\endcsname
\csname XINT_expr_check-_)\expandafter\endcsname
\csname XINT_expr_checkp_)\expandafter\endcsname
\csname XINT_expr_op_-xii\endcsname
{expr}%
\catcode`) 12
% \end{macrocode}
% \let\MakePrivateLetters\xintexprMakePrivateLetters
% \subsection{The comma as binary operator}
%\begin{lverb}
% New with 1.09a. Refactored at 1.4.
%\end{lverb}
% \begin{macrocode}
\expandafter\XINT_defop_comma
\csname XINT_expr_op_,\expandafter\endcsname
\csname XINT_expr_exec_,\expandafter\endcsname
\csname XINT_expr_check-_,\expandafter\endcsname
\csname XINT_expr_checkp_,\expandafter\endcsname
\csname XINT_expr_op_-xii\endcsname {expr}%
% \end{macrocode}
% \subsection{The minus as prefix operator of variable precedence level}
% \begin{macrocode}
\xintApplyInline{\XINT_defop_minus {expr}\xintOpp}{{xii}{xiv}{xvii}}%
% \end{macrocode}
% \subsection{The \texorpdfstring{\protect\lowast}{*}{} as Python-like «unpacking» prefix operator}
% \begin{macrocode}
\expandafter\XINT_defpost_unpack\csname XINT_expr_op_0\expandafter\endcsname
\csname XINT_expr_until_unpack\endcsname {expr}%
% \end{macrocode}
% \subsection{\cshnolabel{xintPow}}
%\begin{lverb}
%(\xintPow{a}{b} -> raw value of a^b
%)
% xintexpr.sty redefines xintfrac's \xintPow: ^, ** and pow() of
% \xinteval use it. b = 0: 1[0]. b an integer: exact power
% (xintfrac) if numerator and denominator of the result have at most
% about 10000 digits, else xintfrac's float power at \XINTdigits. b not
% an integer (half-integers included): \calxFpPow, the power of
% \xintfloateval, its result converted to raw. a = 0, b < 0:
% InvalidOperation, value 0 (as 1/0 in \xinteval).
%\end{lverb}
% \begin{macrocode}
\def\xintPow{\romannumeral0\xintpow}%
\def\xintpow#1#2%
{%
\expandafter\XINT_scipow_a\romannumeral0\xintrez{#2}\XINT_pow_int{#1}%
}%
\def\XINT_scipow_a #1%
{%
\xint_gob_til_zero#1\XINT_scipow_Biszero0\XINT_scipow_b#1%
}%
\def\XINT_scipow_Biszero#1]#2#3{ 1[0]}%
\def\XINT_scipow_b #1#2/#3[#4]#5%
{%
\unless\if1\XINT_is_One#3XY\xint_dothis\XINT_scipow_c\fi
\ifnum#4<\xint_c_ \xint_dothis\XINT_scipow_c\fi
\xint_orthat#5#1#2/#3[#4]%
}%
\def\XINT_scipow_c #1[#2]#3%
{%
\ifnum\xintSgn{#3}=\xint_c_ \expandafter\XINT_scipow_z
\else\expandafter\XINT_scipow_e\fi #1[#2]{#3}%
}%
\def\XINT_scipow_e #1[#2]#3{\CALX_ftoraw{\calxFpPow{#3}{#1[#2]}}}%
\def\XINT_scipow_z #1#2[#3]#4%
{%
\if-#1\xint_dothis{\XINT_legacysignalcondition{InvalidOperation}%
{0 raised to power #1#2[#3].}{}{ 0[0]}}\fi
\xint_orthat{ 0[0]}%
}%
\def\XINT_pow_int #1/1[#2]%
{%
\expandafter\XINT_pow_int_a\romannumeral0\XINT_dsx_addzeros{#2}#1;.%
}%
\def\XINT_pow_int_a #1#2.%
{%
\ifnum\if-#1\xintLength{#2}\else\xintLength{#1#2}\fi>\xint_c_iv
\expandafter\XINT_pow_bigint
\else\expandafter\XINT_pow_int_b
\fi #1#2.%
}%
\def\XINT_pow_bigint #1.#2%
{%
\XINT_flpower_checkB_a#1.\XINTdigits.{#2}{\XINTinfloatS[\XINTdigits]}%
}%
\def\XINT_pow_int_b #1.#2%
{%
\expandafter\XINT_pow_int_c\romannumeral0\xintraw{#2}\xint:#1\xint:
}%
\def\XINT_pow_int_c#1#2/#3[#4]\xint:#5\xint:
{%
\if0\ifnum\numexpr\xint_c_e_iv/%
(\xintLength{#1#2}\if-#1-\xint_c_i\fi)<\XINT_Abs#5 %
1\else
\ifnum\numexpr\xint_c_e_iv/\xintLength{#3}<\XINT_Abs#5 %
1\else
0\fi\fi
\expandafter\XINT_fpow_fork\else\expandafter\XINT_pow_bigint_i
\fi
#5\Z{#4}{#1#2}{#3}%
}%
\def\XINT_pow_bigint_i#1\Z#2#3#4%
{%
\XINT_flpower_checkB_a#1.\XINTdigits.{#3/#4[#2]}{\XINTinfloatS[\XINTdigits]}%
}%
\def\XINT_expr_func_pow #1#2#3%
{%
\expandafter #1\expandafter #2\expandafter{%
\romannumeral`&&@\XINT:NEhook:f:one:from:two
{\romannumeral`&&@\xintPow#3}}%
}%
% \end{macrocode}
% \subsubsection{\&\&, \textbar\textbar, //, /:, +,
% \textendash, \texorpdfstring{\protect\lowast}{*}, /, \textasciicircum,
% \texorpdfstring{\protect\lowast\protect\lowast}{**}{}, \textquotesingle and\textquotesingle, \textquotesingle
% or\textquotesingle, \textquotesingle xor\textquotesingle, and
% \textquotesingle mod\textquotesingle}
% \begin{macrocode}
\XINT_expr_defbin_a {expr} {||} {6} {6} \calxOR
\catcode`& 12
\XINT_expr_defbin_a {expr} {&&} {8} {8} \calxAND
\catcode`& 7
\XINT_expr_defbin_a {expr} {xor}{6} {6} \calxXOR
\XINT_expr_defbin_a {expr} {//} {14}{14}\xintDivFloor
\XINT_expr_defbin_a {expr} {/:} {14}{14}\xintMod
\XINT_expr_defbin_a {expr} + {12}{12}\xintAdd
\XINT_expr_defbin_a {expr} - {12}{12}\xintSub
\XINT_expr_defbin_a {expr} * {14}{14}\xintMul
\XINT_expr_defbin_a {expr} / {14}{14}\xintDiv
\XINT_expr_defbin_a {expr} ^ {18}{17}\xintPow
\catcode`& 12
\expandafter\let\csname XINT_expr_op_and\expandafter\endcsname
\csname XINT_expr_op_&&\endcsname
\expandafter\let\csname XINT_expr_op_or\expandafter\endcsname
\csname XINT_expr_op_||\endcsname
\expandafter\let\csname XINT_expr_op_mod\expandafter\endcsname
\csname XINT_expr_op_/:\endcsname
\catcode`& 7
% \end{macrocode}
% \subsubsection{.., ..[, and ].. for a..b and a..[b]..c syntax}
%\begin{lverb}
% a..[d]..b of \xinteval. Contrarily to a..b which is limited to small
% integers, this works with a, b, and d (big) fractions. It will produce a «nil» list, if a>b and
% d<0 or a0.
%\end{lverb}
%
% \paragraph{\csh{xintSeqA}}
%
% \begin{macrocode}
\def\xintSeqA {\expandafter\XINT_SeqA\romannumeral0\xintraw}%
\def\XINT_SeqA #1]#2{\expandafter\XINT_SeqA_a\romannumeral0\xintraw {#2}#1]}%
\def\XINT_SeqA_a #1{\xint_UDzerominusfork
#1-{z}%
0#1{n}%
0-{p}%
\krof #1}%
% \end{macrocode}
% \paragraph{\csh{xintSeqB:tl:x}}
%\begin{lverb}
% At 1.4, delayed expansion of start and step done here and not before,
% for matters of \xintdeffunc and «NEhooks».
%
% The float variant at 1.4 is made identical to the exact variant. I.e.
% stepping is exact and comparison to the range limit too. But recall that a/b
% input will be converted to a float. To handle 1/3 step for example still
% better to use \xintexpr 1..1/3..10\relax for example inside the \xintfloateval.
%
%\end{lverb}
% \begin{macrocode}
\def\xintSeqB:tl:x #1{\expandafter\XINT_SeqB:tl:x\romannumeral`&&@\xintSeqA#1}%
\def\XINT_SeqB:tl:x #1{\csname XINT_SeqB#1:tl:x\endcsname}%
\def\XINT_SeqBz:tl:x #1]#2]#3{{#2]}}%
\def\XINT_SeqBp:tl:x #1]#2]#3%
{\expandafter\XINT_SeqBp:tl:x_a\romannumeral0\xintraw{#3}#2]#1]}%
\def\XINT_SeqBp:tl:x_a #1]#2]#3]%
{%
\xintifCmp{#1]}{#2]}%
{}{{#2]}}{{#2]}\expandafter\XINT_SeqBp:tl:x_b\romannumeral0\xintadd{#3]}{#2]}#1]#3]}%
}%
\def\XINT_SeqBp:tl:x_b #1]#2]#3]%
{%
\xintifCmp{#1]}{#2]}%
{{#1]}\expandafter\XINT_SeqBp:tl:x_b\romannumeral0\xintadd{#3]}{#1]}#2]#3]}{{#1]}}{}%
}%
\def\XINT_SeqBn:tl:x #1]#2]#3%
{\expandafter\XINT_SeqBn:tl:x_a\romannumeral0\xintraw{#3}#2]#1]}%
\def\XINT_SeqBn:tl:x_a #1]#2]#3]%
{%
\xintifCmp{#1]}{#2]}%
{{#2]}\expandafter\XINT_SeqBn:tl:x_b\romannumeral0\xintadd{#3]}{#2]}#1]#3]}{{#2]}}{}%
}%
\def\XINT_SeqBn:tl:x_b #1]#2]#3]%
{%
\xintifCmp{#1]}{#2]}%
{}{{#1]}}{{#1]}\expandafter\XINT_SeqBn:tl:x_b\romannumeral0\xintadd{#3]}{#1]}#2]#3]}%
}%
\XINT_expr_defbin_b {expr}%
\XINT_expr_defbin_c {expr} {..}\xintSeq:tl:x
\XINT_expr_defbin_c {expr} {]..}\xintSeqB:tl:x
% \end{macrocode}
% \subsubsection{<, >, ==, <=, >=, != with Python-like chaining}
% \begin{macrocode}
\XINT_expr_defbin_d {expr} <\xintLt
\XINT_expr_defbin_d {expr} >\xintGt
\XINT_expr_defbin_d {expr} {==}\xintEq
\XINT_expr_defbin_d {expr} {<=}\xintLtorEq
\XINT_expr_defbin_d {expr} {>=}\xintGtorEq
\XINT_expr_defbin_d {expr} {!=}\xintNotEq
% \end{macrocode}
% \subsubsection{[...] as «oneple» constructor}
% \begin{macrocode}
\XINT_expr_defbin_e {expr}%
% \end{macrocode}
% \subsubsection{[...] brackets and : operator for NumPy-like slicing and item
% indexing syntax}
% \begin{macrocode}
\XINT_expr_defbin_f {expr}%
\XINT_expr_defbin_g {expr}%
% \end{macrocode}
% \subsection{Support for raw A/B[N]}
% See comments in \calxnameimp.
% \odef\MakePrivateLetters{\MakePrivateLetters\catcode`& 11 }^^A
% \begin{macrocode}
\catcode0 11
\let\XINT_expr_precedence_&&@ \xint_c_xiv
\def\XINT_expr_op_&&@ #1#2]%
{%
\expandafter\XINT_expr_put_op_first
\expanded{{{\xintE#1{\xint_zapspaces #2 \xint_gobble_i}}}%
\expandafter}\romannumeral`&&@\XINT_expr_getop
}%
\catcode2 11
\let\XINT_expr_op_&&B\XINT_flexpr_op_&&B
\catcode2 12
\catcode3 11
\let\XINT_expr_op_&&C \XINT_flexpr_op_&&C
\catcode3 12
\catcode0 12
% \end{macrocode}
% \let\MakePrivateLetters\xintexprMakePrivateLetters
% \subsection{? as two-way and ?? as three-way «short-circuit» conditionals}
% \begin{macrocode}
\catcode`- 11
% \end{macrocode}
% \odef\MakePrivateLetters{\MakePrivateLetters\catcode`- 11 }\FixInterMacrocodeVspace
% \begin{macrocode}
\def\XINT_expr_op_? {\XINT_expr_op__? \XINT_expr_op_-xii}%
\catcode`- 12
% \end{macrocode}
% \let\MakePrivateLetters\xintexprMakePrivateLetters
% \subsection{! as postfix factorial operator}
% \begin{macrocode}
\def\XINT_expr_op_! #1%
{%
\expandafter\XINT_expr_put_op_first
\expanded{{\romannumeral`&&@\XINT:NEhook:f:one:from:one
{\romannumeral`&&@\xintFac#1}}\expandafter}\romannumeral`&&@\XINT_expr_getop
}%
% \end{macrocode}
% \subsection{User defined variables: \csh{xintdefvar}}
% \begin{macrocode}
\def\xintdefvar {\xintexprSafeCatcodes\xintdefvar_a}%
\def\xintdefvar_a#1={\XINT_expr_defvar\xintthebareeval{#1}}%
% \end{macrocode}
% \subsection{\cshnolabel{qfrac()} of \cshnolabel{xinteval}}
%\begin{lverb}
% The legacy qfrac() (\xintRaw: any xintfrac input, exact) for \xinteval
% only; the \xintfloateval and \xintiieval ones are calx.sty's (strict
% A/B) and are not changed.
%\end{lverb}
% \begin{macrocode}
\def\XINT_expr_onliteral_qfrac #1)%
{\expandafter\XINT_expr_put_op_first\expanded{{{\xintRaw{#1}}}\expandafter
}\romannumeral`&&@\XINT_expr_getop}%
% \end{macrocode}
% \subsection{Regular built-in functions}
% \begin{macrocode}
\let\XINT_expr_func_num\XINT_iiexpr_func_num
% \end{macrocode}
%\begin{lverb}
% reduce() and preduce() (xintfrac's \xintIrr, \xintPIrr) of \xinteval;
% calx gives none for \xintfloateval: xintexpr.sty adds them, the same
% macros. reduce(): \xintIrrz, \xintIrr's output with [0] appended (the
% [0] follows the input of \XINT_irr_start, as the [N] of \xintPIrr).
% Not user level.
%\end{lverb}
% \begin{macrocode}
\def\xintIrrz {\romannumeral0\xintirrz }%
\def\xintirrz #1%
{%
\expandafter\XINT_irr_start\romannumeral0\xintrawwithzeros {#1}\Z[0]%
}%
\def\XINT_expr_func_reduce #1#2#3%
{%
\expandafter #1\expandafter #2\expandafter{%
\romannumeral`&&@\XINT:NEhook:f:one:from:one
{\romannumeral`&&@\xintIrrz#3}}%
}%
\def\XINT_expr_func_preduce #1#2#3%
{%
\expandafter #1\expandafter #2\expandafter{%
\romannumeral`&&@\XINT:NEhook:f:one:from:one
{\romannumeral`&&@\xintPIrr#3}}%
}%
\let\XINT_flexpr_func_reduce\XINT_expr_func_reduce
\let\XINT_flexpr_func_preduce\XINT_expr_func_preduce
\def\XINT_expr_func_abs #1#2#3%
{%
\expandafter #1\expandafter #2\expandafter{%
\romannumeral`&&@\XINT:NEhook:f:one:from:one
{\romannumeral`&&@\xintAbs#3}}%
}%
\let\XINT_expr_func_sgn\XINT_iiexpr_func_sgn
\def\XINT_expr_func_frac #1#2#3%
{%
\expandafter #1\expandafter #2\expandafter{%
\romannumeral`&&@\XINT:NEhook:f:one:from:one
{\romannumeral`&&@\xintTFrac#3}}%
}%
\def\XINT_expr_func_floor #1#2#3%
{%
\expandafter #1\expandafter #2\expandafter{%
\romannumeral`&&@\XINT:NEhook:f:one:from:one
{\romannumeral`&&@\xintFloor#3}}%
}%
\def\XINT_expr_func_ceil #1#2#3%
{%
\expandafter #1\expandafter #2\expandafter{%
\romannumeral`&&@\XINT:NEhook:f:one:from:one
{\romannumeral`&&@\xintCeil#3}}%
}%
\def\XINT_expr_func_sqr #1#2#3%
{%
\expandafter #1\expandafter #2\expandafter{%
\romannumeral`&&@\XINT:NEhook:f:one:from:one
{\romannumeral`&&@\xintSqr#3}}%
}%
\let\XINT_expr_func_? \XINT_iiexpr_func_?
\let\XINT_expr_func_! \XINT_iiexpr_func_!
\let\XINT_expr_func_not \XINT_iiexpr_func_not
\def\XINT_expr_func_odd #1#2#3%
{%
\expandafter #1\expandafter #2\expandafter{%
\romannumeral`&&@\XINT:NEhook:f:one:from:one
{\romannumeral`&&@\xintOdd#3}}%
}%
\def\XINT_expr_func_even #1#2#3%
{%
\expandafter #1\expandafter #2\expandafter{%
\romannumeral`&&@\XINT:NEhook:f:one:from:one
{\romannumeral`&&@\xintEven#3}}%
}%
\def\XINT_expr_func_isint #1#2#3%
{%
\expandafter #1\expandafter #2\expandafter{%
\romannumeral`&&@\XINT:NEhook:f:one:from:one
{\romannumeral`&&@\xintIsInt#3}}%
}%
\def\XINT_expr_func_isone #1#2#3%
{%
\expandafter #1\expandafter #2\expandafter{%
\romannumeral`&&@\XINT:NEhook:f:one:from:one
{\romannumeral`&&@\xintIsOne#3}}%
}%
\def\XINT_expr_func_factorial #1#2#3%
{%
\expandafter #1\expandafter #2\expandafter{\expandafter{%
\romannumeral`&&@\XINT:NEhook:f:one:and:opt:direct
\XINT:expr:f:one:and:opt #3,!\xintFac\XINTinFloatFac
}}%
}%
\let\XINT_expr_func_sqrt\XINT_flexpr_func_sqrt
\def\XINT_expr_func_inv #1#2#3%
{%
\expandafter #1\expandafter #2\expandafter{%
\romannumeral`&&@\XINT:NEhook:f:one:from:one
{\romannumeral`&&@\xintInv#3}}%
}%
% \end{macrocode}
% \changed{2.0a1}
%
% Eversince |1.4a| and the support for negative arguments the functions
% round(x,n) and trunc(x,n) were half-broken in both \csbxint{eval}
% and \csbxint{floateval} because the underlying \csbxint{Round} and
% \csbxint{Trunc} with a negative rounding argument produced scientific
% notation which is not acceptable in leaves which apply \cs{detokenize}
% hence a catcode 12 e breaking \csbxint{floateval} printer.
% \begin{macrocode}
\def\xintRoundToRaw#1{\romannumeral0\expandafter\xintroundtoraw\the\numexpr#1.}%
\def\xintroundtoraw#1.#2{\xintiround{#1}{#2}[-#1]}%
\def\XINT_expr_func_round #1#2#3%
{%
\expandafter #1\expandafter #2\expandafter{\expandafter{%
\romannumeral`&&@\XINT:NEhook:f:tacitzeroifone:direct
\XINT:expr:f:tacitzeroifone #3,!\xintiRound\xintRoundToRaw
}}%
}%
\def\xintTruncToRaw#1{\romannumeral0\expandafter\xinttrunctoraw\the\numexpr#1.}%
\def\xinttrunctoraw#1.#2{\xintitrunc{#1}{#2}[-#1]}%
\def\XINT_expr_func_trunc #1#2#3%
{%
\expandafter #1\expandafter #2\expandafter{\expandafter{%
\romannumeral`&&@\XINT:NEhook:f:tacitzeroifone:direct
\XINT:expr:f:tacitzeroifone #3,!\xintiTrunc\xintTruncToRaw
}}%
}%
\def\XINT_expr_func_float #1#2#3%
{%
\expandafter #1\expandafter #2\expandafter{\expandafter{%
\romannumeral`&&@\XINT:NEhook:f:one:and:opt:direct
\XINT:expr:f:one:and:opt #3,!\XINTinFloatdigits\XINTinFloat
}}%
}%
\def\XINT_expr_func_float_dgt #1#2#3%
{%
\expandafter #1\expandafter #2\expandafter{%
\romannumeral`&&@\XINT:NEhook:f:one:from:one
{\romannumeral`&&@\XINTinFloatdigits#3}}%
}%
\def\XINT_expr_func_sfloat #1#2#3%
{%
\expandafter #1\expandafter #2\expandafter{\expandafter{%
\romannumeral`&&@\XINT:NEhook:f:one:and:opt:direct
\XINT:expr:f:one:and:opt #3,!\XINTinFloatSdigits\XINTinFloatS
}}%
}%
\expandafter\def\csname XINT_expr_func_ilog10\endcsname #1#2#3%
{%
\expandafter #1\expandafter #2\expandafter{\expandafter{%
\romannumeral`&&@\XINT:NEhook:f:one:and:opt:direct
\XINT:expr:f:one:and:opt #3,!\xintiLogTen\XINTFloatiLogTen
}}%
}%
\def\XINT_expr_func_divmod #1#2#3%
{%
\expandafter #1\expandafter #2\expandafter{\romannumeral`&&@%
\XINT:NEhook:f:one:from:two
{\romannumeral`&&@\xintDivMod #3}}%
}%
\def\XINT_expr_func_mod #1#2#3%
{%
\expandafter #1\expandafter #2\expandafter{\romannumeral`&&@%
\XINT:NEhook:f:one:from:two
{\romannumeral`&&@\xintMod#3}}%
}%
\def\XINT_expr_func_binomial #1#2#3%
{%
\expandafter #1\expandafter #2\expandafter{\romannumeral`&&@%
\XINT:NEhook:f:one:from:two
{\romannumeral`&&@\xintBinomial #3}}%
}%
\def\XINT_expr_func_pfactorial #1#2#3%
{%
\expandafter #1\expandafter #2\expandafter{\romannumeral`&&@%
\XINT:NEhook:f:one:from:two
{\romannumeral`&&@\xintPFactorial #3}}%
}%
\let\XINT_expr_func_randrange\XINT_flexpr_func_randrange
% \end{macrocode}
%\begin{lverb}
% gcd() and lcm() of \xinteval: xintfrac's \XINT_GCDof, \XINT_LCMof
% (fractions, raw A/B[0] output). calx gives none for \xintfloateval:
% xintexpr.sty adds them, the same macros (items converted to raw by
% xintfrac's input parser, \CALX_infr; output left raw as legacy).
%\end{lverb}
% \begin{macrocode}
\def\XINT_expr_func_gcd #1#2#3%
{%
\expandafter #1\expandafter #2\expandafter{\expandafter
{\romannumeral`&&@\XINT:NEhook:f:from:delim:u\XINT_GCDof#3^}}%
}%
\def\XINT_expr_func_lcm #1#2#3%
{%
\expandafter #1\expandafter #2\expandafter{\expandafter
{\romannumeral`&&@\XINT:NEhook:f:from:delim:u\XINT_LCMof#3^}}%
}%
\let\XINT_flexpr_func_gcd\XINT_expr_func_gcd
\let\XINT_flexpr_func_lcm\XINT_expr_func_lcm
\def\XINT_expr_func_max #1#2#3%
{%
\expandafter #1\expandafter #2\expandafter{\expandafter
{\romannumeral`&&@\XINT:NEhook:f:from:delim:u\XINT_Maxof#3^}}%
}%
\def\XINT_expr_func_min #1#2#3%
{%
\expandafter #1\expandafter #2\expandafter{\expandafter
{\romannumeral`&&@\XINT:NEhook:f:from:delim:u\XINT_Minof#3^}}%
}%
\expandafter
\def\csname XINT_expr_func_+\endcsname #1#2#3%
{%
\expandafter #1\expandafter #2\expandafter{\expandafter
{\romannumeral`&&@\XINT:NEhook:f:from:delim:u\XINT_Sum#3^}}%
}%
\expandafter
\def\csname XINT_expr_func_*\endcsname #1#2#3%
{%
\expandafter #1\expandafter #2\expandafter{\expandafter
{\romannumeral`&&@\XINT:NEhook:f:from:delim:u\XINT_Prd#3^}}%
}%
\let\XINT_expr_func_all\XINT_iiexpr_func_all
\let\XINT_expr_func_any\XINT_iiexpr_func_any
\let\XINT_expr_func_xor\XINT_iiexpr_func_xor
\let\XINT_expr_func_len\XINT_iiexpr_func_len
\let\XINT_expr_func_first\XINT_flexpr_func_first
\let\XINT_expr_func_last\XINT_flexpr_func_last
\let\XINT_expr_func_reversed\XINT_flexpr_func_reversed
\let\XINT_expr_func_if\XINT_flexpr_func_if
% \end{macrocode}
%\begin{lverb}
% ifint() and ifone() of \xinteval: xintfrac's \xintifInt, \xintifOne, for
% its values (any xintfrac input, fractions); the calx ones of
% \xintiieval and \xintfloateval are for the native values.
%\end{lverb}
% \begin{macrocode}
\def\XINT_expr_func_ifint #1#2#3%
{%
\expandafter #1\expandafter #2\expandafter{%
\romannumeral`&&@\XINT:NEhook:branch{\romannumeral`&&@\xintifInt #3}}%
}%
\def\XINT_expr_func_ifone #1#2#3%
{%
\expandafter #1\expandafter #2\expandafter{%
\romannumeral`&&@\XINT:NEhook:branch{\romannumeral`&&@\xintifOne #3}}%
}%
\let\XINT_expr_func_ifsgn\XINT_flexpr_func_ifsgn
\let\XINT_expr_func_nuple\XINT_flexpr_func_nuple
\let\XINT_expr_func_unpack\XINT_flexpr_func_unpack
\let\XINT_expr_func_flat\XINT_flexpr_func_flat
\let\XINT_expr_func_zip\XINT_flexpr_func_zip
% \end{macrocode}
% \subsection{User declared functions}
% The mysterious |\XINT_NewFunc| is defined at bottom of this file.
% For comments see \calxnameimp.
% \begin{macrocode}
\def\xintdeffunc{\xintexprSafeCatcodes\xintdeffunc_a}%
\XINT_def_deffunc
\xintdeffunc_a{expr}\XINT_NewFunc{expr}\xintdeffunc_b
\def\xintdefufunc{\xintexprSafeCatcodes\xintdefufunc_a}%
\XINT_def_defufunc
\xintdefufunc_a{expr}\XINT_NewFunc{expr}\xintdefufunc_b\xintdefufunc_c
% \end{macrocode}
% \subsubsection{\cshnolabel{xintunassignexprfunc}}
% \begin{macrocode}
\XINT_def_unassignfunc{expr}%
% \end{macrocode}
% \subsubsection{\csh{xintNewExpr}, \csh{xintNewIExpr}, \csh{xintNewBoolExpr},
% \csh{xintNewFloatExpr}, \csh{xintNewIIExpr}}
%\begin{lverb}
% 1.2c modifications to accomodate \XINT_expr_deffunc_newexpr etc..
%
% 1.2f adds token \XINT_newexpr_clean to be able to have a different
% \XINT_newfunc_clean.
%
% As \XINT_NewExpr always execute \XINT_expr_redefineprints since 1.3e whether
% with \xintNewExpr or \XINT_NewFunc, it has been moved from argument to
% hardcoded in replacement text.
%
% NO MORE \XINT_expr_redefineprints at 1.4 ! This allows better support for
% \xinteval, \xinttheexpr as sub-entities inside an \xintNewExpr. And the
% «cleaning» will remove the new \XINTfstop , to maintain backwards
% compatibility with former behaviour that created macros expand to explicit
% digits and not an encapsulated result.
%
% (obsolete:) The #2#3 in clean stands for \noexpand\XINTfstop.
%\end{lverb}
% \changed{1.4n}
%\begin{lverb}
% The #2#3 in previous paragraph is obsolete, the pattern used for
% \XINT_newexpr_clean was formerly #1>#2#3 (not optimal, but legacy), but is
% now simply #1\XINTfstop. This is simpler and allows compatibility with
% LuaMetaTeX whose \meaning output differs from the one of other engines.
%\end{lverb}
% \begin{macrocode}
\catcode`\~=12
\def\XINT_flexpr_getmacropar #1{%
\def\XINT_flexpr_getmacropar ##1%
{%
\expanded{{{~xintRaw{#1##1}}}\expandafter}%
\romannumeral`&&@\XINT_expr_getop
}%
}\expandafter\XINT_flexpr_getmacropar\string#%
\def\XINT_iiexpr_getmacropar #1{%
\def\XINT_iiexpr_getmacropar ##1%
{%
\expanded{{{~xintiNum{#1##1}}}\expandafter}%
\romannumeral`&&@\XINT_expr_getop
}%
}\expandafter\XINT_iiexpr_getmacropar\string#%
\catcode`\~=3
\def\xintNewFloatExpr{\begingroup
\let\XINT_expr_getmacropar\XINT_flexpr_getmacropar
\XINT_NewExpr_a\xint_firstofone\xintfloatexpr\XINT_newexpr_clean
}%
\def\xintNewIIExpr{\begingroup
\let\XINT_expr_getmacropar\XINT_iiexpr_getmacropar
\XINT_NewExpr_a\xint_firstofone\xintiiexpr\XINT_newexpr_clean
}%
\def\XINT_newexpr_clean #1\XINTfstop{\noexpand\expanded\noexpand\xintNEprinthook}%
\def\xintNEprinthook#1.#2{\expanded{\xint_noxpd{#1.}{#2}}}%
\def\xintNewExpr {\XINT_NewExpr\xint_firstofone\xintexpr \XINT_newexpr_clean}%
\def\xintNewIExpr {\XINT_NewExpr\xint_firstofone\xintiexpr \XINT_newexpr_clean}%
\def\xintNewBoolExpr {\XINT_NewExpr\xint_firstofone\xintboolexpr \XINT_newexpr_clean}%
\def\XINT_NewFunc {\XINT_NewExpr\xint_gobble_i\xintthebareeval\XINT_newfunc_clean}%
\let\XINT_tmpa\undefined \let\XINT_tmpb\undefined \let\XINT_tmpc\undefined
\let\XINT_tmpd\undefined \let\XINT_tmpe\undefined
\XINTrestorecatcodesendinput%
% \end{macrocode}
% \StoreCodelineNo {xintexpr}
% \cleardoublepage\let\xintexprnameUp\undefined
%\gardesactifs
%\let\relax
%\let<*calxcore>\gardesinactifs
%^^A--------------------------------------------------
%<*calxcore>^^A---------------------------------------------------
%^^A -*- coding: utf-8; mode: doctex; fill-column: 78; sentence-end-double-space: t; eval: (auto-fill-mode -1); fill-paragraph-function: nil; -*-
% \clearpage\csname calxcorenameUp\endcsname
% \let\MakePrivateLetters\xintMakePrivateLetters
% \section{Package \calxcorenameimp implementation}
% \RaisedLabel{sec:calxcoreimp}
% \addedcalx{2.0a1}
%
% \localtableofcontents
%
%\begin{lverb}
% The eight-digit block utilities shared by calx and legacy xint arithmetic
% are defined here under their original XINT_ names. The native conversions
% and arithmetic kernels remain in the CALX_ namespace. The legacy
% xintcore.sty depends on calxcore.sty for the shared utilities.
%\end{lverb}
%
% \subsection{Catcodes, \protect\eTeX{} and reload detection}
%
% The code of this subsection is copied over from the xint packages, with
% the package names changed.
%
% \begin{macrocode}
\begingroup\catcode61\catcode48\catcode32=10\relax%
\catcode13=5 % ^^M
\endlinechar=13 %
\catcode123=1 % {
\catcode125=2 % }
\catcode64=11 % @
\catcode44=12 % ,
\catcode46=12 % .
\catcode58=12 % :
\catcode94=7 % ^
\def\empty{}\def\space{ }\newlinechar10
\def\z{\endgroup}%
\expandafter\let\expandafter\x\csname ver@calxcore.sty\endcsname
\expandafter\let\expandafter\w\csname ver@xintkernel.sty\endcsname
\expandafter\ifx\csname numexpr\endcsname\relax
\expandafter\ifx\csname PackageWarningNoLine\endcsname\relax
\immediate\write128{^^JPackage calxcore Warning:^^J%
\space\space\space\space
\numexpr not available, aborting input.^^J}%
\else
\PackageWarningNoLine{calxcore}{\numexpr not available, aborting input}%
\fi
\def\z{\endgroup\endinput}%
\else
\ifx\x\relax % plain-TeX, first loading of calxcore.sty
\ifx\w\relax % but xintkernel.sty not yet loaded.
\def\z{\endgroup\input xintkernel.sty\relax}%
\fi
\else
\ifx\x\empty % LaTeX, first loading,
% variable is initialized, but \ProvidesPackage not yet seen
\ifx\w\relax % xintkernel.sty not yet loaded.
\def\z{\endgroup\RequirePackage{xintkernel}}%
\fi
\else
\def\z{\endgroup\endinput}% xintkernel already loaded.
\fi
\fi
\fi
\z%
\XINTsetupcatcodes% defined in xintkernel.sty
% \end{macrocode}
% \subsection{Package identification}
% \begin{macrocode}
\XINT_providespackage
\ProvidesPackage{calxcore}%
[2026/11/01 v2.0a1 Expandable arithmetic on big integers (JFB)]%
% \end{macrocode}
%
%\odef\MakePrivateLetters{\MakePrivateLetters\catcode`- 11}^^A
%
% \subsection{\cshnolabel{xintNum}, \csh{xintiNum}}
%\begin{lverb}
% For example \xintNum {----+-+++---+----000000000000003}
%
% Very old routine got completely rewritten at 1.2l.
%
% New code uses \numexpr governed expansion and fixes some issues of former
% version particularly regarding inputs of the \numexpr...\relax type without
% \the or \number prefix, and/or possibly no terminating \relax.
%
% \xintiNum{\numexpr 1}\foo in earlier versions caused premature expansion of
% \foo.
%
% \xintiNum{\the\numexpr 1} was ok, but a bit luckily so.
%
% Also, up to 1.2k inclusive, the macro fetched tokens eight by eight, and not
% nine by nine as is done now. I have no idea why.
%\end{lverb}
% \begin{macrocode}
\def\xintiNum {\romannumeral0\xintinum }%
\def\xintinum #1%
{%
\expandafter\XINT_num_cleanup\the\numexpr\expandafter\XINT_num_loop
\romannumeral`&&@#1\xint:\xint:\xint:\xint:\xint:\xint:\xint:\xint:\xint:\Z
}%
\def\xintNum {\romannumeral0\xintnum }%
\let\xintnum\xintinum
% \end{macrocode}
% Attention |\xintnum| (hence |\xintNum|) gets redefined by
% \xintfracnameimp. Click on names to see the redefinition there.
% \begin{macrocode}
\def\XINT_num #1%
{%
\expandafter\XINT_num_cleanup\the\numexpr\XINT_num_loop
#1\xint:\xint:\xint:\xint:\xint:\xint:\xint:\xint:\xint:\Z
}%
\def\XINT_num_loop #1#2#3#4#5#6#7#8#9%
{%
\xint_gob_til_xint: #9\XINT_num_end\xint:
#1#2#3#4#5#6#7#8#9%
\ifnum \numexpr #1#2#3#4#5#6#7#8#9+\xint_c_ = \xint_c_
% \end{macrocode}
%\begin{lverb}
% means that so far only signs encountered, (if syntax is legal) then possibly
% zeroes
% or a terminated or not terminated \numexpr evaluating to zero
% In that latter case a correct zero will be produced in the end.
%\end{lverb}
% \begin{macrocode}
\expandafter\XINT_num_loop
\else
% \end{macrocode}
%\begin{lverb}
% non terminated \numexpr (with nine tokens total) are
% safe as after \fi, there is then \xint:
%\end{lverb}
% \begin{macrocode}
\expandafter\relax
\fi
}%
\def\XINT_num_end\xint:#1\xint:{#1+\xint_c_\xint:}% empty input ok
\def\XINT_num_cleanup #1\xint:#2\Z { #1}%
% \end{macrocode}
% \subsection{\csh{xintiiSgn}}
% Moved to \calxcorenameimp for STUPID REASONS. Too painful to comment.
%\begin{lverb}
% 1.2l made \xintiiSgn robust against non terminated input.
%
% 1.2o deprecates here \xintSgn (it requires xintfrac.sty).
%\end{lverb}
% \begin{macrocode}
\def\xintiiSgn {\romannumeral0\xintiisgn }%
\def\xintiisgn #1%
{%
\expandafter\XINT_sgn \romannumeral`&&@#1\xint:
}%
\def\XINT_sgn #1#2\xint:
{%
\xint_UDzerominusfork
#1-{ 0}%
0#1{-1}%
0-{ 1}%
\krof
}%
\def\XINT_Sgn #1#2\xint:
{%
\xint_UDzerominusfork
#1-{0}%
0#1{-1}%
0-{1}%
\krof
}%
\def\XINT_cntSgn #1#2\xint:
{%
\xint_UDzerominusfork
#1-\xint_c_
0#1\xint_c_mone
0-\xint_c_i
\krof
}%
% \end{macrocode}
% \subsection{\csh{xintiiOpp}}
% Moved to \calxcorenameimp for STUPID REASONS. Too painful to comment.
%\begin{lverb}
% Attention, \xintiiOpp non robust against non terminated inputs.
% Reason is I don't want to have to grab a delimiter at the end, as everything
% happens "upfront".
%\end{lverb}
% \begin{macrocode}
\def\xintiiOpp {\romannumeral0\xintiiopp }%
\def\xintiiopp #1%
{%
\expandafter\XINT_opp \romannumeral`&&@#1%
}%
\def\XINT_Opp #1{\romannumeral0\XINT_opp #1}%
\def\XINT_opp #1%
{%
\xint_UDzerominusfork
#1-{ 0}% zero
0#1{ }% negative
0-{ -#1}% positive
\krof
}%
% \end{macrocode}
% \subsection{\csh{xintiiCmp}}
% The reason for it to be here is a completely silly situation which has
% cost the author perhaps 6 hours due to incompetent assistant preferring
% to work in secret and keep major decisions to itself. It may be provisory
% but will not be modified for |2.0a1|.
% \changed[2022/06/05]{1.4m}
% Now uses the |\xintstrcmp| engine primitive.
% \begin{macrocode}
\def\xintiiCmp {\romannumeral0\xintiicmp }%
\def\xintiicmp #1{\expandafter\XINT_iicmp\romannumeral`&&@#1\xint:}%
\def\XINT_iicmp #1#2\xint:#3%
{%
\expandafter\XINT_cmp_nfork\expandafter #1\romannumeral`&&@#3\xint:#2\xint:
}%
\def\XINT_cmp_nfork #1#2%
{%
\xint_UDzerofork
#1\XINT_cmp_firstiszero
#2\XINT_cmp_secondiszero
0{}%
\krof
\xint_UDsignsfork
#1#2\XINT_cmp_minusminus
#1-\XINT_cmp_minusplus
#2-\XINT_cmp_plusminus
--\XINT_cmp_plusplus
\krof #1#2%
}%
\def\XINT_cmp_firstiszero #1\krof 0#2#3\xint:#4\xint:
{%
\xint_UDzerominusfork
#2-{ 0}%
0#2{ 1}%
0-{ -1}%
\krof
}%
\def\XINT_cmp_secondiszero #1\krof #20#3\xint:#4\xint:
{%
\xint_UDzerominusfork
#2-{ 0}%
0#2{ -1}%
0-{ 1}%
\krof
}%
\def\XINT_cmp_plusminus #1\xint:#2\xint:{ 1}%
\def\XINT_cmp_minusplus #1\xint:#2\xint:{ -1}%
\def\XINT_cmp_minusminus
--{\expandafter\XINT_opp\romannumeral0\XINT_cmp_plusplus {}{}}%
% \end{macrocode}
%\begin{lverb}
% The \romannumeral0 trigger induces some complications here to terminate
% nicely without grabbing too many tokens in the stream or deteriorating
% expansion quality of the non-equal-length branches.
% \expanded simplifies things.
%\end{lverb}
% \begin{macrocode}
\def\XINT_cmp_plusplus #1#2#3\xint:#4\xint:{\expanded{ %
\ifcase\expandafter\XINT_cntSgn\the\numexpr\xintLength{#1#4}-\xintLength{#2#3}\xint:
\xintstrcmp{#1#4}{#2#3}\or1\else-1\fi
}%
}%
% \end{macrocode}
% \subsection{Exceptional conditions: signals, flags, handlers, traps}
% The code of this section comes from the unfinished signal code of
% |xintcore.sty| (dating back to |1.2l|), renamed, kept in the core module,
% and completed.
%\begin{lverb}
% As per the Mike Cowlishaw/IBM's General Decimal Arithmetic Specification
%
% http://speleotrove.com/decimal/decarith.html
%
% and the Python3 implementation in its Decimal module.
%
% Clamped, ConversionSyntax, DivisionByZero, DivisionImpossible,
% DivisionUndefined, Inexact, InsufficientStorage, InvalidContext,
% InvalidOperation, Overflow, Inexact, Rounded, Subnormal,
% Underflow.
%
% X3.274 rajoute LostDigits
%
% Python rajoute FloatOperation (et n'inclut pas InsufficientStorage)
%
% quote de decarith.pdf:
% The Clamped, Inexact, Rounded, and Subnormal conditions can coincide with
% each other or with other conditions. In these cases then any trap enabled
% for another condition takes precedence over (is handled before) all of
% these, any Subnormal trap takes precedence over Inexact, any Inexact trap
% takes precedence over Rounded, and any Rounded trap takes precedence over
% Clamped.
%
% This was initiated at 1.2l (2017/07/26), but the possibility to
% customize handlers was never finished nor documented for users.
% Completely redone for 2.0a1 (2026/11/01).
%
% Model: the decimal module of Python (as for the xintcore code), with the
% IEEE 754 default
% exception handling as default configuration: a condition raises a flag and
% is handled, the handler returns a default result, and NO TeX error is
% emitted. Emitting an (expandable) error is an opt-in, per signal, via
% \calxsetup.
%
% Vocabulary (that of Python's decimal module):
%- a CONDITION is what a calx macro detects and reports;
%- each condition belongs to a SIGNAL; for most conditions, condition and
% signal are the same; five conditions belong to signal InvalidOperation:
%( ConversionSyntax (input which is not a number)
%: DivisionImpossible (integer division result does not fit)
%: DivisionUndefined (0/0)
%: InvalidContext (invalid configuration)
%: ControversialOperation (argument too large for a periodic function)
%)
%- there are eight signals: Clamped, DivisionByZero, Inexact,
% InvalidOperation, Overflow, Rounded, Subnormal, Underflow;
%- each SIGNAL has a FLAG (raised or not) and a TRAP (set or not);
%- each CONDITION has a HANDLER.
%
% What happens when calx code signals a condition C of signal S, via
%( \CALX_signalcondition{C}{}{}{}
%)
% (this is \CALX_signalcondition_a below, Python's Context._raise_error):
%- 1. if S is "ignored" (control sequence \CALX_S_isignoredflag defined;
% Python's Context._ignored_flags), the handler of S is applied to
% , and that is all: no flag is raised;
%- 2. otherwise the flag of S is raised; then
%- 3. if S is not trapped (the default for all signals), the handler of C is
% applied to , and its result is the result;
%- 4. if S is trapped, an expandable error is emitted with , and the
% result is , the value the calling macro would return
% without the signal machinery (e.g. what xint returns: 0 on division by
% zero).
%
% No calx code sets the "ignored" status at this stage; it is kept from
% the xintcore code (and Python) for internal computations which must not
% leave traces in the flags. It is set by \let\CALX_S_isignoredflag\relax (via
% \csname) and cleared by \let to \XINT_undefined.
%
% Default handlers (Python's decimal: the "handle" method of each condition
% class; a class without "handle" returns None in Python, meaning the caller
% keeps the result it has computed, which here is the handler argument):
%( condition handler argument result
%: ------------------------------------------------------------------
%: InvalidOperation (ignored) I? (NaN)
%: ConversionSyntax (ignored) I?
%: DivisionImpossible (ignored) I?
%: DivisionUndefined (ignored) I?
%: InvalidContext (ignored) I?
%: ControversialOperation (ignored) I?
%: DivisionByZero sign + or - I+ or I- (+-Infinity)
%: Overflow sign + or - I+ or I-
%: Underflow computed result the argument
%: Clamped computed result the argument
%: Inexact computed result the argument
%: Rounded computed result the argument
%: Subnormal computed result the argument
%)
% I, ?, + and - in results are catcode 12 characters, the special value
% markers of the calx internal format (I+ is +Infinity, I- is -Infinity, I?
% is NaN). The sign handed to the DivisionByZero and Overflow handlers must be
% a catcode 12 + or -. Printing the special values as NaN, Infinity,
% -Infinity is not done here: it is the task of the output macros of the
% arithmetic modules.
%
% Overflow: Python returns +-Infinity or the largest finite number, depending
% on the rounding mode. calx rounds half away from zero, for which Python
% (ROUND_HALF_UP) returns +-Infinity.
%
% FLAGS. A flag of signal S is raised when \CALX_SFlag_ON is defined. It is
% raised EXPANDABLY by
%( \expandafter\xint_gobble_i\csname CALX_SFlag_ON\endcsname
%)
% which uses the fact that \csname...\endcsname, if the name is undefined,
% \let's it to \relax as a side effect. This assignment is ALWAYS LOCAL to
% the current group (checked under etex: even with \globaldefs=1). Hence:
%- a flag raised by a computation done inside a group (\begingroup or braces,
% an \hbox, an alignment cell, ...) is down again after the group ends;
%- a flag is raised only when the computation is actually expanded: inside
% an \edef, an \expanded, a \message, a \csname, or f-expansion; storing
% an unexpanded computation in a macro via \def raises nothing.
%
% A user wanting a flag to survive a group tests it before the group ends
% and makes the information global by his own means.
%
% Testing (expandable) and lowering (NOT expandable):
%( \calxifflagraised{S}{}{}
%: \calxresetflag{S}
%: \calxresetflags (the eight flags)
%)
% Lowering obeys \ifxintglobaldefs (via \XINT_global): it is global if
% \xintglobaldefstrue, local otherwise.
%
% CONFIGURATION, \calxsetup. Same syntax and method as \bnumsetup of bnumexpr:
% a comma separated list of key=value; spaces around keys are
% removed; a final comma does no harm; each key performs a \let; assignments
% are global if \xintglobaldefstrue, local otherwise (\XINT_global); with
% \xintverbosetrue each assignment is reported on the terminal and in the log
% (\xintMessage).
%
% Keys:
%( .trap = true (or false) for each of the eight signals
%: .handler = \macro for each of the thirteen conditions
%)
% e.g.
%( \calxsetup{DivisionByZero.trap = true, InvalidOperation.trap = true}
%)
% gives back the behaviour of xint (expandable error, then xint's default
% result) for these two signals.
%
% A handler is a macro with ONE argument, the handler argument; it must
% expand to the result (in the contexts where calx macros use it, it is
% expanded by f-expansion). For example a user preferring that conversion
% errors give zero, in the calx internal format of zero, would \let the
% ConversionSyntax handler to a macro expanding to that. The value of
% .handler must be a single control sequence (the \let receives only
% that).
%
% An unknown key, or a value other than true and false for a .trap key, is
% reported by a (non expandable) TeX error, \calxsetup being itself not
% expandable.
%\end{lverb}
% \begin{macrocode}
\catcode`- 11
\def\CALX_ConversionSyntax-signal {{InvalidOperation}}%
\let\CALX_DivisionImpossible-signal\CALX_ConversionSyntax-signal
\let\CALX_DivisionUndefined-signal \CALX_ConversionSyntax-signal
\let\CALX_InvalidContext-signal \CALX_ConversionSyntax-signal
\let\CALX_ControversialOperation-signal\CALX_ConversionSyntax-signal
\catcode`- 12
% \end{macrocode}
% \subsubsection{\csh{CALX_signalcondition}}
%\begin{lverb}
% Syntax (f-expandable):
%(
% \CALX_signalcondition{C}{M}{H}{V} ->
%)
% C a signal or condition name (InvalidOperation, DivisionByZero, ...),
% M the error message, H the handler argument, V the value returned if the
% signal is trapped; : the handler's value (or V).
%
% \CALX_signalcondition$empty: identical to \XINT_signalcondition
% (xintcore.sty of xint 1.4p), renamed. The first \romannumeral0 step turns
% #1 into {}{}, then \CALX_signalcondition_a receives
%( #1 = signal, #2 = condition, #3 = error message,
%: #4 = handler argument, #5 = value returned if the signal is trapped.
%)
% Note that, as in Python, the "ignored" branch applies the handler of the
% SIGNAL, the untrapped branch the handler of the CONDITION.
%
% The expansion is complete (handler included) under f-expansion. The handlers
% defined here expand in one step to their result.
%\end{lverb}
% \begin{macrocode}
\def\CALX_signalcondition #1{\expandafter\CALX_signalcondition_a
\romannumeral0\ifcsname CALX_#1-signal\endcsname
\xint_dothis{\csname CALX_#1-signal\endcsname}%
\fi\xint_orthat{{#1}}{#1}}%
\def\CALX_signalcondition_a %
#1#2#3#4#5{% copied over from Python Decimal module
\ifcsname CALX_#1_isignoredflag\endcsname
\xint_dothis{\csname CALX_#1.handler\endcsname {#4}}%
\fi
\expandafter\xint_gobble_i\csname CALX_#1Flag_ON\endcsname
\unless\ifcsname CALX_#1_istrapped\endcsname
\xint_dothis{\csname CALX_#2.handler\endcsname {#4}}%
\fi
\xint_orthat{%
% the flag raised is named after the signal #1, but we show condition
% #2
\XINT_expandableerror{#3}%
\xint_firstofone{#5}%
}%
}%
\let\XINT_signalcondition\CALX_signalcondition
% \end{macrocode}
%\begin{lverb}
% Flags. \CALX_RaiseFlag is xintcore's \XINT_RaiseFlag, for direct use by calx
% code (raising a flag without going through a handler). The public test and
% reset macros are xintcore's \XINT_ifFlagRaised, \XINT_resetFlag,
% \XINT_resetFlags made public; the reset obeys \XINT_global, and resets all
% eight flags (the xintcore version listed four).
%\end{lverb}
% \begin{macrocode}
\def\CALX_RaiseFlag #1{\expandafter\xint_gobble_i\csname CALX_#1Flag_ON%
\endcsname}%
% \end{macrocode}
% \subsubsection{\csh{calxifflagraised}, \csh{calxresetflag},
% \csh{calxresetflags}}
% \begin{macrocode}
\def\calxifflagraised #1{%
\ifcsname CALX_#1Flag_ON\endcsname
\expandafter\xint_firstoftwo
\else
\expandafter\xint_secondoftwo
\fi}%
% \end{macrocode}
% \subsubsection{\csh{xintifNonFiniteSignalled}}
%\begin{lverb}
% True if InvalidOperation, DivisionByZero or Overflow was signalled in
% the current group since the last corresponding flag reset. The flags
% describe conditions, not the result: a handler can return a finite value.
% Literal NaN/Infinity values alone do not raise flags.
%\end{lverb}
% \begin{macrocode}
\def\xintifNonFiniteSignalled{%
\calxifflagraised{InvalidOperation}{\xint_firstoftwo}{%
\calxifflagraised{DivisionByZero}{\xint_firstoftwo}{%
\calxifflagraised{Overflow}{\xint_firstoftwo}{\xint_secondoftwo}%
}%
}%
}%
\def\calxresetflag #1%
{\XINT_global\expandafter\let\csname CALX_#1Flag_ON\endcsname%
\XINT_undefined}%
\def\calxresetflags {%
\calxresetflag{Clamped}%
\calxresetflag{DivisionByZero}%
\calxresetflag{Inexact}%
\calxresetflag{InvalidOperation}%
\calxresetflag{Overflow}%
\calxresetflag{Rounded}%
\calxresetflag{Subnormal}%
\calxresetflag{Underflow}%
}%
% \end{macrocode}
%\begin{lverb}
% Default handlers. The xintcore table had _NaN and _SignedInfinity(#1) as
% placeholders; here they are the special value markers, catcode 12,
% produced by \detokenize. Underflow, which the xintcore table sent to
% _NaN, is the identity as in Python (Underflow is always accompanied by
% Inexact and Subnormal, and the result is the rounded one). DivisionByZero
% and Overflow both return signed infinity by default (round half up).
%\end{lverb}
% \begin{macrocode}
\catcode`. 11
\let\CALX_Clamped.handler\xint_firstofone
\edef\CALX_InvalidOperation.handler#1{\detokenize{I?}}%
\let\CALX_ConversionSyntax.handler \CALX_InvalidOperation.handler
\let\CALX_DivisionImpossible.handler\CALX_InvalidOperation.handler
\let\CALX_DivisionUndefined.handler \CALX_InvalidOperation.handler
\let\CALX_InvalidContext.handler \CALX_InvalidOperation.handler
\let\CALX_ControversialOperation.handler\CALX_InvalidOperation.handler
\edef\CALX_Overflow.handler#1{\detokenize{I}#1}%
\let\CALX_DivisionByZero.handler\CALX_Overflow.handler
\let\CALX_Inexact.handler\xint_firstofone
\let\CALX_Rounded.handler\xint_firstofone
\let\CALX_Subnormal.handler\xint_firstofone
\let\CALX_Underflow.handler\xint_firstofone
\catcode`. 12
% \end{macrocode}
%\begin{lverb}
% Traps: none is set at load time. (The xintcore code set all eight at load
% time: \csname XINT__istrapped\endcsname.)
%
% \calxsetup$empty: the parsing loop is \bnumsetup's (bnumexpr.dtx),
% with the key dispatched through \csname CALX_setup_\endcsname, one
% such macro per valid key, defined below. The value is handed over complete
% (not only its first token as in \bnumsetup) because .trap keys take a word.
% Each CALX_setup_ macro receives {}{}.
%\end{lverb}
% \begin{macrocode}
\catcode`! 3
% \end{macrocode}
% \subsubsection{\csh{calxsetup}}
% \begin{macrocode}
\def\calxsetup #1{\CALX_parsekeys #1,=!,}%
\def\CALX_parsekeys #1=#2,%
{%
\ifx!#2\expandafter\CALX_parsedone\fi
\ifcsname CALX_setup_\xint_zapspaces #1 \xint_gobble_i\endcsname
\xint_dothis{\csname CALX_setup_\xint_zapspaces #1 \xint_gobble_i%
\endcsname}%
\fi
\xint_orthat{\CALX_setup_badkey}{#1}{#2}%
\CALX_parsekeys
}%
\def\CALX_parsedone #1\CALX_parsekeys {}%
\catcode`! 12
\def\CALX_settrap #1#2#3{%
\ifnum\xintstrcmp{\xint_zapspaces #3 \xint_gobble_i}{true}=\xint_c_
\XINT_global\expandafter\let\csname CALX_#1_istrapped\endcsname\relax
\CALX_setup_info{trap set for signal #1}%
\else
\ifnum\xintstrcmp{\xint_zapspaces #3 \xint_gobble_i}{false}=\xint_c_
\XINT_global\expandafter\let\csname CALX_#1_istrapped\endcsname%
\XINT_undefined
\CALX_setup_info{trap removed for signal #1}%
\else
\CALX_setup_error{value \detokenize{#3} of key \detokenize{#2}
is neither true nor false}%
\fi\fi
}%
\def\CALX_sethandler #1#2#3{%
\XINT_global\expandafter\let\csname CALX_#1.handler\endcsname=#3%
\CALX_setup_info{\string#3 assigned as handler of condition #1}%
}%
\def\CALX_setup_badkey #1#2{\CALX_setup_error{unknown key \detokenize{#1}}}%
\def\CALX_setup_info #1{%
\ifxintverbose
\xintMessage{calxcore}{Info}{\ifxintglobaldefs (global) \fi #1}%
\fi
}%
\def\CALX_setup_error #1{%
\xintMessage{calxcore}{Error}{\string\calxsetup\space #1}%
\errhelp{See the comments of calxcore.sty on \string\calxsetup.}%
\errmessage{calxcore: invalid input to \string\calxsetup}%
}%
\def\CALX_tmpa #1{%
\expandafter\def\csname CALX_setup_#1.trap\endcsname{\CALX_settrap{#1}}%
}%
\CALX_tmpa{Clamped}\CALX_tmpa{DivisionByZero}\CALX_tmpa{Inexact}%
\CALX_tmpa{InvalidOperation}\CALX_tmpa{Overflow}\CALX_tmpa{Rounded}%
\CALX_tmpa{Subnormal}\CALX_tmpa{Underflow}%
\def\CALX_tmpa #1{%
\expandafter\def\csname CALX_setup_#1.handler\endcsname{%
\CALX_sethandler{#1}}%
}%
\CALX_tmpa{Clamped}\CALX_tmpa{DivisionByZero}\CALX_tmpa{Inexact}%
\CALX_tmpa{InvalidOperation}\CALX_tmpa{Overflow}\CALX_tmpa{Rounded}%
\CALX_tmpa{Subnormal}\CALX_tmpa{Underflow}%
\CALX_tmpa{ConversionSyntax}\CALX_tmpa{DivisionImpossible}%
\CALX_tmpa{DivisionUndefined}\CALX_tmpa{InvalidContext}%
\CALX_tmpa{ControversialOperation}%
\let\CALX_tmpa\XINT_undefined
% \end{macrocode}
% \subsection{Blocks of eight digits}
%
% \subsubsection{\csh{XINT_cuz_small}}
%\begin{lverb}
% \XINT_cuz_small removes leading zeroes from the first eight digits. Expands
% following \romannumeral0. At least one digit is produced.
%\end{lverb}
% \begin{macrocode}
\def\XINT_cuz_small#1{%
\def\XINT_cuz_small ##1##2##3##4##5##6##7##8%
{%
\expandafter#1\the\numexpr ##1##2##3##4##5##6##7##8\relax
}}\XINT_cuz_small{ }%
% \end{macrocode}
% \subsubsection{\csh{XINT_zeroes_forviii}}
%
%\begin{lverb}
%( \romannumeral0\XINT_zeroes_forviii #1\R\R\R\R\R\R\R\R{10}0000001\W
%)
% produces a string of k 0's such that k+length(#1) is smallest bigger multiple
% of eight.
%\end{lverb}
% \begin{macrocode}
\def\XINT_zeroes_forviii #1#2#3#4#5#6#7#8%
{%
\xint_gob_til_R #8\XINT_zeroes_forviii_end\R\XINT_zeroes_forviii
}%
\def\XINT_zeroes_forviii_end#1{%
\def\XINT_zeroes_forviii_end\R\XINT_zeroes_forviii ##1##2##3##4##5##6##7##8##9\W
{%
\expandafter#1\xint_gob_til_one ##2##3##4##5##6##7##8%
}}\XINT_zeroes_forviii_end{ }%
% \end{macrocode}
% \subsubsection{\csh{XINT_rsepbyviii}}
%
%\begin{lverb}
% This is used as
%( \the\numexpr1\XINT_rsepbyviii <8Ndigits>$%
%: \XINT_rsepbyviii_end_A 2345678$%
%: \XINT_rsepbyviii_end_B 2345678\relax UV$%
%)
% and will produce
%( 1<8digits>!1<8digits>\xint:1<8digits>!...
%)
% where the original
% digits are organized by eight, and the order inside successive pairs of
% blocks separated by \xint: has been reversed. Output ends either in
% 1<8d>!1<8d>\xint:1U\xint: (even) or 1<8d>!1<8d>\xint:1V!1<8d>\xint: (odd)
%
% The U an V should be \numexpr1 stoppers (or will expand and be ended by !).
% This macro is currently (1.2..1.2l) exclusively used in combination with
% \XINT_sepandrev_andcount or \XINT_sepandrev.
%\end{lverb}
% \begin{macrocode}
\def\XINT_rsepbyviii #1#2#3#4#5#6#7#8%
{%
\XINT_rsepbyviii_b {#1#2#3#4#5#6#7#8}%
}%
\def\XINT_rsepbyviii_b #1#2#3#4#5#6#7#8#9%
{%
#2#3#4#5#6#7#8#9\expandafter!\the\numexpr
1#1\expandafter\xint:\the\numexpr 1\XINT_rsepbyviii
}%
\def\XINT_rsepbyviii_end_B #1\relax #2#3{#2\xint:}%
\def\XINT_rsepbyviii_end_A #11#2\expandafter #3\relax #4#5{#5!1#2\xint:}%
% \end{macrocode}
% \subsubsection{\csh{XINT_sepandrev_andcount}}
%\begin{lverb}
% This is used typically as
%( \romannumeral0\XINT_sepandrev_andcount <8Ndigits>$%
%: \XINT_rsepbyviii_end_A 2345678$%
%: \XINT_rsepbyviii_end_B 2345678\relax\xint_c_ii\xint_c_i
%: \R\xint:\xint_c_xii \R\xint:\xint_c_x \R\xint:\xint_c_viii \R\xint:\xint_c_vi
%: \R\xint:\xint_c_iv \R\xint:\xint_c_ii \R\xint:\xint_c_\W
%)
% and will produce
%( .1<8digits>!1<8digits>!1<8digits>!...
%)
% where the
% blocks have been globally reversed and is the number of blocks.
%\end{lverb}
% \begin{macrocode}
\def\XINT_sepandrev_andcount
{%
\expandafter\XINT_sepandrev_andcount_a\the\numexpr 1\XINT_rsepbyviii
}%
\def\XINT_sepandrev_andcount_a {\XINT_sepandrev_andcount_b 0!{}}%
\def\XINT_sepandrev_andcount_b #1!#2#3\xint:#4\xint:#5\xint:#6\xint:#7\xint:#8\xint:#9\xint:%
{%
\xint_gob_til_R #9\XINT_sepandrev_andcount_end\R
\expandafter\XINT_sepandrev_andcount_b \the\numexpr #1+\xint_c_i!%
{#9!#8!#7!#6!#5!#4!#3!#2}%
}%
\def\XINT_sepandrev_andcount_end\R
\expandafter\XINT_sepandrev_andcount_b\the\numexpr #1+\xint_c_i!#2#3#4\W
{\expandafter\XINT_sepandrev_andcount_done\the\numexpr #3+\xint_c_xiv*#1!#2}%
\def\XINT_sepandrev_andcount_done#1{%
\def\XINT_sepandrev_andcount_done##1!##21##3!{\expandafter#1\the\numexpr##1-##3\xint:}%
}\XINT_sepandrev_andcount_done{ }%
% \end{macrocode}
% \subsubsection{\csh{XINT_rev_nounsep}}
%\begin{lverb}
% This is used as
%( \romannumeral0\XINT_rev_nounsep {}!>\R!\R!\R!\R!\R!\R!\R!\R!\W
%)
% It reverses the blocks, keeping the 1's and ! separators. Used multiple
% times in the division algorithm. The inserted {} here is not optional.
%\end{lverb}
% \begin{macrocode}
\def\XINT_rev_nounsep #1#2!#3!#4!#5!#6!#7!#8!#9!%
{%
\xint_gob_til_R #9\XINT_rev_nounsep_end\R
\XINT_rev_nounsep {#9!#8!#7!#6!#5!#4!#3!#2!#1}%
}%
\def\XINT_rev_nounsep_end\R\XINT_rev_nounsep #1#2\W {\XINT_rev_nounsep_done #1}%
\def\XINT_rev_nounsep_done #11{ 1}%
% \end{macrocode}
% \subsubsection{\csh{XINT_unrevbyviii}}
%\begin{lverb}
% Used as \romannumeral0\XINT_unrevbyviii 1<8d>!....1<8d>! terminated
% by
%( 1;!1\R!1\R!1\R!1\R!1\R!1\R!1\R!1\R!\W
%)
% The \romannumeral in unrevbyviii_a is for special effects (expand some token
% which was put as 1! at the end of the original blocks). This
% mechanism is used by 1.2 subtraction (still true for 1.2l).
%\end{lverb}
% \begin{macrocode}
\def\XINT_unrevbyviii #11#2!1#3!1#4!1#5!1#6!1#7!1#8!1#9!%
{%
\xint_gob_til_R #9\XINT_unrevbyviii_a\R
\XINT_unrevbyviii {#9#8#7#6#5#4#3#2#1}%
}%
\def\XINT_unrevbyviii_a#1{%
\def\XINT_unrevbyviii_a\R\XINT_unrevbyviii ##1##2\W
{\expandafter#1\romannumeral`&&@\xint_gob_til_sc ##1}%
}\XINT_unrevbyviii_a{ }%
% \end{macrocode}
% \subsubsection{Aliases for native callers}
%\begin{lverb}
% The native arithmetic section uses I and N with catcode 12. Its callers
% use CALX aliases of the common block utilities, whose implementations
% remain under the XINT names for the legacy packages.
%\end{lverb}
% \begin{macrocode}
\let\CALX_cuz_small\XINT_cuz_small
\let\CALX_zeroes_forviii\XINT_zeroes_forviii
\let\CALX_rsepbyviii\XINT_rsepbyviii
\let\CALX_rsepbyviii_end_A\XINT_rsepbyviii_end_A
\let\CALX_rsepbyviii_end_B\XINT_rsepbyviii_end_B
\let\CALX_sepandrev_andcount\XINT_sepandrev_andcount
\let\CALX_rev_nounsep\XINT_rev_nounsep
\let\CALX_unrevbyviii\XINT_unrevbyviii
% \end{macrocode}
% \subsection{Core arithmetic}
%
% \subsubsection{\csh{CALX_add_a}}
%\begin{lverb}
% From this subsection of xintcore (\xintiiAdd$empty) calx copies only the
% macros used by the native layer: \CALX_add_a, \CALX_add_b, \CALX_add_bi,
% \CALX_add_c, \CALX_add_d, \CALX_add_di, \CALX_add_e, \CALX_add_f,
% \CALX_add_fi, \CALX_add_g, \CALX_add_h, \CALX_add_hi, \CALX_add_i,
% \CALX_add_k, \CALX_add_ke, \CALX_add_kf, \CALX_add_l, \CALX_add_lf,
% \CALX_add_m, \CALX_add_n, \CALX_add_o. The other macros are not copied.
%\end{lverb}
%
% \begin{macrocode}
\def\CALX_add_a #1!#2!#3!#4!#5\W
#6!#7!#8!#9!%
{%
\CALX_add_b
#1!#6!#2!#7!#3!#8!#4!#9!%
#5\W
}%
\def\CALX_add_b #11#2#3!#4!%
{%
\xint_gob_til_sc #2\CALX_add_bi ;%
\expandafter\CALX_add_c\the\numexpr#1+1#2#3+#4-\xint_c_ii\xint:%
}%
\def\CALX_add_bi;\expandafter\CALX_add_c
\the\numexpr#1+#2+#3-\xint_c_ii\xint:#4!#5!#6!#7!#8!#9!\W
{%
\CALX_add_k #1#3!#5!#7!#9!%
}%
\def\CALX_add_c #1#2\xint:%
{%
1#2\expandafter!\the\numexpr\CALX_add_d #1%
}%
\def\CALX_add_d #11#2#3!#4!%
{%
\xint_gob_til_sc #2\CALX_add_di ;%
\expandafter\CALX_add_e\the\numexpr#1+1#2#3+#4-\xint_c_ii\xint:%
}%
\def\CALX_add_di;\expandafter\CALX_add_e
\the\numexpr#1+#2+#3-\xint_c_ii\xint:#4!#5!#6!#7!#8\W
{%
\CALX_add_k #1#3!#5!#7!%
}%
\def\CALX_add_e #1#2\xint:%
{%
1#2\expandafter!\the\numexpr\CALX_add_f #1%
}%
\def\CALX_add_f #11#2#3!#4!%
{%
\xint_gob_til_sc #2\CALX_add_fi ;%
\expandafter\CALX_add_g\the\numexpr#1+1#2#3+#4-\xint_c_ii\xint:%
}%
\def\CALX_add_fi;\expandafter\CALX_add_g
\the\numexpr#1+#2+#3-\xint_c_ii\xint:#4!#5!#6\W
{%
\CALX_add_k #1#3!#5!%
}%
\def\CALX_add_g #1#2\xint:%
{%
1#2\expandafter!\the\numexpr\CALX_add_h #1%
}%
\def\CALX_add_h #11#2#3!#4!%
{%
\xint_gob_til_sc #2\CALX_add_hi ;%
\expandafter\CALX_add_i\the\numexpr#1+1#2#3+#4-\xint_c_ii\xint:%
}%
\def\CALX_add_hi;%
\expandafter\CALX_add_i\the\numexpr#1+#2+#3-\xint_c_ii\xint:#4\W
{%
\CALX_add_k #1#3!%
}%
\def\CALX_add_i #1#2\xint:%
{%
1#2\expandafter!\the\numexpr\CALX_add_a #1%
}%
\def\CALX_add_k #1{\if #12\expandafter\CALX_add_ke\else\expandafter%
\CALX_add_l \fi}%
\def\CALX_add_ke #11;#2\W {\CALX_add_kf #11;!}%
\def\CALX_add_kf 1{1\relax }%
\def\CALX_add_l 1#1{\xint_gob_til_sc #1\CALX_add_lf ;\CALX_add_m 1#1}%
\def\CALX_add_lf #1\W {1\relax 00000001!1;!}%
\def\CALX_add_m #1!{\expandafter\CALX_add_n\the\numexpr\xint_c_i+#1\xint:}%
\def\CALX_add_n #1#2\xint:{1#2\expandafter!\the\numexpr\CALX_add_o #1}%
\def\CALX_add_o #1{\if #12\expandafter\CALX_add_l\else\expandafter%
\CALX_add_ke \fi}%
% \end{macrocode}
% \subsubsection{\csh{CALX_mul_loop}, \csh{CALX_smallmul},
% \csh{CALX_verysmallmul}}
%\begin{lverb}
% From this subsection of xintcore (\xintiiMul$empty) calx copies only the
% macros used by the native layer: \CALX_mul_loop, \CALX_mul_a, \CALX_mul_b,
% \CALX_mul_e, \CALX_minimulwc_a, \CALX_minimulwc_b, \CALX_minimulwc_c,
% \CALX_smallmul, \CALX_smallmul_a, \CALX_smallmul_e, \CALX_smallmul_f,
% \CALX_verysmallmul, \CALX_verysmallmul_e, \CALX_verysmallmul_f,
% \CALX_verysmallmul_a, \CALX_verysmallmul_bj, \CALX_verysmallmul_cj,
% \CALX_verysmallmul_bi, \CALX_minimul_a, \CALX_minimul_b, \CALX_minimul_c.
% The other macros are not copied.
%\end{lverb}
%
% \begin{macrocode}
\def\CALX_mul_loop #1\W #2\W 1#3!%
{%
\xint_gob_til_sc #3\CALX_mul_e ;%
\expandafter\CALX_mul_a\the\numexpr \CALX_smallmul 1#3!#2\W
#1\W #2\W
}%
\def\CALX_mul_a #1\W #2\W
{%
\expandafter\CALX_mul_b\the\numexpr
\CALX_add_a \xint_c_ii #21;!1;!1;!\W #11;!1;!1;!\W\W
}%
\def\CALX_mul_b 1#1!{1#1\expandafter!\the\numexpr\CALX_mul_loop }%
\def\CALX_mul_e;#1\W 1#2\W #3\W {1\relax #2}%
% \end{macrocode}
%
% \begin{macrocode}
\def\CALX_minimulwc_a 1#1\xint:#2\xint:#3!#4#5#6#7#8\xint:%
{%
\expandafter\CALX_minimulwc_b
\the\numexpr \xint_c_e_ix+#1+#3*#8\xint:
#3*#4#5#6#7+#2*#8\xint:
#2*#4#5#6#7\xint:%
}%
\def\CALX_minimulwc_b 1#1#2#3#4#5#6\xint:#7\xint:%
{%
\expandafter\CALX_minimulwc_c
\the\numexpr \xint_c_e_ix+#1#2#3#4#5+#7\xint:#6\xint:%
}%
\def\CALX_minimulwc_c 1#1#2#3#4#5#6\xint:#7\xint:#8\xint:%
{%
1#6#7\expandafter!%
\the\numexpr\expandafter\CALX_smallmul_a
\the\numexpr \xint_c_e_viii+#1#2#3#4#5+#8\xint:%
}%
\def\CALX_smallmul 1#1#2#3#4#5!{\CALX_smallmul_a 100000000\xint:#1#2#3#4%
\xint:#5!}%
\def\CALX_smallmul_a #1\xint:#2\xint:#3!1#4!%
{%
\xint_gob_til_sc #4\CALX_smallmul_e;%
\CALX_minimulwc_a #1\xint:#2\xint:#3!#4\xint:#2\xint:#3!%
}%
\def\CALX_smallmul_e;\CALX_minimulwc_a 1#1\xint:#2;#3!%
{\xint_gob_til_eightzeroes #1\CALX_smallmul_f 000000001\relax #1!1;!}%
\def\CALX_smallmul_f 000000001\relax 00000000!1{1\relax}%
\def\CALX_verysmallmul #1\xint:#2!1#3!%
{%
\xint_gob_til_sc #3\CALX_verysmallmul_e;%
\expandafter\CALX_verysmallmul_a
\the\numexpr #2*#3+#1\xint:#2!%
}%
\def\CALX_verysmallmul_e;\expandafter\CALX_verysmallmul_a\the\numexpr
#1+#2#3\xint:#4!%
{\xint_gob_til_zero #2\CALX_verysmallmul_f 0\xint_c_e_viii+#2#3!1;!}%
\def\CALX_verysmallmul_f #1!1{1\relax}%
\def\CALX_verysmallmul_a #1#2\xint:%
{%
\unless\ifnum #1#2<\xint_c_e_ix
\expandafter\CALX_verysmallmul_bi\else
\expandafter\CALX_verysmallmul_bj\fi
\the\numexpr \xint_c_e_ix+#1#2\xint:%
}%
\def\CALX_verysmallmul_bj{\expandafter\CALX_verysmallmul_cj }%
\def\CALX_verysmallmul_cj 1#1#2\xint:%
{1#2\expandafter!\the\numexpr\CALX_verysmallmul #1\xint:}%
\def\CALX_verysmallmul_bi\the\numexpr\xint_c_e_ix+#1#2#3\xint:%
{1#3\expandafter!\the\numexpr\CALX_verysmallmul #1#2\xint:}%
% \end{macrocode}
%
% \begin{macrocode}
\def\CALX_minimul_a #1\xint:#2!#3#4#5#6#7!%
{%
\expandafter\CALX_minimul_b
\the\numexpr \xint_c_e_viii+#2*#7\xint:#2*#3#4#5#6+#1*#7\xint:#1*#3#4#5#6%
\xint:%
}%
\def\CALX_minimul_b 1#1#2#3#4#5\xint:#6\xint:%
{%
\expandafter\CALX_minimul_c
\the\numexpr \xint_c_e_ix+#1#2#3#4+#6\xint:#5\xint:%
}%
\def\CALX_minimul_c 1#1#2#3#4#5#6\xint:#7\xint:#8\xint:%
{%
1#6#7\expandafter!\the\numexpr \xint_c_e_viii+#1#2#3#4#5+#8!%
}%
% \end{macrocode}
% \subsubsection{\csh{CALX_smalldivx_a}}
%\begin{lverb}
% From this subsection of xintcore (\xintiiDivision$empty) calx copies only
% the macros used by the native layer: \CALX_smalldivx_a, \CALX_smalldivx_b,
% \CALX_smalldiv_c, \CALX_smalldiv_d, \CALX_smalldiv_end, \CALX_smalldiv_e,
% \CALX_smalldiv_f, \CALX_smalldiv_fz, \CALX_smalldiv_g, \CALX_smalldiv_h,
% \CALX_smalldiv_i, \CALX_smalldiv_j, \CALX_smalldiv_k. The other macros are
% not copied.
%\end{lverb}
%
% \begin{macrocode}
\def\CALX_smalldivx_a #1\xint:1#2!1#3!%
{%
\expandafter\CALX_smalldivx_b
\the\numexpr (#3+#1)/#2-\xint_c_i!#1\xint:#2!#3!%
}%
\def\CALX_smalldivx_b #1#2!%
{%
\if0#1\else
\xint_c_e_viii+#1#2\xint_afterfi{\expandafter!\the\numexpr}\fi
\CALX_smalldiv_c #1#2!%
}%
\def\CALX_smalldiv_c #1!#2\xint:#3!#4!%
{%
\expandafter\CALX_smalldiv_d\the\numexpr #4-#1*#3!#2\xint:#3!%
}%
\def\CALX_smalldiv_d #1!#2!1#3#4!%
{%
\xint_gob_til_sc #3\CALX_smalldiv_end ;%
\CALX_smalldiv_e #1!#2!1#3#4!%
}%
\def\CALX_smalldiv_end;\CALX_smalldiv_e #1!#2!1;!{1!;!#1!}%
\def\CALX_smalldiv_e #1!#2\xint:#3!%
{%
\expandafter\CALX_smalldiv_f\the\numexpr
\xint_c_xi_e_viii_mone+#1*\xint_c_e_viii/#3!#2\xint:#3!#1!%
}%
\def\CALX_smalldiv_f 1#1#2#3#4#5#6!#7\xint:#8!%
{%
\xint_gob_til_zero #1\CALX_smalldiv_fz 0%
\expandafter\CALX_smalldiv_g
\the\numexpr\CALX_minimul_a #2#3#4#5\xint:#6!#8!#2#3#4#5#6!#7\xint:#8!%
}%
\def\CALX_smalldiv_fz 0%
\expandafter\CALX_smalldiv_g\the\numexpr\CALX_minimul_a
9999\xint:9999!#1!99999999!#2!0!1#3!%
{%
\CALX_smalldiv_i \xint:#3!\xint_c_!#2!%
}%
\def\CALX_smalldiv_g 1#1!1#2!#3!#4!#5!#6!%
{%
\expandafter\CALX_smalldiv_h\the\numexpr 1#6-#1\xint:#2!#5!#3!#4!%
}%
\def\CALX_smalldiv_h 1#1#2\xint:#3!#4!%
{%
\expandafter\CALX_smalldiv_i\the\numexpr #4-#3+#1-\xint_c_i\xint:#2!%
}%
\def\CALX_smalldiv_i #1\xint:#2!#3!#4\xint:#5!%
{%
\expandafter\CALX_smalldiv_j\the\numexpr (#1#2+#4)/#5-%
\xint_c_i!#3!#1#2!#4\xint:#5!%
}%
\def\CALX_smalldiv_j #1!#2!%
{%
\xint_c_e_viii+#1+#2\expandafter!\the\numexpr\CALX_smalldiv_k
#1!%
}%
\def\CALX_smalldiv_k #1!#2!#3\xint:#4!%
{%
\expandafter\CALX_smalldiv_d\the\numexpr #2-#1*#4!#3\xint:#4!%
}%
% \end{macrocode}
% \subsection{Native integer format}
%\begin{lverb}
% A calx integer in native format is the sequence of catcode 12 tokens
%( N . ...
%)
%- N: type tag;
%- : + or -, always present; zero is N+0. (no blocks);
%- : number of blocks, decimal, terminated by a dot;
%- the blocks are xint's blocks 1dddddddd! (the 1 protects leading zeros
% for \numexpr), least significant block first;
%- the most significant block (the last one) is not 00000000.
%
% The value is sum_{k=1}^{n} d_k 10^{8(k-1)} with d_k the 8 digits of
% . There is no terminator: macros append their own delimiters.
%
% All macros below are used as \romannumeral0\CALX_n...{...}{...} and
% deliver their result after a space token. Arguments are f-expanded first
% (as in xintcore).
%
% Coding rules followed here (second pass, efficiency):
%- block lists are copied as few times as possible: a macro parameter
% holding blocks appears ONCE in each replacement text; branch selection
% (\xint_dothis/\xint_orthat, \ifcase) only selects a macro token, the
% arguments follow once after the selection;
%- the header N. of a result is produced in front of the blocks
% by \expandafter\CALX_sp\expandafter N\expandafter\the\numexpr.
% so that the blocks, once grabbed to remove the kernel terminator 1;!,
% are not grabbed again (\CALX_sp expands to the space which ends the
% \romannumeral0 expansion);
%- counting the blocks of a product skips them seven at a time.
%
% In this section N and I have catcode 12, so macro names here use neither
% letter in upper case.
%\end{lverb}
% \begin{macrocode}
\catcode`N=12 \catcode`I=12
% \end{macrocode}
%\begin{lverb}
% \CALX_sp expands to a space token; it ends the \romannumeral0 expansion of
% the native macros.
%\end{lverb}
% \begin{macrocode}
\def\CALX_sp{ }%
% \end{macrocode}
%\begin{lverb}
% \CALX_pten{k} = 10^k, 0 <= k <= 8, k a \numexpr expression: one
% \csname lookup of \CALX_pt (k in decimal), cheaper than an \ifcase
% table. The other value tables and dispatches of calx are built in the
% same way.
%\end{lverb}
% \begin{macrocode}
\def\CALX_pten #1{\csname CALX_pt\the\numexpr#1\endcsname}%
\expandafter\def\csname CALX_pt0\endcsname{1}%
\expandafter\def\csname CALX_pt1\endcsname{10}%
\expandafter\def\csname CALX_pt2\endcsname{100}%
\expandafter\def\csname CALX_pt3\endcsname{1000}%
\expandafter\def\csname CALX_pt4\endcsname{10000}%
\expandafter\def\csname CALX_pt5\endcsname{100000}%
\expandafter\def\csname CALX_pt6\endcsname{1000000}%
\expandafter\def\csname CALX_pt7\endcsname{10000000}%
\expandafter\def\csname CALX_pt8\endcsname{100000000}%
% \end{macrocode}
%\begin{lverb}
% Digit counts without \ifnum (each \ifnum scans its two numbers: three
% nested \ifnum on an 8-digit block cost about twice as much). The digits
% are followed by a sentinel list and the ninth token is the answer
% (xintfrac's \XINT_FL_fac_countdigits); \CALX_nd_b removes the leftover
% sentinel up to \xint: and outputs the answer, so the macros are
% f-expandable.
%- \CALX_ndig{v}: number of digits of 0 <= v < 10^8 (1 for 0); v may have
% leading zeros (removed by \numexpr);
%- \CALX_ndigs{v}: same, v explicit digits without leading zeros;
%- \CALX_nlz{v}: number of leading zeros of an 8-digit block v > 0.
%
% \CALX_nd_c ...\xint: (v: 1 to 10 explicit digits, no
% leading zero; s_k: one token or a braced group) outputs s_k for
% k = 11 - (number of digits of v), the eleventh token: a value per digit
% count (sentinel list of the caller).
%\end{lverb}
% \begin{macrocode}
\def\CALX_ndig #1%
{\expandafter\CALX_nd_a\the\numexpr#1\relax 87654321\xint:}%
\def\CALX_ndigs #1{\CALX_nd_a #187654321\xint:}%
\def\CALX_nlz #1%
{\expandafter\CALX_nd_a\the\numexpr#1\relax 01234567\xint:}%
\def\CALX_nd_a #1#2#3#4#5#6#7#8#9{\CALX_nd_b #9}%
\def\CALX_nd_b #1#2\xint:{#1}%
\def\CALX_nd_c #1#2#3#4#5#6#7#8#9{\CALX_nd_d}%
\def\CALX_nd_d #1#2#3\xint:{#2}%
% \end{macrocode}
% \subsubsection{\csh{CALX_nfromraw}}
%\begin{lverb}
% Syntax (use with \romannumeral0; R f-expanded):
%(
% \CALX_nfromraw{R} -> N.
%)
% Conversion from the raw integer format of xintcore (optional minus sign, no
% leading zeros, zero is 0) to native. The shared \CALX_sepandrev_andcount,
% as called by \XINT_add_pp_a, delivers \xint:, and
% \CALX_nfromraw_c inserts the header without touching the blocks.
%\end{lverb}
% \begin{macrocode}
\def\CALX_nfromraw #1{\expandafter\CALX_nfromraw_a\romannumeral`&&@#1\xint:}%
\def\CALX_nfromraw_a #1{%
\xint_UDzerominusfork
#1-{\CALX_nfromraw_z}%
0#1{\CALX_nfromraw_b -}%
0-{\CALX_nfromraw_b +#1}%
\krof
}%
\def\CALX_nfromraw_z #1\xint:{ N+0.}%
\def\CALX_nfromraw_b #1#2\xint:{%
\expandafter\CALX_nfromraw_c\expandafter#1%
\romannumeral0\expandafter\CALX_sepandrev_andcount
\romannumeral0\CALX_zeroes_forviii #2\R\R\R\R\R\R\R\R{10}0000001\W
#2\CALX_rsepbyviii_end_A 2345678%
\CALX_rsepbyviii_end_B 2345678\relax\xint_c_ii\xint_c_i
\R\xint:\xint_c_xii \R\xint:\xint_c_x \R\xint:\xint_c_viii \R%
\xint:\xint_c_vi
\R\xint:\xint_c_iv \R\xint:\xint_c_ii \R\xint:\xint_c_\W
}%
\def\CALX_nfromraw_c #1#2\xint:{ N#1#2.}%
% \end{macrocode}
% \subsubsection{\csh{CALX_ntoraw}}
%\begin{lverb}
% Syntax (use with \romannumeral0; X f-expanded native integer):
%(
% \CALX_ntoraw{X} -> (xintcore format: -digits, digits, 0)
%)
% Conversion to raw: the shared \CALX_unrevbyviii then \CALX_cuz_small,
% as in \XINT_add_out. The header is examined without grabbing the blocks.
%\end{lverb}
% \begin{macrocode}
\def\CALX_ntoraw #1{\expandafter\CALX_ntoraw_a\romannumeral`&&@#1\xint:}%
\def\CALX_ntoraw_a N#1#2.{%
\ifnum#2=\xint_c_ \xint_dothis\CALX_ntoraw_z\fi
\if-#1\xint_dothis\CALX_ntoraw_m\fi
\xint_orthat\CALX_ntoraw_b
}%
\def\CALX_ntoraw_z #1\xint:{ 0}%
\def\CALX_ntoraw_m {\expandafter-\romannumeral0\CALX_ntoraw_b}%
\def\CALX_ntoraw_b #1\xint:{%
\expandafter\CALX_cuz_small\romannumeral0\CALX_unrevbyviii {}#11;!%
1\R!1\R!1\R!1\R!1\R!1\R!1\R!1\R!\W
}%
% \end{macrocode}
% \subsubsection{\csh{CALX_nskip}}
%\begin{lverb}
% Skipping blocks. \CALX_nskip . removes k blocks (k a
% \numexpr expression, k>=0) and leaves in front of what follows.
% The whole skip is done inside \romannumeral\csname, waits behind
% an \expandafter. \CALX_nskip_a takes the first two tokens of k: if the
% second one is the dot (k <= 9), \xint_gob_til_dot leaves \CALX_nskip_s,
% which completes the name \CALX_nskip; this macro removes the k blocks
% and expands to \xint_c_ (ends \romannumeral). Otherwise \CALX_nskip_g
% removes eight blocks and loops.
%\end{lverb}
% \begin{macrocode}
\def\CALX_nskip #1#2.{\expandafter#1\romannumeral
\csname\expandafter\CALX_nskip_a\the\numexpr#2.}%
\def\CALX_nskip_a #1#2%
{\xint_gob_til_dot #2\CALX_nskip_s.\CALX_nskip_g #1#2}%
\def\CALX_nskip_s.\CALX_nskip_g #1.{CALX_nskip#1\endcsname}%
\def\CALX_nskip_g #1.#2!#3!#4!#5!#6!#7!#8!#9!%
{\expandafter\CALX_nskip_a\the\numexpr#1-\xint_c_viii.}%
\expandafter\let\csname CALX_nskip0\endcsname\xint_c_
\expandafter\def\csname CALX_nskip1\endcsname #1!{\xint_c_}%
\expandafter\def\csname CALX_nskip2\endcsname #1!#2!{\xint_c_}%
\expandafter\def\csname CALX_nskip3\endcsname #1!#2!#3!{\xint_c_}%
\expandafter\def\csname CALX_nskip4\endcsname #1!#2!#3!#4!{\xint_c_}%
\expandafter\def\csname CALX_nskip5\endcsname #1!#2!#3!#4!#5!{\xint_c_}%
\expandafter\def\csname CALX_nskip6\endcsname #1!#2!#3!#4!#5!#6!{\xint_c_}%
\expandafter\def\csname CALX_nskip7\endcsname #1!#2!#3!#4!#5!#6!#7!%
{\xint_c_}%
\expandafter\def\csname CALX_nskip8\endcsname #1!#2!#3!#4!#5!#6!#7!#8!%
{\xint_c_}%
\expandafter\def\csname CALX_nskip9\endcsname #1!#2!#3!#4!#5!#6!#7!#8!#9!%
{\xint_c_}%
% \end{macrocode}
% \subsection{Sign and zero tests of values}
% \subsubsection{\csh{CALX_ifnz}, \csh{CALX_ifsgn}}
%\begin{lverb}
% Syntax (use with \romannumeral0; X f-expanded):
%(
% \CALX_ifnz{X}{A}{B} -> A (X <> 0) or B
%: \CALX_ifnz_a \xint: -> (v <> 0) or
%: \CALX_ifsgn{X}{A}{B}{C} -> A, B or C (X <0, =0, >0)
%: \CALX_ifsgn_a \xint:{A}{B}{C} -> the same
%)
% The values are those of the three parsers, after f-expansion: native
% N., M.., F.. (blocks after the header), I+,
% I-, I?, or raw A, A[N], A/B[N] (A a raw integer without leading zeros,
% B > 0). The low level forms take the value v already expanded, in front
% of the \xint: that ends it; \CALX_ifnz_a also takes the two tokens
% and which select a branch (\CALX_ifnz uses \xint_stop_atfirstoftwo,
% \xint_stop_atsecondoftwo; loops use \xint_firstoftwo, \xint_secondoftwo,
% which add no space).
%
% Only the first tokens are read, no xintfrac parsing: 0 is zero, - is
% negative, another digit is positive; a token of character code above `9
% is a tag: I+ and I- are infinities, I? is non-zero for \CALX_ifnz and
% signals InvalidOperation for \CALX_ifsgn, which then takes the zero
% branch; after F, M, N comes the sign token, then the count, whose first
% character is 0 only for zero.
%\end{lverb}
% \begin{macrocode}
\def\CALX_ifnz #1{\expandafter\CALX_ifnz_a\romannumeral`&&@#1\xint:%
\xint_stop_atfirstoftwo\xint_stop_atsecondoftwo}%
\def\CALX_ifnz_a #1%
{%
\if0#1\xint_dothis\CALX_ifnz_z\fi
\ifnum`#1>57 \xint_dothis\CALX_ifnz_t\fi
\xint_orthat\CALX_ifnz_n #1%
}%
\def\CALX_ifnz_t #1#2%
{\if I#1\expandafter\CALX_ifnz_n\else\expandafter\CALX_ifnz_c\fi}%
\def\CALX_ifnz_c #1%
{\if0#1\expandafter\CALX_ifnz_z\else\expandafter\CALX_ifnz_n\fi}%
\def\CALX_ifnz_z #1\xint:#2#3{#3}%
\def\CALX_ifnz_n #1\xint:#2#3{#2}%
\def\CALX_ifsgn #1{\expandafter\CALX_ifsgn_a\romannumeral`&&@#1\xint:}%
\def\CALX_ifsgn_a #1%
{%
\if0#1\xint_dothis\CALX_ifsgn_z\fi
\if-#1\xint_dothis\CALX_ifsgn_m\fi
\ifnum`#1>57 \xint_dothis\CALX_ifsgn_t\fi
\xint_orthat\CALX_ifsgn_p #1%
}%
\def\CALX_ifsgn_t #1#2%
{\if I#1\expandafter\CALX_ifsgn_i\else\expandafter\CALX_ifsgn_c\fi #2}%
\def\CALX_ifsgn_c #1#2%
{%
\if0#2\xint_dothis\CALX_ifsgn_z\fi
\if-#1\xint_dothis\CALX_ifsgn_m\fi
\xint_orthat\CALX_ifsgn_p
}%
\def\CALX_ifsgn_i #1%
{%
\if-#1\xint_dothis\CALX_ifsgn_m\fi
\if+#1\xint_dothis\CALX_ifsgn_p\fi
\xint_orthat\CALX_ifsgn_q
}%
\def\CALX_ifsgn_q #1\xint:%
{\expandafter\CALX_ifsgn_z\romannumeral`&&@%
\CALX_signalcondition{InvalidOperation}{sign of I?}{}{}\xint:}%
\def\CALX_ifsgn_z #1\xint:{\xint_stop_atsecondofthree}%
\def\CALX_ifsgn_m #1\xint:{\xint_stop_atfirstofthree}%
\def\CALX_ifsgn_p #1\xint:{\xint_stop_atthirdofthree}%
% \end{macrocode}
% \subsection{Native addition and subtraction}
% \subsubsection{\csh{CALX_nadd}}
%\begin{lverb}
% Syntax (use with \romannumeral0; X, Y f-expanded, native integers or
% I+, I-, I?):
%(
% \CALX_nadd{X}{Y} -> Z Z = X + Y
%: \CALX_nsub{X}{Y} -> Z Z = X - Y
%)
% Z: native integer, or I+, I-, I? (special operands, rules of the
% signals section).
%
% Addition and subtraction: dispatch.
%
% \CALX_nadd{X}{Y}: \CALX_nadd_x f-expands Y and leaves
%( Y\xint:X1;!1;!1;!1;!\W\xint:
%)
% so that X is already followed by the kernel terminator. With P = Y
% (count n, sign s) and Q = X (count m, sign t), \CALX_nadd_y grabs only
% P's list and Q's header N. and runs a chain of tests. A test
% that fires puts a "jumper" in its branch: a macro taking a few data
% tokens, delimited by the \fi of that branch, which swallows the rest
% of \CALX_nadd_y's body (P's list included) and starts with the \fi it
% removed. Without jumper, the common case runs inline: same signs and
% n<=m, kernel started with P's list, Q's list left where it is.
%( n=0: Q \CALX_nadd_retx
%: m=0: P \CALX_nadd_rety
%: s<>t, nt, n>m: |P|-|Q|, sign s \CALX_ndiff_p
%: s<>t, n=m: P-Q, possibly negative \CALX_ndiff_e
%: s=t, n>m: Q shorter \CALX_nsum_q
%: s=t, n<=m: inline
%)
% The count of the result (m, or n) is written BEFORE the kernel:
%( \expandafter\CALX_naddm\expandafter\the\numexpr%
%: \expandafter.\the\numexpr\CALX_nadd_a\xint_c_ii1;!1;!1;!1;!\W
%: 1;!1;!1;!1;!\W\xint:
%)
% Lists grabbed: P's once more in the jumper cases, Q's once in
% \CALX_ndiff_p, _e and \CALX_nsum_q, the result once by the final macro
% (its header must precede it).
%
% Addition kernel: xintcore's \XINT_add_a ... \XINT_add_o (xintcore
% l.598-668, code-only numbering), copied as \CALX_nadd_a ... \CALX_nadd_o.
%
% Contract: first list the SHORTER (or equal) one, both lists followed by
% 1;!1;!1;!1;!\W, initial state 2; output: the LS-first sum blocks followed
% by 1;!, then the tokens which followed the second list's \W. The only
% place where the result gets one more block than the longer operand is
% \XINT_add_lf, which appends block 00000001; its copy \CALX_nadd_lf also
% emits +\xint_c_i after the 1;!, before the final \xint:. \CALX_naddm
% grabs . the list and that optional increment.
%
% Subtraction kernel: xintcore's \XINT_sub_a ... \XINT_sub_i with
% \XINT_sub_bi, _di, _fi, _hi (xintcore l.786-851, code-only numbering),
% copied as \CALX_nsub_*. Contract: called as
%( \CALX_nsub_a\xint_c_i 1;!1;!1;!1;!\W 1;!1;!1;!1;!\W
%)
% with S not longer than L, it computes L-S; each step produces a block and a
% state digit, 1 for no borrow, 0 for borrow; when S is exhausted it calls
%( \CALX_nsub_k 1;!1;!1;!1;!\W
%)
% xintcore's \XINT_sub_k and what follows are tied to its decimal output; the
% end of the loop (\CALX_nsub_k and the following) is calx's own. It ends
% the list with 1;! followed by one digit, before the final \xint:.
%
% Unequal lengths (n_L > n_S): remaining L blocks are not empty and
% |L| > |S|, so a final borrow is absorbed by L:
%- no borrow: copy the remaining blocks (\CALX_nsub_kc), digit 0;
%- borrow: 00000000 blocks become 99999999 and the borrow goes on; the
% first non zero block d becomes d-1, then copy (\CALX_nsub_kb). If d is
% the top block (next is 1;!) and d=1, the block is dropped
% (\CALX_nsub_kt) and the digit is 1: the blocks produced by the loop
% below it may be zero (e.g. 10^16-(10^16-1)). This happens only when
% n_L=n_S+1, the top block of L is 00000001 and absorbs a borrow.
%
% \CALX_nsubu: digit 0, the result is final; digit 1, \CALX_nsubrd takes
% the n_L-1 blocks again with \CALX_ntakex and normalizes (\CALX_nnorm).
%
% Equal lengths: remaining L blocks are empty; \CALX_nsub_ke ends the list
% and leaves the state as digit. State 0 means P complements them (\CALX_nnega), flips
% the sign and goes to \CALX_nsubf. \CALX_nsubf examines the top block
% (\CALX_ntop_c): if it is not zero, the count is n and the result is
% final; otherwise \CALX_nsubr strips zero top blocks (\CALX_nnorm).
%
% \CALX_ntakex . takes exactly n blocks 1<8 digits>! from the input
% stream and leaves them followed by 1;! (inside \numexpr chains): the
% list then needs no delimiter, so the final result N. can be
% left as is in the common case and taken again only in the rare ones.
%\end{lverb}
% \begin{macrocode}
\def\CALX_nadd #1{\expandafter\CALX_nadd_x\romannumeral`&&@#1\xint:}%
\def\CALX_nadd_x #1#2\xint:#3{\expandafter\CALX_nsp_t\expandafter\CALX_nadd_y
\expandafter\CALX_nadd_sp\expandafter#1\romannumeral`&&@#3\xint:#1#2%
1;!1;!1;!1;!\W\xint:}%
% \end{macrocode}
%\begin{lverb}
% Special values (SPEC_native D9). \CALX_nsp_t
% (tags of X and Y, the stream continues with Y without its tag, then
% \xint:X\xint:, see below): both tags N: , else
% . For \CALX_nmul is empty.
%
% \CALX_nadd_sp ...\xint:...\xint: (the tail of X
% is swallowed with it; s = second token:
% sign, or + - ? after I): NaN in an operand: I?; Inf + finite: that Inf;
% Inf + Inf: that Inf if same sign, else InvalidOperation (default I?).
%
% \CALX_nsub_sp flips sY (I? unchanged) and goes to \CALX_nadd_sp.
%\end{lverb}
% \begin{macrocode}
\def\CALX_nsp_t #1#2#3#4%
{\if\if N#3#4\else ?\fi N\xint_dothis{#1#4}\fi\xint_orthat{#2#3#4}}%
\def\CALX_nadd_sp #1#2#3#4\xint:#5#6#7\xint:%
{%
\if ?#3\xint_dothis{ I?}\fi
\if ?#6\xint_dothis{ I?}\fi
\if N#2\xint_dothis{ I#6}\fi
\if N#5\xint_dothis{ I#3}\fi
\if #3#6\xint_dothis{ I#3}\fi
\xint_orthat{\CALX_nsig{InvalidOperation}{inf - inf}{}}%
}%
\def\CALX_nadd_y N#1#2.#3\xint:N#4#5.%
{%
\ifnum#2=\xint_c_ \CALX_nadd_retx#4#5.\fi
\ifnum#5=\xint_c_ \CALX_nadd_rety#1#2.\fi
\if#1#4\else
\ifnum#2<#5 \CALX_ndiff_q#4#5.\fi
\ifnum#2>#5 \CALX_ndiff_p#1#2.\fi
\CALX_ndiff_e#1#2.%
\fi
\ifnum#2>#5 \CALX_nsum_q#1#2.\fi
\expandafter\CALX_naddm\expandafter#1\the\numexpr#5\expandafter.%
\the\numexpr\CALX_nadd_a\xint_c_ii#31;!1;!1;!1;!\W
}%
\def\CALX_nadd_retx#1#2.\fi#3\W#41;!1;!1;!1;!\W\xint:{\fi\CALX_sp N#1#2.#4}%
\def\CALX_nadd_rety#1#2.\fi#3\xint_c_ii#41;!1;!1;!1;!\W
1;!1;!1;!1;!\W\xint:{\fi\CALX_sp N#1#2.#4}%
\def\CALX_nsum_q#1#2.\fi#3\xint_c_ii#41;!1;!1;!1;!\W
#51;!1;!1;!1;!\W\xint:%
{%
\fi\expandafter\CALX_naddm\expandafter#1\the\numexpr#2\expandafter.%
\the\numexpr\CALX_nadd_a\xint_c_ii#51;!1;!1;!1;!\W#41;!1;!1;!1;!\W\xint:
}%
\def\CALX_naddm #1#2.#31;!#4\xint:%
{\expandafter\CALX_sp\expandafter N\expandafter#1\the\numexpr#2#4.#3}%
\def\CALX_ndiff_q#1#2.\fi#3\xint_c_ii#41;!1;!1;!1;!\W
{%
\fi\fi\expandafter\CALX_nsubu\expandafter#1\the\numexpr#2\expandafter.%
\the\numexpr\CALX_nsub_a\xint_c_i#41;!1;!1;!1;!\W
}%
\def\CALX_ndiff_p#1#2.\fi#3\xint_c_ii#41;!1;!1;!1;!\W
#51;!1;!1;!1;!\W\xint:%
{%
\fi\fi\expandafter\CALX_nsubu\expandafter#1\the\numexpr#2\expandafter.%
\the\numexpr\CALX_nsub_a\xint_c_i#51;!1;!1;!1;!\W#41;!1;!1;!1;!\W\xint:
}%
\def\CALX_ndiff_e#1#2.\fi#3\xint_c_ii#41;!1;!1;!1;!\W
#51;!1;!1;!1;!\W\xint:%
{%
\fi\expandafter\CALX_nsube\expandafter#1\the\numexpr#2\expandafter.%
\the\numexpr\CALX_nsub_a\xint_c_i#51;!1;!1;!1;!\W#41;!1;!1;!1;!\W\xint:
}%
\def\CALX_nsubu #1#2.#31;!#4\xint:%
{%
\ifnum#4=\xint_c_ \expandafter\CALX_sp\else\expandafter\CALX_nsubrd\fi
N#1#2.#3%
}%
\def\CALX_nsube #1#2.#31;!#4\xint:%
{%
\if0#4\csname CALX_nsubng#1\expandafter\endcsname
\else\expandafter\CALX_nsubf\fi #1#2.#31;!%
}%
\expandafter\def\csname CALX_nsubng+\endcsname #1#2.#31;!%
{%
\expandafter\CALX_nsubf\expandafter-\the\numexpr#2\expandafter.%
\the\numexpr\CALX_nnega#31;!%
}%
\expandafter\def\csname CALX_nsubng-\endcsname #1#2.#31;!%
{%
\expandafter\CALX_nsubf\expandafter+\the\numexpr#2\expandafter.%
\the\numexpr\CALX_nnega#31;!%
}%
\def\CALX_nsubf #1#2.#31;!%
{%
\ifnum\CALX_nskip\CALX_ntop_c #2-\xint_c_i.#3\xint:=\xint_c_
\expandafter\CALX_nsubr\else\expandafter\CALX_sp\fi
N#1#2.#3%
}%
\def\CALX_nsubr N#1#2.%
{\expandafter\CALX_nnorm\expandafter#1\the\numexpr\CALX_ntakex#2.}%
\def\CALX_nsubrd N#1#2.%
{%
\expandafter\CALX_nnorm\expandafter#1\the\numexpr
\expandafter\CALX_ntakex\the\numexpr#2-\xint_c_i.%
}%
\def\CALX_ntakex #1.%
{%
\ifnum#1=\xint_c_ \expandafter\CALX_ntakex_e\else
\expandafter\CALX_ntakex_b\fi #1.%
}%
\def\CALX_ntakex_e #1.{1\relax;!}%
\def\CALX_ntakex_b #1.1#2!%
{%
1#2\expandafter!\the\numexpr
\expandafter\CALX_ntakex\the\numexpr#1-\xint_c_i.%
}%
\def\CALX_ntop_c 1#1!#2\xint:{#1}%
\def\CALX_nsub_k #1#2#3{%
\xint_gob_til_sc #3\CALX_nsub_ke;%
\xint_gob_til_zero #1\CALX_nsub_kz0\CALX_nsub_kc #2#3%
}%
\def\CALX_nsub_ke;\xint_gob_til_zero#1#2\W{1\relax;!#1}%
\def\CALX_nsub_kz0\CALX_nsub_kc{\CALX_nsub_kb}%
\def\CALX_nsub_kc #11;!1;!1;!1;!\W{#11;!0}%
\def\CALX_nsub_kb 1#1!#2#3{%
\xint_gob_til_sc #3\CALX_nsub_kt;%
\ifnum#1=\xint_c_ \expandafter\CALX_nsub_kbz\else
\expandafter\CALX_nsub_kbn\fi #1!#2#3%
}%
\def\CALX_nsub_kbz #1!{199999999\expandafter!\the\numexpr\CALX_nsub_kb}%
\def\CALX_nsub_kbn #1!{1#1-\xint_c_i\expandafter!\the\numexpr\CALX_nsub_kc}%
\def\CALX_nsub_kt;\ifnum#1=#2\W{%
\ifnum#1=\xint_c_i \expandafter\CALX_nsub_kto\else
\expandafter\CALX_nsub_ktn\fi #1!%
}%
\def\CALX_nsub_kto #1!{1\relax;!1}%
\def\CALX_nsub_ktn #1!{1#1-\xint_c_i\relax!1;!0}%
% \end{macrocode}
% \subsubsection{\csh{CALX_nsub}}
%\begin{lverb}
% \CALX_nsub{X}{Y} = X-Y: flips the sign of Y and goes to the addition
% (N-0. may arise transiently but is caught by the zero tests of
% \CALX_nadd_y before any use of the sign).
%\end{lverb}
% \begin{macrocode}
\def\CALX_nsub #1{\expandafter\CALX_nsub_x\romannumeral`&&@#1\xint:}%
\def\CALX_nsub_x #1#2\xint:#3{\expandafter\CALX_nsp_t\expandafter\CALX_nsub_y
\expandafter\CALX_nsub_sp\expandafter#1\romannumeral`&&@#3\xint:#1#2%
1;!1;!1;!1;!\W\xint:}%
\def\CALX_nsub_sp #1#2#3%
{%
\if +#3\xint_dothis{\CALX_nadd_sp#1#2-}\fi
\if -#3\xint_dothis{\CALX_nadd_sp#1#2+}\fi
\xint_orthat{\CALX_nadd_sp#1#2#3}%
}%
\def\CALX_nsub_y N#1%
{\if#1-\expandafter\CALX_nsub_yp\else\expandafter\CALX_nsub_ym\fi}%
\def\CALX_nsub_yp{\CALX_nadd_y N+}%
\def\CALX_nsub_ym{\CALX_nadd_y N-}%
% \end{macrocode}
% \subsubsection{\csh{CALX_nnega}, \csh{CALX_nnegb}, \csh{CALX_nnorm},
% \csh{CALX_nlast}, \csh{CALX_ntake}}
%\begin{lverb}
% \CALX_nnega$empty: 10^(8n)-R on LS-first blocks terminated by 1;! (R not
% zero): low zero blocks stay, the first non zero block d becomes 10^8-d
% (written 2*10^8-d to keep the protecting 1), the next ones 99999999-d
% (written 199999999-d).
%\end{lverb}
% \begin{macrocode}
\def\CALX_nnega 1#1!{%
\ifnum#1=\xint_c_ 100000000\expandafter!\the\numexpr
\expandafter\CALX_nnega
\else \xint_c_ii*\xint_c_e_viii-#1\expandafter!\the\numexpr
\expandafter\CALX_nnegb
\fi
}%
\def\CALX_nnegb 1#1#2!{\xint_gob_til_sc #1\CALX_nnegz;%
199999999-#1#2\expandafter!\the\numexpr\CALX_nnegb}%
\def\CALX_nnegz;#1\CALX_nnegb{1\relax;!}%
% \end{macrocode}
%\begin{lverb}
% Syntax:
%(
% \CALX_nnorm 1;! -> N.
%)
% (blocks LS first, zero top blocks allowed; blocks' without them, N+0. if
% all are zero.)
% \CALX_nnorm 1;!: strips the zero top blocks and counts, in
% two linear passes: \CALX_nlast finds the index of the last non zero block
% (arguments are two numbers ..), then \CALX_ntake emits that
% many blocks inside a \numexpr chain (xintcore's
% 1\expandafter!\the\numexpr technique) and gobbles the rest up to
% \xint:. Returns N+0. if all blocks are zero.
%\end{lverb}
% \begin{macrocode}
\def\CALX_nnorm #1#21;!%
{\expandafter\CALX_nnorm_b\romannumeral0\CALX_nlast 0.0.#21;!.#1#2\xint:}%
\def\CALX_nlast #1.#2.1#3#4!{%
\xint_gob_til_sc #3\CALX_nlast_e;%
\ifnum#3#4=\xint_c_
\expandafter\CALX_nlast_z
\else
\expandafter\CALX_nlast_nz
\fi #1.#2.%
}%
\def\CALX_nlast_z #1.#2.{\expandafter\CALX_nlast\the\numexpr#1+\xint_c_i.#2.}%
\def\CALX_nlast_nz #1.#2.%
{\expandafter\CALX_nlast\the\numexpr#1+\xint_c_i\expandafter.\the%
\numexpr#1+\xint_c_i.}%
\def\CALX_nlast_e;#1\fi #2.#3.{ #3}%
\def\CALX_nnorm_b #1.{\ifnum#1=\xint_c_ \CALX_nnorm_z\fi\CALX_nnorm_c #1.}%
\def\CALX_nnorm_z\fi#1\xint:{\fi\CALX_sp N+0.}%
\def\CALX_nnorm_c #1.#2#3\xint:%
{\expandafter\CALX_nnorm_d\the\numexpr\CALX_ntake #1.#31;!\xint:#2#1.}%
\def\CALX_nnorm_d #11;!#2#3.{ N#2#3.#1}%
\def\CALX_ntake #1.1#2!{%
\ifnum#1=\xint_c_ \expandafter\CALX_ntake_e\fi
1#2\expandafter!\the\numexpr
\expandafter\CALX_ntake\the\numexpr#1-\xint_c_i.%
}%
\def\CALX_ntake_e #1\xint:{1\relax;!}%
% \end{macrocode}
% \subsection{Native multiplication}
% \subsubsection{\csh{CALX_nmul}}
%\begin{lverb}
% Syntax (use with \romannumeral0; X, Y f-expanded, native integers or
% I+, I-, I?):
%(
% \CALX_nmul{X}{Y} -> Z Z = X Y (native integer, or I)
%)
% Multiplication. \CALX_nmul{X}{Y}. The kernels are used as they are, from
% the renamed copy of xintcore (they are self contained, the addition they
% use is the unmodified \CALX_add_a): \CALX_mul_loop, \CALX_smallmul,
% \CALX_verysmallmul. Only the dispatch (xintcore's \XINT_mul_checklengths,
% \XINT_mul_smallbyfirst/second) is rewritten, with the stored block counts,
% and the output.
%
% Contracts (from the code, xintcore l.1013-1097 code-only):
%- \the\numexpr\CALX_mul_loop 100000000!1;!\W 1;!\W 1;! computes
% X*Y, iterating over the blocks of Y (the initial 100000000!1;! is the
% zero accumulator); output: product blocks LS-first then 1;!, then the
% tokens which followed Y's 1;!;
%- \the\numexpr\CALX_smallmul 1!1;! for a single block y, and
% \the\numexpr\CALX_verysmallmul 0\xint:!1;! for y<22 (xintcore's
% threshold): same output form.
%
% These kernels never produce a zero top block (the final carry block is
% dropped when zero, \XINT_smallmul_f, \XINT_verysmallmul_f). A product
% of n and m blocks has n+m-1 or n+m blocks: \CALX_nmulo receives
% n+m-1 (computed before the kernel), skips that many blocks
% (\CALX_nskip) and checks whether one more follows.
%
% Dispatch as for \CALX_nadd: \CALX_nmul_x writes X followed by 1;!\xint:,
% \CALX_nmul_y grabs P's list and Q's header; jumpers \CALX_nmul_zero,
% \CALX_nmul_sp (P one block: Q stays in place), \CALX_nmul_sq (Q one
% block), \CALX_nmul_xq (iteration over P: Q's list grabbed); inline
% default: iteration over Q, left in place. A one-block factor y uses
% \CALX_verysmallmul if y<22, else \CALX_smallmul (y=1 included).
%
% Choice of the iterated operand: the rule of xintcore's
% \XINT_mul_checklengths, transcribed with X=Q, Y=P by default (A=P, B=Q in
% xintcore): exchange if m=n and
% (n-1)(m-n)>383.
%
% \CALX_psign gives + or - (sign of a
% product) by expansion (used by the division).
%\end{lverb}
% \begin{macrocode}
\def\CALX_psign #1#2#3%
{\if#1#2\expandafter#3\expandafter+\else\expandafter#3\expandafter-\fi}%
\def\CALX_nmul #1{\expandafter\CALX_nmul_x\romannumeral`&&@#1\xint:}%
\def\CALX_nmul_x #1#2\xint:#3{\expandafter\CALX_nsp_t\expandafter\CALX_nmul_y
\expandafter\CALX_nmul_spv\expandafter#1\romannumeral`&&@#3\xint:#1#2%
1;!\xint:}%
% \end{macrocode}
%\begin{lverb}
% \CALX_nmul_spv (same input as \CALX_nadd_sp): NaN: I?; Inf times 0:
% InvalidOperation (I?); otherwise Inf with the product of the signs.
%
% \CALX_nsp_z : its block count.
%
% \CALX_nsp_ps : I+ or I- (product of the signs, with the space).
%\end{lverb}
% \begin{macrocode}
\def\CALX_nsp_z #1.#2\xint:{#1}%
\def\CALX_nsp_ps #1#2{\if#1#2\xint_dothis{ I+}\fi\xint_orthat{ I-}}%
\def\CALX_nmul_spv #1#2#3#4\xint:#5#6#7\xint:%
{%
\if ?#3\xint_dothis{ I?}\fi
\if ?#6\xint_dothis{ I?}\fi
\ifnum\if N#2\CALX_nsp_z#4\xint:\else\if N#5\CALX_nsp_z#7\xint:\else
\xint_c_i\fi\fi=\xint_c_
\xint_dothis{\CALX_nsig{InvalidOperation}{inf * 0}{}}\fi
\xint_orthat{\CALX_nsp_ps#3#6}%
}%
\def\CALX_nmul_y N#1#2.#3\xint:N#4#5.%
{%
\ifnum#2=\xint_c_ \CALX_nmul_zero\fi
\ifnum#5=\xint_c_ \CALX_nmul_zero\fi
\ifnum#2=\xint_c_i \CALX_nmul_sp#1#4#2.#5.\fi
\ifnum#5=\xint_c_i \CALX_nmul_sq#1#4#2.#5.\fi
\ifnum\ifnum#5<#2 \numexpr383-(#5-\xint_c_i)*(#2-#5)\relax
\else\numexpr(#2-\xint_c_i)*(#5-#2)-383\relax\fi>\xint_c_
\else\CALX_nmul_xq#1#4#2.#5.\fi
\csname CALX_nmulo\if#1#4+\else-\fi\expandafter\endcsname
\the\numexpr#2+#5-\xint_c_i\expandafter.%
\the\numexpr\CALX_mul_loop 100000000!1;!\W #31;!\W
}%
\def\CALX_nmul_zero\fi#1\W#2\W#31;!\xint:{\fi\CALX_sp N+0.}%
\def\CALX_nmul_sp#1#2#3.#4.\fi#5\W1#6!1;!\W
{%
\fi\csname CALX_nmulo\if#1#2+\else-\fi\expandafter\endcsname
\the\numexpr#4\expandafter.\the\numexpr
\ifnum#6<\xint_c_xxii \expandafter\CALX_nmul_vs\else
\expandafter\CALX_nmul_s\fi #6!%
}%
\def\CALX_nmul_sq#1#2#3.#4.\fi#5\W#6\W1#7!1;!\xint:%
{%
\fi\csname CALX_nmulo\if#1#2+\else-\fi\expandafter\endcsname
\the\numexpr#3\expandafter.\the\numexpr
\ifnum#7<\xint_c_xxii \expandafter\CALX_nmul_vs\else
\expandafter\CALX_nmul_s\fi #7!#6\xint:
}%
\def\CALX_nmul_vs #1!{\CALX_verysmallmul 0\xint:#1!}%
\def\CALX_nmul_s #1!{\CALX_smallmul 1#1!}%
\def\CALX_nmul_xq#1#2#3.#4.\fi#5\W#6\W#71;!\xint:%
{%
\fi\csname CALX_nmulo\if#1#2+\else-\fi\expandafter\endcsname
\the\numexpr#3+#4-\xint_c_i\expandafter.%
\the\numexpr\CALX_mul_loop 100000000!1;!\W#71;!\W#6\xint:
}%
\expandafter\def\csname CALX_nmulo+\endcsname #1.#21;!\xint:%
{%
\expandafter\CALX_sp\expandafter N\expandafter+\the\numexpr
#1+\CALX_nskip\CALX_nmul_c #1.#21;!\xint:.#2%
}%
\expandafter\def\csname CALX_nmulo-\endcsname #1.#21;!\xint:%
{%
\expandafter\CALX_sp\expandafter N\expandafter-\the\numexpr
#1+\CALX_nskip\CALX_nmul_c #1.#21;!\xint:.#2%
}%
\def\CALX_nmul_c 1#1#2!#3\xint:{\xint_gob_til_sc #1\CALX_nmul_ce;\xint_c_i}%
\def\CALX_nmul_ce;\xint_c_i{\xint_c_}%
\def\CALX_nadd_a #1!#2!#3!#4!#5\W
#6!#7!#8!#9!%
{%
\CALX_nadd_b
#1!#6!#2!#7!#3!#8!#4!#9!%
#5\W
}%
\def\CALX_nadd_b #11#2#3!#4!%
{%
\xint_gob_til_sc #2\CALX_nadd_bi ;%
\expandafter\CALX_nadd_c\the\numexpr#1+1#2#3+#4-\xint_c_ii\xint:%
}%
\def\CALX_nadd_bi;\expandafter\CALX_nadd_c
\the\numexpr#1+#2+#3-\xint_c_ii\xint:#4!#5!#6!#7!#8!#9!\W
{%
\CALX_nadd_k #1#3!#5!#7!#9!%
}%
\def\CALX_nadd_c #1#2\xint:%
{%
1#2\expandafter!\the\numexpr\CALX_nadd_d #1%
}%
\def\CALX_nadd_d #11#2#3!#4!%
{%
\xint_gob_til_sc #2\CALX_nadd_di ;%
\expandafter\CALX_nadd_e\the\numexpr#1+1#2#3+#4-\xint_c_ii\xint:%
}%
\def\CALX_nadd_di;\expandafter\CALX_nadd_e
\the\numexpr#1+#2+#3-\xint_c_ii\xint:#4!#5!#6!#7!#8\W
{%
\CALX_nadd_k #1#3!#5!#7!%
}%
\def\CALX_nadd_e #1#2\xint:%
{%
1#2\expandafter!\the\numexpr\CALX_nadd_f #1%
}%
\def\CALX_nadd_f #11#2#3!#4!%
{%
\xint_gob_til_sc #2\CALX_nadd_fi ;%
\expandafter\CALX_nadd_g\the\numexpr#1+1#2#3+#4-\xint_c_ii\xint:%
}%
\def\CALX_nadd_fi;\expandafter\CALX_nadd_g
\the\numexpr#1+#2+#3-\xint_c_ii\xint:#4!#5!#6\W
{%
\CALX_nadd_k #1#3!#5!%
}%
\def\CALX_nadd_g #1#2\xint:%
{%
1#2\expandafter!\the\numexpr\CALX_nadd_h #1%
}%
\def\CALX_nadd_h #11#2#3!#4!%
{%
\xint_gob_til_sc #2\CALX_nadd_hi ;%
\expandafter\CALX_nadd_i\the\numexpr#1+1#2#3+#4-\xint_c_ii\xint:%
}%
\def\CALX_nadd_hi;%
\expandafter\CALX_nadd_i\the\numexpr#1+#2+#3-\xint_c_ii\xint:#4\W
{%
\CALX_nadd_k #1#3!%
}%
\def\CALX_nadd_i #1#2\xint:%
{%
1#2\expandafter!\the\numexpr\CALX_nadd_a #1%
}%
\def\CALX_nadd_k #1{\if #12\expandafter\CALX_nadd_ke\else\expandafter%
\CALX_nadd_l \fi}%
\def\CALX_nadd_ke #11;#2\W {\CALX_nadd_kf #11;!}%
\def\CALX_nadd_kf 1{1\relax }%
\def\CALX_nadd_l 1#1{\xint_gob_til_sc #1\CALX_nadd_lf ;\CALX_nadd_m 1#1}%
\def\CALX_nadd_lf #1\W {1\relax 00000001!1;!+\xint_c_i}% calx: count +1
\def\CALX_nadd_m #1!{\expandafter\CALX_nadd_n\the\numexpr\xint_c_i+#1\xint:}%
\def\CALX_nadd_n #1#2\xint:{1#2\expandafter!\the\numexpr\CALX_nadd_o #1}%
\def\CALX_nadd_o #1{\if #12\expandafter\CALX_nadd_l\else\expandafter%
\CALX_nadd_ke \fi}%
\def\CALX_nsub_a #1!#2!#3!#4!#5\W #6!#7!#8!#9!%
{%
\CALX_nsub_b
#1!#6!#2!#7!#3!#8!#4!#9!%
#5\W
}%
\def\CALX_nsub_b #1#2#3#4!#5!%
{%
\xint_gob_til_sc #3\CALX_nsub_bi ;%
\expandafter\CALX_nsub_c\the\numexpr#1+1#5-#3#4-\xint_c_i\xint:%
}%
\def\CALX_nsub_c 1#1#2\xint:%
{%
1#2\expandafter!\the\numexpr\CALX_nsub_d #1%
}%
\def\CALX_nsub_d #1#2#3#4!#5!%
{%
\xint_gob_til_sc #3\CALX_nsub_di ;%
\expandafter\CALX_nsub_e\the\numexpr#1+1#5-#3#4-\xint_c_i\xint:
}%
\def\CALX_nsub_e 1#1#2\xint:%
{%
1#2\expandafter!\the\numexpr\CALX_nsub_f #1%
}%
\def\CALX_nsub_f #1#2#3#4!#5!%
{%
\xint_gob_til_sc #3\CALX_nsub_fi ;%
\expandafter\CALX_nsub_g\the\numexpr#1+1#5-#3#4-\xint_c_i\xint:
}%
\def\CALX_nsub_g 1#1#2\xint:%
{%
1#2\expandafter!\the\numexpr\CALX_nsub_h #1%
}%
\def\CALX_nsub_h #1#2#3#4!#5!%
{%
\xint_gob_til_sc #3\CALX_nsub_hi ;%
\expandafter\CALX_nsub_i\the\numexpr#1+1#5-#3#4-\xint_c_i\xint:
}%
\def\CALX_nsub_i 1#1#2\xint:%
{%
1#2\expandafter!\the\numexpr\CALX_nsub_a #1%
}%
\def\CALX_nsub_bi;%
\expandafter\CALX_nsub_c\the\numexpr#1+1#2-#3\xint:
#4!#5!#6!#7!#8!#9!\W
{%
\CALX_nsub_k #1#2!#5!#7!#9!%
}%
\def\CALX_nsub_di;%
\expandafter\CALX_nsub_e\the\numexpr#1+1#2-#3\xint:
#4!#5!#6!#7!#8\W
{%
\CALX_nsub_k #1#2!#5!#7!%
}%
\def\CALX_nsub_fi;%
\expandafter\CALX_nsub_g\the\numexpr#1+1#2-#3\xint:
#4!#5!#6\W
{%
\CALX_nsub_k #1#2!#5!%
}%
\def\CALX_nsub_hi;%
\expandafter\CALX_nsub_i\the\numexpr#1+1#2-#3\xint:
#4\W
{%
\CALX_nsub_k #1#2!%
}%
% \end{macrocode}
% \subsection{Native division}
% \subsubsection{\csh{CALX_nudiv}}
%\begin{lverb}
% Division (calx). Unsigned core:
%( \CALX_nudiv {na}{A}{nb}{B}
%)
% with A, B non zero, given by their block counts and LS-first blocks.
% It expands to
%( {nq}{Q}{s}{R'}
%)
% where nq, Q (count, LS-first blocks) is the quotient floor(A/B), and R'
% the LS-first blocks (non normalized: zero top blocks possible) terminated
% by 1;! of 10^s times the remainder R = A - Q*B. Use \CALX_nudiv_rem to get
% R in native format. The tokens following the last argument are left
% untouched after {nq}{Q}{s}{R'}.
%
% Paths:
%- na < nb: Q = 0, R' = A, s = 0.
%- nb = 1, na = 1: \numexpr.
%- nb = 1, divisor d <= 45249: dedicated kernel (see below).
%- nb = 1, larger divisor: A reversed (\CALX_rev_nounsep),
% \CALX_smalldivx_a (from xintcore) (MS-first), quotient reversed.
%- nb = 2, 3, 4: dedicated loops without normalization (see below), s = 0.
%- nb >= 5: Knuth's algorithm D in base 10^8, described now.
%
% Algorithm D (general path).
%
% Normalisation: s = number of leading zeros of the top block of B (as an
% 8 digit block); A'' = 10^s A with exactly na+1 blocks (a zero block is
% appended before multiplying), B' = 10^s B (nb blocks, top block v1 >=
% 10^7). \CALX_smallmul (from xintcore) does both products, LS-first.
% The quotient is the same, the remainder is multiplied by 10^s.
%
% Data: the window W (nb+1 blocks w_0..w_nb, W < 10^8 B') and B' (b_0 ..
% b_{nb-1}) are kept INTERLEAVED in one list
%( L = 1w_0!1b_0!1w_1!1b_1!...1w_{nb-1}!1b_{nb-1}!1w_nb!1;;;;;!
%)
% (1;;;;;! = marker Z). The remaining blocks of A'' are kept MS-first in the
% input stream, after L, terminated by 1;!.
%
% The multiply-subtract pass \CALX_ndms_a reads the pairs (w_k,b_k) and emits
% b_k then r_k, where r = W - q*B' (one borrow chain); its output is
%( 1b_0!1r_0!1b_1!1r_1!...1b_{nb-1}!1r_{nb-1}!1;;;;;!{fin}
%)
% with fin = 0 if r >= 0 and fin = -1 if r < 0 (then the blocks hold
% r + 10^(8nb)). Prefixing the next block of A'' gives exactly the next
% window in the layout of L: pairs (new,b_0), (r_0,b_1), ..., top
% (r_{nb-1},Z).
%
% Estimation of q (with u0, u1, u2 the three top blocks of W, v1, v2 those
% of B', U = u0 b^2+u1 b+u2, V = v1 b+v2, b = 10^8): q* = min(floor(U/V),
% b-1) satisfies q <= q* <= q+1. Indeed W/B' < (U+1)/V gives q <=
% floor(U/V), and W/B' >= U/(V+1) gives q >= floor(U/(V+1)) >= floor(U/V)-1
% as U/V - U/(V+1) = U/(V(V+1)) < 1 (U < b V, V >= b). This holds for any
% v1 > 0; q* = q+1 needs the lower blocks to matter (probability about
% 1/v1). q* is obtained from
%( q0 = round(u0*10^9/Vp) + round(u1d/Vp),
%)
% where Vp = 10 v1 + first digit of v2 (9 digits) and u1d = 10 u1 + first
% digit of u2 (eTeX's a*b/c has a 64 bit intermediate product), clamped to
% [0, b-1]; then T = U - q0 V is computed exactly as T = a b + c with
% 0 <= c < b, by splitting q0 and v1, v2 in 4 digit halves, and corrected:
%( while T < 0: q0 -= 1, T += V;
%: while T >= V and q0 < b-1: q0 += 1, T -= V.
%)
% (|q0 - U/V| < 2.1, so at most three corrections.)
%
% If fin < 0 after the pass, B' is added back (\CALX_ndab) and q decreases.
%
% The quotient blocks are left behind in a \numexpr chain (xintcore's
% technique, value 10^8+q emitted by the enclosing \numexpr), MS-first, and
% reversed once at the end.
%\end{lverb}
% \begin{macrocode}
\def\CALX_nudiv #1#2#3#4{%
\ifnum#2<#4 \xint_dothis\CALX_nudiv_lt\fi
\xint_orthat{\CALX_nudiv_sel #4.}#1{#2}{#3}{#4}%
}%
\def\CALX_nudiv_sel #1.{%
\ifcase#1
\or \expandafter\CALX_nudiv_one
\or \expandafter\CALX_nudiv_two
\or \expandafter\CALX_nudiv_three
\or \expandafter\CALX_nudiv_four
\else\expandafter\CALX_nudiv_gen
\fi
}%
\def\CALX_nudiv_lt #1#2#3#4#5{#1{0}{}{0}{#31;!}}%
% \end{macrocode}
%\begin{lverb}
% One block divisor.
%\end{lverb}
% \begin{macrocode}
\def\CALX_nudiv_one #1#2#3#4#5{\CALX_nudiv_oa #1{#2}#5{#3}}%
\def\CALX_nudiv_oa #1#21#3!{%
\ifnum#2=\xint_c_i \xint_dothis\CALX_nudiv_oo\fi
\ifnum#3<45250 \xint_dothis\CALX_nudiv_otd\fi
\xint_orthat\CALX_nudiv_ob #1{#2}{#3}%
}%
\def\CALX_nudiv_oo #1#2#3#4{\CALX_nudiv_oo_a #1{#3}#4}%
\def\CALX_nudiv_oo_a #1#21#3!{%
\expandafter\CALX_nudiv_oo_b
\the\numexpr(#3+#2/\xint_c_ii)/#2-\xint_c_i\xint:#3\xint:#2\xint:#1%
}%
\def\CALX_nudiv_oo_b #1\xint:#2\xint:#3\xint:{%
\expandafter\CALX_nudiv_oo_c
\the\numexpr\xint_c_e_viii+#1\expandafter\xint:%
\the\numexpr\xint_c_e_viii+#2-#1*#3\xint:%
}%
\def\CALX_nudiv_oo_c 1#1\xint:#2\xint:#3{%
\ifnum#1=\xint_c_ \xint_dothis{#3{0}{}}\fi
\xint_orthat{#3{1}{1#1!}}{0}{#2!1;!}%
}%
\def\CALX_nudiv_ob #1#2#3#4{%
\expandafter\CALX_nudiv_oc
\romannumeral0\CALX_rev_nounsep {}#4\R!\R!\R!\R!\R!\R!\R!\R!\W%
\xint:{#3}{#2}#1%
}%
\def\CALX_nudiv_oc 1#1!#2\xint:#3#4{%
\expandafter\CALX_nudiv_od
\the\numexpr\expandafter\CALX_smalldivx_a\the\numexpr#3/\xint_c_ii%
\xint:1#3!1#1!#21;!%
{\ifnum#1<#3 -\xint_c_i\fi+#4}%
}%
\def\CALX_nudiv_od #11!;!#2!#3{%
\expandafter\CALX_nudiv_oe
\romannumeral0\CALX_rev_nounsep {}#1\R!\R!\R!\R!\R!\R!\R!\R!\W%
\xint:{#3}{#2}%
}%
\def\CALX_nudiv_oe #1\xint:#2#3{%
\expandafter\CALX_nudiv_of
\the\numexpr\xint_c_e_viii+#3\expandafter\xint:\the\numexpr#2\xint:{#1}%
}%
\def\CALX_nudiv_of #1\xint:#2\xint:#3#4{#4{#2}{#3}{0}{#1!1;!}}%
% \end{macrocode}
%\begin{lverb}
% General path. \CALX_nudiv_gs computes s from the top block of B.
%\end{lverb}
% \begin{macrocode}
\def\CALX_nudiv_gen #1#2#3#4#5{%
\expandafter\CALX_nudiv_ga\the\numexpr
\CALX_nskip\CALX_nudiv_gs #4-\xint_c_i.#5\xint:\xint:{#5}{#2}{#3}{#4}#1%
}%
\def\CALX_nudiv_gs 1#1!\xint:{\CALX_nlz{#1}}%
\def\CALX_nudiv_pow #1{\csname CALX_nudiv_pow\the\numexpr#1\endcsname}%
\expandafter\def\csname CALX_nudiv_pow0\endcsname{100000001}%
\expandafter\def\csname CALX_nudiv_pow1\endcsname{100000010}%
\expandafter\def\csname CALX_nudiv_pow2\endcsname{100000100}%
\expandafter\def\csname CALX_nudiv_pow3\endcsname{100001000}%
\expandafter\def\csname CALX_nudiv_pow4\endcsname{100010000}%
\expandafter\def\csname CALX_nudiv_pow5\endcsname{100100000}%
\expandafter\def\csname CALX_nudiv_pow6\endcsname{101000000}%
\expandafter\def\csname CALX_nudiv_pow7\endcsname{110000000}%
% \end{macrocode}
%\begin{lverb}
% #1=s, #2=B, #3=na, #4=A, #5=nb, #6=cont. Produces
%( \CALX_nudiv_gc 1;!\xint:1;!\xint:{na}{nb}{s}
%)
%\end{lverb}
% \begin{macrocode}
\def\CALX_nudiv_ga #1\xint:{%
\ifnum#1=\xint_c_ \xint_dothis\CALX_nudiv_gz\fi
\xint_orthat\CALX_nudiv_gm {#1}%
}%
\def\CALX_nudiv_gz #1#2#3#4#5{\CALX_nudiv_gc #4100000000!1;!\xint:#21;!%
\xint:{#3}{#5}{0}}%
\def\CALX_nudiv_gm #1#2{%
\expandafter\CALX_nudiv_gb\the\numexpr
\expandafter\CALX_smallmul\the\numexpr\CALX_nudiv_pow{#1}!#21;!\xint:%
{#1}%
}%
\def\CALX_nudiv_gb #11;!\xint:#2#3#4#5{%
\expandafter\CALX_nudiv_gc\the\numexpr
\expandafter\CALX_smallmul\the\numexpr\CALX_nudiv_pow{#2}!#4100000000!1;!%
\xint:#11;!\xint:{#3}{#5}{#2}%
}%
% \end{macrocode}
%\begin{lverb}
% #1=A'' (na+1 blocks), #2=B', #3=na, #4=nb, #5=s, then .
% The constants C = {k}{v1h}{v1l}{v2h}{v2l}{Vp}, k = 2nb-4, are obtained
% from the two top blocks of a copy of B'.
%\end{lverb}
% \begin{macrocode}
\def\CALX_nudiv_gc #11;!\xint:#21;!\xint:#3#4#5{%
\CALX_nskip\CALX_nudiv_gv #4-\xint_c_ii.#21;!%
\xint:{#4}{#3-#4}{#5}{#1}{#2}%
}%
\def\CALX_nudiv_gv 1#1#2#3#4#5!1#6#7#8#9{\CALX_nudiv_gu %
{#1#2#3#4}{#5}{#6#7#8#9}{#1}}%
% \end{macrocode}
%\begin{lverb}
% #1=v2h, #2=v2l, #3=v1h, #4=first digit of v2, #5=v1l, #6=nb, #7=m (number
% of low blocks of A'' to reverse, expression), #8=s, #9=A'', then {B'}.
%
% C = {k}{v1h}{v1l}{v2h}{v2l}{Vp} with k an expression (only used through
% \numexpr).
%\end{lverb}
% \begin{macrocode}
\def\CALX_nudiv_gu #1#2#3#4#5!1;!\xint:#6#7#8#9{%
\expandafter\CALX_nrevk\the\numexpr#7.\CALX_nudiv_gw{}#91;!\xint:%
{{\xint_c_ii*#6-\xint_c_iv}{#3}{#5}{#1}{#2}{#3#5#4}}{#7+\xint_c_i}{#8}%
}%
% \end{macrocode}
% \subsubsection{\csh{CALX_nrevk}}
%\begin{lverb}
% \CALX_nrevk .{acc}: reverses k blocks onto acc, then
% {acc'}. Six blocks per step.
%\end{lverb}
% \begin{macrocode}
\def\CALX_nrevk #1.{%
\ifnum#1>\xint_c_v\expandafter\CALX_nrevk_g\else\expandafter\CALX_nrevk_b%
\fi #1.%
}%
\def\CALX_nrevk_g #1.#2#3#4!#5!#6!#7!#8!#9!%
{\expandafter\CALX_nrevk\the\numexpr#1-%
\xint_c_vi.#2{#9!#8!#7!#6!#5!#4!#3}}%
\def\CALX_nrevk_b #1.{%
\ifcase#1
\expandafter\CALX_nrevk_z
\or \expandafter\CALX_nrevk_i
\or \expandafter\CALX_nrevk_ii
\or \expandafter\CALX_nrevk_iii
\or \expandafter\CALX_nrevk_iv
\else\expandafter\CALX_nrevk_v
\fi
}%
\def\CALX_nrevk_z #1{#1}%
\def\CALX_nrevk_i #1#2#3!{#1{#3!#2}}%
\def\CALX_nrevk_ii #1#2#3!#4!{#1{#4!#3!#2}}%
\def\CALX_nrevk_iii #1#2#3!#4!#5!{#1{#5!#4!#3!#2}}%
\def\CALX_nrevk_iv #1#2#3!#4!#5!#6!{#1{#6!#5!#4!#3!#2}}%
\def\CALX_nrevk_v #1#2#3!#4!#5!#6!#7!{#1{#7!#6!#5!#4!#3!#2}}%
% \end{macrocode}
%\begin{lverb}
% #1=R (MS-first low blocks of A''), #2=window (LS-first), #3=C,
% #4=steps, #5=s, #6=B'. The interleaving \CALX_nilv takes one block of each
% list per step (it regrabs the rest of the window).
%\end{lverb}
% \begin{macrocode}
\def\CALX_nudiv_gw #1#21;!\xint:#3#4#5#6{%
\expandafter\CALX_nudiv_gl\the\numexpr\CALX_nilv #21;!\xint:#61;;;;;!%
{#3}{#11;!}{#4}{#5}%
}%
% \end{macrocode}
% \subsubsection{\csh{CALX_nilv}}
% \begin{macrocode}
\def\CALX_nilv 1#1!#2\xint:1#3#4!{%
\xint_gob_til_sc #3\CALX_nilv_e;%
1#1\expandafter!\the\numexpr1#3#4\expandafter!\the\numexpr\CALX_nilv #2%
\xint:%
}%
\def\CALX_nilv_e;1#1\expandafter!\the\numexpr1#2\xint:{1#1\relax!1;;;;;!}%
\def\CALX_nudiv_gl #1;;;;;!#2#3{%
\expandafter\CALX_nudiv_x\the\numexpr\CALX_nds {#2}#1;;;;;!#3%
}%
% \end{macrocode}
%\begin{lverb}
% The main loop. Input stream: \CALX_nds {C};;;;;!1;!...
% (here lacks its final ;;;;;! which is written explicitly).
%
% \CALX_nds_t receives the top of a copy of L after k = 2nb-4 blocks are
% skipped.
%\end{lverb}
% \begin{macrocode}
\def\CALX_ndc_k #1#2#3#4#5#6{#1}%
\def\CALX_ndc_ah #1#2#3#4#5#6{#2}%
\def\CALX_ndc_al #1#2#3#4#5#6{#3}%
\def\CALX_ndc_bh #1#2#3#4#5#6{#4}%
\def\CALX_ndc_bl #1#2#3#4#5#6{#5}%
\def\CALX_ndc_a #1#2#3#4#5#6{#2#3}%
\def\CALX_ndc_b #1#2#3#4#5#6{#4#5}%
\def\CALX_ndc_vp #1#2#3#4#5#6{#6}%
% \end{macrocode}
% \subsubsection{\csh{CALX_nds}}
% \begin{macrocode}
\def\CALX_nds #1#2;;;;;!{%
\CALX_nskip\CALX_nds_t\CALX_ndc_k#1.#2;;;;;!\xint:{#1}#2;;;;;!%
}%
\def\CALX_nds_t 1#1#2!1#3!1#4!1#5!1#6!1;;;;;!\xint:#7{%
\expandafter\CALX_nds_r
\the\numexpr#6*\xint_c_e_ix/\CALX_ndc_vp#7+#4#1/\CALX_ndc_vp#7\xint:%
{#6}{#4}{#1#2}{#7}%
}%
\def\CALX_nds_r #1\xint:{%
\ifnum#1>\xint_c_e_viii_mone \CALX_nds_rm\fi
\expandafter\CALX_nds_s\the\numexpr\xint_c_e_viii+#1\xint:%
}%
% \end{macrocode}
%\begin{lverb}
% #1#2#3#4=qh (4 digits), #5=ql, #6=u0, #7=u1, #8=u2, #9=C.
%
% Splitting M1 = qh v1l + ql v1h and M2 = qh v2l + ql v2h as
% M = 10^4 Mh + Ml, with Mh = floor(M/10^4) = (M+5000)/10^4-1:
%( q0 v1 = (qh v1h + M1h) b + 10^4 M1l + ql v1l, idem for v2;
%: T = U - q0 (v1 b + v2) = Ax b + Bx with
%: Bx = u2 - 10^4 M2l - ql v2l in (-2b, b),
%: Ax = (u0 - qh v1h - M1h) b + u1 - 10^4 M1l - ql v1l - qh v2h - M2h.
%)
% 3b+Bx is in (b, 4b) and has nine digits e, so that T = a b + c with
% a = Ax+e-3, 0 <= c < b.
%\end{lverb}
% \begin{macrocode}
\def\CALX_nds_rm\fi#1\xint:{\fi\CALX_nds_s 199999999\xint:}%
\def\CALX_nds_s 1#1#2#3#4#5\xint:#6#7#8#9{%
\expandafter\CALX_nds_u\the\numexpr
(#1#2#3#4*\CALX_ndc_al#9+#5*\CALX_ndc_ah#9+5000)/\xint_c_e_iv-\xint_c_i
\expandafter\xint:\the\numexpr
(#1#2#3#4*\CALX_ndc_bl#9+#5*\CALX_ndc_bh#9+5000)/\xint_c_e_iv-\xint_c_i
\xint:{#1#2#3#4}{#5}{#6}{#7}{#8}{#9}%
}%
\def\CALX_nds_u #1\xint:#2\xint:#3#4#5#6#7#8{%
\expandafter\CALX_nds_w\the\numexpr
\xint_c_iii*\xint_c_e_viii+#7-#4*\CALX_ndc_bl#8%
-(#3*\CALX_ndc_bl#8+#4*\CALX_ndc_bh#8-\xint_c_e_iv*#2)*\xint_c_e_iv
\expandafter\xint:\the\numexpr
(#5-#3*\CALX_ndc_ah#8-#1)*\xint_c_e_viii+#6%
-(#3*\CALX_ndc_al#8+#4*\CALX_ndc_ah#8-\xint_c_e_iv*#1)*\xint_c_e_iv
-#4*\CALX_ndc_al#8-#3*\CALX_ndc_bh#8-#2%
\xint:{#3#4}{#8}%
}%
\def\CALX_nds_w #1#2\xint:#3\xint:{%
\expandafter\CALX_nds_c\the\numexpr#3+#1-%
\xint_c_iii.{#2}%
}%
% \end{macrocode}
%\begin{lverb}
% Correction loop: #1=a, #2=c (T = a b + c, 0 <= c < b), #3=q, #4=C.
% T < 0 iff a < 0. T >= V iff 2(a-v1) + (0 if c >= v2 else -1) >= 0.
%\end{lverb}
% \begin{macrocode}
\def\CALX_nds_c #1.#2#3#4{%
\ifnum#1<\xint_c_ \xint_dothis\CALX_nds_cd\fi
\ifnum\numexpr\xint_c_ii*(#1-\CALX_ndc_a#4)\ifnum#2<\CALX_ndc_b#4 -%
\xint_c_i\fi
<\xint_c_ \xint_dothis\CALX_nds_g\fi
\ifnum#3=\xint_c_e_viii_mone \xint_dothis\CALX_nds_g\fi
\xint_orthat\CALX_nds_ci {#1}{#2}{#3}{#4}%
}%
\def\CALX_nds_cd #1#2#3#4{%
\expandafter\CALX_nds_ce\the\numexpr\xint_c_e_viii+#2+\CALX_ndc_b#4\xint:%
{#1+\CALX_ndc_a#4}{#3-\xint_c_i}{#4}%
}%
\def\CALX_nds_ce #1#2\xint:#3#4{%
\expandafter\CALX_nds_cf\the\numexpr#3+#1-\xint_c_i\expandafter\xint:%
\the\numexpr#4\xint:{#2}%
}%
\def\CALX_nds_cf #1\xint:#2\xint:#3{\CALX_nds_c #1.{#3}{#2}}%
\def\CALX_nds_ci #1#2#3#4{%
\expandafter\CALX_nds_ce\the\numexpr
\xint_c_ii*\xint_c_e_viii+#2-\CALX_ndc_b#4\xint:%
{#1-\CALX_ndc_a#4-\xint_c_i}{#3+\xint_c_i}{#4}%
}%
% \end{macrocode}
%\begin{lverb}
% \CALX_nds_g #1=a, #2=c, #3=q, #4=C; then ;;;;;!1;!.
%
% The multiply-subtract pass runs on L.
%\end{lverb}
% \begin{macrocode}
\def\CALX_nds_g #1#2#3#4#5;;;;;!{%
\expandafter\CALX_nds_h\the\numexpr\xint_c_e_viii+#3\xint:{#4}#5;;;;;!%
}%
\def\CALX_nds_h 1#1#2#3#4#5\xint:#6#7;;;;;!{%
\expandafter\CALX_nds_p\the\numexpr
\CALX_ndms_a 0\xint:#1#2#3#4\xint:#5!#7;;;;;!{#1#2#3#4#5}{#6}%
}%
\def\CALX_nds_p #1;;;;;!#2{%
\ifnum\numexpr#2<\xint_c_ \xint_dothis\CALX_nds_pa\fi
\xint_orthat\CALX_nds_pb #1;;;;;!%
}%
\def\CALX_nds_pa #1;;;;;!{%
\expandafter\CALX_nds_pc\the\numexpr\CALX_ndab 0\xint:#1;;;;;!%
}%
\def\CALX_nds_pc #1;;;;;!#2{\CALX_nds_pb #1;;;;;!{#2-\xint_c_i}}%
% \end{macrocode}
%\begin{lverb}
% #1=new list without ;;;;;!, #2=q (expression), #3=C, then the first block
% of R. Emission of 10^8+q into the enclosing \numexpr.
%\end{lverb}
% \begin{macrocode}
\def\CALX_nds_pb #1;;;;;!#2#31#4#5!{%
\xint_gob_til_sc #4\CALX_nds_end;%
\xint_c_e_viii+#2\expandafter!\the\numexpr\CALX_nds {#3}1#4#5!#1;;;;;!%
}%
\def\CALX_nds_end;\xint_c_e_viii+#1\expandafter!\the\numexpr\CALX_nds %
#21#3!#4;;;;;!%
{\xint_c_e_viii+#1\relax!\xint:{#4}}%
% \end{macrocode}
%\begin{lverb}
% Multiply-subtract pass. State \xint:\xint:! where cexpr is
% an expression for the borrow c (0 <= c < 10^8), then the pairs
% 1!1!. With M = qh bl + ql bh = 10^4 Mh + Ml (10^9+M has ten
% digits: 1, Mh on five, Ml on four):
%( w - c - q b = X - (qh bh + Mh) 10^8, X = w - c - ql bl - 10^4 Ml,
%)
% X in (-3 10^8, 10^8); 4 10^8 + X has nine digits e, r is the block,
% and the new borrow is qh bh + Mh + 4 - e. At the marker Z, the expression
% w_nb - c (0 or -1) is left in braces.
%\end{lverb}
% \begin{macrocode}
\def\CALX_ndms_a #1\xint:#2\xint:#3!1#4!1#5#6#7#8#9!{%
\xint_gob_til_sc #5\CALX_ndms_e;%
1#5#6#7#8#9\expandafter!\the\numexpr\expandafter\CALX_ndms_b
\the\numexpr\xint_c_e_ix+#2*#9+#3*#5#6#7#8\xint:%
#4-(#1)\xint:#3*#9\xint:#2*#5#6#7#8\xint:#2\xint:#3!%
}%
\def\CALX_ndms_e;#1\xint:#2\xint:#3\xint:#4\xint:#5\xint:#6!{1%
\relax;;;;;!{#2}}%
\def\CALX_ndms_b 1#1#2#3#4#5#6#7#8#9\xint:{\CALX_ndms_c #1#2#3#4#5%
\xint:#6#7#8#9\xint:}%
\def\CALX_ndms_c #1\xint:#2\xint:#3\xint:#4\xint:#5\xint:{%
\expandafter\CALX_ndms_d
\the\numexpr\xint_c_iv*\xint_c_e_viii+#3-#4-#2*\xint_c_e_iv\xint:#5+#1%
\xint:%
}%
\def\CALX_ndms_d #1#2\xint:#3\xint:%
{1#2\expandafter!\the\numexpr\CALX_ndms_a #3+\xint_c_iv-#1\xint:}%
% \end{macrocode}
% \subsubsection{\csh{CALX_ndab}}
%\begin{lverb}
% Add back: on 1b_0!1r_0!...1b_{nb-1}!1r_{nb-1}!1;;;;;!, r += B' (final
% carry dropped), b's copied.
%\end{lverb}
% \begin{macrocode}
\def\CALX_ndab #1\xint:1#2#3!{\xint_gob_til_sc #2\CALX_ndab_e;\CALX_ndab_c #1%
\xint:#2#3!}%
\def\CALX_ndab_e;\CALX_ndab_c #1\xint:#2!{1\relax;;;;;!}%
\def\CALX_ndab_c #1\xint:#2!1#3!{%
1#2\expandafter!\the\numexpr\expandafter\CALX_ndab_d
\the\numexpr\xint_c_e_viii+#3+#2+#1\xint:%
}%
\def\CALX_ndab_d #1#2\xint:{1#2\expandafter!\the\numexpr\CALX_ndab #1-%
\xint_c_i\xint:}%
% \end{macrocode}
%\begin{lverb}
% End: \xint:{}{steps}{s}.
% The top quotient block may be zero (only the top one).
%\end{lverb}
% \begin{macrocode}
\def\CALX_nudiv_x 1#1!#2\xint:#3#4{%
\ifcase\numexpr\ifnum#1=\xint_c_
\ifnum\numexpr#4=\xint_c_i \xint_c_ii\else\xint_c_i\fi
\else\xint_c_\fi\relax
\expandafter\CALX_nudiv_x_n
\or \expandafter\CALX_nudiv_x_z
\else\expandafter\CALX_nudiv_x_zero
\fi {#1}{#2}{#3}{#4}%
}%
\def\CALX_nudiv_x_zero #1#2#3#4{\CALX_nudiv_y \xint:{0}{#3}}%
\def\CALX_nudiv_x_z #1#2#3#4{%
\expandafter\CALX_nudiv_y
\romannumeral0\CALX_rev_nounsep {}#2\R!\R!\R!\R!\R!\R!\R!\R!\W\xint:{#4-%
\xint_c_i}{#3}%
}%
\def\CALX_nudiv_x_n #1#2#3#4{%
\expandafter\CALX_nudiv_y
\romannumeral0\CALX_rev_nounsep {}1#1!#2\R!\R!\R!\R!\R!\R!\R!\R!\W%
\xint:{#4}{#3}%
}%
\def\CALX_nudiv_y #1\xint:#2#3{%
\expandafter\CALX_nudiv_z\the\numexpr#2\expandafter.%
\the\numexpr\CALX_ndrx #3;;;;;!1;!.{#1}%
}%
\def\CALX_nudiv_z #1.#2.#3#4#5{#5{#1}{#3}{#4}{#2}}%
% \end{macrocode}
% \subsubsection{\csh{CALX_ndrx}}
% \begin{macrocode}
\def\CALX_ndrx 1#1#2!1#3!{%
\xint_gob_til_sc #1\CALX_ndrx_e;1#3\expandafter!\the\numexpr\CALX_ndrx
}%
\def\CALX_ndrx_e;1#1\CALX_ndrx{1\relax;!}%
% \end{macrocode}
%\begin{lverb}
% \CALX_nudiv_rem {s}{R'}: native positive R (or N+0.). For s>0,
% R = 10^(8-s) R' / 10^8: \CALX_smallmul (from xintcore) then the low
% block (zero) is dropped. Then \CALX_nnorm counts and strips zero top blocks.
%\end{lverb}
% \begin{macrocode}
\def\CALX_nudiv_rem #1#2{%
\ifnum#1=\xint_c_ \xint_dothis{\CALX_nnorm +}\fi
\xint_orthat{\expandafter\CALX_nudiv_rem_a\the\numexpr
\expandafter\CALX_smallmul\the\numexpr\CALX_nudiv_pow{%
\xint_c_viii-#1}!}#2%
}%
\def\CALX_nudiv_rem_a 1#1!{\CALX_nnorm +}%
% \end{macrocode}
%\begin{lverb}
% Two-block divisor (nb = 2). No normalization: A'' = A with a zero block
% appended (na+1 blocks), reversed once (MS-first); s = 0. With s the number
% of leading zeros of v1 (here s only scales the estimate), M = 10^(s+1) and
% Vp = v1 M + floor(v2/10^(7-s)) (nine digits), the first guess is
%( q0 = round((u0 M) 10^8/Vp) + round(u1 M/Vp) + round(round(u2 M/10^8)/Vp).
%)
% The window is U = u0 b^2 + u1 b + u2 exactly and the divisor V = v1 b + v2
% exactly, so q = floor(U/V) is the quotient block (no add-back) and
% T = U - qV = a b + c is the next (u0, u1).
%
% Loop: \CALX_ndtw {Vp}{M}{v1h}{v1l}{v2h}{v2l}{u0}{u1}1!...1;!
% with u1 (and u2) on eight digits. qh and ql by \numexpr, then
%( M1 = qh v1l + ql v1h, M2 = qh v2l + ql v2h, Mh = (M+5000)/10^4-1,
%: Bx = 3b + u2 - ql v2l - 10^4 (M2 - 10^4 M2h),
%: Ax = (u0 - qh v1h - M1h) b + u1 - 10^4 (M1 - 10^4 M1h) - ql v1l
%: - qh v2h - M2h,
%)
% T = Ax b + Bx, 3b+Bx has nine digits e, a = Ax+e-3, then the
% correction loop \CALX_ndtw_l (same tests as \CALX_nds_c).
%
% Quotient blocks are emitted MS-first into the enclosing \numexpr chain,
% which ends with 1;!.
%\end{lverb}
% \begin{macrocode}
\def\CALX_nudiv_two #1#2#3#4#5{\CALX_nudiv_tw #5{#2}{#3}#1}%
\def\CALX_nudiv_tw 1#1#2#3#4#5!1#6#7#8#9{\CALX_nudiv_tu %
{#1#2#3#4}{#5}{#6#7#8#9}}%
\def\CALX_nudiv_tu #1#2#3#4!{%
\expandafter\CALX_nudiv_tv
\expanded{\CALX_nudiv_mp{\CALX_nudiv_gs 1#3#4!\xint:}}{#1}{#2}{#3}{#4}%
}%
% \end{macrocode}
%\begin{lverb}
% \CALX_nudiv_mp{s} gives M.P. with M = 10^(s+1), P = 10^(7-s), so that
% Vp = v1 M + floor(v2/P) has nine digits (first guess of q0, see the
% two-block divisor above).
%\end{lverb}
% \begin{macrocode}
\def\CALX_nudiv_mp #1{\csname CALX_nudiv_mp\the\numexpr#1\endcsname}%
\expandafter\def\csname CALX_nudiv_mp0\endcsname{10.10000000.}%
\expandafter\def\csname CALX_nudiv_mp1\endcsname{100.1000000.}%
\expandafter\def\csname CALX_nudiv_mp2\endcsname{1000.100000.}%
\expandafter\def\csname CALX_nudiv_mp3\endcsname{10000.10000.}%
\expandafter\def\csname CALX_nudiv_mp4\endcsname{100000.1000.}%
\expandafter\def\csname CALX_nudiv_mp5\endcsname{1000000.100.}%
\expandafter\def\csname CALX_nudiv_mp6\endcsname{10000000.10.}%
\expandafter\def\csname CALX_nudiv_mp7\endcsname{100000000.1.}%
\def\CALX_nudiv_tv #1.#2.#3#4#5#6{%
\expandafter\CALX_nudiv_tt
\the\numexpr#5#6*#1+(#3#4+#2/\xint_c_ii)/#2-\xint_c_i\xint:%
{#1}{#5}{#6}{#3}{#4}%
}%
\def\CALX_nudiv_tt #1\xint:#2#3#4#5#6#7#8{%
\expandafter\CALX_nudiv_tf
\romannumeral0\CALX_rev_nounsep {}#8\R!\R!\R!\R!\R!\R!\R!\R!\W
\xint:{{#1}{#2}{#3}{#4}{#5}{#6}}{#7}%
}%
% \end{macrocode}
%\begin{lverb}
% #1, #2 = two top blocks of A, #3 = the others (MS-first), #4 = K =
% {Vp}{M}{v1h}{v1l}{v2h}{v2l}, #5 = na. If (a1, a2) < (v1, v2) the window
% starts at (a1, a2, a3) (na-2 steps; if na = 2, Q = 0 and R = A), else at
% (0, a1, a2) (na-1 steps): in both cases the top quotient block is not 0.
%\end{lverb}
% \begin{macrocode}
\def\CALX_nudiv_tcmp #1#2#3#4#5#6#7#8{%
\ifnum#1<#5#6 -\xint_c_i\else\ifnum#1>#5#6 \xint_c_\else
\ifnum#2<#7#8 -\xint_c_i\else\xint_c_\fi\fi\fi
}%
\def\CALX_nudiv_tf 1#1!1#2!#3\xint:#4#5{%
\ifnum\CALX_nudiv_tcmp{#1}{#2}#4<\xint_c_
\ifnum#5=\xint_c_ii \CALX_nudiv_tq\fi
\expandafter\CALX_nudiv_tn
\else
\expandafter\CALX_nudiv_tp
\fi {#1}{#2}{#3}{#4}{#5}%
}%
\def\CALX_nudiv_tq\fi\expandafter\CALX_nudiv_tn\else\expandafter%
\CALX_nudiv_tp\fi
#1#2#3#4#5#6{\fi\fi#6{0}{}{0}{1#2!1#1!1;!}}%
\def\CALX_nudiv_tn #1#2#3#4#5{%
\expandafter\CALX_ndtw_z\the\numexpr\CALX_ndtw #4{#1}{#2}#31;!{#5-%
\xint_c_i}%
}%
\def\CALX_nudiv_tp #1#2#3#4{%
\expandafter\CALX_ndtw_z\the\numexpr\CALX_ndtw #4{0}{#1}1#2!#31;!%
}%
% \end{macrocode}
% \subsubsection{\csh{CALX_ndtw}}
% \begin{macrocode}
\def\CALX_ndtw #1#2#3#4#5#6#7#81#9!{%
\xint_gob_til_sc #9\CALX_ndtw_end;%
\expandafter\CALX_ndtw_q
\the\numexpr(#7*#2)*\xint_c_e_viii/#1+#8*#2/#1+(#9*#2/\xint_c_e_viii)/#1%
\xint:%
{#3}{#4}{#5}{#6}{#7}{#8}{#9}{{#1}{#2}}%
}%
\def\CALX_ndtw_end;\expandafter\CALX_ndtw_q\the\numexpr#1%
\xint:#2#3#4#5#6#7#8#9%
{1\relax;!\xint:{#6}{#7}}%
\def\CALX_ndtw_q #1\xint:%
{\ifnum#1>\xint_c_e_viii_mone \CALX_ndtw_qm\fi\CALX_ndtw_h #1\xint:}%
\def\CALX_ndtw_qm\fi#1\xint:{\fi\CALX_ndtw_h 99999999\xint:}%
\def\CALX_ndtw_h #1\xint:{%
\expandafter\CALX_ndtw_x
\the\numexpr(#1+5000)/\xint_c_e_iv-\xint_c_i\expandafter\xint:%
\the\numexpr#1-\xint_c_e_iv*((#1+5000)/\xint_c_e_iv-\xint_c_i)\xint:%
}%
\def\CALX_ndtw_x #1\xint:#2\xint:#3#4#5#6#7#8#9{%
\expandafter\CALX_ndtw_w\the\numexpr
\xint_c_iii*\xint_c_e_viii+#9-#2*#6%
-(#1*#6+#2*#5-\xint_c_e_iv*((#1*#6+#2*#5+5000)/\xint_c_e_iv-\xint_c_i))%
*\xint_c_e_iv
\expandafter\xint:\the\numexpr
(#7-#1*#3-(#1*#4+#2*#3+5000)/\xint_c_e_iv+\xint_c_i)*\xint_c_e_viii+#8%
-(#1*#4+#2*#3-\xint_c_e_iv*((#1*#4+#2*#3+5000)/\xint_c_e_iv-\xint_c_i))%
*\xint_c_e_iv
-#2*#4-#1*#5-(#1*#6+#2*#5+5000)/\xint_c_e_iv+\xint_c_i
\xint:{#1*\xint_c_e_iv+#2}{#3}{#4}{#5}{#6}%
}%
\def\CALX_ndtw_w #1#2\xint:#3\xint:{%
\expandafter\CALX_ndtw_l\the\numexpr#3+#1-%
\xint_c_iii.{#2}%
}%
\def\CALX_ndtw_l #1.#2#3#4#5#6#7{%
\ifnum#1<\xint_c_ \xint_dothis\CALX_ndtw_d\fi
\ifnum\numexpr\xint_c_ii*(#1-#4#5)\ifnum#2<#6#7 -\xint_c_i\fi
<\xint_c_ \xint_dothis\CALX_ndtw_g\fi
\ifnum\numexpr#3=\xint_c_e_viii_mone \xint_dothis\CALX_ndtw_g\fi
\xint_orthat\CALX_ndtw_i {#1}{#2}{#3}{#4}{#5}{#6}{#7}%
}%
\def\CALX_ndtw_d #1#2#3#4#5#6#7{%
\expandafter\CALX_ndtw_e\the\numexpr\xint_c_e_viii+#2+#6#7\xint:%
{#1+#4#5}{#3-\xint_c_i}{#4}{#5}{#6}{#7}%
}%
\def\CALX_ndtw_i #1#2#3#4#5#6#7{%
\expandafter\CALX_ndtw_e\the\numexpr\xint_c_ii*\xint_c_e_viii+#2-#6#7%
\xint:%
{#1-#4#5-\xint_c_i}{#3+\xint_c_i}{#4}{#5}{#6}{#7}%
}%
\def\CALX_ndtw_e #1#2\xint:#3#4{%
\expandafter\CALX_ndtw_f\the\numexpr#3+#1-\xint_c_i\expandafter\xint:%
\the\numexpr#4\xint:{#2}%
}%
\def\CALX_ndtw_f #1\xint:#2\xint:#3{\CALX_ndtw_l #1.{#3}{#2}}%
\def\CALX_ndtw_g #1#2#3#4#5#6#7#8{%
\xint_c_e_viii+#3\expandafter!\the\numexpr\CALX_ndtw %
#8{#4}{#5}{#6}{#7}{#1}{#2}%
}%
% \end{macrocode}
%\begin{lverb}
% Exit: 1;!\xint:{u0}{u1}{na}{s}; R' = 1u1!1u0!1;!.
%
% \CALX_nudiv_qx \xint:{R'}{steps}{s} drops a zero top
% block, reverses Q and delivers {nq}{Q}{s}{R'}.
%\end{lverb}
% \begin{macrocode}
\def\CALX_ndtw_z #11;!\xint:#2#3#4{%
\expandafter\CALX_ndtw_zz\the\numexpr\xint_c_e_viii+#2\xint:{#3}{#4}{#1}%
}%
\def\CALX_ndtw_zz #1\xint:#2#3#4{\CALX_nudiv_qx #4\xint:{1#2!#1!1;!}{#3-%
\xint_c_i}{0}}%
\def\CALX_nudiv_qx 1#1!#2\xint:#3#4{%
\ifcase\numexpr\ifnum#1=\xint_c_
\ifnum\numexpr#4=\xint_c_i \xint_c_ii\else\xint_c_i\fi
\else\xint_c_\fi\relax
\expandafter\CALX_nudiv_qx_n
\or \expandafter\CALX_nudiv_qx_z
\else\expandafter\CALX_nudiv_qx_zero
\fi {#1}{#2}{#3}{#4}%
}%
\def\CALX_nudiv_qx_zero #1#2#3#4{\CALX_nudiv_qy \xint:{0}{#3}}%
\def\CALX_nudiv_qx_z #1#2#3#4{%
\expandafter\CALX_nudiv_qy
\romannumeral0\CALX_rev_nounsep {}#2\R!\R!\R!\R!\R!\R!\R!\R!\W\xint:{#4-%
\xint_c_i}{#3}%
}%
\def\CALX_nudiv_qx_n #1#2#3#4{%
\expandafter\CALX_nudiv_qy
\romannumeral0\CALX_rev_nounsep {}1#1!#2\R!\R!\R!\R!\R!\R!\R!\R!\W%
\xint:{#4}{#3}%
}%
\def\CALX_nudiv_qy #1\xint:#2#3#4#5{%
\expandafter#5\expandafter{\the\numexpr#2}{#1}{#4}{#3}%
}%
% \end{macrocode}
%\begin{lverb}
% Tiny one-block divisor d <= 45249. With 10^8 = Bq d + Bm (0 <= Bm < d)
% and incoming remainder r < d, a block a gives
%( y = r Bm + a, q = r Bq + floor(y/d), r' = y - d floor(y/d),
%)
% exact since r 10^8 + a = r Bq d + y; y + round(d/2) < 2^31 for d <= 45249.
% floor(y/d) = (y + round(d/2))/d - 1. One explicit \numexpr per block plus
% the emission (10^8 + q is evaluated by the enclosing \numexpr chain).
%( \CALX_ndts \xint:\xint:\xint:\xint:!
%: 1;!
%)
% \CALX_ndts_k . expands to 0\xint:d\xint:dh\xint:Bq\xint:Bm!
%\end{lverb}
% \begin{macrocode}
\def\CALX_ndts_k #1.{%
\expandafter\CALX_ndts_ka\the\numexpr(\xint_c_e_viii+#1/\xint_c_ii)/#1-%
\xint_c_i
\xint:#1\xint:%
}%
\def\CALX_ndts_ka #1\xint:#2\xint:{%
\expandafter\CALX_ndts_kb\the\numexpr\xint_c_e_viii-#1*#2\expandafter%
\xint:%
\the\numexpr#2/\xint_c_ii\xint:#1\xint:#2\xint:%
}%
\def\CALX_ndts_kb #1\xint:#2\xint:#3\xint:#4\xint:#5{#50\xint:#4\xint:#2%
\xint:#3\xint:#1!}%
\def\CALX_nudiv_ot #1#2#3#4{%
\expandafter\CALX_ndts_s
\romannumeral0\CALX_rev_nounsep {}#4\R!\R!\R!\R!\R!\R!\R!\R!\W%
\xint:{#3}{#2}#1%
}%
\def\CALX_ndts_s #1\xint:#2{%
\expandafter\CALX_ndts_z\the\numexpr\CALX_ndts_k #2.\CALX_ndts #11;!%
}%
% \end{macrocode}
% \subsubsection{\csh{CALX_ndts}}
% \begin{macrocode}
\def\CALX_ndts #1\xint:#2\xint:#3\xint:#4\xint:#5!1#6#7!{%
\xint_gob_til_sc #6\CALX_ndts_end;%
\expandafter\CALX_ndts_b\the\numexpr(#1)*#5+#6#7\xint:#1\xint:#2\xint:#3%
\xint:#4\xint:#5!%
}%
\def\CALX_ndts_end;#1\xint:#2\xint:#3!{1\relax;!\xint:{#2}}%
\def\CALX_ndts_b #1\xint:#2\xint:#3\xint:#4\xint:#5\xint:#6!{%
\xint_c_e_viii+(#2)*#5+(#1+#4)/#3-\xint_c_i
\expandafter!\the\numexpr\CALX_ndts #1-#3*((#1+#4)/#3-\xint_c_i)\xint:#3%
\xint:#4\xint:#5\xint:#6!%
}%
\def\CALX_ndts_z #11;!\xint:#2#3{%
\expandafter\CALX_ndts_zz\the\numexpr\xint_c_e_viii+(#2)\xint:{#3}{#1}%
}%
\def\CALX_ndts_zz #1\xint:#2#3{\CALX_nudiv_qx #3\xint:{#1!1;!}{#2}{0}}%
% \end{macrocode}
%\begin{lverb}
% Unrolled entries for na = 2, 3, 4 (tiny divisor): the MS-first input is
% written from the parameters and the quotient is assembled directly
% (the top block may be zero, the others are present).
%\end{lverb}
% \begin{macrocode}
\def\CALX_nudiv_otd #1#2{%
\ifcase#2
\or\or \expandafter\CALX_ndts_ii
\or \expandafter\CALX_ndts_iii
\or \expandafter\CALX_ndts_iv
\else \expandafter\CALX_nudiv_ot
\fi #1{#2}%
}%
\def\CALX_ndts_ii #1#2#3#4{\CALX_ndts_iia #4{#3}#1}%
\def\CALX_ndts_iia 1#1!1#2!#3{%
\expandafter\CALX_ndts_iib\the\numexpr\CALX_ndts_k #3.\CALX_ndts %
1#2!1#1!1;!%
}%
\def\CALX_ndts_iib 1#1!1#2!1;!\xint:#3{%
\expandafter\CALX_ndts_iic\the\numexpr\xint_c_e_viii+(#3)\xint:{#1}{#2}%
}%
\def\CALX_ndts_iic #1\xint:#2#3#4{%
\ifnum#2=\xint_c_ \xint_dothis{#4{1}{1#3!}}\fi
\xint_orthat{#4{2}{1#3!1#2!}}{0}{#1!1;!}%
}%
\def\CALX_ndts_iii #1#2#3#4{\CALX_ndts_iiia #4{#3}#1}%
\def\CALX_ndts_iiia 1#1!1#2!1#3!#4{%
\expandafter\CALX_ndts_iiib\the\numexpr\CALX_ndts_k #4.\CALX_ndts %
1#3!1#2!1#1!1;!%
}%
\def\CALX_ndts_iiib 1#1!1#2!1#3!1;!\xint:#4{%
\expandafter\CALX_ndts_iiic\the\numexpr\xint_c_e_viii+(#4)%
\xint:{#1}{1#3!1#2!}%
}%
\def\CALX_ndts_iiic #1\xint:#2#3#4{%
\ifnum#2=\xint_c_ \xint_dothis{#4{2}{#3}}\fi
\xint_orthat{#4{3}{#31#2!}}{0}{#1!1;!}%
}%
\def\CALX_ndts_iv #1#2#3#4{\CALX_ndts_iva #4{#3}#1}%
\def\CALX_ndts_iva 1#1!1#2!1#3!1#4!#5{%
\expandafter\CALX_ndts_ivb\the\numexpr\CALX_ndts_k #5.\CALX_ndts %
1#4!1#3!1#2!1#1!1;!%
}%
\def\CALX_ndts_ivb 1#1!1#2!1#3!1#4!1;!\xint:#5{%
\expandafter\CALX_ndts_ivc\the\numexpr\xint_c_e_viii+(#5)%
\xint:{#1}{1#4!1#3!1#2!}%
}%
\def\CALX_ndts_ivc #1\xint:#2#3#4{%
\ifnum#2=\xint_c_ \xint_dothis{#4{3}{#3}}\fi
\xint_orthat{#4{4}{#31#2!}}{0}{#1!1;!}%
}%
% \end{macrocode}
%\begin{lverb}
% Three-block divisor (nb = 3). Estimate and correction loop as for nb = 2
% (U = u0 u1 u2, V = v1 v2: q is the true quotient block or one more), the
% macros are duplicated (\CALX_ndth_q ... \CALX_ndth_f), only the exit
% \CALX_ndth_g differs: with T = a b + c = U - qV, the window minus q B' is
%( a b^2 + c b + u3 - q v3, q v3 = (qh v3h + M3h) b + 10^4 M3l + ql v3l.
%: X = 3b + u3 - ql v3l - 10^4 M3l in (b, 4b): digits e1,
%: Y = 3b + c - qh v3h - M3h - 3 + e1 in (b, 4b): digits e2,
%: r0 = a + e2 - 3; if r0 < 0, B' is added back and q decreases.
%)
% Loop state: \CALX_ndth {C12}{V3}{u0}{u1}{u2}1!...1;!
% C12 = {Vp}{M}{{v1h}{v1l}{v2h}{v2l}}, V3 = {v3h}{v3l}; q0 as for nb = 2.
%\end{lverb}
% \begin{macrocode}
\def\CALX_nudiv_three #1#2#3#4#5{\CALX_nudiv_hw #5{#2}{#3}#1}%
\def\CALX_nudiv_hw 1#1#2#3#4#5!1#6#7#8#9{\CALX_nudiv_ha %
{#1#2#3#4}{#5}{#6#7#8#9}}%
\def\CALX_nudiv_ha #1#2#3#4!1#5#6#7#8{\CALX_nudiv_hb %
{#1}{#2}{#3}{#4}{#5#6#7#8}}%
\def\CALX_nudiv_hb #1#2#3#4#5#6!{%
\expandafter\CALX_nudiv_hv
\expanded{\CALX_nudiv_mp{\CALX_nudiv_gs 1#5#6!%
\xint:}}{#1}{#2}{#3}{#4}{#5}{#6}%
}%
\def\CALX_nudiv_hv #1.#2.#3#4#5#6#7#8{%
\expandafter\CALX_nudiv_hc
\the\numexpr#7#8*#1+(#5#6+#2/\xint_c_ii)/#2-\xint_c_i\xint:%
{#1}{{#7}{#8}{#5}{#6}}{{#3}{#4}}%
}%
\def\CALX_nudiv_hc #1\xint:#2#3#4#5#6{%
\expandafter\CALX_nudiv_he
\romannumeral0\CALX_rev_nounsep {}#6\R!\R!\R!\R!\R!\R!\R!\R!\W
\xint:{{#1}{#2}{#3}}{#4}{#5}%
}%
\def\CALX_nudiv_hcmp #1#2#3#4#5{%
\ifnum#1<\CALX_ndth_vone#4 -\xint_c_i\else\ifnum#1>\CALX_ndth_vone#4 %
\xint_c_\else
\ifnum#2<\CALX_ndth_vtwo#4 -\xint_c_i\else\ifnum#2>\CALX_ndth_vtwo#4 %
\xint_c_\else
\ifnum#3<\CALX_ndth_vthree#5 -\xint_c_i\else\xint_c_\fi\fi\fi\fi\fi
}%
\def\CALX_nudiv_he 1#1!1#2!1#3!#4\xint:#5#6#7{%
\ifnum\CALX_nudiv_hcmp{#1}{#2}{#3}{#5}{#6}<\xint_c_
\ifnum#7=\xint_c_iii \CALX_nudiv_hq\fi
\expandafter\CALX_nudiv_hn
\else
\expandafter\CALX_nudiv_hp
\fi {#1}{#2}{#3}{#4}{#5}{#6}{#7}%
}%
\def\CALX_nudiv_hq\fi\expandafter\CALX_nudiv_hn\else\expandafter%
\CALX_nudiv_hp\fi
#1#2#3#4#5#6#7#8{\fi\fi#8{0}{}{0}{1#3!1#2!1#1!1;!}}%
\def\CALX_nudiv_hn #1#2#3#4#5#6#7{%
\expandafter\CALX_ndth_z\the\numexpr\CALX_ndth %
{#5}{#6}{#1}{#2}{#3}#41;!{#7-\xint_c_iii}{0}%
}%
\def\CALX_nudiv_hp #1#2#3#4#5#6#7{%
\expandafter\CALX_ndth_z\the\numexpr\CALX_ndth %
{#5}{#6}{0}{#1}{#2}1#3!#41;!{#7-\xint_c_ii}{0}%
}%
% \end{macrocode}
% \subsubsection{\csh{CALX_ndth}}
% \begin{macrocode}
\def\CALX_ndth #1{\CALX_ndth_a #1}%
\def\CALX_ndth_a #1#2#3#4#5#6#7{%
\expandafter\CALX_ndth_q
\the\numexpr(#5*#2)*\xint_c_e_viii/#1+#6*#2/#1+(#7*#2/\xint_c_e_viii)/#1%
\xint:%
#3{#5}{#6}{#7}{{#1}{#2}{#3}}{#4}%
}%
\def\CALX_ndth_q #1\xint:%
{\ifnum#1>\xint_c_e_viii_mone \CALX_ndth_qm\fi\CALX_ndth_h #1\xint:}%
\def\CALX_ndth_qm\fi#1\xint:{\fi\CALX_ndth_h 99999999\xint:}%
\def\CALX_ndth_h #1\xint:{%
\expandafter\CALX_ndth_x
\the\numexpr(#1+5000)/\xint_c_e_iv-\xint_c_i\expandafter\xint:%
\the\numexpr#1-\xint_c_e_iv*((#1+5000)/\xint_c_e_iv-\xint_c_i)\xint:%
}%
\def\CALX_ndth_x #1\xint:#2\xint:#3#4#5#6#7#8#9{%
\expandafter\CALX_ndth_w\the\numexpr
\xint_c_iii*\xint_c_e_viii+#9-#2*#6%
-(#1*#6+#2*#5-\xint_c_e_iv*((#1*#6+#2*#5+5000)/\xint_c_e_iv-\xint_c_i))%
*\xint_c_e_iv
\expandafter\xint:\the\numexpr
(#7-#1*#3-(#1*#4+#2*#3+5000)/\xint_c_e_iv+\xint_c_i)*\xint_c_e_viii+#8%
-(#1*#4+#2*#3-\xint_c_e_iv*((#1*#4+#2*#3+5000)/\xint_c_e_iv-\xint_c_i))%
*\xint_c_e_iv
-#2*#4-#1*#5-(#1*#6+#2*#5+5000)/\xint_c_e_iv+\xint_c_i
\xint:{#1*\xint_c_e_iv+#2}{#3}{#4}{#5}{#6}%
}%
\def\CALX_ndth_w #1#2\xint:#3\xint:{%
\expandafter\CALX_ndth_l\the\numexpr#3+#1-%
\xint_c_iii.{#2}%
}%
\def\CALX_ndth_l #1.#2#3#4#5#6#7{%
\ifnum#1<\xint_c_ \xint_dothis\CALX_ndth_d\fi
\ifnum\numexpr\xint_c_ii*(#1-#4#5)\ifnum#2<#6#7 -\xint_c_i\fi
<\xint_c_ \xint_dothis\CALX_ndth_g\fi
\ifnum\numexpr#3=\xint_c_e_viii_mone \xint_dothis\CALX_ndth_g\fi
\xint_orthat\CALX_ndth_i {#1}{#2}{#3}{#4}{#5}{#6}{#7}%
}%
\def\CALX_ndth_d #1#2#3#4#5#6#7{%
\expandafter\CALX_ndth_e\the\numexpr\xint_c_e_viii+#2+#6#7\xint:%
{#1+#4#5}{#3-\xint_c_i}{#4}{#5}{#6}{#7}%
}%
\def\CALX_ndth_i #1#2#3#4#5#6#7{%
\expandafter\CALX_ndth_e\the\numexpr\xint_c_ii*\xint_c_e_viii+#2-#6#7%
\xint:%
{#1-#4#5-\xint_c_i}{#3+\xint_c_i}{#4}{#5}{#6}{#7}%
}%
\def\CALX_ndth_e #1#2\xint:#3#4{%
\expandafter\CALX_ndth_f\the\numexpr#3+#1-\xint_c_i\expandafter\xint:%
\the\numexpr#4\xint:{#2}%
}%
\def\CALX_ndth_f #1\xint:#2\xint:#3{\CALX_ndth_l #1.{#3}{#2}}%
% \end{macrocode}
%\begin{lverb}
% Exit of the correction loop: #1=a, #2=c, #3=q, #4-#7=v1h v1l v2h v2l,
% #8=C12, #9=V3, then 1! in the stream.
%\end{lverb}
% \begin{macrocode}
\def\CALX_ndth_g #1#2#3#4#5#6#7#8#9{%
\expandafter\CALX_ndth_m\the\numexpr(#3+5000)/\xint_c_e_iv-\xint_c_i%
\xint:#9%
{#1}{#2}{#3}{#8}%
}%
\def\CALX_ndth_m #1\xint:#2#3#4#5#6#71#8!{%
\expandafter\CALX_ndth_n\the\numexpr
\xint_c_iii*\xint_c_e_viii+#8-(#6-\xint_c_e_iv*#1)*#3%
-(#1*#3+(#6-\xint_c_e_iv*#1)*#2%
-\xint_c_e_iv*((#1*#3+(#6-\xint_c_e_iv*#1)*#2+5000)/\xint_c_e_iv-%
\xint_c_i))%
*\xint_c_e_iv
\xint:{#1*#2+(#1*#3+(#6-\xint_c_e_iv*#1)*#2+5000)/\xint_c_e_iv-\xint_c_i}%
{#4}{#5}{#6}{#7}{{#2}{#3}}%
}%
\def\CALX_ndth_n #1#2\xint:#3#4#5{%
\expandafter\CALX_ndth_o\the\numexpr
\xint_c_iii*\xint_c_e_viii+#5-(#3)-\xint_c_iii+#1%
\xint:{#2}{#4}%
}%
\def\CALX_ndth_o #1#2\xint:#3#4{%
\expandafter\CALX_ndth_oa\the\numexpr#4+#1-\xint_c_iii\xint:{#2}{#3}%
}%
\def\CALX_ndth_oa #1\xint:{%
\ifnum#1<\xint_c_ \expandafter\CALX_ndth_ab\else\expandafter\CALX_ndth_p%
\fi {#1}%
}%
\def\CALX_ndth_p #1#2#3#4#5#61#7#8!{%
\xint_gob_til_sc #7\CALX_ndth_end;%
\xint_c_e_viii+#4\expandafter!\the\numexpr\CALX_ndth %
{#5}{#6}{#1}{#2}{#3}1#7#8!%
}%
\def\CALX_ndth_end;\xint_c_e_viii+#1\expandafter!\the\numexpr\CALX_ndth %
#2#3#4#5#61;!%
{\xint_c_e_viii+#1\relax!\xint:{#4}{#5}{#6}}%
% \end{macrocode}
%\begin{lverb}
% Add back (rare): #1=r0 (<0), #2=r1, #3=r2, #4=q, #5=C12, #6=V3.
%\end{lverb}
% \begin{macrocode}
\def\CALX_ndth_vone #1#2#3{\CALX_ndth_vonea #3}%
\def\CALX_ndth_vonea #1#2#3#4{#1#2}%
\def\CALX_ndth_vtwo #1#2#3{\CALX_ndth_vtwoa #3}%
\def\CALX_ndth_vtwoa #1#2#3#4{#3#4}%
\def\CALX_ndth_vthree #1#2{#1#2}%
\def\CALX_ndth_ab #1#2#3#4#5#6{%
\expandafter\CALX_ndth_ac\the\numexpr\xint_c_e_viii+#3+%
\CALX_ndth_vthree#6\xint:%
{#1}{#2}{#4}{#5}{#6}%
}%
\def\CALX_ndth_ac #1#2\xint:#3#4#5#6{%
\expandafter\CALX_ndth_ad\the\numexpr\xint_c_e_viii+#4+%
\CALX_ndth_vtwo#6+#1-\xint_c_i\xint:%
{#2}{#3}{#5}{#6}%
}%
\def\CALX_ndth_ad #1#2\xint:#3#4#5#6{%
\expandafter\CALX_ndth_ae\the\numexpr#4+\CALX_ndth_vone#6+#1-\xint_c_i%
\xint:%
{#2}{#3}{#5-\xint_c_i}{#6}%
}%
\def\CALX_ndth_ae #1\xint:{\CALX_ndth_p {#1}}%
\def\CALX_ndth_z #1\xint:#2#3#4{%
\expandafter\CALX_ndth_zz\the\numexpr\xint_c_e_viii+(#2)%
\xint:{#3}{#4}{#1}%
}%
\def\CALX_ndth_zz #1\xint:#2#3#4{\CALX_nudiv_qx #4\xint:{1#3!1#2!#1!1;!}}%
% \end{macrocode}
%\begin{lverb}
% Four-block divisor (nb = 4), no normalization, estimate and loop as for
% nb = 2 (duplicated as \CALX_ndfo_q ... \CALX_ndfo_f). With T = a b + c,
% the window minus q B' is a b^3 + c b^2 + u3 b + u4 - q (v3 b + v4):
%( X4 = 3b + u4 - ql v4l - 10^4 M4l digits e4
%: X3 = 5b + u3 - ql v3l - 10^4 M3l - H4 - 3 + e4 digits e3
%: Y = 3b + c - H3 - 5 + e3 digits e2
%: r0 = a + e2 - 3 (add-back if negative)
%)
% with Hk = qh vkh + Mkh, Mk = qh vkl + ql vkh.
%
% Loop state: \CALX_ndfo {C12}{V34}{u0}{u1}{u2}{u3}1!...1;!
% C12 = {Vp}{M}{{v1h}{v1l}{v2h}{v2l}}, V34 = {v3h}{v3l}{v4h}{v4l}.
%
% After the correction loop: pack P3 = {a}{c}{q}{C12}.
%\end{lverb}
% \begin{macrocode}
\def\CALX_nudiv_four #1#2#3#4#5{\CALX_nudiv_fw #5{#2}{#3}#1}%
\def\CALX_nudiv_fw 1#1#2#3#4#5!1#6#7#8#9{\CALX_nudiv_fa %
{#1#2#3#4}{#5}{#6#7#8#9}}%
\def\CALX_nudiv_fa #1#2#3#4!1#5#6#7#8{\CALX_nudiv_fb %
{{#3}{#4}{#1}{#2}}{#5#6#7#8}}%
\def\CALX_nudiv_fb #1#2#3!1#4#5#6#7{\CALX_nudiv_fc {#1}{#2}{#3}{#4#5#6#7}}%
\def\CALX_nudiv_fc #1#2#3#4#5!{%
\expandafter\CALX_nudiv_fv
\expanded{\CALX_nudiv_mp{\CALX_nudiv_gs 1#4#5!%
\xint:}}{#4}{#5}{#2}{#3}{#1}%
}%
\def\CALX_nudiv_fv #1.#2.#3#4#5#6{%
\expandafter\CALX_nudiv_fd
\the\numexpr#3#4*#1+(#5#6+#2/\xint_c_ii)/#2-\xint_c_i\xint:%
{#1}{{#3}{#4}{#5}{#6}}%
}%
\def\CALX_nudiv_fd #1\xint:#2#3#4#5#6{%
\expandafter\CALX_nudiv_fe
\romannumeral0\CALX_rev_nounsep {}#6\R!\R!\R!\R!\R!\R!\R!\R!\W
\xint:{{#1}{#2}{#3}}{#4}{#5}%
}%
\def\CALX_nudiv_fcmp #1#2#3#4#5#6{%
\ifnum#1<\CALX_ndth_vone#5 -\xint_c_i\else\ifnum#1>\CALX_ndth_vone#5 %
\xint_c_\else
\ifnum#2<\CALX_ndth_vtwo#5 -\xint_c_i\else\ifnum#2>\CALX_ndth_vtwo#5 %
\xint_c_\else
\ifnum#3<\CALX_ndfo_vthree#6 -\xint_c_i\else\ifnum#3>\CALX_ndfo_vthree#6 %
\xint_c_\else
\ifnum#4<\CALX_ndfo_vfour#6 -\xint_c_i\else\xint_c_\fi\fi\fi\fi\fi\fi\fi
}%
\def\CALX_nudiv_fe 1#1!1#2!1#3!1#4!#5\xint:#6#7#8{%
\ifnum\CALX_nudiv_fcmp{#1}{#2}{#3}{#4}{#6}{#7}<\xint_c_
\ifnum#8=\xint_c_iv \CALX_nudiv_fq\fi
\expandafter\CALX_nudiv_fn
\else
\expandafter\CALX_nudiv_fp
\fi {#1}{#2}{#3}{#4}{#5}{#6}{#7}{#8}%
}%
\def\CALX_nudiv_fq\fi\expandafter\CALX_nudiv_fn\else\expandafter%
\CALX_nudiv_fp\fi
#1#2#3#4#5#6#7#8#9{\fi\fi#9{0}{}{0}{1#4!1#3!1#2!1#1!1;!}}%
\def\CALX_nudiv_fn #1#2#3#4#5#6#7#8{%
\expandafter\CALX_ndfo_z
\the\numexpr\CALX_ndfo {#6}{#7}{#1}{#2}{#3}{#4}#51;!{#8-\xint_c_iv}{0}%
}%
\def\CALX_nudiv_fp #1#2#3#4#5#6#7#8{%
\expandafter\CALX_ndfo_z
\the\numexpr\CALX_ndfo {#6}{#7}{0}{#1}{#2}{#3}1#4!#51;!{#8-%
\xint_c_iii}{0}%
}%
% \end{macrocode}
% \subsubsection{\csh{CALX_ndfo}}
% \begin{macrocode}
\def\CALX_ndfo #1{\CALX_ndfo_a #1}%
\def\CALX_ndfo_a #1#2#3#4#5#6#7{%
\expandafter\CALX_ndfo_q
\the\numexpr(#5*#2)*\xint_c_e_viii/#1+#6*#2/#1+(#7*#2/\xint_c_e_viii)/#1%
\xint:%
#3{#5}{#6}{#7}{{#1}{#2}{#3}}{#4}%
}%
\def\CALX_ndfo_q #1\xint:%
{\ifnum#1>\xint_c_e_viii_mone \CALX_ndfo_qm\fi\CALX_ndfo_h #1\xint:}%
\def\CALX_ndfo_qm\fi#1\xint:{\fi\CALX_ndfo_h 99999999\xint:}%
\def\CALX_ndfo_h #1\xint:{%
\expandafter\CALX_ndfo_x
\the\numexpr(#1+5000)/\xint_c_e_iv-\xint_c_i\expandafter\xint:%
\the\numexpr#1-\xint_c_e_iv*((#1+5000)/\xint_c_e_iv-\xint_c_i)\xint:%
}%
\def\CALX_ndfo_x #1\xint:#2\xint:#3#4#5#6#7#8#9{%
\expandafter\CALX_ndfo_w\the\numexpr
\xint_c_iii*\xint_c_e_viii+#9-#2*#6%
-(#1*#6+#2*#5-\xint_c_e_iv*((#1*#6+#2*#5+5000)/\xint_c_e_iv-\xint_c_i))%
*\xint_c_e_iv
\expandafter\xint:\the\numexpr
(#7-#1*#3-(#1*#4+#2*#3+5000)/\xint_c_e_iv+\xint_c_i)*\xint_c_e_viii+#8%
-(#1*#4+#2*#3-\xint_c_e_iv*((#1*#4+#2*#3+5000)/\xint_c_e_iv-\xint_c_i))%
*\xint_c_e_iv
-#2*#4-#1*#5-(#1*#6+#2*#5+5000)/\xint_c_e_iv+\xint_c_i
\xint:{#1*\xint_c_e_iv+#2}{#3}{#4}{#5}{#6}%
}%
\def\CALX_ndfo_w #1#2\xint:#3\xint:{%
\expandafter\CALX_ndfo_l\the\numexpr#3+#1-%
\xint_c_iii.{#2}%
}%
\def\CALX_ndfo_l #1.#2#3#4#5#6#7{%
\ifnum#1<\xint_c_ \xint_dothis\CALX_ndfo_d\fi
\ifnum\numexpr\xint_c_ii*(#1-#4#5)\ifnum#2<#6#7 -\xint_c_i\fi
<\xint_c_ \xint_dothis\CALX_ndfo_g\fi
\ifnum\numexpr#3=\xint_c_e_viii_mone \xint_dothis\CALX_ndfo_g\fi
\xint_orthat\CALX_ndfo_i {#1}{#2}{#3}{#4}{#5}{#6}{#7}%
}%
\def\CALX_ndfo_d #1#2#3#4#5#6#7{%
\expandafter\CALX_ndfo_e\the\numexpr\xint_c_e_viii+#2+#6#7\xint:%
{#1+#4#5}{#3-\xint_c_i}{#4}{#5}{#6}{#7}%
}%
\def\CALX_ndfo_i #1#2#3#4#5#6#7{%
\expandafter\CALX_ndfo_e\the\numexpr\xint_c_ii*\xint_c_e_viii+#2-#6#7%
\xint:%
{#1-#4#5-\xint_c_i}{#3+\xint_c_i}{#4}{#5}{#6}{#7}%
}%
\def\CALX_ndfo_e #1#2\xint:#3#4{%
\expandafter\CALX_ndfo_f\the\numexpr#3+#1-\xint_c_i\expandafter\xint:%
\the\numexpr#4\xint:{#2}%
}%
\def\CALX_ndfo_f #1\xint:#2\xint:#3{\CALX_ndfo_l #1.{#3}{#2}}%
% \end{macrocode}
%\begin{lverb}
% Exit: #1=a, #2=c, #3=q, #4-#7 v1h v1l v2h v2l, #8=C12, #9=V34, then
% {u3}1! in the stream.
%\end{lverb}
% \begin{macrocode}
\def\CALX_ndfo_pa #1#2#3#4{#1}%
\def\CALX_ndfo_pc #1#2#3#4{#2}%
\def\CALX_ndfo_pq #1#2#3#4{#3}%
\def\CALX_ndfo_g #1#2#3#4#5#6#7#8#9{\CALX_ndfo_m {{#1}{#2}{#3}{#8}}#9}%
\def\CALX_ndfo_m #1#2#3#4#5#61#7!{%
\expandafter\CALX_ndfo_n
\the\numexpr(\CALX_ndfo_pq#1+5000)/\xint_c_e_iv-\xint_c_i\xint:%
{#1}{#2}{#3}{#4}{#5}{#6}{#7}%
}%
\def\CALX_ndfo_n #1\xint:#2#3#4#5#6#7#8{%
\expandafter\CALX_ndfo_o\the\numexpr
\xint_c_iii*\xint_c_e_viii+#8-(\CALX_ndfo_pq#2-\xint_c_e_iv*#1)*#6%
-(#1*#6+(\CALX_ndfo_pq#2-\xint_c_e_iv*#1)*#5-\xint_c_e_iv*((#1*#6+(%
\CALX_ndfo_pq#2-\xint_c_e_iv*#1)*#5+5000)/\xint_c_e_iv-\xint_c_i))*%
\xint_c_e_iv
\xint:{#1*#5+(#1*#6+(\CALX_ndfo_pq#2-\xint_c_e_iv*#1)*#5+5000)/%
\xint_c_e_iv-\xint_c_i}{#1}{#2}{#3}{#4}{#7}%
{{#3}{#4}{#5}{#6}}%
}%
\def\CALX_ndfo_o #1#2\xint:#3#4#5#6#7#8{%
\expandafter\CALX_ndfo_r\the\numexpr
\xint_c_v*\xint_c_e_viii+#8-(\CALX_ndfo_pq#5-\xint_c_e_iv*#4)*#7%
-(#4*#7+(\CALX_ndfo_pq#5-\xint_c_e_iv*#4)*#6-\xint_c_e_iv*((#4*#7+(%
\CALX_ndfo_pq#5-\xint_c_e_iv*#4)*#6+5000)/\xint_c_e_iv-\xint_c_i))*%
\xint_c_e_iv
-(#3)-\xint_c_iii+#1%
\xint:{#4*#6+(#4*#7+(\CALX_ndfo_pq#5-\xint_c_e_iv*#4)*#6+5000)/%
\xint_c_e_iv-\xint_c_i}{#2}{#5}%
}%
\def\CALX_ndfo_r #1#2\xint:#3#4#5{%
\expandafter\CALX_ndfo_s\the\numexpr
\xint_c_iii*\xint_c_e_viii+\CALX_ndfo_pc#5-(#3)-\xint_c_v+#1%
\xint:{#2}{#4}{#5}%
}%
\def\CALX_ndfo_s #1#2\xint:#3#4#5{%
\expandafter\CALX_ndfo_t\the\numexpr\CALX_ndfo_pa#5+#1-\xint_c_iii\xint:%
{#2}{#3}{#4}{#5}%
}%
\def\CALX_ndfo_t #1\xint:#2#3#4#5{%
\ifnum#1<\xint_c_ \expandafter\CALX_ndfo_ab\else\expandafter\CALX_ndfo_tu%
\fi
#5{#1}{#2}{#3}{#4}%
}%
\def\CALX_ndfo_tu #1#2{\CALX_ndfo_y}%
\def\CALX_ndfo_y #1#2#3#4#5#6#71#8#9!{%
\xint_gob_til_sc #8\CALX_ndfo_end;%
\xint_c_e_viii+#1\expandafter!\the\numexpr\CALX_ndfo %
{#2}{#7}{#3}{#4}{#5}{#6}1#8#9!%
}%
\def\CALX_ndfo_end;\xint_c_e_viii+#1\expandafter!\the\numexpr\CALX_ndfo %
#2#3#4#5#6#71;!%
{\xint_c_e_viii+#1\relax!\xint:{#4}{#5}{#6}{#7}}%
% \end{macrocode}
%\begin{lverb}
% Add back (rare): #1=a, #2=c, #3=q, #4=C12 (P3 unpacked), #5=r0 (<0),
% #6=r1, #7=r2, #8=r3, #9=V34.
%\end{lverb}
% \begin{macrocode}
\def\CALX_ndfo_vthree #1#2#3#4{#1#2}%
\def\CALX_ndfo_vfour #1#2#3#4{#3#4}%
\def\CALX_ndfo_pvone #1#2#3#4{\CALX_ndth_vone#4}%
\def\CALX_ndfo_pvtwo #1#2#3#4{\CALX_ndth_vtwo#4}%
\def\CALX_ndfo_ab #1#2#3#4#5#6#7#8#9{%
\expandafter\CALX_ndfo_ac\the\numexpr\xint_c_e_viii+#8+\CALX_ndfo_vfour#9%
\xint:%
{#5}{#6}{#7}{#9}{{#1}{#2}{#3}{#4}}%
}%
\def\CALX_ndfo_ac #1#2\xint:#3#4#5#6{%
\expandafter\CALX_ndfo_ad\the\numexpr\xint_c_e_viii+#5+%
\CALX_ndfo_vthree#6+#1-\xint_c_i
\xint:{#2}{#3}{#4}{#6}%
}%
\def\CALX_ndfo_ad #1#2\xint:#3#4#5#6#7{%
\expandafter\CALX_ndfo_ae\the\numexpr\xint_c_e_viii+#5+%
\CALX_ndfo_pvtwo#7+#1-\xint_c_i
\xint:{#2}{#3}{#4}{#6}{#7}%
}%
\def\CALX_ndfo_ae #1#2\xint:#3#4#5#6#7{%
\expandafter\CALX_ndfo_af\the\numexpr#5+\CALX_ndfo_pvone#7+#1-\xint_c_i%
\xint:%
{#2}{#3}{#4}{#6}{#7}%
}%
\def\CALX_ndfo_af #1\xint:#2#3#4#5#6{\CALX_ndfo_ah #6{#1}{#2}{#3}{#4}{#5}}%
\def\CALX_ndfo_ah #1#2#3{\CALX_ndfo_y {#3-\xint_c_i}}%
\def\CALX_ndfo_z #1\xint:#2#3#4#5{%
\expandafter\CALX_ndfo_zz\the\numexpr\xint_c_e_viii+(#2)%
\xint:{#3}{#4}{#5}{#1}%
}%
\def\CALX_ndfo_zz #1\xint:#2#3#4#5{\CALX_nudiv_qx #5%
\xint:{1#4!1#3!1#2!#1!1;!}}%
% \end{macrocode}
% \subsection{Native signed division}
% \subsubsection{\csh{CALX_ndivtrunc}, \csh{CALX_nmodtrunc},
% \csh{CALX_ndivfloor}, \csh{CALX_nmod}, \csh{CALX_nquo}, \csh{CALX_nrem},
% \csh{CALX_ndivround}, \csh{CALX_ndivision}, \csh{CALX_ndivmod}}
%\begin{lverb}
% Syntax (use with \romannumeral0; A, B f-expanded native integers):
%(
% \CALX_n{A}{B} -> Z (op: divtrunc, modtrunc,
%: divfloor, mod, quo, rem, divround)
%: \CALX_ndivision{A}{B} -> {Q}{R}
%: \CALX_ndivmod{A}{B} -> {Q}{R}
%)
% Z, Q, R native integers (zero divisor: I values or the trap value, see
% below).
%
% Signed division. All macros are used as \romannumeral0\CALX_n...{A}{B},
% the arguments being f-expanded native integers (A first). With a = |A|,
% b = |B|, q = floor(a/b), r = a - q b (unsigned core \CALX_nudiv), sA, sB
% the signs:
%- \CALX_ndivtrunc$empty: sA sB q (truncation);
%- \CALX_nmodtrunc$empty: sA r, remainder of the truncated division;
%- \CALX_ndivfloor$empty: sA sB (q + d), d = 1 if sA <> sB and r <> 0, else 0;
%- \CALX_nmod$empty: A - B \CALX_ndivfloor(A,B), i.e. sA r + e sB b with e = 1
% if sA <> sB and r <> 0, else 0 (sign of B or zero);
%- \CALX_nquo$empty: sA sB (q + d), d = 1 if sA = - and r <> 0, else 0; this
% is sB floor(A/b) (xint's \xintiiQuo);
%- \CALX_nrem$empty: A - B \CALX_nquo(A,B) = sA r + e b, e = 1 if sA = - and
% r <> 0, else 0; it is >= 0 (xint's \xintiiRem);
%- \CALX_ndivround$empty: sA sB (q + d), d = 1 if 2r >= b, else 0 (rounding
% half away from zero, xint's \xintiiDivRound);
%- \CALX_ndivision$empty: {\CALX_nquo}{\CALX_nrem} (xint's \xintiiDivision);
%- \CALX_ndivmod$empty: {\CALX_ndivfloor}{\CALX_nmod} (xint's \xintiiDivMod).
%
% A zero divisor is signalled as in Python's decimal module (conditions of
% the signals section, trap value N+0. which is what xint returns):
%- quotient of x <> 0 by 0: DivisionByZero, handler argument the sign of x,
% default result I+ or I-; quotient 0 by 0: DivisionUndefined, I?;
%- remainder of x <> 0 by 0: InvalidOperation, I?; remainder 0 by 0:
% DivisionUndefined, I?;
%- pair, x <> 0 by 0: DivisionByZero then InvalidOperation, {I+ or I-}{I?};
% pair 0 by 0: one DivisionUndefined, {I?}{I?}.
%
% Implementation. \CALX_ndiv_y receives B, A and three tokens of the
% family: a starter, a macro for B = 0, a macro for A = 0. The starter is
% followed by {na}{A}{nb}{B}. For the families which do not need B
% after the division the starter is a parameterless macro expanding to
% \CALX_nudiv, so that nothing is copied; the others copy {nb}{B} once
% after the arguments of \CALX_nudiv. \CALX_nudiv leaves the following
% tokens untouched, hence receives
%( {nq}{Q}{s}{R'} or {nq}{Q}{s}{R'}{nb}{B}
%)
% Quotient-only families never compute R (the test r <> 0 is \CALX_nrz on
% R', which does not need the normalization of R'). q + 1 is one pass of
% the addition kernel (\CALX_nqinc). The rounding test 2r >= b doubles R
% with the addition kernel, compares block counts, and for equal counts
% reads the final borrow state of the subtraction kernel computing 2R - B.
% The added terms e b and e sB b are done by \CALX_nadd_y.
%\end{lverb}
% \begin{macrocode}
\def\CALX_ndiv_x #1#2\xint:#3#4#5#6%
{\expandafter\CALX_nsp_t\expandafter\CALX_ndiv_y\expandafter\CALX_ndiv_sp
\expandafter#1\romannumeral`&&@#6\xint:#1#2\xint:#3#4#5}%
% \end{macrocode}
%\begin{lverb}
% \CALX_ndiv_sp ..\xint:..\xint: (A
% dividend, B divisor; = \CALX_ndiv_zq, _zr or _zp tells quotient,
% remainder or pair). Quotient: NaN: I?; Inf/Inf: InvalidOperation (I?);
% Inf/0: Inf with the sign of A; Inf/c: Inf, product of signs; c/Inf: 0.
%
% Remainder: NaN: I?; Inf dividend: InvalidOperation (I?); finite A by
% Inf: A (Python decimal model, for all members of the family). Pair:
% {quotient}{remainder}.
%\end{lverb}
% \begin{macrocode}
\def\CALX_ndiv_sp #1#2#3#4\xint:#5#6#7\xint:#8#9%
{%
\ifx#9\CALX_ndiv_zq\xint_dothis\CALX_ndiv_spq\fi
\ifx#9\CALX_ndiv_zr\xint_dothis\CALX_ndiv_spr\fi
\xint_orthat\CALX_ndiv_spp #2#3{#4}#5#6{#7}%
}%
\def\CALX_ndiv_spq #1#2#3#4#5#6#7%
{%
\if ?#2\xint_dothis{ I?}\fi
\if ?#5\xint_dothis{ I?}\fi
\if N#4\xint_dothis{ N+0.}\fi
\if I#1\xint_dothis{\CALX_nsig{InvalidOperation}{inf // inf}{}}\fi
\ifnum\CALX_nsp_z#3\xint:=\xint_c_ \xint_dothis{ I#5}\fi
\xint_orthat{\CALX_nsp_ps#2#5}%
}%
\def\CALX_ndiv_spr #1#2#3#4#5#6#7%
{%
\if ?#2\xint_dothis{ I?}\fi
\if ?#5\xint_dothis{ I?}\fi
\if I#4\xint_dothis{\CALX_nsig{InvalidOperation}{inf mod x}{}}\fi
\xint_orthat{ N#5#6}%
}%
\def\CALX_ndiv_spp #1#2#3#4#5#6#7%
{\CALX_npair{\CALX_ndiv_spq#1#2{#3}#4#5{#6}{}}{%
\CALX_ndiv_spr#1#2{#3}#4#5{#6}{}}}%
\def\CALX_ndiv_y N#1#2.#3\xint:N#4#5.#6\xint:#7#8#9{%
\ifnum#2=\xint_c_ \xint_dothis{#8#4{#5}}\fi
\ifnum#5=\xint_c_ \xint_dothis#9\fi
\xint_orthat{#7{#5}{#6}{#2}{#3}#4#1}%
}%
\def\CALX_ndivtrunc #1{\expandafter\CALX_ndiv_x\romannumeral`&&@#1\xint:%
\CALX_ndt_go\CALX_ndiv_zq\CALX_ndiv_zz}%
\def\CALX_nmodtrunc #1{\expandafter\CALX_ndiv_x\romannumeral`&&@#1\xint:%
\CALX_nmt_go\CALX_ndiv_zr\CALX_ndiv_zz}%
\def\CALX_ndivfloor #1{\expandafter\CALX_ndiv_x\romannumeral`&&@#1\xint:%
\CALX_ndf_go\CALX_ndiv_zq\CALX_ndiv_zz}%
\def\CALX_nmod #1{\expandafter\CALX_ndiv_x\romannumeral`&&@#1\xint:%
\CALX_nmd_go\CALX_ndiv_zr\CALX_ndiv_zz}%
\def\CALX_nquo #1{\expandafter\CALX_ndiv_x\romannumeral`&&@#1\xint:%
\CALX_nqu_go\CALX_ndiv_zq\CALX_ndiv_zz}%
\def\CALX_nrem #1{\expandafter\CALX_ndiv_x\romannumeral`&&@#1\xint:%
\CALX_nre_go\CALX_ndiv_zr\CALX_ndiv_zz}%
\def\CALX_ndivround #1{\expandafter\CALX_ndiv_x\romannumeral`&&@#1\xint:%
\CALX_ndr_go\CALX_ndiv_zq\CALX_ndiv_zz}%
\def\CALX_ndivision #1{\expandafter\CALX_ndiv_x\romannumeral`&&@#1\xint:%
\CALX_ndn_go\CALX_ndiv_zp\CALX_ndiv_zzp}%
\def\CALX_ndivmod #1{\expandafter\CALX_ndiv_x\romannumeral`&&@#1\xint:%
\CALX_ndm_go\CALX_ndiv_zp\CALX_ndiv_zzp}%
% \end{macrocode}
% \subsubsection{\csh{CALX_nsig}}
%\begin{lverb}
% Zero operands. \CALX_ndiv_zq, _zr, _zp receive {nA}.
%
% \CALX_nsig{}{}{} signals and puts the
% space token ending \romannumeral0 in front of the result.
%\end{lverb}
% \begin{macrocode}
\def\CALX_ndiv_zz{ N+0.}%
\def\CALX_ndiv_zzp{{N+0.}{N+0.}}%
\def\CALX_nsig #1#2#3%
{\expandafter\CALX_sp\romannumeral`&&@%
\CALX_signalcondition{#1}{#2}{#3}{N+0.}}%
\def\CALX_ndiv_zq #1#2{%
\ifnum#2=\xint_c_ \xint_dothis{\CALX_nsig{DivisionUndefined}{0 // 0}{}}\fi
\xint_orthat{\CALX_nsig{DivisionByZero}{x // 0}{#1}}%
}%
\def\CALX_ndiv_zr #1#2{%
\ifnum#2=\xint_c_ \xint_dothis{\CALX_nsig{DivisionUndefined}{0 mod 0}{}}%
\fi
\xint_orthat{\CALX_nsig{InvalidOperation}{x mod 0}{}}%
}%
\def\CALX_ndiv_zp #1#2{%
\ifnum#2=\xint_c_ \xint_dothis\CALX_ndiv_zpu\fi
\xint_orthat{\CALX_npair{\CALX_nsig{DivisionByZero}{x // 0}{#1}}%
{\CALX_nsig{InvalidOperation}{x mod 0}{}}}%
}%
\def\CALX_ndiv_zpu{\expandafter\CALX_ndiv_zpv\romannumeral`&&@%
\CALX_signalcondition{DivisionUndefined}{divmod(0, 0)}{}{N+0.}\xint:}%
\def\CALX_ndiv_zpv #1\xint:{{#1}{#1}}%
% \end{macrocode}
% \subsubsection{\csh{CALX_nq}, \csh{CALX_nqinc}, \csh{CALX_nrz},
% \csh{CALX_nrs}, \csh{CALX_nrb}, \csh{CALX_npair}}
%\begin{lverb}
% Helpers.
%- \CALX_nq {nq}{Q}: the native integer (N+0. if nq = 0).
%- \CALX_nqinc {nq}{Q}: the same for Q + 1 (addition kernel with
% the one block list 100000001!, which is not longer than Q).
%- \CALX_nrz \xint:{}{}: selects according to R' = 0
% (R' terminated by 1;!; zero top blocks are allowed).
%- \CALX_nrs {s}{R'}: R as native integer (N+0. if R = 0).
%- \CALX_nrb N+.\xint:{nb}{B}: N+0. if R = 0, else
% sR R + sB B by \CALX_nadd_y.
%- \CALX_npair {}{}: {Q}{R}, each code being expanded by
% \romannumeral0 (R first).
%\end{lverb}
% \begin{macrocode}
\def\CALX_nq #1#2#3{%
\ifnum#2=\xint_c_ \xint_dothis{ N+0.}\fi
\xint_orthat{ N#1#2.#3}%
}%
\def\CALX_nqinc #1#2#3{%
\ifnum#2=\xint_c_ \xint_dothis{ N#11.100000001!}\fi
\xint_orthat{\expandafter\CALX_naddm\expandafter#1\the\numexpr#2%
\expandafter.\the\numexpr\CALX_nadd_a\xint_c_ii
100000001!1;!1;!1;!1;!\W #31;!1;!1;!1;!\W\xint:}%
}%
\def\CALX_nrz 1#1#2!{%
\xint_gob_til_sc #1\CALX_nrz_z;%
\ifnum#1#2=\xint_c_ \expandafter\CALX_nrz\else\expandafter\CALX_nrz_nz\fi
}%
\def\CALX_nrz_z;#1\xint:#2#3{#2}%
\def\CALX_nrz_nz #1\xint:#2#3{#3}%
\def\CALX_nrs #1#2#3%
{\expandafter\CALX_nrs_a\expandafter#1\romannumeral0%
\CALX_nudiv_rem{#2}{#3}\xint:}%
\def\CALX_nrs_a #1N+#2.{%
\ifnum#2=\xint_c_ \xint_dothis\CALX_nrs_z\fi
\xint_orthat\CALX_nrs_n #1N+#2.%
}%
\def\CALX_nrs_z #1N+#2.#3\xint:{ N+0.}%
\def\CALX_nrs_n #1N+#2.#3\xint:{ N#1#2.#3}%
\def\CALX_nrb N+#1.{%
\ifnum#1=\xint_c_ \xint_dothis\CALX_nrb_z\fi
\xint_orthat\CALX_nrb_n #1.%
}%
\def\CALX_nrb_z #1.#2\xint:#3#4#5#6{ N+0.}%
\def\CALX_nrb_n #1.#2\xint:#3#4#5#6%
{\CALX_nadd_y N#4#5.#6\xint:N#3#1.#21;!1;!1;!1;!\W\xint:}%
\def\CALX_npair #1#2{\expandafter\CALX_npair_a\romannumeral0#2\xint:{#1}}%
\def\CALX_npair_a #1\xint:#2{\expandafter\CALX_npair_b\romannumeral0#2%
\xint:{#1}}%
\def\CALX_npair_b #1\xint:{{#1}}%
% \end{macrocode}
%\begin{lverb}
% Quotients and remainders without B after the division.
%\end{lverb}
% \begin{macrocode}
\def\CALX_ndt_go{\CALX_nudiv\CALX_ndt_q}%
\def\CALX_ndt_q #1#2#3#4#5#6{\CALX_psign#5#6\CALX_nq{#1}{#2}}%
\def\CALX_nmt_go{\CALX_nudiv\CALX_nmt_r}%
\def\CALX_nmt_r #1#2#3#4#5#6{\CALX_nrs#5{#3}{#4}}%
\def\CALX_ndf_go{\CALX_nudiv\CALX_ndf_q}%
\def\CALX_ndf_q #1#2#3#4#5#6{%
\if#5#6\xint_dothis{\CALX_nq+}\fi
\xint_orthat{\CALX_nrz#4\xint:{\CALX_nq-}{\CALX_nqinc-}}{#1}{#2}%
}%
\def\CALX_nqu_go{\CALX_nudiv\CALX_nqu_q}%
\def\CALX_nqu_q #1#2#3#4#5#6{%
\if#5+\xint_dothis{\CALX_nq#6}\fi
\xint_orthat{\CALX_psign-#6\CALX_nqu_a#4\xint:}{#1}{#2}%
}%
\def\CALX_nqu_a #1#2\xint:{\CALX_nrz#2\xint:{\CALX_nq#1}{\CALX_nqinc#1}}%
% \end{macrocode}
%\begin{lverb}
% Families using B after the division: the starter copies {nb}{B}.
%
% Rounding: \CALX_ndr_a gets R, doubles it (\CALX_nsum_p), \CALX_ndr_c
% compares 2R with B, \CALX_ndr_e reads the borrow state (1: 2R >= B).
%\end{lverb}
% \begin{macrocode}
\def\CALX_ndr_go #1#2#3#4{\CALX_nudiv\CALX_ndr_q{#1}{#2}{#3}{#4}{#3}{#4}}%
\def\CALX_ndr_q #1#2#3#4#5#6#7#8{%
\expandafter\CALX_ndr_a\romannumeral0\CALX_nudiv_rem{#3}{#4}\xint:%
{#5}{#6}#7#8{#1}{#2}%
}%
\def\CALX_ndr_a N+#1.{%
\ifnum#1=\xint_c_ \xint_dothis\CALX_ndr_a_z\fi
\xint_orthat\CALX_ndr_a_n #1.%
}%
\def\CALX_ndr_a_z #1.#2\xint:#3#4{\CALX_ndr_dn}%
\def\CALX_ndr_a_n #1.#2\xint:#3#4{%
\expandafter\CALX_ndr_c
\romannumeral0\expandafter\CALX_naddm\expandafter+%
\the\numexpr#1\expandafter.\the\numexpr\CALX_nadd_a\xint_c_ii
#21;!1;!1;!1;!\W#21;!1;!1;!1;!\W\xint:\xint:{#3}{#4}%
}%
\def\CALX_ndr_c N+#1.#2\xint:#3#4{%
\ifnum#1>#3 \xint_dothis\CALX_ndr_up\fi
\ifnum#1<#3 \xint_dothis\CALX_ndr_dn\fi
\xint_orthat{\expandafter\CALX_ndr_e\the\numexpr
\CALX_nsub_a\xint_c_i #41;!1;!1;!1;!\W #21;!1;!1;!1;!\W}%
}%
\def\CALX_ndr_e #11;!#2%
{\if#21\expandafter\CALX_ndr_up\else\expandafter\CALX_ndr_dn\fi}%
\def\CALX_ndr_up #1#2{\CALX_psign#1#2\CALX_nqinc}%
\def\CALX_ndr_dn #1#2{\CALX_psign#1#2\CALX_nq}%
\def\CALX_nmd_go #1#2#3#4{\CALX_nudiv\CALX_nmd_r{#1}{#2}{#3}{#4}{#3}{#4}}%
\def\CALX_nmd_r #1#2#3#4#5#6#7#8{%
\if#7#8\xint_dothis{\CALX_nrs#7{#3}{#4}}\fi
\xint_orthat{\expandafter\CALX_nrb\romannumeral0\CALX_nudiv_rem{#3}{#4}%
\xint:#7#8{#5}{#6}}%
}%
\def\CALX_nre_go #1#2#3#4{\CALX_nudiv\CALX_nre_r{#1}{#2}{#3}{#4}{#3}{#4}}%
\def\CALX_nre_r #1#2#3#4#5#6#7#8{%
\if#7+\xint_dothis{\CALX_nudiv_rem{#3}{#4}}\fi
\xint_orthat{\expandafter\CALX_nrb\romannumeral0\CALX_nudiv_rem{#3}{#4}%
\xint:-+{#5}{#6}}%
}%
\def\CALX_ndn_go #1#2#3#4{\CALX_nudiv\CALX_ndn_r{#1}{#2}{#3}{#4}{#3}{#4}}%
\def\CALX_ndn_r #1#2#3#4#5#6#7#8{%
\if#7+\xint_dothis{\CALX_npair{\CALX_nq#8{#1}{#2}}{%
\CALX_nudiv_rem{#3}{#4}}}\fi
\xint_orthat{\expandafter\CALX_ndn_a\romannumeral0\CALX_nudiv_rem{#3}{#4}%
\xint:{#5}{#6}#8{#1}{#2}}%
}%
\def\CALX_ndn_a N+#1.{%
\ifnum#1=\xint_c_ \xint_dothis\CALX_ndn_a_z\fi
\xint_orthat\CALX_ndn_a_n #1.%
}%
\def\CALX_ndn_a_z #1.#2\xint:#3#4#5#6#7%
{\CALX_npair{\CALX_psign-#5\CALX_nq{#6}{#7}}{ N+0.}}%
\def\CALX_ndn_a_n #1.#2\xint:#3#4#5#6#7%
{\CALX_npair{\CALX_psign-#5\CALX_nqinc{#6}{#7}}%
{\CALX_nadd_y N+#3.#4\xint:N-#1.#21;!1;!1;!1;!\W\xint:}}%
\def\CALX_ndm_go #1#2#3#4{\CALX_nudiv\CALX_ndm_r{#1}{#2}{#3}{#4}{#3}{#4}}%
\def\CALX_ndm_r #1#2#3#4#5#6#7#8{%
\if#7#8\xint_dothis{\CALX_npair{\CALX_nq+{#1}{#2}}{\CALX_nrs#7{#3}{#4}}}%
\fi
\xint_orthat{\expandafter\CALX_ndm_a\romannumeral0\CALX_nudiv_rem{#3}{#4}%
\xint:{#5}{#6}#7#8{#1}{#2}}%
}%
\def\CALX_ndm_a N+#1.{%
\ifnum#1=\xint_c_ \xint_dothis\CALX_ndm_a_z\fi
\xint_orthat\CALX_ndm_a_n #1.%
}%
\def\CALX_ndm_a_z #1.#2\xint:#3#4#5#6#7#8%
{\CALX_npair{\CALX_nq-{#7}{#8}}{ N+0.}}%
\def\CALX_ndm_a_n #1.#2\xint:#3#4#5#6#7#8%
{\CALX_npair{\CALX_nqinc-{#7}{#8}}%
{\CALX_nadd_y N#6#3.#4\xint:N#5#1.#21;!1;!1;!1;!\W\xint:}}%
% \end{macrocode}
% \subsection{Already expanded native arithmetic}
%\begin{lverb}
% Inputs to the following interfaces are two expanded native integers,
% both with N tags. No argument expansion, tag dispatch, or conversion
% is needed. Each kernel appends its own block terminators.
%\end{lverb}
% \begin{macrocode}
\def\CALX_naddready #1#2{\CALX_nadd_y #1\xint:#21;!1;!1;!1;!\W\xint:}%
\def\CALX_nsubready #1#2{\CALX_nsub_y #2\xint:#11;!1;!1;!1;!\W\xint:}%
\def\CALX_nmulready #1#2{\CALX_nmul_y #1\xint:#21;!\xint:}%
% \end{macrocode}
% \subsection{Native power}
%\begin{lverb}
% Syntax (use with \romannumeral0; k a \numexpr expression, k >= 0; X
% f-expanded native integer, not I):
%(
% \CALX_npow{k}{X} -> N. (X^k; X^0 = 1)
%)
% Binary powering, least significant bit of k first. The even low bits of
% k only square X (\CALX_npow_e); at the first odd bit the accumulator is
% the current base itself (no multiplication by 1), then \CALX_npow_l
% squares the base and multiplies it into the accumulator for each further
% bit, the last squaring being skipped. The new base and accumulator are
% computed inside one \expanded and handed over as braced groups.
%\end{lverb}
% \begin{macrocode}
\def\CALX_npow #1#2%
{\expandafter\CALX_npow_a\the\numexpr#1\expandafter.%
\romannumeral`&&@#2\xint:}%
\def\CALX_npow_a #1.#2\xint:%
{\ifnum#1=\xint_c_ \xint_dothis{ N+1.100000001!}\fi
\xint_orthat{\CALX_npow_e #1.{#2}}}%
\def\CALX_npow_e #1.#2%
{%
\ifnum#1=\xint_c_i \xint_dothis{ #2}\fi
\ifodd#1 \xint_dothis{\expandafter\CALX_npow_l
\the\numexpr(#1-\xint_c_i)/\xint_c_ii\expandafter.%
\expandafter{\romannumeral0\CALX_nmul{#2}{#2}}{#2}}\fi
\xint_orthat{\expandafter\CALX_npow_e\the\numexpr#1/\xint_c_ii%
\expandafter.\expandafter{\romannumeral0\CALX_nmul{#2}{#2}}}%
}%
\def\CALX_npow_l #1.#2#3%
{%
\ifnum#1=\xint_c_i \xint_dothis{\CALX_nmul{#3}{#2}}\fi
\ifodd#1 \xint_dothis{\expandafter\CALX_npow_l
\the\numexpr(#1-\xint_c_i)/\xint_c_ii\expandafter.%
\expanded{{\romannumeral0\CALX_nmul{#2}{#2}}%
{\romannumeral0\CALX_nmul{#3}{#2}}}}\fi
\xint_orthat{\expandafter\CALX_npow_l\the\numexpr#1/\xint_c_ii%
\expandafter.\expandafter{\romannumeral0\CALX_nmul{#2}{#2}}{#3}}%
}%
% \end{macrocode}
% \subsection{Native partial factorial and factorial}
%\begin{lverb}
% Syntax (use with \romannumeral0; a, b \numexpr expressions, 0 <= a < b <
% 10^8, k = 1 .. 10^4, not checked):
%(
% \CALX_npfac{a}{b} -> N+. ((a+1)(a+2)...b)
%: \CALX_nfac{k} -> N+