% Copyright 2019 by Christian Feuersaenger % % This file may be distributed and/or modified % % 1. under the LaTeX Project Public License and/or % 2. under the GNU Public License. % % See the file doc/generic/pgf/licenses/LICENSE for more details. % % This file contains methods for basic floating point arithmetics, rounding % to arbitrary precision and number pretty printing. % \pgfkeys{ % The bug 3430171 (wrong minus sign spacing in pgfmathprintnumber) % has been fixed in 2.10 CVS. Since it changes the spacing, its % effects can be undone with this compatibility switch. /pgf/compat/number printer/.is choice, /pgf/compat/number printer/2.10/.code={% \def\pgfmathprintnumber@begingroup{\bgroup}% \def\pgfmathprintnumber@endgroup{\egroup}% }, % I do not know the version number of the next release at this % time. Please be so kind and KEEP THIS NAME INTACT. Add an alias % if needed. /pgf/compat/number printer/next after 2.10/.code={% \def\pgfmathprintnumber@begingroup{\begingroup}% \def\pgfmathprintnumber@endgroup{\endgroup}% }, % activate the fix by default. /pgf/compat/number printer/next after 2.10,% } \global\newif\ifpgfmathfloatcomparison \newif\ifpgfmathfloatroundhasperiod \newif\ifpgfmathprintnumberskipzeroperiod % used internally in grouped macros: \toksdef\pgfmathfloat@tmptoks=1 \newif\ifpgfmathfloat@fixed@digits@after@period \newif\ifpgfmathfloatroundmayneedrenormalize \toksdef\pgfmathfloat@a@Mtok=0 %% WARNING: avoid conflicting register names! \let\pgfmathfloat@a@S=\c@pgf@counta \let\pgfmathfloat@a@M=\pgf@xa \let\pgfmathfloat@a@E=\c@pgf@countb \let\pgfmathfloat@b@S=\c@pgf@countc \let\pgfmathfloat@b@M=\pgf@xb \let\pgfmathfloat@b@E=\c@pgf@countd % can be changed with options. \def\pgfmathfloat@round@precision{2} % I introduced this to access the "original" precision in case a % formatted changes it locally... in this case, the formatter may % overwrite \pgfmathfloat@round@precision@orig to provide the original % one. % The default implementation here does nothing: \def\pgfmathfloat@round@precision@orig{\pgfmathfloat@round@precision}% \gdef\pgfmathfloat@glob@TMP{} % Computes a normalised floating point representation for #1 of the % form % [FLAGS] MANTISSE EXPONENT % meaning % [+-]X.XXXXXXX*10^C % where % X.XXXXXX is a mantissa with first number != 0, C is an integer and % FLAGS contains the sign and some other special cases. % % This method does NOT use TeX Registers to represent the numbers! The % computation is COMPLETELY STRING BASED. % This allows numbers such at 10000000 or 5.23e-10 to be represented % properly, although TeX-registers would produce overflow/underflow % errors in these cases. % % It is to be used to compute logs, because log(X*10^Y) = log(X) + log(10)*Y % % Arguments: % #1: an arbitrary number which shall be parsed. Maybe a macro. % Examples: % [+-]XXXXX.XXXXXX % [+-]XXXXX.XXXXXXeXXXX % [+-]0.0000XXXXXX % [+-]0.0000XXXXXXeXXXX % [+-]inf % nan % Maybe a macro containing such a number. % % Return value: % \pgfmathresult will be \def'ed to % FLAGS MANTISSE 'e' EXPONENT % where % FLAGS is a number in [0-5] where % 0 == '0' (the number is +- 0.0), % 1 == '+', % 2 == '-', % 3 == 'not a number' % 4 == '+ infinity' % 5 == '- infinity' % % MANTISSE is a normalised number 1 <= M < 10. It always contains a % period and at least one digit after the period. % % EXPONENT is an integer value. % % Example: % \pgfmathfloatparsenumber{1} % -> \pgfmathresult = 11.0e0 % \pgfmathfloatparsenumber{141.212} % -> \pgfmathresult = 11.41212e2 \def\pgfmathfloatparsenumber#1{% \begingroup \edef\pgfmathresult{#1}% \expandafter\pgfflt@impl\pgfmathresult\pgfflt@EOI \ifpgfmathfloatparsenumberpendingperiod \pgfmathfloat@a@Mtok=\expandafter{\the\pgfmathfloat@a@Mtok.0}% \fi \pgfmathfloatcreate{\the\pgfmathfloat@a@S}{\the\pgfmathfloat@a@Mtok}{\the\pgfmathfloat@a@E}% \pgfmath@smuggleone\pgfmathresult \endgroup } % The same as \pgfmathfloatparsenumber, but does not perform sanity checking. % FIXME: there is no longer any difference here. \let\pgfmathfloatqparsenumber=\pgfmathfloatparsenumber % Takes a floating point number #1 as input and writes flags to count % register #2, mantissa to dimen register #3 and exponent to count % register #4. \def\pgfmathfloattoregisters#1#2#3#4{% \expandafter\pgfmathfloat@decompose#1\relax{#2}{#3}{#4}% } % the same, but writes the mantissa into a token register. \def\pgfmathfloattoregisterstok#1#2#3#4{% \expandafter\pgfmathfloat@decompose@tok#1\relax{#2}{#3}{#4}% } % Extracts the flags of #1 into the count register #2. \def\pgfmathfloatgetflags#1#2{% \expandafter\pgfmathfloat@decompose@F#1\relax{#2}% } % Extracts the flags of #1 into the macro #2. \def\pgfmathfloatgetflagstomacro#1#2{% \expandafter\pgfmathfloat@decompose@Fmacro#1\relax{#2}% }% % Extracts the mantissa of #1 into the dimen register #2. \def\pgfmathfloatgetmantissa#1#2{% \expandafter\pgfmathfloat@decompose@M#1\relax{#2}% } \let\pgfmathfloatgetmantisse=\pgfmathfloatgetmantissa % Extracts the mantissa of #1 into the token register #2. \def\pgfmathfloatgetmantissatok#1#2{% \expandafter\pgfmathfloat@decompose@Mtok#1\relax{#2}% } \let\pgfmathfloatgetmantissetok=\pgfmathfloatgetmantissatok % Extracts the exponent of #1 into the count register #2. \def\pgfmathfloatgetexponent#1#2{% \expandafter\pgfmathfloat@decompose@E#1\relax{#2}% } % Assigns \pgfmathresult to be a float encoded as % e % % example: % \pgfmathfloatcreate{1}{2.0}{10} % \pgfmathfloat@to@FMeE@style\pgfmathresult % -> % \pgfmathresult is now '12.0e10' regardless of the internal float % format. \def\pgfmathfloat@to@FMeE@style#1{\expandafter\pgfmathfloat@to@FMeE@style@#1\relax\relax}% \def\pgfmathfloat@to@FMeE@style@#1#2{% \ifx#2Y% \expandafter\pgfmathfloat@to@FMeE@style@@% \else \expandafter\pgfmathfloat@to@FMeE@style@error% \fi #1#2% }% \def\pgfmathfloat@to@FMeE@style@@#1Y#2e#3]\relax\relax{\def\pgfmathresult{#1#2e#3}}% \def\pgfmathfloat@to@FMeE@style@error#1\relax\relax{% \begingroup \pgfmathfloatparsenumber@handleerror{wrong lowlevel format}{#1}{#1}% \xdef\pgfmathfloat@decompose@TMP{% \noexpand\pgfmathfloatcreate{\the\pgfmathfloat@a@S}{\the\pgfmathfloat@a@Mtok}{\the\pgfmathfloat@a@E}% }% \endgroup \pgfmathfloat@decompose@TMP }% % decomposes a lowlevel floating point representation into flags, % mantissa and exponent. % % #4: integer register for the flags. % #5: dimen registers for the mantissa. % #6: integer register for the exponent. % % \expandafter\pgfmathfloat@decompose\pgfmathresult\relax\pgfmathfloat@a@S\pgfmathfloat@a@M\pgfmathfloat@a@E % -> the three temp registers contain flags, mantissa and exponent \def\pgfmathfloat@decompose#1#2{% sanitize! \ifx#2Y% \expandafter\pgfmathfloat@decompose@% \else \expandafter\pgfmathfloat@decompose@error% \fi #1#2% } \def\pgfmathfloat@decompose@#1Y#2e#3]\relax#4#5#6{% #4=#1\relax #5=#2pt % keep space here. #6=#3\relax% } % overloaded, #5 needs to be a token register for the mantissa. % @see also \pgfmathfloatvalueof which does also employ the load % level repr. % \expandafter\pgfmathfloat@decompose@tok\pgfmathresult\relax\pgfmathfloat@a@S\pgfmathfloat@a@Mtok\pgfmathfloat@a@E % -> the three temp registers contain flags, mantissa and exponent \def\pgfmathfloat@decompose@tok#1#2{% \ifx#2Y% \expandafter\pgfmathfloat@decompose@tok@% \else \expandafter\pgfmathfloat@decompose@tok@error% \fi #1#2% }% \def\pgfmathfloat@decompose@tok@#1Y#2e#3]\relax#4#5#6{% #4=#1\relax #5={#2}% #6=#3\relax% } % overloaded, returns only ONE of the three components into #4: % \expandafter\pgfmathfloat@decompose@tok\pgfmathresult\relax\pgfmathfloat@a@S % -> \pgfmathfloat@a@S contains the flags field. \def\pgfmathfloat@decompose@F#1#2{% \ifx#2Y% \expandafter\pgfmathfloat@decompose@F@% \else \expandafter\pgfmathfloat@decompose@F@error% \fi #1#2% }% \def\pgfmathfloat@decompose@Fmacro#1#2{% \ifx#2Y% \expandafter\pgfmathfloat@decompose@Fmacro@% \else \expandafter\pgfmathfloat@decompose@F@error% \fi #1#2% }% \def\pgfmathfloat@decompose@M#1#2{% \ifx#2Y% \expandafter\pgfmathfloat@decompose@M@% \else \expandafter\pgfmathfloat@decompose@M@error% \fi #1#2% }% \def\pgfmathfloat@decompose@E#1#2{% \ifx#2Y% \expandafter\pgfmathfloat@decompose@E@% \else \expandafter\pgfmathfloat@decompose@E@error% \fi #1#2% }% \def\pgfmathfloat@decompose@Mtok#1#2{% \ifx#2Y% \expandafter\pgfmathfloat@decompose@Mtok@% \else \expandafter\pgfmathfloat@decompose@Mtok@error% \fi #1#2% }% \def\pgfmathfloat@decompose@F@#1Y#2e#3]\relax#4{#4=#1\relax}% \def\pgfmathfloat@decompose@Fmacro@#1Y#2e#3]\relax#4{\def#4{#1}}% \def\pgfmathfloat@decompose@M@#1Y#2e#3]\relax#4{#4=#2pt}% \def\pgfmathfloat@decompose@Mtok@#1Y#2e#3]\relax#4{#4={#2}}% \def\pgfmathfloat@decompose@E@#1Y#2e#3]\relax#4{#4=#3\relax}% \def\pgfmathfloat@decompose@error#1\relax#2#3#4{% \begingroup \pgfmathfloatparsenumber@handleerror{wrong lowlevel format}{#1}{#1}% \xdef\pgfmathfloat@decompose@TMP{% \noexpand#2=\the\pgfmathfloat@a@S\space \noexpand#3=\the\pgfmathfloat@a@Mtok pt \noexpand#4=\the\pgfmathfloat@a@E\space }% \endgroup \pgfmathfloat@decompose@TMP }% \def\pgfmathfloat@decompose@tok@error#1\relax#2#3#4{% \begingroup \pgfmathfloatparsenumber@handleerror{wrong lowlevel format}{#1}{#1}% \xdef\pgfmathfloat@decompose@TMP{% \noexpand#2=\the\pgfmathfloat@a@S\space \noexpand#3={\the\pgfmathfloat@a@Mtok}% \noexpand#4=\the\pgfmathfloat@a@E\space }% \endgroup \pgfmathfloat@decompose@TMP }% \def\pgfmathfloat@decompose@F@error#1\relax#2{% \begingroup \pgfmathfloatparsenumber@handleerror{wrong lowlevel format}{#1}{#1}% \xdef\pgfmathfloat@decompose@TMP{\noexpand#2=\the\pgfmathfloat@a@S\space}% \endgroup \pgfmathfloat@decompose@TMP }% \def\pgfmathfloat@decompose@M@error#1\relax#2{% \begingroup \pgfmathfloatparsenumber@handleerror{wrong lowlevel format}{#1}{#1}% \xdef\pgfmathfloat@decompose@TMP{\noexpand#2=\the\pgfmathfloat@a@Mtok pt }% \endgroup \pgfmathfloat@decompose@TMP }% \def\pgfmathfloat@decompose@Mtok@error#1\relax#2{% \begingroup \pgfmathfloatparsenumber@handleerror{wrong lowlevel format}{#1}{#1}% \xdef\pgfmathfloat@decompose@TMP{\noexpand#2={\the\pgfmathfloat@a@Mtok}}% \endgroup \pgfmathfloat@decompose@TMP }% \def\pgfmathfloat@decompose@E@error#1\relax#2{% \begingroup \pgfmathfloatparsenumber@handleerror{wrong lowlevel format}{#1}{#1}% \xdef\pgfmathfloat@decompose@TMP{\noexpand#2=\the\pgfmathfloat@a@E\space}% \endgroup \pgfmathfloat@decompose@TMP }% % Takes a floating point number #1 as input and writes flags to macro % #2, mantissa to macro #3 and exponent to macro #4. \def\pgfmathfloattomacro#1#2#3#4{% \begingroup \expandafter\pgfmathfloat@decompose@tok#1\relax\pgfmathfloat@a@S\pgfmathfloat@a@Mtok\pgfmathfloat@a@E \xdef\pgfmathfloat@glob@TMP{% \noexpand\def\noexpand#2{\the\pgfmathfloat@a@S}% \noexpand\def\noexpand#3{\the\pgfmathfloat@a@Mtok}% \noexpand\def\noexpand#4{\the\pgfmathfloat@a@E}% }% \endgroup \pgfmathfloat@glob@TMP } % Defines \pgfmathresult as the floating point number encoded by % the flags #1, mantissa #2 and exponent #3. % % All arguments are characters and will be expanded using '\edef'. \def\pgfmathfloatcreate#1#2#3{% \edef\pgfmathresult{#1Y#2e#3]}% }% % This is the character present in any low-level floating point % number. It is assumed to be the SECOND character of a float (after % the flags integer). \def\pgfmathfloat@POSTFLAGSCHAR{Y} % Converts a composed floating point representation to fixed point. % % Example: % \pgfmathfloattofixed{142e1} % -> \pgfmathresult = 42.0 \def\pgfmathfloattofixed@#1{% \begingroup \expandafter\pgfmathfloat@decompose@tok#1\relax\pgfmathfloat@a@S\pgfmathfloat@a@Mtok\pgfmathfloat@a@E \ifcase\pgfmathfloat@a@S \def\pgfmathresult{0.0}% \or \expandafter\pgfmathfloattofixed@impl\the\pgfmathfloat@a@Mtok\relax \or \expandafter\pgfmathfloattofixed@impl\the\pgfmathfloat@a@Mtok\relax \pgfmathfloat@a@Mtok=\expandafter{\pgfmathresult}% \edef\pgfmathresult{-\the\pgfmathfloat@a@Mtok}% \or\def\pgfmathresult{nan}% \or\def\pgfmathresult{inf}% \or\def\pgfmathresult{-inf}% \fi \pgfmath@smuggleone\pgfmathresult \endgroup } \let\pgfmathfloattofixed=\pgfmathfloattofixed@ % Converts a float to an integer (in integer format). % % @see \pgfmathfloatint \def\pgfmathfloattoint#1{% \pgfmathfloattofixed{#1}% \expandafter\pgfmathfloattoint@@\pgfmathresult\relax }% \def\pgfmathfloattoint@@#1.#2\relax{% \def\pgfmathresult{#1}% }% % Converts a floating point number to scientific format 1.234e5. % % This operation is very fast. \def\pgfmathfloattosci@#1{% \begingroup \expandafter\pgfmathfloat@decompose@tok#1\relax\pgfmathfloat@a@S\pgfmathfloat@a@Mtok\pgfmathfloat@a@E \ifcase\pgfmathfloat@a@S \def\pgfmathresult{0.0e0}% \or \edef\pgfmathresult{\the\pgfmathfloat@a@Mtok e\the\pgfmathfloat@a@E}% \or \edef\pgfmathresult{-\the\pgfmathfloat@a@Mtok e\the\pgfmathfloat@a@E}% \or\def\pgfmathresult{nan}% \or\def\pgfmathresult{inf}% \or\def\pgfmathresult{-inf}% \fi \pgfmath@smuggleone\pgfmathresult \endgroup }% \let\pgfmathfloattosci=\pgfmathfloattosci@ % Expands a floating point number to scientific format 1.234e5. % % This operation is very fast. \def\pgfmathfloatvalueof#1{\expandafter\pgfmathfloatvalueof@@#1@@}% % Make it fool proof such that the following arguments work: % \pgfmathfloatvalueof{1Y1.0e1} -> 1.0e1 % \pgfmathfloatvalueof{2Y1.0e1} -> -1.0e1 % and wrong arguments as well: % \pgfmathfloatvalueof{1} -> 1 % \pgfmathfloatvalueof{1e2} -> 1e2 \def\pgfmathfloatvalueof@@#1#2{% \if#2Y% % keep in mind that \pgfmathfloatvalueof should be expandable! % We must not use \let here. Let's hope that #1 and #2 are % single tokens (not something which was enclosed by curly % braces...) \expandafter\pgfmathfloatvalueof@@@\expandafter#1\expandafter#2% \else % Oh - no float!? Ok, we cannot report errors in this context. % So: make it a feature and return the input argument as-is. % Might be useful, in fact... \expandafter\pgfmathfloatvalueof@abort\expandafter#1\expandafter#2% \fi } \def\pgfmathfloatvalueof@@@#1Y#2e#3]@@{% \ifcase#1 % 0.0e0% \or #2e#3% \or -#2e#3% \or nan% \or inf% \or -inf% \fi }% \def\pgfmathfloatvalueof@abort#1@@{#1}% % Rounds a fixed point number #1 to \pgfmathfloat@round@precision digits precision and returns % the result into \pgfmathresult. % % Any trailing zeros after the period are discarded. % See \pgfmathroundtozerofill if you want trailing zeros and fixed % width. % % This method is PURELY text based and can work with arbitrary % precision (well, limited to TeX's stack size and integer size). % % Examples: % \pgfmathroundto{1} % -> \pgfmathresult = '1' % % \pgfmathroundto{19999.9996} % -> \pgfmathresult = '20000' % % Arguments: % #1 may be either a number or a macro (\pgfmathresult is allowed) expanding to a number. % % SIDE EFFECT: the global variable \ifpgfmathfloatroundhasperiod will be set. \def\pgfmathroundto#1{% \pgfmathfloatroundhasperiodtrue \begingroup \pgfmathfloat@fixed@digits@after@periodfalse \pgfmathroundto@impl{#1}% \pgfmath@smuggleone\pgfmathresult \endgroup } % Overloaded method. % % This variant always uses a FIXED number behind the period and fills % in zeros if necessary. % Examples: % \pgfmathroundtozerofill{1} % -> \pgfmathresult = '1.00' % % \pgfmathroundtozerofill{19999.9996} % -> \pgfmathresult = '20000.00' % % SIDE EFFECT: the global variable \ifpgfmathfloatroundhasperiod will be set. \def\pgfmathroundtozerofill#1{% \pgfmathfloatroundhasperiodtrue \begingroup \pgfmathfloat@fixed@digits@after@periodtrue \pgfmathroundto@impl{#1}% \pgfmath@smuggleone\pgfmathresult \endgroup } % see \pgfmathprintnumber@fixed@style for docs \def\pgfmathprintnumber@fixed@styleDEFAULT#1#2#3e#4\relax{% \begingroup \pgfkeysgetvalue{/pgf/number format/set decimal separator}\pgfmathprintnumber@fixed@styleDEFAULT@DEC@SEP \pgfkeysgetvalue{/pgf/number format/@dec sep mark}\pgfmathprintnumber@fixed@styleDEFAULT@DEC@SEP@MARK \pgfkeysgetvalue{/pgf/number format/set thousands separator}\pgfmathprintnumber@fixed@styleDEFAULT@THOUSAND@SEP \c@pgf@counta=#4\relax % it is the exponent here. \ifnum#2=0 \c@pgf@counta=0 \fi \def\pgfmathresult{}% \ifpgfmathfloatroundhasperiod \expandafter\pgfmathprintnumber@fixed@styleDEFAULT@impl@period#1\pgfmathfloat@EOI \else \expandafter\pgfmathprintnumber@fixed@styleDEFAULT@impl@noperiod#1\pgfmathfloat@EOI\pgfmathfloat@EOI\pgfmathfloat@EOI% \begingroup \toks0=\expandafter{\pgfmathresult}% \toks1=\expandafter{\pgfmathprintnumber@fixed@styleDEFAULT@DEC@SEP@MARK}% \xdef\pgfmathfloat@glob@TMP{\the\toks0 \the\toks1 }% \endgroup \let\pgfmathresult=\pgfmathfloat@glob@TMP \fi \pgfmath@smuggleone\pgfmathresult \endgroup } \def\pgfmathprintnumber@fixed@styleDEFAULT@impl@period#1.#2\pgfmathfloat@EOI{% \ifpgfmathprintnumberskipzeroperiod \def\pgfmathfloat@loc@TMPb{#1}% \ifx\pgfmathfloatparsenumber@tok@ZERO\pgfmathfloat@loc@TMPb \else \def\pgfmathfloat@loc@TMPc{-0}% \ifx\pgfmathfloat@loc@TMPc\pgfmathfloat@loc@TMPb \def\pgfmathresult{-}% \else \def\pgfmathfloat@loc@TMPc{+0}% \ifx\pgfmathfloat@loc@TMPc\pgfmathfloat@loc@TMPb \def\pgfmathresult{+}% \else \pgfmathprintnumber@fixed@styleDEFAULT@impl@noperiod#1\pgfmathfloat@EOI\pgfmathfloat@EOI\pgfmathfloat@EOI \fi \fi \fi \else \pgfmathprintnumber@fixed@styleDEFAULT@impl@noperiod#1\pgfmathfloat@EOI\pgfmathfloat@EOI\pgfmathfloat@EOI \fi \ifpgfmathprintnumber@thousand@sep@in@fractional \let\pgfmathresultfractional\pgfutil@empty% \pgfmathprintnumber@thousand@sep@in@fractional#2MMMM\@@ \else \def\pgfmathresultfractional{#2}% \fi \begingroup \toks0=\expandafter{\pgfmathresult}% \toks1=\expandafter{\pgfmathprintnumber@fixed@styleDEFAULT@DEC@SEP@MARK}% \toks2=\expandafter{\pgfmathprintnumber@fixed@styleDEFAULT@DEC@SEP}% \toks3=\expandafter{\pgfmathresultfractional}% \xdef\pgfmathfloat@glob@TMP{\the\toks0 \the\toks1 \the\toks2 \the\toks3 }% \endgroup \let\pgfmathresult=\pgfmathfloat@glob@TMP }% % assigns \pgfmathresult such that it contains the formatted result. % It assumes that none of the following tokens contains a period. \def\pgfmathprintnumber@fixed@styleDEFAULT@impl@noperiod{% \ifx\pgfmathprintnumber@fixed@styleDEFAULT@THOUSAND@SEP\pgfutil@empty \def\pgfmathprintnumber@fixed@styleDEFAULT@impl@noperiod@NEXT{% \pgfmathprintnumber@fixed@styleDEFAULT@impl@noperiod@printall}% \else \ifnum\c@pgf@counta<0\relax % exponent of the number in this context \def\pgfmathprintnumber@fixed@styleDEFAULT@impl@noperiod@NEXT{% \pgfmathprintnumber@fixed@styleDEFAULT@impl@noperiod@printall}% \else \ifnum\c@pgf@counta<\pgfkeysvalueof{/pgf/number format/min exponent for 1000 sep}\relax \def\pgfmathprintnumber@fixed@styleDEFAULT@impl@noperiod@NEXT{% \pgfmathprintnumber@fixed@styleDEFAULT@impl@noperiod@printall}% \else \advance\c@pgf@counta by1 % counta:= total number of digits, N. \c@pgf@countb=\c@pgf@counta \divide\c@pgf@countb by3 % countb := N DIV 3 \c@pgf@countc=\c@pgf@countb \multiply\c@pgf@countc by3 \advance\c@pgf@counta by-\c@pgf@countc% now counta := N MOD 3 \def\pgfmathprintnumber@fixed@styleDEFAULT@impl@noperiod@NEXT{% \pgfmathprintnumber@fixed@styleDEFAULT@impl@noperiod@printsign }% \fi \fi \fi \pgfmathprintnumber@fixed@styleDEFAULT@impl@noperiod@NEXT } \def\pgfmathprintnumber@fixed@styleDEFAULT@impl@noperiod@printsign#1{% \def\pgfmathfloat@loc@TMPb{#1}% \ifx\pgfmathfloat@loc@TMPb\pgfmathfloatparsenumber@tok@MINUS \expandafter\def\expandafter\pgfmathresult\expandafter{\pgfmathresult #1}% \let\pgfmathfloat@loc@TMPb=\pgfutil@empty \else \ifx\pgfmathfloat@loc@TMPb\pgfmathfloatparsenumber@tok@PLUS \expandafter\def\expandafter\pgfmathresult\expandafter{\pgfmathresult #1}% \let\pgfmathfloat@loc@TMPb=\pgfutil@empty \else \ifpgfmathprintnumber@showpositive \expandafter\def\expandafter\pgfmathresult\expandafter{\pgfmathresult +}% \fi \fi \fi \ifnum\c@pgf@counta>0 % \c@pgf@counta = N MOD 3 in this context \def\pgfmathprintnumber@fixed@styleDEFAULT@impl@noperiod@NEXT{% \expandafter\pgfmathprintnumber@fixed@styleDEFAULT@impl@noperiod@printtrailingdigits\pgfmathfloat@loc@TMPb }% \else \def\pgfmathprintnumber@fixed@styleDEFAULT@impl@noperiod@NEXT{% \expandafter\pgfmathprintnumber@fixed@styleDEFAULT@impl@noperiod@counteverythird\pgfmathfloat@loc@TMPb }% \fi \pgfmathprintnumber@fixed@styleDEFAULT@impl@noperiod@NEXT } \def\pgfmathprintnumber@fixed@styleDEFAULT@impl@noperiod@printtrailingdigits#1#2{% \ifcase\c@pgf@counta % = N MOD 3 in this context % does not happen per construction \or \expandafter\def\expandafter\pgfmathresult\expandafter{\pgfmathresult #1}% \def\pgfmathprintnumber@fixed@styleDEFAULT@impl@noperiod@NEXT{% \pgfmathprintnumber@fixed@styleDEFAULT@impl@noperiod@counteverythird#2% }% \or \expandafter\def\expandafter\pgfmathresult\expandafter{\pgfmathresult #1#2}% \def\pgfmathprintnumber@fixed@styleDEFAULT@impl@noperiod@NEXT{% \pgfmathprintnumber@fixed@styleDEFAULT@impl@noperiod@counteverythird% }% \fi \ifnum\c@pgf@countb>0\relax % \c@pgf@countb = N DIV 3 in this context \begingroup \toks0=\expandafter{\pgfmathresult}% \toks1=\expandafter{\pgfmathprintnumber@fixed@styleDEFAULT@THOUSAND@SEP}% \xdef\pgfmathfloat@glob@TMP{\the\toks0 \the\toks1 }% \endgroup \let\pgfmathresult=\pgfmathfloat@glob@TMP \fi \pgfmathprintnumber@fixed@styleDEFAULT@impl@noperiod@NEXT } \def\pgfmathprintnumber@fixed@styleDEFAULT@impl@noperiod@counteverythird#1#2#3{% \ifnum\c@pgf@countb>0\relax \expandafter\def\expandafter\pgfmathresult\expandafter{\pgfmathresult #1#2#3}% \advance\c@pgf@countb by-1 \ifnum\c@pgf@countb>0\relax \begingroup \toks0=\expandafter{\pgfmathresult}% \toks1=\expandafter{\pgfmathprintnumber@fixed@styleDEFAULT@THOUSAND@SEP}% \xdef\pgfmathfloat@glob@TMP{\the\toks0 \the\toks1 }% \endgroup \let\pgfmathresult=\pgfmathfloat@glob@TMP \fi \def\pgfmathprintnumber@fixed@styleDEFAULT@impl@noperiod@NEXT{% \pgfmathprintnumber@fixed@styleDEFAULT@impl@noperiod@counteverythird% }% \else % in this case, #1#2#3 are expected to be % \pgfmathfloat@EOI\pgfmathfloat@EOI\pgfmathfloat@EOI %-------------------------------------------------- % \def\pgfmathfloat@loc@TMPb{\pgfmathfloat@EOI\pgfmathfloat@EOI\pgfmathfloat@EOI}% % \def\pgfmathfloat@loc@TMPc{#1#2#3}% % \ifx\pgfmathfloat@loc@TMPc\pgfmathfloat@loc@TMPb % \else % \pgfmath@error{INTERNAL ERROR in fixed style - The input sequence did not terminate as expected; which indicates a wrong exponent argument provided to \string\pgfmathprintnumber@fixed@style}{}% % \fi %-------------------------------------------------- \let\pgfmathprintnumber@fixed@styleDEFAULT@impl@noperiod@NEXT=\relax \fi \pgfmathprintnumber@fixed@styleDEFAULT@impl@noperiod@NEXT } % \pgfmathprintnumber@thousand@sep@in@fractional 01234525MMMM\@@ % -> % 01234525 \def\pgfmathprintnumber@thousand@sep@in@fractional#1#2#3#4{% \if#4M% % Ok, no further separator \def\pgfmathprint@next{\pgfmathprintnumber@thousand@sep@in@fractional@finish#1#2#3#4}% \else \begingroup \toks0=\expandafter{\pgfmathresultfractional}% \toks1={#1#2#3}% \toks2=\expandafter{\pgfmathprintnumber@fixed@styleDEFAULT@THOUSAND@SEP}% \xdef\pgfmathfloat@glob@TMP{\the\toks0 \the\toks1 \the\toks2 }% \endgroup \let\pgfmathresultfractional=\pgfmathfloat@glob@TMP \def\pgfmathprint@next{\pgfmathprintnumber@thousand@sep@in@fractional#4}% \fi \pgfmathprint@next }% \def\pgfmathprintnumber@thousand@sep@in@fractional@finish#1M{% \expandafter\def\expandafter\pgfmathresultfractional\expandafter{\pgfmathresultfractional #1}% \pgfmathprintnumber@thousand@sep@in@fractional@finish@ }% \def\pgfmathprintnumber@thousand@sep@in@fractional@finish@#1\@@{}% \def\pgfmathprintnumber@fixed@styleDEFAULT@impl@noperiod@printall#1{% \def\pgfmathfloat@loc@TMPb{#1}% \let\pgfmathfloat@loc@TMPc=\pgfutil@empty \ifx\pgfmathfloat@loc@TMPb\pgfmathfloatparsenumber@tok@MINUS \else \ifx\pgfmathfloat@loc@TMPb\pgfmathfloatparsenumber@tok@PLUS \else \ifpgfmathprintnumber@showpositive \def\pgfmathfloat@loc@TMPc{+}% \fi \fi \fi \expandafter\pgfmathprintnumber@fixed@styleDEFAULT@impl@noperiod@printall@\pgfmathfloat@loc@TMPc#1% } \def\pgfmathprintnumber@fixed@styleDEFAULT@impl@noperiod@printall@#1\pgfmathfloat@EOI\pgfmathfloat@EOI\pgfmathfloat@EOI{% \expandafter\def\expandafter\pgfmathresult\expandafter{\pgfmathresult #1}% }% % @deprecated. It has been replaced by \pgfmathprintnumber@fixed@styleDEFAULT % #1 maybe a macro \def\pgfmathprintnumber@fixed@stylePERIOD#1#2#3e#4\relax{% \def\pgfmathresult{#1}% } % @deprecated. It has been replaced by \pgfmathprintnumber@fixed@styleDEFAULT % #1 maybe a macro \def\pgfmathprintnumber@fixed@styleCOMMA#1#2#3e#4\relax{% \ifpgfmathfloatroundhasperiod \expandafter\pgfmathprintnumber@fixed@styleCOMMA@impl#1\pgfmathfloat@EOI \else \def\pgfmathresult{#1}% \fi } \def\pgfmathprintnumber@fixed@styleCOMMA@impl#1.#2\pgfmathfloat@EOI{\def\pgfmathresult{#1{,}#2}} % The default style to display fixed point numbers. % % It does not apply numerics, but it is responsible for typesetting the % rounded number. % It can access the \ifpgfmathfloatroundhasperiod boolean. % % Arguments: % #1#2#3e#4\relax % Input: % #1 the fixed point number to be displayed (maybe a macro). % #2#3e#4: the (possibly unformatted) floating point representation % which belongs to #1. This format is returned (only!) by % \pgfmathfloat@to@FMeE@style. % It is used to determine sign and exponent. \let\pgfmathprintnumber@fixed@style=\pgfmathprintnumber@fixed@styleDEFAULT % Rounds a normalized floating point number to \pgfmathfloat@round@precision % digits precision and writes the result to \pgfmathresult. % % This method uses \pgfmathroundto for the mantissa. % % @see pgfmathfloatroundzerofill % % SIDE EFFECT: the global variable \ifpgfmathfloatroundhasperiod will be set to % whether the final mantissa #5 has a period or not. \def\pgfmathfloatround#1{% \pgfmathfloatroundhasperiodtrue \begingroup \pgfmathfloat@fixed@digits@after@periodfalse \expandafter\pgfmathfloat@decompose@tok#1\relax\pgfmathfloat@a@S\pgfmathfloat@a@Mtok\pgfmathfloat@a@E \pgfmathfloatround@impl \pgfmath@smuggleone\pgfmathresult \endgroup } % Overload. % % This method uses a fixed width for the mantissa and fills in zeros % if necessary. % % This method uses \pgfmathroundtozerofill for the mantissa. % % SIDE EFFECT: the global variable \ifpgfmathfloatroundhasperiod will be set to % whether the final mantissa #5 has a period or not. \def\pgfmathfloatroundzerofill#1{% \pgfmathfloatroundhasperiodtrue \begingroup \pgfmathfloat@fixed@digits@after@periodtrue \expandafter\pgfmathfloat@decompose@tok#1\relax\pgfmathfloat@a@S\pgfmathfloat@a@Mtok\pgfmathfloat@a@E \pgfmathfloatround@impl \pgfmath@smuggleone\pgfmathresult \endgroup } \newif\ifpgfmathfloatround@allow@empty@mantissa \def\pgfmathfloatround@mantissa@ONE{1pt }% % #1: sign % #2: mantissa % #3: exponent % #4: CODE to display if the mantissa is drawn. % This code will be shown just before the exponent. % Example: #4=\cdot % #5: CODE to display if the mantissa is NOT draw. (unused currently) % Might be used to display '10^1' instead of '1*10^1'. % #6: CODE to display the exponent. \def\pgfmathfloatrounddisplaystyle@shared@impl#1#2e#3\relax#4#5#6{% \pgfkeysgetvalue{/pgf/number format/@sci exponent mark}\pgfmathfloatrounddisplaystyle@e@mark \ifcase#1\relax \pgfmathprintnumber@fixed@style{#2}#1#2e0\relax% \expandafter\pgfmathfloatrounddisplaystyle@shared@impl@\expandafter{\pgfmathresult}{#4#6}% \or \def\pgfmathfloat@loc@TMPa{1}% "should draw mantissa=1" \ifpgfmathfloatround@allow@empty@mantissa \else \ifdim#2pt=\pgfmathfloatround@mantissa@ONE \def\pgfmathfloat@loc@TMPa{0}% do not draw it. \fi \fi % \if1\pgfmathfloat@loc@TMPa \pgfmathprintnumber@fixed@style{#2}#1#2e0\relax% \expandafter\pgfmathfloatrounddisplaystyle@shared@impl@\expandafter{\pgfmathresult}{#4#6}% \else \def\pgfmathfloat@loc@TMPa{0}% \pgfmathfloatrounddisplaystyle@shared@impl@{#5}{#6}% \fi \or \def\pgfmathfloat@loc@TMPa{1}% "should draw mantissa=1" \ifpgfmathfloatround@allow@empty@mantissa \else \ifdim#2pt=\pgfmathfloatround@mantissa@ONE \def\pgfmathfloat@loc@TMPa{0}% do not draw it. \fi \fi % \if1\pgfmathfloat@loc@TMPa \pgfmathprintnumber@fixed@style{-#2}#1#2e0\relax% \expandafter\pgfmathfloatrounddisplaystyle@shared@impl@\expandafter{\pgfmathresult}{#4#6}% \else \def\pgfmathfloat@loc@TMPa{0}% \pgfmathfloatrounddisplaystyle@shared@impl@{-#5}{#6}% \fi \or \pgfmathfloatrounddisplaystyle@shared@impl@@{\hbox{NaN}}{}% \or \ifpgfmathprintnumber@showpositive \pgfmathfloatrounddisplaystyle@shared@impl@@{+\infty}{}% \else \pgfmathfloatrounddisplaystyle@shared@impl@@{\infty}{}% \fi \or \pgfmathfloatrounddisplaystyle@shared@impl@@{-\infty}{}% \fi } % #1: the part before the exponent code % #2: the part for the exponent code. \def\pgfmathfloatrounddisplaystyle@shared@impl@#1#2{% \pgfmathprintnumber@begingroup \toks0={#1}% \toks1=\expandafter{\pgfmathfloatrounddisplaystyle@e@mark #2}% \xdef\pgfmathfloat@glob@TMP{\the\toks0 \the\toks1 }% \pgfmathprintnumber@endgroup \let\pgfmathresult=\pgfmathfloat@glob@TMP }% % Same as \pgfmathfloatrounddisplaystyle@shared@impl@, but it also % inserts the '@dec sep mark' at the end. \def\pgfmathfloatrounddisplaystyle@shared@impl@@#1#2{% \pgfmathprintnumber@begingroup \toks0={#1}% \toks1=\expandafter{\pgfmathfloatrounddisplaystyle@e@mark #2}% \pgfkeysgetvalue{/pgf/number format/@dec sep mark}\pgfmathprintnumber@fixed@styleDEFAULT@DEC@SEP@MARK \toks2=\expandafter{\pgfmathprintnumber@fixed@styleDEFAULT@DEC@SEP@MARK}% \xdef\pgfmathfloat@glob@TMP{\the\toks0 \the\toks1 \the\toks2 }% \pgfmathprintnumber@endgroup \let\pgfmathresult=\pgfmathfloat@glob@TMP } \def\pgfmathfloatrounddisplaystyle@std#1#2e#3\relax{% \pgfmathfloatrounddisplaystyle@shared@impl#1#2e#3\relax{\cdot}{}{10^{#3}}% } \def\pgfmathfloatrounddisplaystyle@subscript#1#2e#3\relax{% \pgfmathfloatrounddisplaystyle@shared@impl#1#2e#3\relax{}{1}{_{#3}}% } \def\pgfmathfloatrounddisplaystyle@superscript#1#2e#3\relax{% \pgfmathfloatrounddisplaystyle@shared@impl#1#2e#3\relax{}{1}{^{#3}}% } \def\pgfmathfloatrounddisplaystyle@e#1#2e#3\relax{% \ifnum#3<0\relax \pgfmathprintnumber@begingroup \count0=#3\relax \multiply\count0 by-1 \xdef\pgfmathfloat@glob@TMP{e{-}\the\count0}% \pgfmathprintnumber@endgroup% \let\pgfmathresult=\pgfmathfloat@glob@TMP \else \def\pgfmathresult{e{+}#3}% \fi \def\pgfmathfloat@loc@TMPb{\pgfmathfloatrounddisplaystyle@shared@impl#1#2e#3\relax{}{1}}% \expandafter\pgfmathfloat@loc@TMPb\expandafter{\pgfmathresult}% } \def\pgfmathfloatrounddisplaystyle@E#1#2e#3\relax{% \ifnum#3<0\relax \pgfmathprintnumber@begingroup \count0=#3\relax \multiply\count0 by-1 \xdef\pgfmathfloat@glob@TMP{E{-}\the\count0}% \pgfmathprintnumber@endgroup% \let\pgfmathresult=\pgfmathfloat@glob@TMP \else \def\pgfmathresult{E{+}#3}% \fi \def\pgfmathfloat@loc@TMPb{\pgfmathfloatrounddisplaystyle@shared@impl#1#2e#3\relax{}{1}}% \expandafter\pgfmathfloat@loc@TMPb\expandafter{\pgfmathresult}% } \def\pgfmathfloatrounddisplaystyle@generic#1#2e#3\relax{% \begingroup \pgfkeysvalueof {/pgf/number format/sci generic/@/.@cmd}{#3}{#1}{#2}\pgfeov \pgfkeysgetvalue{/pgf/number format/sci generic/mantissa sep}\pgfmathdisplay@aftermantissa \pgfkeysgetvalue{/pgf/number format/sci generic/empty mantissa sep}\pgfmathdisplay@nomantissa \pgfkeysgetvalue{/pgf/number format/sci generic/exponent}\pgfmathdisplay@e \toks0=\expandafter{\pgfmathdisplay@aftermantissa}% \toks1=\expandafter{\pgfmathdisplay@nomantissa}% \toks2=\expandafter{\pgfmathdisplay@e}% \xdef\pgfmathfloat@glob@TMP{\noexpand\pgfmathfloatrounddisplaystyle@shared@impl#1#2e#3\noexpand\relax{\the\toks0}{\the\toks1}{\the\toks2}}% \endgroup \pgfmathfloat@glob@TMP } % A macro which takes the argument 'e' and % expands to the final TeX-representation for that floating point % number. % % PRECONDITION: % the floating point number has already been rounded properly and % the mantissa has been rounded correctly. % % The argument needs to be in the format returned by % \pgfmathfloat@to@FMeE@style and terminated by '\relax'. \let\pgfmathfloatrounddisplaystyle=\pgfmathfloatrounddisplaystyle@std \newif\ifpgfmathfloat@usezerofill@sci \newif\ifpgfmathfloat@usezerofill@fixed \newif\ifpgfmathprintnumber@assumemathmode \newif\ifpgfmathprintnumber@showpositive \newif\ifpgfmathprintnumber@frac@warn \newif\ifpgfmathprintnumber@frac@whole \newif\ifpgfmathparsenumber@comma@as@period \long\def\pgfmathfloatfrac@verbatim#1#2{#1/#2}% \let\pgfmathround@@orig=\pgfmathround@ % 2 = compatible % 0 = no % 1 = yes \def\pgfmathprintnumber@RELATIVE@choice@roundtofixed{2}% \newif\ifpgfmathprintnumber@thousand@sep@in@fractional \pgfkeys{% /pgf/number format/.is family, /pgf/number format, fixed/.code= \pgfmath@set@number@printer{pgfmathprintnumber@FIXED}, sci/.code= \pgfmath@set@number@printer{pgfmathprintnumber@SCI}, std/.code= {\pgfmath@set@number@printer{pgfmathprintnumber@STD}\pgfmathprintnumber@STD@setparam{#1}}, std/.default=,% relative round mode/.is choice, relative round mode/fixed/.code={\def\pgfmathprintnumber@RELATIVE@choice@roundtofixed{1}}, relative round mode/mantissa/.code={\def\pgfmathprintnumber@RELATIVE@choice@roundtofixed{0}}, relative round mode/compatible/.code={\def\pgfmathprintnumber@RELATIVE@choice@roundtofixed{2}}, % relative={} relative/.code={% \pgfmath@set@number@printer{pgfmathprintnumber@RELATIVE}% \pgfmathround@@orig{#1}% \expandafter\pgfmathfloattoint@@\pgfmathresult\relax \let\pgfmathprintnumber@RELATIVE@param=\pgfmathresult },% relative/.value required, relative*/.style={/pgf/number format/relative={#1},/pgf/number format/relative round mode=fixed}, every relative/.style=std, relative style/.style={/pgf/number format/every relative/.append style={#1}}, fixed relative/.code= \pgfmath@set@number@printer{pgfmathprintnumber@FIXED@RELATIVE}, int detect/.code= \pgfmath@set@number@printer{pgfmathprintnumber@INT@DETECT}, int trunc/.code= \pgfmath@set@number@printer{pgfmathprintnumber@INT@TRUNC}, frac/.code= \pgfmath@set@number@printer{pgfmathprintnumber@frac},% frac TeX/.initial=\frac, frac whole format/.code={\def\pgfmathresult{#1}}, frac denom/.initial=, frac whole/.is if=pgfmathprintnumber@frac@whole, frac whole=true, frac shift/.initial=4, frac warning/.is if=pgfmathprintnumber@frac@warn, frac warning=true, assume math mode/.is if=pgfmathprintnumber@assumemathmode, assume math mode/.default=true, fixed zerofill/.is if= pgfmathfloat@usezerofill@fixed, fixed zerofill/.default=true, sci zerofill/.is if= pgfmathfloat@usezerofill@sci, sci zerofill/.default=true, zerofill/.style= {/pgf/number format/fixed zerofill=#1,/pgf/number format/sci zerofill=#1}, zerofill/.default= true, precision/.store in= \pgfmathfloat@round@precision, sci precision/.code={% \edef\pgfmathfloat@loc@TMPa{#1}% \ifx\pgfmathfloat@loc@TMPa\pgfutil@empty \def\pgfmathprintnumber@sci@precision{\pgfmathfloat@round@precision}% \else \let\pgfmathprintnumber@sci@precision=\pgfmathfloat@loc@TMPa \fi },% sci precision/.default=, sci precision=, fixed default/.code= {\let\pgfmathprintnumber@fixed@style=\pgfmathprintnumber@fixed@styleDEFAULT}, set decimal separator/.initial=, dec sep/.style={/pgf/number format/set decimal separator={#1}}, @dec sep mark/.initial=, @sci exponent mark/.initial=, set thousands separator/.initial=, 1000 sep in fractionals/.is if=pgfmathprintnumber@thousand@sep@in@fractional, 1000 sep in fractionals/.default=true, 1000 sep/.style={/pgf/number format/set thousands separator={#1}}, min exponent for 1000 sep/.initial=0, use period/.style= {/pgf/number format/set decimal separator={.},/pgf/number format/set thousands separator={{{,}}}}, use comma/.style= {/pgf/number format/set decimal separator={{{,}}},/pgf/number format/set thousands separator={.}}, showpos/.is if=pgfmathprintnumber@showpositive, showpos/.default=true, print sign/.is if=pgfmathprintnumber@showpositive, print sign/.default=true, read comma as period/.is if=pgfmathparsenumber@comma@as@period, read comma as period/.default=true, skip 0./.is if=pgfmathprintnumberskipzeroperiod, skip 0./.default=true, skip 0.= false, use period, sci 10^e/.code= {\let\pgfmathfloatrounddisplaystyle=\pgfmathfloatrounddisplaystyle@std}, sci 10e/.code= {\let\pgfmathfloatrounddisplaystyle=\pgfmathfloatrounddisplaystyle@std}, sci e/.code= {\let\pgfmathfloatrounddisplaystyle=\pgfmathfloatrounddisplaystyle@e}, sci E/.code= {\let\pgfmathfloatrounddisplaystyle=\pgfmathfloatrounddisplaystyle@E}, sci subscript/.code= {\let\pgfmathfloatrounddisplaystyle=\pgfmathfloatrounddisplaystyle@subscript}, sci superscript/.code= {\let\pgfmathfloatrounddisplaystyle=\pgfmathfloatrounddisplaystyle@superscript}, sci generic/.code= {% \let\pgfmathfloatrounddisplaystyle=\pgfmathfloatrounddisplaystyle@generic \pgfkeysdefargs{/pgf/number format/sci generic/@}% {##1##2##3}% {\pgfqkeys{/pgf/number format/sci generic}{#1}}% }, sci generic/mantissa sep/.initial=,% sci generic/empty mantissa sep/.initial=,% sci generic/mantisse sep/.style={/pgf/number format/sci generic/mantissa sep={#1}},% sci generic/empty mantisse sep/.style={/pgf/number format/sci generic/empty mantissa sep={#1}},% sci generic/exponent/.initial=,% sci generic/.value required, verbatim/.code={% \pgfqkeys{/pgf/number format}{% sci generic={mantissa sep=,exponent={e##1}}, 1000 sep=, skip 0.=false, print sign=false, dec sep=., assume math mode, frac TeX=\pgfmathfloatfrac@verbatim, frac whole format/.code={\def\pgfmathresult{##1 }}, @dec sep mark=, @sci exponent mark=, }% }, retain unit mantissa/.is if=pgfmathfloatround@allow@empty@mantissa, retain unit mantissa/.default=true, retain unit mantissa=true, % % allows to replace the implementation, for example % 'implementation=\num'. This is experimental -- it is unclear % if all consumers work well since they rely on the keys in % /pgf/number format. implementation/.code={\def\pgfmathprintnumber@protected{#1}}, } \def\pgfmathprintnumber@STD#1{% % parse the input: \pgfmathfloatparsenumber{#1}% \pgfmathfloat@to@FMeE@style\pgfmathresult \expandafter\pgfmathprintnumber@STD@issci\pgfmathresult\relax } \def\pgfmathprintnumber@STD@setparam#1{% \edef\pgfmathfloat@loc@TMPb{#1}% \ifx\pgfmathfloat@loc@TMPb\pgfutil@empty % DEFAULT for lower and upper bound. \def\pgfmathprintnumber@STD@getlowerbound{% \c@pgf@counta=\pgfmathfloat@round@precision@orig\relax \divide\c@pgf@counta by-2\relax }% \def\pgfmathprintnumber@STD@upperbound{4}% \else \expandafter\pgfutil@in@\expandafter:\expandafter{\pgfmathfloat@loc@TMPb}% \ifpgfutil@in@ % we have -4:5 or something like that. % parse both values: \def\pgfmathfloat@loc@TMPa##1:##2\relax{% \edef\pgfmathprintnumber@STD@getlowerbound{% \noexpand\c@pgf@counta=##1\space }% \edef\pgfmathprintnumber@STD@upperbound{##2}% }% \expandafter\pgfmathfloat@loc@TMPa\pgfmathfloat@loc@TMPb\relax \else % we have just the lower bound: \def\pgfmathprintnumber@STD@upperbound{4}% \edef\pgfmathprintnumber@STD@getlowerbound{% \noexpand\c@pgf@counta=\pgfmathfloat@loc@TMPb\space }% \fi \fi }% \def\pgfmathprintnumber@STD@issci#1#2e#3\relax{% \expandafter\ifnum#1<3 \expandafter\ifnum#3>\pgfmathprintnumber@STD@upperbound\relax \pgfmathprintnumber@SCI@issci#1#2e#3\relax% \else \begingroup \pgfmathprintnumber@STD@getlowerbound \ifnum#3<\c@pgf@counta \pgfmathprintnumber@SCI@issci#1#2e#3\relax% \else \pgfmathprintnumber@FIXED@issci#1#2e#3\relax% \fi \pgfmath@smuggleone\pgfmathresult \endgroup \fi \else% nan or inf: \pgfmathfloatrounddisplaystyle#1#2e#3\relax% \fi } \def\pgfmathprintnumber@RELATIVE#1{% % parse the input: \pgfmathfloatparsenumber{#1}% \pgfmathfloat@to@FMeE@style\pgfmathresult \expandafter\pgfmathprintnumber@RELATIVE@issci\pgfmathresult\relax } \def\pgfmathprintnumber@RELATIVE@choice@roundtofixed@warn{% \pgf@typeout{! Package pgf warning: the use of /pgf/number format/relative is discouraged (buggy). Please use 'relative*' instead or type \string\pgfkeys{/pgf/number format/relative round mode=fixed} into your preamble.}% \global\let\pgfmathprintnumber@RELATIVE@choice@roundtofixed@warn=\relax } \def\pgfmathprintnumber@RELATIVE@issci#1#2e#3\relax{% \begingroup % format X / 10^{relative}: \c@pgf@counta=#3\relax \advance\c@pgf@counta by-\pgfmathprintnumber@RELATIVE@param\relax \pgfmathfloatcreate{#1}{#2}{\the\c@pgf@counta}% % OK, round it to the desired precision: \if0\pgfmathprintnumber@RELATIVE@choice@roundtofixed % relative round mode=mantissa \def\b@round@fixed{0}% \else \if1\pgfmathprintnumber@RELATIVE@choice@roundtofixed % relative round mode=fixed \def\b@round@fixed{1}% \else \pgfmathprintnumber@RELATIVE@choice@roundtofixed@warn % relative round mode=compatible \ifnum\c@pgf@counta>0 % hm. for positive exponents, we should round the % mantissa rather than only the fractional part. \def\b@round@fixed{0}% \else % negative exponent -> round fixed representation: \def\b@round@fixed{1}% \fi \fi \fi \if1\b@round@fixed % round fixed representation: \pgfmathfloattofixed\pgfmathresult \expandafter\pgfmathroundto\expandafter{\pgfmathresult}% \pgfmathfloatparsenumber{\pgfmathresult}% \pgfmathfloatroundhasperiodtrue% make sure the code below works: \else % round the mantissa: \expandafter\pgfmathfloatround\expandafter{\pgfmathresult}% \fi % Now, compute result * 10^{relative} and format the result: \pgfmathfloattoregisterstok\pgfmathresult\pgfmathfloat@a@S\pgfmathfloat@a@Mtok\pgfmathfloat@a@E \ifnum\pgfmathfloat@a@S=0 \pgfmathfloat@a@E=\pgfmathfloat@a@S % avoid 0 * 10^8 \else \advance\pgfmathfloat@a@E by+\pgfmathprintnumber@RELATIVE@param\relax \fi \edef\pgfmathresultX{% \the\pgfmathfloat@a@S \the\pgfmathfloat@a@Mtok \ifpgfmathfloatroundhasperiod\else.0\fi e\the\pgfmathfloat@a@E}% % call another formatter for the result (but avoid rounding inside of it): \pgfqkeys{/pgf/number format}{/pgf/number format/every relative, fixed zerofill=false,% useless here! sci zerofill=false}% \ifx\pgfmathprintnumber@issci\pgfmathprintnumber@RELATIVE@issci \pgfmath@error{The '/pgf/number format/every relative' style should set a valid display style}{}% \fi \let\pgfmathfloat@round@precision@orig=\pgfmathfloat@round@precision \def\pgfmathfloat@round@precision{9999}% \expandafter\pgfmathprintnumber@issci\pgfmathresultX\relax% \pgfmath@smuggleone\pgfmathresult \endgroup } \def\pgfmathprintnumber@FIXED@RELATIVE#1{% % parse the input: \pgfmathfloatparsenumber{#1}% \pgfmathfloat@to@FMeE@style\pgfmathresult \expandafter\pgfmathprintnumber@FIXED@RELATIVE@issci\pgfmathresult\relax } \def\pgfmathprintnumber@FIXED@RELATIVE@issci#1#2e#3\relax{% \begingroup \pgfmathfloatcreate{#1}{#2}{#3}% % we want the first digits - not the first % +1 digits: \c@pgf@counta=\pgfmathfloat@round@precision\relax \advance\c@pgf@counta by-1 \edef\pgfmathfloat@round@precision{\the\c@pgf@counta}% \pgfmathfloatround{\pgfmathresult}% \pgfmathfloattoregisterstok\pgfmathresult\pgfmathfloat@a@S\pgfmathfloat@a@Mtok\pgfmathfloat@a@E \ifnum\pgfmathfloat@a@S=0 \pgfmathfloat@a@E=\pgfmathfloat@a@S % avoid 0 * 10^8 \fi \edef\pgfmathresultX{% \the\pgfmathfloat@a@S \the\pgfmathfloat@a@Mtok \ifpgfmathfloatroundhasperiod\else.0\fi e\the\pgfmathfloat@a@E}% \let\pgfmathfloat@round@precision@orig=\pgfmathfloat@round@precision \pgfmathfloat@usezerofill@fixedfalse \def\pgfmathfloat@round@precision{9999}% typeset all remaining digits! \expandafter\pgfmathprintnumber@FIXED@issci\pgfmathresultX\relax% \pgfmath@smuggleone\pgfmathresult \endgroup } \def\pgfmathprintnumber@frac#1{% % parse the input: \pgfmathfloatparsenumber{#1}% \pgfmathfloatgetfrac{\pgfmathresult}% \expandafter\pgfmathprintnumber@frac@formatresult\pgfmathresult } \def\pgfmathprintnumber@frac@issci#1#2e#3\relax{% \pgfmathfloatcreate{#1}{#2}{#3}% \pgfmathfloatgetfrac{\pgfmathresult}% \expandafter\pgfmathprintnumber@frac@formatresult\pgfmathresult } \def\pgfmathprintnumber@frac@formatresult#1#2#3{% \begingroup \pgfkeysgetvalue{/pgf/number format/frac TeX}\pgfmathresult \toks0=\expandafter{\pgfmathresult}% \def\pgfmathfloat@loc@TMPa{#1}% \ifx\pgfmathfloat@loc@TMPa\pgfutil@empty \ifpgfmathprintnumber@showpositive \def\pgfmathfloat@loc@TMPa{+}% \fi \else \ifx\pgfmathfloat@loc@TMPa-% \else \ifx\pgfmathfloat@loc@TMPa+% \else \ifpgfmathprintnumber@showpositive \edef\pgfmathfloat@loc@TMPa{+\pgfmathfloat@loc@TMPa}% \fi \def\pgfmathfloat@loc@TMPb{\pgfkeysvalueof{/pgf/number format/frac whole format/.@cmd}}% \expandafter\pgfmathfloat@loc@TMPb\pgfmathfloat@loc@TMPa\pgfeov \let\pgfmathfloat@loc@TMPa=\pgfmathresult \fi \fi \fi \toks1=\expandafter{\pgfmathfloat@loc@TMPa}% \edef\pgfmathresult{% \the\toks1 \ifnum#2=0 \else\the\toks0 {#2}{#3}\fi% }% \pgfmath@smuggleone\pgfmathresult \endgroup }% % Defines \pgfmathresult to contain three sets of braces containing % the sign (optionally containing any components >1), the numerator and the denominator for #1. % % \pgfmathfloatgetfrac{0.5} -> \pgfmathresult contains {}{1}{2} % \pgfmathfloatgetfrac{-0.5} -> \pgfmathresult contains {-}{1}{2} % \pgfmathfloatgetfrac{1.5} -> \pgfmathresult contains {1}{1}{2} % % special cases: % \pgfmathfloatgetfrac{0} -> \pgfmathresult contains {0}{0}{1} % \pgfmathfloatgetfrac{1} -> \pgfmathresult contains {1}{0}{1} % % The numerator and denominator is always a number (not empty) \def\pgfmathfloatgetfrac#1{% \pgfutil@ifundefined{pgfmathfloatmultiply@}{% \pgfmath@error{Sorry, the number format 'frac' requires '\string\usetikzlibrary{fpu}' (and, optionally, \string\usepackage{fp}) in order to work correctly}{}% \edef\pgfmathresult{{#1}{0}{1}}% }{% \pgfmathfloatgetfrac@{#1}% }% }% \def\pgfmathfloatgetfrac@#1{% \begingroup \edef\pgfmathfloat@arg{#1}% \expandafter\pgfmathfloat@decompose@tok\pgfmathfloat@arg\relax\pgfmathfloat@a@S\pgfmathfloat@a@Mtok\pgfmathfloat@a@E \def\pgfmathfloat@loc@TMPa{0}% \ifcase\pgfmathfloat@a@S % #1 = 0: \def\pgfmathresult{{0}{0}{1}}% \or% #1 > 0 \pgfmathfloat@a@S=1 \def\pgfmathfloat@loc@TMPa{1}% \or% #1 < 0 \pgfmathfloat@a@S=-1 \def\pgfmathfloat@loc@TMPa{1}% \or \edef\pgfmathresult{{}{NaN}{1}}% \or \edef\pgfmathresult{{}{\infty}{1}}% \or \edef\pgfmathresult{{-}{\infty}{1}}% \fi \if1\pgfmathfloat@loc@TMPa \ifnum\pgfmathfloat@a@E<0 \def\pgfmathfloat@wholenumber{}% \else \pgfmathfloatcreate{1}{\the\pgfmathfloat@a@Mtok}{\the\pgfmathfloat@a@E}% \pgfmathfloattofixed\pgfmathresult% \def\pgfmathfloat@loc@TMPa##1.##2\relax{% \def\pgfmathfloat@wholenumber{##1}% \pgfmathfloatparsenumber{0.##2}% }% \expandafter\pgfmathfloat@loc@TMPa\pgfmathresult\relax \expandafter\pgfmathfloat@decompose@tok\pgfmathresult\relax\pgfmathfloat@b@S\pgfmathfloat@a@Mtok\pgfmathfloat@a@E \fi % \def\pgfmathfloat@loc@TMPa##1.##2\relax{% \def\pgfmathfloat@mantissa@first{##1}% \def\pgfmathfloat@mantissa@ltone{0.##2}% }% \expandafter\pgfmathfloat@loc@TMPa\the\pgfmathfloat@a@Mtok\relax % \def\pgfmathfloat@loc@@to@int##1.##2\relax##3{% ##3=##1 \ifdim0.##2pt>0.5pt \advance##3 by1 \fi }% % % alias registers names: \let\pgfmathresultnumerator=\pgfmathfloat@b@S \let\pgfmathresultdenom=\pgfmathfloat@b@E % \pgfkeysgetvalue{/pgf/number format/frac denom}\pgfmath@target@denominator \ifx\pgfmath@target@denominator\pgfutil@empty % \pgfmathfloat@a@E=-\pgfmathfloat@a@E \ifdim\pgfmathfloat@mantissa@ltone pt=0pt \def\pgfmathfloat@factor{1}% \edef\pgfmathfloat@scaled@numerator{\the\pgfmathfloat@a@Mtok}% \else % FIXME : this here is numerically instable. % % The errors of 1/r are magnified by 10^k which % doesn't work. \pgfutil@ifundefined{FPdiv}{% \pgfmathfloatparsenumber{\pgfmathfloat@mantissa@ltone}% \pgfmathfloatreciprocal@{\pgfmathresult}% }{% % \usepackage{fp}. % yields higher absolute precision. \FPmessagesfalse% \FPdebugfalse% \FPdiv\pgfmathresult{1}{\pgfmathfloat@mantissa@ltone}% \pgfmathfloatparsenumber{\pgfmathresult}% }% \let\pgfmathfloat@inv=\pgfmathresult \pgfmathfloatcreate{1}{1.0}{\pgfkeysvalueof{/pgf/number format/frac shift}}% \let\pgfmathfloat@scalebaseten=\pgfmathresult \pgfmathfloatmultiply@{\pgfmathfloat@inv}{\pgfmathfloat@scalebaseten}% \let\pgfmathfloat@factor=\pgfmathresult % \expandafter\pgfmathfloatparsenumber\expandafter{\the\pgfmathfloat@a@Mtok}% \let\pgfmathfloat@loc@TMPa=\pgfmathresult \pgfmathfloatmultiply@{\pgfmathfloat@factor}{\pgfmathfloat@loc@TMPa}% \pgfmathfloattofixed\pgfmathresult \let\pgfmathfloat@scaled@numerator=\pgfmathresult % \pgfmathfloattofixed\pgfmathfloat@factor \expandafter\pgfmathfloat@loc@@to@int\pgfmathresult\relax{\pgfmathfloat@b@S}% \edef\pgfmathfloat@factor{\the\pgfmathfloat@b@S}% \fi % % \pgfmathresultdenom=\pgfmathfloat@factor\relax \pgfmathfloat@multiply@ten@to@the@E\pgfmathresultdenom % \expandafter\pgfmathfloat@loc@@to@int\pgfmathfloat@scaled@numerator\relax{\pgfmathresultnumerator}% %\message{scale = \pgfmathfloat@factor; Z = \the\pgfmathresultnumerator\space ( von \pgfmathfloat@scaled@numerator), N = \the\pgfmathresultdenom.}% % \pgfmathgreatestcommondivisor{\pgfmathresultnumerator}{\pgfmathresultdenom}% \divide\pgfmathresultnumerator by\pgfmathresult\relax \divide\pgfmathresultdenom by\pgfmathresult\relax \ifpgfmathprintnumber@frac@warn \ifnum\pgfmathresultdenom>1000 \pgfutil@ifundefined{FPdiv}{% \pgfmathfloattosci@\pgfmathfloat@arg \pgf@typeout{! Package pgf /pgf/number format/frac warning=true: /pgf/number format/frac of `\pgfmathresult' = \the\pgfmathresultnumerator\space / \the\pgfmathresultdenom\space might be large due to instabilities. Try \string\usepackage{fp} to improve accuracy.}% }{}% \fi \fi \else % use target denominator: \pgfmathresultdenom=\pgfmath@target@denominator\relax \pgfmathfloatcreate{1}{\the\pgfmathfloat@a@Mtok}{\the\pgfmathfloat@a@E}% \pgfmathfloattofixed\pgfmathresult \pgf@xa=\pgfmathresult pt \multiply\pgf@xa by\pgfmathresultdenom \edef\pgfmathfloat@scaled@numerator{\pgfmath@tonumber\pgf@xa}% \expandafter\pgfmathfloat@loc@@to@int\pgfmathfloat@scaled@numerator\relax{\pgfmathresultnumerator}% \fi \ifpgfmathprintnumber@frac@whole \else \ifx\pgfmathfloat@wholenumber\pgfutil@empty \else \count0=\pgfmathfloat@wholenumber\relax \multiply\count0 by\pgfmathresultdenom \advance\pgfmathresultnumerator by\count0 \def\pgfmathfloat@wholenumber{}% \fi \fi \ifnum\pgfmathfloat@a@S<0 \edef\pgfmathresult{{-\pgfmathfloat@wholenumber}{\the\pgfmathresultnumerator}{\the\pgfmathresultdenom}}% \else \edef\pgfmathresult{{\pgfmathfloat@wholenumber}{\the\pgfmathresultnumerator}{\the\pgfmathresultdenom}}% \fi \fi \pgfmath@smuggleone\pgfmathresult \endgroup }% \def\pgfmathfloat@gobble@until@relax#1\relax{} % computes the greatest common divisor of two integer numbers (in % integer arithmetics). \def\pgfmathgreatestcommondivisor#1#2{% \begingroup \count0=#1\relax \count1=#2\relax \ifnum\count0=0 \edef\pgfmathresult{\the\count1}% \else \pgfmathgreatestcommondivisor@loop \edef\pgfmathresult{\the\count0}% \fi \pgfmath@smuggleone\pgfmathresult \endgroup } \def\pgfmathgreatestcommondivisor@loop{% \ifnum\count1=0 \else \ifnum\count0>\count1 \advance\count0 by-\count1 \else \advance\count1 by-\count0 \fi \expandafter\pgfmathgreatestcommondivisor@loop \fi }% % multiplies a TeX register by 10^E where E is stored in the register % \pgfmathfloat@a@E (and it should be positive!)% % % #1 a TeX register \def\pgfmathfloat@multiply@ten@to@the@E#1{% \ifnum\pgfmathfloat@a@E>0 \multiply#1 by10 \advance\pgfmathfloat@a@E by-1 \def\pgfmathfloat@multiply@ten@to@the@E@next{\pgfmathfloat@multiply@ten@to@the@E{#1}}% \else \let\pgfmathfloat@multiply@ten@to@the@E@next=\relax% \fi \pgfmathfloat@multiply@ten@to@the@E@next }% \def\pgfmathprintnumber@INT@TRUNC#1{% \pgfmathfloatparsenumber{#1}% \pgfmathfloat@to@FMeE@style\pgfmathresult \expandafter\pgfmathprintnumber@INT@TRUNC@issci\pgfmathresult\relax } \def\pgfmathprintnumber@INT@TRUNC@impl#1.#2\relax#3#4e#5\relax{% \pgfmathfloatroundhasperiodfalse \pgfmathprintnumber@fixed@style{#1}#3#4e#5\relax% } \def\pgfmathprintnumber@INT@TRUNC@issci#1#2e#3\relax{% \ifnum#1<3\relax \pgfmathfloatcreate{#1}{#2}{#3}% \pgfmathfloattofixed{\pgfmathresult}% \expandafter\pgfmathprintnumber@INT@TRUNC@impl\pgfmathresult\relax#1#2e#3\relax \else \pgfmathfloatrounddisplaystyle#1#2e#3\relax% \fi } % Invokes '#2' if '#1' is actually an integer or '#3' if not. % % As a side-effect, \pgfretval will be set to the integer value if it % actually *is* an integer. Otherwise, \pgfretval will contain the % parsed floating point number. % % #1 a number constant (not necessarily a parsed float). \def\pgfmathifisint#1#2#3{% \gdef\pgfmathfloatisint@@{0}% \begingroup \pgfmathfloatparsenumber{#1}% \let\pgfretval\pgfmathresult \pgfmathfloat@to@FMeE@style\pgfmathresult \expandafter\pgfmathfloatisint@\pgfmathresult\relax \pgfmath@smuggleone\pgfretval \endgroup \if1\pgfmathfloatisint@@ #2\else #3\fi }% \def\pgfmathfloatisint@#1#2e#3\relax{% \ifnum#1<3\relax \pgfmathfloatcreate{#1}{#2}{#3}% \pgfmathfloattofixed{\pgfmathresult}% \def\pgfmathfloat@round@precision{6}% \expandafter\pgfmathroundto\expandafter{\pgfmathresult}% \ifpgfmathfloatroundhasperiod \else \let\pgfretval\pgfmathresult% \gdef\pgfmathfloatisint@@{1}% \fi \fi } \def\pgfmathprintnumber@INT@DETECT#1{% \pgfmathfloatparsenumber{#1}% \pgfmathfloat@to@FMeE@style\pgfmathresult \expandafter\pgfmathprintnumber@INT@DETECT@issci\pgfmathresult\relax } \def\pgfmathprintnumber@INT@DETECT@issci#1#2e#3\relax{% \begingroup \ifnum#1<3\relax \pgfmathfloatcreate{#1}{#2}{#3}% \pgfmathfloattofixed{\pgfmathresult}% \let\pgfmathfloat@round@precision@=\pgfmathfloat@round@precision \def\pgfmathfloat@round@precision{6}% \expandafter\pgfmathroundto\expandafter{\pgfmathresult}% \let\pgfmathfloat@round@precision=\pgfmathfloat@round@precision@ \ifpgfmathfloatroundhasperiod \pgfmathprintnumber@SCI@issci#1#2e#3\relax \else \expandafter\pgfmathprintnumber@fixed@style\expandafter{\pgfmathresult}#1#2e#3\relax \fi \else \pgfmathfloatrounddisplaystyle#1#2e#3\relax% \fi \pgfmath@smuggleone\pgfmathresult \endgroup } \def\pgfmathprintnumber@FIXED#1{% \pgfmathfloatparsenumber{#1}% \pgfmathfloat@to@FMeE@style\pgfmathresult \expandafter\pgfmathprintnumber@FIXED@issci\pgfmathresult\relax } \def\pgfmathprintnumber@FIXED@issci#1#2e#3\relax{% \begingroup \ifnum#1<3 \pgfmathfloatcreate{#1}{#2}{#3}% \pgfmathfloattofixed{\pgfmathresult}% \ifpgfmathfloat@usezerofill@fixed \expandafter\pgfmathroundtozerofill\expandafter{\pgfmathresult}% \else \expandafter\pgfmathroundto\expandafter{\pgfmathresult}% \fi \ifpgfmathfloatroundmayneedrenormalize \pgfmathfloat@a@E=#3\relax \advance\pgfmathfloat@a@E by1 \edef\pgfmathfloat@loc@TMPb{\noexpand\pgfmathprintnumber@fixed@style{\pgfmathresult}#1#2e\the\pgfmathfloat@a@E}% \pgfmathfloat@loc@TMPb\relax% \else \expandafter\pgfmathprintnumber@fixed@style\expandafter{\pgfmathresult}#1#2e#3\relax% \fi \else% nan or inf: \pgfmathfloatrounddisplaystyle#1#2e#3\relax% \fi \pgfmath@smuggleone\pgfmathresult \endgroup } \def\pgfmathprintnumber@SCI#1{% \pgfmathfloatparsenumber{#1}% \pgfmathfloat@to@FMeE@style\pgfmathresult \expandafter\pgfmathprintnumber@SCI@issci\pgfmathresult\relax } \def\pgfmathprintnumber@SCI@issci#1#2e#3\relax{% \begingroup \pgfmathfloatcreate{#1}{#2}{#3}% \edef\pgfmathfloat@round@precision{\pgfmathprintnumber@sci@precision}% \ifpgfmathfloat@usezerofill@sci \pgfmathfloatroundzerofill{\pgfmathresult}% \else \pgfmathfloatround{\pgfmathresult}% \fi \pgfmathfloat@to@FMeE@style\pgfmathresult \expandafter\pgfmathfloatrounddisplaystyle\pgfmathresult\relax \pgfmath@smuggleone\pgfmathresult \endgroup } % Prints argument #1 using the current pretty printer environment (all % variables in /pgf/number format). % % You may specify optional arguments with \pgfmathprintnumber[...]. \def\pgfmathprintnumber{% % \protect allows to supply \pgfmathprintnumber inside of latex % captions. The \csname yields \relax in case protect is undefined. \pgf@texdist@protect\pgfmathprintnumber@protected }% \def\pgfmathprintnumber@protected{% \pgfutil@ifnextchar[% {\pgfmathprintnumber@OPT}% {\pgfmathprintnumber@noopt}% } \def\pgfmathprintnumber@noopt#1{% \pgfmathprintnumber@{#1}% \ifpgfmathprintnumber@assumemathmode \pgfmathresult \else \pgfutilensuremath{\pgfmathresult}% \fi }% \def\pgfmathprintnumber@OPT[#1]#2{% \begingroup \pgfqkeys{/pgf/number format}{#1}% \pgfmathprintnumber@{#2}% \ifpgfmathprintnumber@assumemathmode \pgfmathresult \else \pgfutilensuremath{\pgfmathresult}% \fi \endgroup }% % As \pgfmathprintnumber, but it produces its output into the second % argument. \def\pgfmathprintnumberto{% \pgfutil@ifnextchar[% {\pgfmathprintnumberto@OPT}% {\pgfmathprintnumberto@noopt}% } \def\pgfmathprintnumberto@noopt#1#2{% \begingroup \pgfmathprintnumber@{#1}% \ifpgfmathprintnumber@assumemathmode \global\let\pgfmathfloat@glob@TMP=\pgfmathresult \else \toks0=\expandafter{\pgfmathresult}% \xdef\pgfmathfloat@glob@TMP{\noexpand\pgfutilensuremath{\the\toks0 }}% \fi \endgroup \let#2=\pgfmathfloat@glob@TMP }% \def\pgfmathprintnumberto@OPT[#1]#2#3{% \begingroup \pgfqkeys{/pgf/number format}{#1}% \pgfmathprintnumber@{#2}% \ifpgfmathprintnumber@assumemathmode \global\let\pgfmathfloat@glob@TMP=\pgfmathresult \else \toks0=\expandafter{\pgfmathresult}% \xdef\pgfmathfloat@glob@TMP{\noexpand\pgfutilensuremath{\the\toks0 }}% \fi \endgroup \let#3=\pgfmathfloat@glob@TMP }% % Changes the current number pretty printer to #1. % % #1 is the macro base name for the pretty print routine, without the % leading '\'. \def\pgfmath@set@number@printer#1{% \expandafter\let\expandafter\pgfmathprintnumber@\csname #1\endcsname \expandafter\let\expandafter\pgfmathprintnumber@issci\csname #1@issci\endcsname } \pgfkeys{/pgf/number format/std} %%%%%%%%%%%%%%%%%%%%%%%%%% % % IMPL % %%%%%%%%%%%%%%%%%%%%%%%%%% % equals only itself when compared with \ifx: \def\pgfmathfloat@EOI{\pgfmathfloat@EOI}% % Re-use counters internally. % % They are always grouped and only used inside of the rounding % routines. \let\c@pgfmathroundto@prec=\pgfmathfloat@b@S% ATTENTION: DOUBLE-USED REGISTERS! \let\c@pgfmathroundto@offsetbehindperiod=\pgfmathfloat@b@E \newcount\c@pgfmathroundto@lastzeros \newif\ifpgfmathround@impl@PREPERIOD@is@negative@zero % PRECONDITION: % \ifpgfmathfloatroundhasperiod=\iftrue holds outside of the current TeX group. % % POSTCONDITION: % \ifpgfmathfloatroundhasperiod will be set correctly AFTER the % current TeX group. % \ifpgfmathfloatroundmayneedrenormalize will be set globally \def\pgfmathroundto@impl#1{% \edef\pgfmathround@input{#1}% \global\pgfmathfloatroundmayneedrenormalizefalse \pgfmathfloat@tmptoks={}% \let\pgfmathround@next=\pgfutil@empty \let\pgfmathround@cur=\pgfutil@empty \let\pgfmathresult=\pgfutil@empty \expandafter\c@pgfmathroundto@prec\pgfmathfloat@round@precision\relax \c@pgfmathroundto@lastzeros=0 \c@pgfmathroundto@offsetbehindperiod=-1 % means: no period found so far \pgfmathround@impl@PREPERIOD@is@negative@zerotrue \expandafter\pgfmathroundto@impl@ITERATE@NODOT@firstcall\pgfmathround@input\pgfmathfloat@EOI } % \pgfmathroundto implementation in WORDS: % % coarse idea: % 1. collect all digits/sign BEFORE the first period in REVERSE order % 2. then, collect UP TO \prec digits after the period in REVERSE order % Steps 1. and 2. lead to the digit [sign] sequence % "x_{-p} x_{-p+1} ... x_{-2} x_{-1} '.' x_0 ... x_r" % where 'r' is the total number of digits. The integer 'p' denotes the % ACTUALLY collected number of digits behind the period. % % Let 'k' be the desired precision. % % Please note that pgfmathroundto rounds the mantissa, that means |abs(x)|. % % There are exactly TWO cases: % 1. The case with p<=k and x_{-p-1} = end of input. % 2. The case with p=k and x_{-p-1} is a further, next character. % % Then, for case 1.): % discard any unused zeros at the tail of our number (possibly % including the period) % % and in case 2.) % if NEXT DIGIT < 5: % do exactly the same as in case 1.) above and discard any % following digits. % else % let q := -p % while(x_q = 9 and q<=r ) % if q>=0 % set x_q = '0' % else % discard digit x_q='9' % fi % ++q % if q=0 % discard the period % fi % end while % if q = r+1 % insert a '1' % else % set x_q = x_q + 1 % fi % fi % % All these loops have been implemented in spaghetti-code below. % Sorry, I fear its hard to understand. In principle, everything is % realised using more or less finite state machines (with some number % counting logic). % % Some comments: % - The token register \pgfmathfloat@tmptoks is used to accumulate the REVERSED input number. % - \pgfmathfloat@EOI always denotes 'END OF INPUT'. % - in the second stage, we need to reverse \pgfmathfloat@tmptoks. % This is -- again -- done with \pgfmathfloat@tmptoks. \def\pgfmathroundto@impl@discard@period#1.#2\pgfmathfloat@EOI{% \pgfmathfloatroundhasperiodfalse \aftergroup\pgfmathfloatroundhasperiodfalse \def\pgfmathresult{#1}% } \def\pgfmathroundto@impl@gobble@rest@and@start#1\pgfmathfloat@EOI{% \pgfmathroundto@impl@start } \def\pgfmathroundto@impl@gobble@and@start\pgfmathfloat@EOI{% \pgfmathroundto@impl@start } \def\pgfmathroundto@impl@gobble\pgfmathfloat@EOI{}% \def\pgfmathroundto@impl@gobble@rest#1\pgfmathfloat@EOI{}% % This method will be invoked as soon as the first step, the reverse % collection of up to PREC digits after the period, has finished. \def\pgfmathroundto@impl@start{% \ifx\pgfmathround@next\pgfutil@empty \ifnum\c@pgfmathroundto@offsetbehindperiod<0 % no period found. \ifpgfmathfloat@fixed@digits@after@period \ifnum\c@pgfmathroundto@prec=0\relax \pgfmathfloatroundhasperiodfalse \aftergroup\pgfmathfloatroundhasperiodfalse \edef\pgfmathresult{\pgfmathround@input}% \else \pgfmathfloat@tmptoks=\expandafter{\pgfmathround@input.}% \c@pgfmathroundto@offsetbehindperiod=\c@pgfmathroundto@prec \pgfmathroundto@impl@append@zeros \edef\pgfmathresult{\the\pgfmathfloat@tmptoks}% \fi \else \pgfmathfloatroundhasperiodfalse \aftergroup\pgfmathfloatroundhasperiodfalse \edef\pgfmathresult{\pgfmathround@input}% \fi \else %\ifnum\c@pgfmathroundto@offsetbehindperiod>\c@pgfmathroundto@prec % \pgfmath@error{Internal logic error in pgfmathroundto at [I] - should not have happened!?}{}% %\fi \pgfmathroundto@impl@finish@with@truncation \fi \else %\ifnum\c@pgfmathroundto@offsetbehindperiod=\c@pgfmathroundto@prec %\else % \pgfmath@error{Internal logic error in pgfmathroundto at [II] - should not have happened!? I have offsetbehindperiod=\the\c@pgfmathroundto@offsetbehindperiod and prec = \the\c@pgfmathroundto@prec}{}% %\fi \expandafter\ifnum\pgfmathround@next<5\relax \pgfmathroundto@impl@finish@with@truncation \else \multiply\c@pgfmathroundto@offsetbehindperiod by-1 \expandafter\pgfmathroundto@impl@ADD@ONE\the\pgfmathfloat@tmptoks\pgfmathfloat@EOI \fi \fi } % takes the current input and decides whether trailing zeros shall be % discarded or more zeros need to be filled in. \def\pgfmathroundto@impl@finish@with@truncation{% \ifpgfmathfloat@fixed@digits@after@period \expandafter\pgfmathroundto@impl@REVERSE\the\pgfmathfloat@tmptoks\pgfmathfloat@EOI \ifnum\c@pgfmathroundto@lastzeros=\c@pgfmathroundto@offsetbehindperiod \ifpgfmathround@impl@PREPERIOD@is@negative@zero % write '0.0000' instead of '-0.0000': \expandafter\pgfmathroundto@impl@discard@minus\the\pgfmathfloat@tmptoks\pgfmathfloat@EOI \fi \fi \ifnum\c@pgfmathroundto@prec=0\relax \expandafter\pgfmathroundto@impl@discard@period\the\pgfmathfloat@tmptoks\pgfmathfloat@EOI \else \advance\c@pgfmathroundto@prec by-\c@pgfmathroundto@offsetbehindperiod \c@pgfmathroundto@offsetbehindperiod=\c@pgfmathroundto@prec \pgfmathroundto@impl@append@zeros \edef\pgfmathresult{\the\pgfmathfloat@tmptoks}% \fi \else \pgfmathroundto@impl@discard@suffix@zeros \fi } \def\pgfmathroundto@impl@discard@minus-#1\pgfmathfloat@EOI{\pgfmathfloat@tmptoks={#1}}% % appends \c@pgfmathroundto@offsetbehindperiod zeros at the end of \pgfmathfloat@tmptoks. \def\pgfmathroundto@impl@append@zeros{% \ifnum\c@pgfmathroundto@offsetbehindperiod>0 \pgfmathfloat@tmptoks=\expandafter{\the\pgfmathfloat@tmptoks0}% \advance\c@pgfmathroundto@offsetbehindperiod by-1 \pgfmathroundto@impl@append@zeros \fi } \def\pgfmathroundto@impl@ADD@ONE{% \pgfmathfloat@tmptoks={}% no longer needed because its old value will be read from input \pgfmathroundto@impl@ADD@ONE@ITERATE } \def\pgfmathroundto@impl@ADD@ONE@ITERATE{% \pgfutil@ifnextchar\pgfmathfloat@EOI{% \global\pgfmathfloatroundmayneedrenormalizetrue \edef\pgfmathresult{1\the\pgfmathfloat@tmptoks}% \pgfmathroundto@impl@gobble }{% \pgfutil@ifnextchar.{% \ifnum\c@pgfmathroundto@prec=0 % silently discard period in special case precision=0 \def\pgfmathround@nextcmd{\pgfmathroundto@impl@ADD@ONE@ITERATE@gobble@dot}% \else \def\pgfmathround@nextcmd{\pgfmathroundto@impl@ADD@ONE@NEXT@COLLECT}% \fi \pgfmathround@nextcmd }{% \pgfutil@ifnextchar+{% \global\pgfmathfloatroundmayneedrenormalizetrue \edef\pgfmathresult{1\the\pgfmathfloat@tmptoks}% \pgfmathroundto@impl@gobble@rest }{% \pgfutil@ifnextchar-{% \global\pgfmathfloatroundmayneedrenormalizetrue \edef\pgfmathresult{-1\the\pgfmathfloat@tmptoks}% \pgfmathroundto@impl@gobble@rest }{% \pgfmathroundto@impl@ADD@ONE@NEXT }% }% }% }% } \def\pgfmathroundto@impl@ADD@ONE@ITERATE@gobble@dot.{% \pgfmathfloatroundhasperiodfalse \aftergroup\pgfmathfloatroundhasperiodfalse \pgfmathroundto@impl@ADD@ONE@ITERATE } \def\pgfmathroundto@impl@ADD@ONE@NEXT@COLLECT#1{% \pgfmathfloat@tmptoks=\expandafter{\expandafter#1\the\pgfmathfloat@tmptoks}% \pgfmathroundto@impl@ADD@ONE@ITERATE } \def\pgfmathroundto@impl@ADD@ONE@NEXT#1{% \ifnum#1=9 \ifnum\c@pgfmathroundto@offsetbehindperiod<0 \ifpgfmathfloat@fixed@digits@after@period \pgfmathfloat@tmptoks=\expandafter{\expandafter0\the\pgfmathfloat@tmptoks}% \else % silently DROP digit \fi \else \pgfmathfloat@tmptoks=\expandafter{\expandafter0\the\pgfmathfloat@tmptoks}% \fi \advance\c@pgfmathroundto@offsetbehindperiod by1 \ifnum\c@pgfmathroundto@offsetbehindperiod=0 \ifpgfmathfloat@fixed@digits@after@period \def\pgfmathround@nextcmd{\pgfmathroundto@impl@ADD@ONE@ITERATE}% \else \def\pgfmathround@nextcmd{\pgfmathroundto@impl@ADD@ONE@ITERATE@gobble@dot}% \fi \else \def\pgfmathround@nextcmd{\pgfmathroundto@impl@ADD@ONE@ITERATE}% \fi \else % re-use this counter: \c@pgfmathroundto@lastzeros=#1 \advance\c@pgfmathroundto@lastzeros by1 \edef\pgfmathresult{\the\c@pgfmathroundto@lastzeros\the\pgfmathfloat@tmptoks}% \pgfmathfloat@tmptoks=\expandafter{\pgfmathresult}% \def\pgfmathround@nextcmd{\pgfmathroundto@impl@REVERSE@ITERATE}% \fi \pgfmathround@nextcmd } \def\pgfmathroundto@impl@discard@suffix@zeros{% \ifnum\c@pgfmathroundto@lastzeros=\c@pgfmathroundto@offsetbehindperiod \ifpgfmathround@impl@PREPERIOD@is@negative@zero \pgfmathfloatroundhasperiodfalse \aftergroup\pgfmathfloatroundhasperiodfalse \def\pgfmathresult{0}% write '0' instead of '-0' \else \expandafter\pgfmathroundto@impl@discard@period\pgfmathround@input\pgfmathfloat@EOI \fi \else \ifnum\c@pgfmathroundto@lastzeros=0 \expandafter\pgfmathroundto@impl@REVERSE\the\pgfmathfloat@tmptoks\pgfmathfloat@EOI \else \expandafter\pgfmathroundto@impl@discard@suffix@zeros@ITERATE\the\pgfmathfloat@tmptoks\pgfmathfloat@EOI \fi \fi } % PRECONDITION: % \c@pgfmathroundto@lastzeros > 0 \def\pgfmathroundto@impl@discard@suffix@zeros@ITERATE#1{% \advance\c@pgfmathroundto@lastzeros by-1 \ifnum\c@pgfmathroundto@lastzeros=0 \def\pgfmathround@nextcmd{\pgfmathroundto@impl@REVERSE}% \else \def\pgfmathround@nextcmd{\pgfmathroundto@impl@discard@suffix@zeros@ITERATE}% \fi \pgfmathround@nextcmd } % Usage: % \pgfmathroundto@impl@REVERSE#1\pgfmathfloat@EOI % -> writes #1 reversed into \pgfmathfloat@tmptoks \def\pgfmathroundto@impl@REVERSE{% \pgfmathfloat@tmptoks={}% \pgfmathroundto@impl@REVERSE@ITERATE } \def\pgfmathroundto@impl@REVERSE@ITERATE{% \pgfutil@ifnextchar\pgfmathfloat@EOI{% \edef\pgfmathresult{\the\pgfmathfloat@tmptoks}% \pgfmathroundto@impl@gobble }{% \pgfmathroundto@impl@REVERSE@NEXT }% } \def\pgfmathroundto@impl@REVERSE@NEXT#1{% \pgfmathfloat@tmptoks=\expandafter{\expandafter#1\the\pgfmathfloat@tmptoks}% \pgfmathroundto@impl@REVERSE@ITERATE } \def\pgfmathroundto@impl@BEGIN@DOT.{% \pgfmathfloat@tmptoks=\expandafter{\expandafter.\the\pgfmathfloat@tmptoks}% \c@pgfmathroundto@offsetbehindperiod=0 \pgfmathroundto@impl@ITERATE@DOT } \def\pgfmathroundto@impl@ITERATE@DOT{% \pgfutil@ifnextchar\pgfmathfloat@EOI{% % finished. \pgfmathroundto@impl@gobble@and@start }{% \pgfmathroundto@impl@NEXT@DOT }% } \def\pgfmathroundto@impl@NEXT@DOT#1{% \ifnum\c@pgfmathroundto@offsetbehindperiod=\c@pgfmathroundto@prec \def\pgfmathround@next{#1}% \def\pgfmathround@nextcmd{\pgfmathroundto@impl@gobble@rest@and@start}% \else \advance\c@pgfmathroundto@offsetbehindperiod by1 \ifnum#1=0 \advance\c@pgfmathroundto@lastzeros by1 \else \c@pgfmathroundto@lastzeros=0 \fi \pgfmathfloat@tmptoks=\expandafter{\expandafter#1\the\pgfmathfloat@tmptoks}% \def\pgfmathround@nextcmd{\pgfmathroundto@impl@ITERATE@DOT}% \fi \pgfmathround@nextcmd }% % in contrast to pgfmathroundto@impl@ITERATE@NODOT, this method here % checks also for signs \def\pgfmathroundto@impl@ITERATE@NODOT@firstcall#1{% \def\pgfmathround@cur{#1}% \ifx\pgfmathround@cur\pgfmathfloat@EOI \pgfmathround@impl@PREPERIOD@is@negative@zerofalse \def\pgfmathround@nextcmd{\pgfmathroundto@impl@start}% \else \ifx\pgfmathround@cur\pgfmathfloatparsenumber@tok@PERIOD \pgfmathround@impl@PREPERIOD@is@negative@zerofalse \def\pgfmathround@nextcmd{\pgfmathroundto@impl@BEGIN@DOT.}% \else \ifx\pgfmathround@cur\pgfmathfloatparsenumber@tok@MINUS \else \pgfmathround@impl@PREPERIOD@is@negative@zerofalse \fi \pgfmathfloat@tmptoks=\expandafter{\expandafter#1\the\pgfmathfloat@tmptoks}% \def\pgfmathround@nextcmd{\pgfmathroundto@impl@ITERATE@NODOT}% \fi \fi \pgfmathround@nextcmd } \def\pgfmathroundto@impl@ITERATE@NODOT#1{% \def\pgfmathround@cur{#1}% \ifx\pgfmathround@cur\pgfmathfloat@EOI \def\pgfmathround@nextcmd{\pgfmathroundto@impl@start}% \else \ifx\pgfmathround@cur\pgfmathfloatparsenumber@tok@PERIOD \def\pgfmathround@nextcmd{\pgfmathroundto@impl@BEGIN@DOT.}% \else \ifx\pgfmathround@cur\pgfmathfloatparsenumber@tok@ZERO \else \pgfmathround@impl@PREPERIOD@is@negative@zerofalse \fi \pgfmathfloat@tmptoks=\expandafter{\expandafter#1\the\pgfmathfloat@tmptoks}% \def\pgfmathround@nextcmd{\pgfmathroundto@impl@ITERATE@NODOT}% \fi \fi \pgfmathround@nextcmd } %-------------------------------------------- % END of pgfmathroundto implementation. %-------------------------------------------- % flags, mantissa and exponent has already been stored into % \pgfmathfloat@a@* [using ...@Mtok] % % PRECONDITION: % \ifpgfmathfloatroundhasperiod = \iftrue outside of the current % group % % POSTCONDITION: % \ifpgfmathfloatroundhasperiod will be set after the current TeX % group. \def\pgfmathfloatround@impl{% \expandafter\pgfmathroundto@impl\expandafter{\the\pgfmathfloat@a@Mtok}% \ifpgfmathfloatroundmayneedrenormalize \ifpgfmathfloatroundhasperiod \expandafter\pgfmathfloatround@impl@renormalize\pgfmathresult\pgfmathfloat@EOI% \else \expandafter\pgfmathfloatround@impl@renormalize\pgfmathresult.\pgfmathfloat@EOI% \fi \advance\pgfmathfloat@a@E by1 \fi \pgfmathfloatcreate{\the\pgfmathfloat@a@S}{\pgfmathresult}{\the\pgfmathfloat@a@E}% } \def\pgfmathfloatround@impl@renormalize#1#2.#3\pgfmathfloat@EOI{% \pgfmathroundto@impl{#1.#2#3}% } % ATTENTION: this thing REQUIRES a period in the mantissa! % collects everything into \pgfmathresult \def\pgfmathfloattofixed@impl#1.#2\relax{% \ifnum\pgfmathfloat@a@E<0 \ifcase-\pgfmathfloat@a@E \or%e-1 \pgfmathfloat@a@Mtok={0.}% \or%e-2 \pgfmathfloat@a@Mtok={0.0}% \or%e-3 \pgfmathfloat@a@Mtok={0.00}% \or%e-4 \pgfmathfloat@a@Mtok={0.000}% \or%e-5 \pgfmathfloat@a@Mtok={0.0000}% \or%e-6 \pgfmathfloat@a@Mtok={0.00000}% \or%e-7 \pgfmathfloat@a@Mtok={0.000000}% \or%e-8 \pgfmathfloat@a@Mtok={0.0000000}% \or%e-9 \pgfmathfloat@a@Mtok={0.00000000}% \or%e-10 \pgfmathfloat@a@Mtok={0.000000000}% \else%<= -11 \pgfmathfloat@a@Mtok={0.0000000000}% \advance\pgfmathfloat@a@E by10 \pgfutil@loop \ifnum\pgfmathfloat@a@E<-1 \pgfmathfloat@a@Mtok=\expandafter{\the\pgfmathfloat@a@Mtok 0}% \advance\pgfmathfloat@a@E by1 \pgfutil@repeat \fi \def\pgfmathfloat@loc@TMPb{#2}% \def\pgfmathfloat@loc@TMPc{0}% \ifx\pgfmathfloat@loc@TMPb\pgfmathfloat@loc@TMPc \edef\pgfmathresult{\the\pgfmathfloat@a@Mtok #1}% \else \edef\pgfmathresult{\the\pgfmathfloat@a@Mtok #1#2}% \fi \else %-------------------------------------------------- % \ifnum\pgfmathfloat@a@E=0% % \edef\pgfmathresult{#1.#2}% % \else % \pgfmathfloat@a@Mtok={#1}% % \pgfmathfloattofixed@impl@collectmantissa#2\count\pgfmathfloat@a@E % \edef\pgfmathresult{\the\pgfmathfloat@a@Mtok}% % \fi %-------------------------------------------------- \pgfmathfloat@a@Mtok{#1}% \pgfmathfloattofixed@impl@pos#2000000000\pgfmathfloat@EOI \edef\pgfmathresult{\the\pgfmathfloat@a@Mtok}% \fi } % FIXME: this implementation here is very fast, but it introduces trailing zeros. Is that acceptable? \def\pgfmathfloattofixed@impl@pos#1#2#3#4#5#6#7#8#9\pgfmathfloat@EOI{% \ifcase\pgfmathfloat@a@E % e+0 \pgfmathfloat@a@Mtok\expandafter{\the\pgfmathfloat@a@Mtok .#1#2#3#4#5#6#7#8#9}% \or%e+1 \pgfmathfloat@a@Mtok\expandafter{\the\pgfmathfloat@a@Mtok #1.#2#3#4#5#6#7#8#9}% \or%e+2 \pgfmathfloat@a@Mtok\expandafter{\the\pgfmathfloat@a@Mtok #1#2.#3#4#5#6#7#8#9}% \or%e+3 \pgfmathfloat@a@Mtok\expandafter{\the\pgfmathfloat@a@Mtok #1#2#3.#4#5#6#7#8#9}% \or%e+4 \pgfmathfloat@a@Mtok\expandafter{\the\pgfmathfloat@a@Mtok #1#2#3#4.#5#6#7#8#9}% \or%e+5 \pgfmathfloat@a@Mtok\expandafter{\the\pgfmathfloat@a@Mtok #1#2#3#4#5.#6#7#8#9}% \or%e+6 \pgfmathfloat@a@Mtok\expandafter{\the\pgfmathfloat@a@Mtok #1#2#3#4#5#6.#7#8#9}% \or%e+7 \pgfmathfloat@a@Mtok\expandafter{\the\pgfmathfloat@a@Mtok #1#2#3#4#5#6#7.#8#9}% \or%e+8 \pgfmathfloat@a@Mtok\expandafter{\the\pgfmathfloat@a@Mtok #1#2#3#4#5#6#7#8.#9}% \else%>=9 \pgfmathfloat@a@Mtok\expandafter{\the\pgfmathfloat@a@Mtok #1#2#3#4#5#6#7#8}% \advance\pgfmathfloat@a@E by-8 \pgfmathfloattofixed@impl@collectmantissa#9\count\pgfmathfloat@a@E \fi }% \def\pgfmathfloattofixed@impl@collectmantissa#1#2\count#3{% \pgfmathfloat@a@Mtok=\expandafter{\the\pgfmathfloat@a@Mtok #1}% \advance\pgfmathfloat@a@E by-1% \def\pgfmathfloat@loc@TMPb{#2}% \ifx\pgfmathfloat@loc@TMPb\pgfutil@empty \pgfutil@loop \ifnum\pgfmathfloat@a@E>0% \pgfmathfloat@a@Mtok=\expandafter{\the\pgfmathfloat@a@Mtok 0}% \advance\pgfmathfloat@a@E by-1% \pgfutil@repeat \pgfmathfloat@a@Mtok=\expandafter{\the\pgfmathfloat@a@Mtok .0}% \else \ifnum\pgfmathfloat@a@E=0 \pgfmathfloat@a@Mtok=\expandafter{\the\pgfmathfloat@a@Mtok .#2}% \else \pgfmathfloattofixed@impl@collectmantissa#2\count#3% \fi \fi } % ============================================ % % % \pgfmathfloatparsenumber implementation % % % ============================================ % accepted parser tokens: \def\pgfmathfloatparsenumber@tok@ZERO{0} \def\pgfmathfloatparsenumber@tok@PLUS{+} \def\pgfmathfloatparsenumber@tok@MINUS{-} \def\pgfmathfloatparsenumber@tok@PERIOD{.} \newif\ifpgfmathfloatparsenumberpendingperiod \def\pgfflt@EOI{p@EOI}% \def\pgfflt@EOI@unexpanded{\pgfflt@EOI}% % Starts a finite-start-machine parser to read a number. % % The machine's state is represented by the macro which is currently % processed; state transitions are realised using \csname...#1\endcsname % constructions. % % It assigns \pgfmathfloat@a@S, \pgfmathfloat@a@Mtok, \pgfmathfloat@a@E. \def\pgfflt@impl#1{% \pgfmathfloatparsenumberpendingperiodfalse \pgfmathfloat@tmptoks={}% this register is used to collect PENDING ZEROS \pgfmathfloat@a@E=0 % start parsing: check for sign: \expandafter\ifx\csname pgfflt@#1\endcsname\relax \pgfmathfloat@a@S=1 \expandafter\pgfflt@init\expandafter#1% \else \expandafter\expandafter\csname pgfflt@#1\endcsname \fi } % State transitions: \expandafter\def\csname pgfflt@+\endcsname{% \pgfmathfloat@a@S=1 % \pgfflt@init}% \expandafter\def\csname pgfflt@-\endcsname{% \pgfmathfloat@a@S=2 % \pgfflt@init}% \expandafter\def\csname pgfflt@\pgfflt@EOI\endcsname{% \pgfmathfloatparsenumber@handleerror{empty number}{}{}}% \pgfkeys{ /pgf/fpu/handlers/empty number/.style 2 args={% /pgf/fpu/handlers/invalid number={#1}{#2}% }, /pgf/fpu/empty number is zero/.style={% /pgf/fpu/handlers/empty number/.code 2 args={% \pgfmathfloatcreate{0}{0.0}{0}% }% },% /pgf/fpu/handlers/invalid separator/.code 2 args={% \pgfmath@error{Could not parse input '#1' as a floating point number, sorry. The unreadable part was near the decimal separator '#2'. Do you need the option 'read comma as period'?}{}% }, /pgf/fpu/handlers/invalid number/.code 2 args={% \pgfmath@error{Could not parse input '#1' as a floating point number, sorry. The unreadable part was near '#2'.}{}% }, /pgf/fpu/handlers/wrong lowlevel format/.code 2 args={% \pgfmath@error{Sorry, an internal routine of the floating point unit got an ill-formatted floating point number `#1'. The unreadable part was near '#2'.}{}% \let\pgfmathresult=\pgfutil@empty }, } % #1 the error handler % #2 the number which was invalid. % #3 the part which produced the error % % POSTCONDITION: the three registers % \pgfmathfloat@a@S % \pgfmathfloat@a@Mtok % \pgfmathfloat@a@E % will contain the number which results from the error handler. \def\pgfmathfloatparsenumber@handleerror#1#2#3{% \let\pgfmathresult=\pgfutil@empty \pgfmathfloatparsenumberpendingperiodfalse \pgfkeys{/pgf/fpu/handlers/#1={#2}{#3}}% \ifx\pgfmathresult\pgfutil@empty \pgfmathfloat@a@S=3 \pgfmathfloat@a@Mtok={0.0}% \pgfmathfloat@a@E=0 \else \expandafter\pgfmathfloat@decompose@tok\pgfmathresult\relax\pgfmathfloat@a@S\pgfmathfloat@a@Mtok\pgfmathfloat@a@E \fi } \def\pgfflt@error#1\pgfflt@EOI{% \begingroup \pgfmathfloat@a@Mtok={#1}% \xdef\pgfmathfloat@glob@TMP{% \noexpand\pgfmathfloatparsenumber@handleerror {invalid number}{\pgfmathresult}{\the\pgfmathfloat@a@Mtok}}% \endgroup \pgfmathfloat@glob@TMP }% % FROM: checksign. % \def\pgfflt@init#1{% \expandafter\ifx\csname pgffltA@#1\endcsname\relax \expandafter\pgfflt@error\expandafter#1% \else \expandafter\expandafter\csname pgffltA@#1\endcsname \fi} % state transitions: \expandafter\def\csname pgffltA@0\endcsname{\pgfflt@leadingzero}% FIXME: inline optimization! \expandafter\def\csname pgffltA@1\endcsname{\pgfflt@nonzerodigit1}% \expandafter\def\csname pgffltA@2\endcsname{\pgfflt@nonzerodigit2}% \expandafter\def\csname pgffltA@3\endcsname{\pgfflt@nonzerodigit3}% \expandafter\def\csname pgffltA@4\endcsname{\pgfflt@nonzerodigit4}% \expandafter\def\csname pgffltA@5\endcsname{\pgfflt@nonzerodigit5}% \expandafter\def\csname pgffltA@6\endcsname{\pgfflt@nonzerodigit6}% \expandafter\def\csname pgffltA@7\endcsname{\pgfflt@nonzerodigit7}% \expandafter\def\csname pgffltA@8\endcsname{\pgfflt@nonzerodigit8}% \expandafter\def\csname pgffltA@9\endcsname{\pgfflt@nonzerodigit9}% \def\pgfflt@nonzerodigit#1{% \pgfmathfloat@a@Mtok={#1}% \pgfmathfloatparsenumberpendingperiodtrue \pgfflt@positiveexp}% \expandafter\def\csname pgffltA@n\endcsname{\pgfflt@readnan}% FIXME: inlining? \expandafter\def\csname pgffltA@N\endcsname{\pgfflt@readnan}% FIXME: inlining? \expandafter\def\csname pgffltA@i\endcsname{\pgfflt@readinf}% FIXME: inlining? \expandafter\def\csname pgffltA@I\endcsname{\pgfflt@readinf}% FIXME: inlining? \expandafter\def\csname pgffltA@.\endcsname{% read '.9' like '0.9' \pgfmathfloat@a@E=-1 \pgfflt@leadingzero@foundperiod}% \expandafter\def\csname pgffltA@,\endcsname{% read ',9' like '0,9' \pgfmathfloat@frenchinput{% \pgfmathfloat@a@E=-1 \pgfflt@leadingzero@foundperiod }% }% \def\pgfmathfloat@frenchinput#1{% \ifpgfmathparsenumber@comma@as@period \def\pgf@marshal{#1}% \expandafter\pgf@marshal \else \expandafter\pgfflt@error@separator\expandafter,% \fi }% \def\pgfflt@error@separator#1\pgfflt@EOI{% \begingroup \pgfmathfloat@a@Mtok={#1}% \xdef\pgfmathfloat@glob@TMP{% \noexpand\pgfmathfloatparsenumber@handleerror {invalid separator}{\pgfmathresult}{\the\pgfmathfloat@a@Mtok}}% \endgroup \pgfmathfloat@glob@TMP }% \def\pgfflt@finish#1\pgfflt@EOI{} \def\pgfflt@readnan #1#2{% \def\pgfflt@readnan@ok{1}% \if#1a\else\if#1A\else\def\pgfflt@readnan@ok{0}\fi\fi \if#2n\else\if#2N\else\def\pgfflt@readnan@ok{0}\fi\fi \if\pgfflt@readnan@ok1% \pgfmathfloat@a@S=3\relax% \pgfmathfloat@a@Mtok={0.0}% \pgfmathfloat@a@E=0% \expandafter\pgfflt@finish \else \def\pgfflt@readnan@{\pgfflt@error #1#2}% \expandafter\pgfflt@readnan@ \fi } \def\pgfflt@readinf #1#2{% \def\pgfflt@readinf@ok{1}% \if#1n\else\if#1N\else\def\pgfflt@readinf@ok{0}\fi\fi \if#2f\else\if#2F\else\def\pgfflt@readinf@ok{0}\fi\fi \if\pgfflt@readinf@ok1% \ifnum\pgfmathfloat@a@S=1 % \pgfmathfloat@a@S=4 % \pgfmathfloat@a@Mtok={0.0}% \else \pgfmathfloat@a@S=5 % \pgfmathfloat@a@Mtok={0.0}% \fi \pgfmathfloat@a@E=0 % \expandafter\pgfflt@finish \else \def\pgfflt@readinf@{\pgfflt@error #1#2}% \expandafter\pgfflt@readinf@ \fi } \def\pgfflt@leadingzero#1{% \expandafter\ifx\csname pgffltB@#1\endcsname\relax \expandafter\pgfflt@error\expandafter#1% \else \expandafter\expandafter\csname pgffltB@#1\endcsname \fi} % State transitions: \expandafter\def\csname pgffltB@0\endcsname{\pgfflt@leadingzero}% \expandafter\def\csname pgffltB@1\endcsname{\pgfmathfloat@a@Mtok={1}\pgfmathfloatparsenumberpendingperiodtrue \pgfflt@positiveexp} \expandafter\def\csname pgffltB@2\endcsname{\pgfmathfloat@a@Mtok={2}\pgfmathfloatparsenumberpendingperiodtrue \pgfflt@positiveexp} \expandafter\def\csname pgffltB@3\endcsname{\pgfmathfloat@a@Mtok={3}\pgfmathfloatparsenumberpendingperiodtrue \pgfflt@positiveexp} \expandafter\def\csname pgffltB@4\endcsname{\pgfmathfloat@a@Mtok={4}\pgfmathfloatparsenumberpendingperiodtrue \pgfflt@positiveexp} \expandafter\def\csname pgffltB@5\endcsname{\pgfmathfloat@a@Mtok={5}\pgfmathfloatparsenumberpendingperiodtrue \pgfflt@positiveexp} \expandafter\def\csname pgffltB@6\endcsname{\pgfmathfloat@a@Mtok={6}\pgfmathfloatparsenumberpendingperiodtrue \pgfflt@positiveexp} \expandafter\def\csname pgffltB@7\endcsname{\pgfmathfloat@a@Mtok={7}\pgfmathfloatparsenumberpendingperiodtrue \pgfflt@positiveexp} \expandafter\def\csname pgffltB@8\endcsname{\pgfmathfloat@a@Mtok={8}\pgfmathfloatparsenumberpendingperiodtrue \pgfflt@positiveexp} \expandafter\def\csname pgffltB@9\endcsname{\pgfmathfloat@a@Mtok={9}\pgfmathfloatparsenumberpendingperiodtrue \pgfflt@positiveexp} \expandafter\def\csname pgffltB@\pgfmathfloat@POSTFLAGSCHAR\endcsname{\pgfmathfloat@a@Mtok={0}\pgfflt@readlowlevelfloat}% \expandafter\def\csname pgffltB@.\endcsname{% \pgfmathfloat@a@E=-1 \pgfflt@leadingzero@foundperiod}% \expandafter\def\csname pgffltB@,\endcsname{% \pgfmathfloat@frenchinput{% \pgfmathfloat@a@E=-1 \pgfflt@leadingzero@foundperiod }% }% \expandafter\def\csname pgffltB@e\endcsname{% \pgfmathfloat@a@S=0\relax% \pgfmathfloat@a@Mtok={0.0}% \pgfmathfloat@a@E=0% \pgfflt@readexponent}% \let\pgffltB@E=\pgffltB@e \expandafter\def\csname pgffltB@\pgfflt@EOI\endcsname{% \pgfmathfloat@a@S=0\relax% \pgfmathfloat@a@Mtok={0.0}% \pgfmathfloat@a@E=0}% \def\pgfflt@leadingzero@foundperiod#1{% \expandafter\ifx\csname pgffltC@#1\endcsname\relax \expandafter\pgfflt@error\expandafter#1% \else \expandafter\expandafter\csname pgffltC@#1\endcsname \fi} % State transitions: \expandafter\def\csname pgffltC@0\endcsname{% \advance\pgfmathfloat@a@E by-1 \pgfflt@leadingzero@foundperiod}% \expandafter\def\csname pgffltC@1\endcsname{\pgfmathfloat@a@Mtok={1}\pgfmathfloatparsenumberpendingperiodtrue\pgfflt@finish@number@after@period}% \expandafter\def\csname pgffltC@2\endcsname{\pgfmathfloat@a@Mtok={2}\pgfmathfloatparsenumberpendingperiodtrue\pgfflt@finish@number@after@period}% \expandafter\def\csname pgffltC@3\endcsname{\pgfmathfloat@a@Mtok={3}\pgfmathfloatparsenumberpendingperiodtrue\pgfflt@finish@number@after@period}% \expandafter\def\csname pgffltC@4\endcsname{\pgfmathfloat@a@Mtok={4}\pgfmathfloatparsenumberpendingperiodtrue\pgfflt@finish@number@after@period}% \expandafter\def\csname pgffltC@5\endcsname{\pgfmathfloat@a@Mtok={5}\pgfmathfloatparsenumberpendingperiodtrue\pgfflt@finish@number@after@period}% \expandafter\def\csname pgffltC@6\endcsname{\pgfmathfloat@a@Mtok={6}\pgfmathfloatparsenumberpendingperiodtrue\pgfflt@finish@number@after@period}% \expandafter\def\csname pgffltC@7\endcsname{\pgfmathfloat@a@Mtok={7}\pgfmathfloatparsenumberpendingperiodtrue\pgfflt@finish@number@after@period}% \expandafter\def\csname pgffltC@8\endcsname{\pgfmathfloat@a@Mtok={8}\pgfmathfloatparsenumberpendingperiodtrue\pgfflt@finish@number@after@period}% \expandafter\def\csname pgffltC@9\endcsname{\pgfmathfloat@a@Mtok={9}\pgfmathfloatparsenumberpendingperiodtrue\pgfflt@finish@number@after@period}% \expandafter\def\csname pgffltC@e\endcsname{% \pgfmathfloat@a@S=0\relax% \pgfmathfloat@a@Mtok={0.0}% \pgfmathfloat@a@E=0% \pgfflt@readexponent}% \let\pgffltC@E=\pgffltC@e \expandafter\def\csname pgffltC@\pgfflt@EOI\endcsname{% \pgfmathfloat@a@S=0\relax% \pgfmathfloat@a@Mtok={0.0}% \pgfmathfloat@a@E=0}% \def\pgfflt@positiveexp#1{% \expandafter\ifx\csname pgffltD@#1\endcsname\relax \expandafter\pgfflt@error\expandafter#1% \else \expandafter\expandafter\csname pgffltD@#1\endcsname \fi} % State transitions: \expandafter\def\csname pgffltD@0\endcsname{% \advance\pgfmathfloat@a@E by1 \pgfmathfloat@tmptoks=\expandafter{\the\pgfmathfloat@tmptoks0}% \pgfflt@pendingzeros@positiveexp}% \expandafter\def\csname pgffltD@1\endcsname{\pgffltD@nonzerodigit1}% \expandafter\def\csname pgffltD@2\endcsname{\pgffltD@nonzerodigit2}% \expandafter\def\csname pgffltD@3\endcsname{\pgffltD@nonzerodigit3}% \expandafter\def\csname pgffltD@4\endcsname{\pgffltD@nonzerodigit4}% \expandafter\def\csname pgffltD@5\endcsname{\pgffltD@nonzerodigit5}% \expandafter\def\csname pgffltD@6\endcsname{\pgffltD@nonzerodigit6}% \expandafter\def\csname pgffltD@7\endcsname{\pgffltD@nonzerodigit7}% \expandafter\def\csname pgffltD@8\endcsname{\pgffltD@nonzerodigit8}% \expandafter\def\csname pgffltD@9\endcsname{\pgffltD@nonzerodigit9}% \expandafter\def\csname pgffltD@\pgfmathfloat@POSTFLAGSCHAR\endcsname{\pgfflt@readlowlevelfloat}% \expandafter\def\csname pgffltD@.\endcsname{\pgfflt@finish@number@after@period}% FIXME : inlining? \expandafter\def\csname pgffltD@,\endcsname{\pgfmathfloat@frenchinput{\pgfflt@finish@number@after@period}}% \expandafter\def\csname pgffltD@e\endcsname{\pgfflt@readexponent}% FIXME : inlining? \let\pgffltD@E=\pgffltD@e \expandafter\def\csname pgffltD@\pgfflt@EOI\endcsname{}% NOP \def\pgffltD@nonzerodigit#1{% \advance\pgfmathfloat@a@E by1 \ifpgfmathfloatparsenumberpendingperiod \pgfmathfloat@a@Mtok=\expandafter{\the\pgfmathfloat@a@Mtok.}% \pgfmathfloatparsenumberpendingperiodfalse \fi \pgfmathfloat@a@Mtok=\expandafter{\the\pgfmathfloat@a@Mtok#1}% \pgfflt@positiveexp}% % Read a low-level floating point. % Since we are in the second state, \pgfmathfloat@a@Mtok contains the % FLAGS. The post-flags-char has also been read. \def\pgfflt@readlowlevelfloat#1e#2]\pgfflt@EOI{% \pgfmathfloatparsenumberpendingperiodfalse \pgfmathfloat@a@S=\the\pgfmathfloat@a@Mtok\relax \pgfmathfloat@a@Mtok={#1}% \pgfmathfloat@a@E=#2 }% \def\pgfflt@readexponent#1\pgfflt@EOI{% \afterassignment\pgfflt@readexponent@ \pgfmathfloat@b@E=#1 \pgfflt@EOI% the white space is important, otherwise \pgfflt@EOI will be expanded. } \def\pgfflt@readexponent@#1{% \advance\pgfmathfloat@a@E by\pgfmathfloat@b@E\relax % % sanity checking: \def\pgfmathfloat@loc@TMPb{#1}% \ifx\pgfmathfloat@loc@TMPb\pgfflt@EOI@unexpanded \else \def\pgfmathfloat@loc@TMPb{\pgfflt@error#1}% \expandafter\pgfmathfloat@loc@TMPb \fi } \def\pgfflt@pendingzeros@positiveexp#1{% \expandafter\ifx\csname pgffltE@#1\endcsname\relax \expandafter\pgfflt@error\expandafter#1% \else \expandafter\expandafter\csname pgffltE@#1\endcsname \fi} % State transitions: \expandafter\def\csname pgffltE@0\endcsname{% \pgfmathfloat@tmptoks=\expandafter{\the\pgfmathfloat@tmptoks0}% \advance\pgfmathfloat@a@E by1 \pgfflt@pendingzeros@positiveexp}% \expandafter\def\csname pgffltE@1\endcsname{\pgffltE@nonzerodigit1}% \expandafter\def\csname pgffltE@2\endcsname{\pgffltE@nonzerodigit2}% \expandafter\def\csname pgffltE@3\endcsname{\pgffltE@nonzerodigit3}% \expandafter\def\csname pgffltE@4\endcsname{\pgffltE@nonzerodigit4}% \expandafter\def\csname pgffltE@5\endcsname{\pgffltE@nonzerodigit5}% \expandafter\def\csname pgffltE@6\endcsname{\pgffltE@nonzerodigit6}% \expandafter\def\csname pgffltE@7\endcsname{\pgffltE@nonzerodigit7}% \expandafter\def\csname pgffltE@8\endcsname{\pgffltE@nonzerodigit8}% \expandafter\def\csname pgffltE@9\endcsname{\pgffltE@nonzerodigit9}% \expandafter\def\csname pgffltE@.\endcsname{\pgfflt@finish@number@after@period}% FIXME : inlining? \expandafter\def\csname pgffltE@,\endcsname{\pgfmathfloat@frenchinput{\pgfflt@finish@number@after@period}}% FIXME : inlining? \def\pgffltE@e{\pgfflt@readexponent}% FIXME : inlining? \let\pgffltE@E=\pgffltE@e \expandafter\def\csname pgffltE@\pgfflt@EOI\endcsname{}% NOP \def\pgffltE@nonzerodigit#1{% \advance\pgfmathfloat@a@E by1 \ifpgfmathfloatparsenumberpendingperiod \pgfmathfloat@a@Mtok=\expandafter{\the\pgfmathfloat@a@Mtok.}% \pgfmathfloatparsenumberpendingperiodfalse \fi \pgfmathfloat@a@Mtok=\expandafter\expandafter\expandafter{\expandafter\the\expandafter\pgfmathfloat@a@Mtok\the\pgfmathfloat@tmptoks}% \pgfmathfloat@tmptoks={}% \pgfmathfloat@a@Mtok=\expandafter{\the\pgfmathfloat@a@Mtok#1}% \pgfflt@positiveexp}% \def\pgfflt@finish@number@after@period#1{% \expandafter\ifx\csname pgffltF@#1\endcsname\relax \expandafter\pgfflt@error\expandafter#1% \else \expandafter\expandafter\csname pgffltF@#1\endcsname \fi} % State transitions: \expandafter\def\csname pgffltF@0\endcsname{% \pgfmathfloat@tmptoks=\expandafter{\the\pgfmathfloat@tmptoks0}% \pgfflt@pendingzeros}% \expandafter\def\csname pgffltF@1\endcsname{\pgffltF@nonzerodigit1}% \expandafter\def\csname pgffltF@2\endcsname{\pgffltF@nonzerodigit2}% \expandafter\def\csname pgffltF@3\endcsname{\pgffltF@nonzerodigit3}% \expandafter\def\csname pgffltF@4\endcsname{\pgffltF@nonzerodigit4}% \expandafter\def\csname pgffltF@5\endcsname{\pgffltF@nonzerodigit5}% \expandafter\def\csname pgffltF@6\endcsname{\pgffltF@nonzerodigit6}% \expandafter\def\csname pgffltF@7\endcsname{\pgffltF@nonzerodigit7}% \expandafter\def\csname pgffltF@8\endcsname{\pgffltF@nonzerodigit8}% \expandafter\def\csname pgffltF@9\endcsname{\pgffltF@nonzerodigit9}% \def\pgffltF@e{\pgfflt@readexponent}% \let\pgffltF@E=\pgffltF@e \expandafter\def\csname pgffltF@\pgfflt@EOI\endcsname{}% NOP \def\pgffltF@nonzerodigit#1{% \ifpgfmathfloatparsenumberpendingperiod \pgfmathfloat@a@Mtok=\expandafter{\the\pgfmathfloat@a@Mtok.}% \pgfmathfloatparsenumberpendingperiodfalse \fi \pgfmathfloat@a@Mtok=\expandafter\expandafter\expandafter{\expandafter\the\expandafter\pgfmathfloat@a@Mtok\the\pgfmathfloat@tmptoks}% \pgfmathfloat@tmptoks={}% \pgfmathfloat@a@Mtok=\expandafter{\the\pgfmathfloat@a@Mtok#1}% \pgfflt@finish@number@after@period}% \def\pgfflt@pendingzeros#1{% \expandafter\ifx\csname pgffltG@#1\endcsname\relax \expandafter\pgfflt@error\expandafter#1% \else \expandafter\expandafter\csname pgffltG@#1\endcsname \fi} % State transitions: \expandafter\def\csname pgffltG@0\endcsname{% \pgfmathfloat@tmptoks=\expandafter{\the\pgfmathfloat@tmptoks0}% \pgfflt@pendingzeros}% \expandafter\def\csname pgffltG@1\endcsname{\pgffltG@nonzerodigit1}% \expandafter\def\csname pgffltG@2\endcsname{\pgffltG@nonzerodigit2}% \expandafter\def\csname pgffltG@3\endcsname{\pgffltG@nonzerodigit3}% \expandafter\def\csname pgffltG@4\endcsname{\pgffltG@nonzerodigit4}% \expandafter\def\csname pgffltG@5\endcsname{\pgffltG@nonzerodigit5}% \expandafter\def\csname pgffltG@6\endcsname{\pgffltG@nonzerodigit6}% \expandafter\def\csname pgffltG@7\endcsname{\pgffltG@nonzerodigit7}% \expandafter\def\csname pgffltG@8\endcsname{\pgffltG@nonzerodigit8}% \expandafter\def\csname pgffltG@9\endcsname{\pgffltG@nonzerodigit9}% \def\pgffltG@e{\pgfflt@readexponent}% FIXME: inlining? \let\pgffltG@E=\pgffltG@e \expandafter\def\csname pgffltG@\pgfflt@EOI\endcsname{}% NOP \def\pgffltG@nonzerodigit#1{% \ifpgfmathfloatparsenumberpendingperiod \pgfmathfloat@a@Mtok=\expandafter{\the\pgfmathfloat@a@Mtok.}% \pgfmathfloatparsenumberpendingperiodfalse \fi \pgfmathfloat@a@Mtok=\expandafter\expandafter\expandafter{\expandafter\the\expandafter\pgfmathfloat@a@Mtok\the\pgfmathfloat@tmptoks}% \pgfmathfloat@tmptoks={}% \pgfmathfloat@a@Mtok=\expandafter{\the\pgfmathfloat@a@Mtok#1}% \pgfflt@finish@number@after@period}% \endinput