pgf 2.10 (28oct10)

git-svn-id: svn://tug.org/texlive/trunk@20236 c570f23f-e606-0410-a88d-b1316a301751

1 files changed, 870 insertions, 284 deletions

diff --git a/Master/texmf-dist/doc/generic/pgf/text-en/pgfmanual-en-math-parsing.tex b/Master/texmf-dist/doc/generic/pgf/text-en/pgfmanual-en-math-parsing.tex
index 7ec64df937c..1d28cfa4fea 100644
--- a/Master/texmf-dist/doc/generic/pgf/text-en/pgfmanual-en-math-parsing.tex
+++ b/Master/texmf-dist/doc/generic/pgf/text-en/pgfmanual-en-math-parsing.tex
@@ -11,22 +11,20 @@
 \section{Evaluating Mathematical Expressions}
 
 The easiest way of using \pgfname's mathematical engine is to provide
-a mathematical expression given in the usual infix notation (such as
-|1cm+4*2cm/5.5| or |2*3+3*sin(30)|). This expression can be parsed by
-the mathematical engine and the result be placed in a dimension
-register, a counter, or a macro. Supported are infix mathematical
-operations involving integers and non-integers, with or without
-units.
-
-It should be noted that all 
-calculations must not exceed $\pm16383.99999$ at \emph{any} point, 
-because the underlying algorithms rely on \TeX{} dimensions. This
-means that many of the underlying algorithms are necessarily
-approximate. It also means that some of the algorithms are not very
-fast. \TeX{} is, after all, a typesetting language and not ideally
-suited to relatively advanced mathematical operations. However, it is
-possible to change the algorithms as described in
-Section~\ref{pgfmath-reimplement}. 
+a mathematical expression given in familiar infix notation, for
+example, |1cm+4*2cm/5.5| or |2*3+3*sin(30)|. This expression can be
+parsed by the mathematical engine and the result be placed in a
+dimension register, a counter, or a macro.
+
+It should be noted that all
+calculations must not exceed $\pm16383.99999$ at \emph{any} point,
+because the underlying computations rely on \TeX{} dimensions. This
+means that many of the underlying computations are necessarily
+approximate and that in addition, are not very fast. \TeX{} is,
+after all, a typesetting language and not ideally
+suited to relatively advanced mathematical operations. However, it
+is possible to change the computations as described in
+Section~\ref{pgfmath-reimplement}.
 
 In the present section, the high-level macros for parsing an
 expression are explained first, then the syntax for expression is
@@ -55,136 +53,104 @@ engine is the following:
 
   \begin{itemize}
   \item
-    The result stored in the macro |\pgfmathresult| is a decimal
-    \emph{without units}. This is true regardless of whether the
-    \meta{expression} contains any unit specification. But, any units
-    specified will be converted to points first.
-\begin{codeexample}[]
-\pgfmathparse{2pt+3.4pt} \pgfmathresult
-\end{codeexample}
-
-\begin{codeexample}[]
-\pgfmathparse{2cm+3.4cm} \pgfmathresult
-\end{codeexample}
-
-  \item If no units are specified \emph{at any point} in the 
-    expression, the result will be multiplied by the value in 
-    |\pgfmathresultunitscale|, which can be a number or a dimension 
-    (which will be converted to points). By default it is set to 1, 
-    but can be changed with |\pgfmathsetresultunitscale|. Note that 
-    the result will still be a number \emph{without} units.
+  The result stored in the macro |\pgfmathresult| is a decimal
+  \emph{without units}. This is true regardless of whether the
+  \meta{expression} contains any unit specification. All numbers
+  with units are converted to points first.
 
-\begin{codeexample}[]
-\pgfmathparse{2pt+3.4pt} \pgfmathresult
-\end{codeexample}
-
-\begin{codeexample}[]
-\pgfmathsetresultunitscale{1cm}
-\pgfmathparse{2+3.4} \pgfmathresult
-\end{codeexample}
+  \item
+ 	You can check whether an expression contained a unit using
+  the \TeX-if |\||ifpgfmathunitsdeclared|. After a call
+  of |\pgfmathparse| this if will be true exactly if some unit was
+  encountered in the expression.
 
-    \pgfmathsetresultunitscale{1pt}
-    
-  \item You can check whether an expression contained a unit using 
-    the \TeX-if |\||ifpgfmathunitsdeclared|. After a call
-    of |\pgfmathparse| this if will be true exactly if some unit was
-    encountered in the expression.
-    
-  \item The parser handles numbers with or without units regardless
-    of the operation.
+  \item
+  The parser can recognize \TeX{} registers and box dimensions,
+  so |\mydimen|, |0.5\mydimen|, |\wd\mybox|, |0.5\dp\mybox|,
+  |\mycount\mydimen| and so on can be parsed.
 
-\begin{codeexample}[]
-\pgfmathparse{54pt/3cm*2.1} \pgfmathresult
-\end{codeexample}
+  \item
+  Parenthesis can be used to change the order of the evaluation.
 
-  \item the parser can cope with \TeX{} registers, including those 
-    preceded by |\the|.
+  \item
+  Various functions are recognized, so it is possible to parse
+  |sin(.5*pi r)*60|, which means ``the sine of $0.5$ times $\pi$
+  radians, multiplied by 60''. The argument of functions can
+  be any expression.
 
-    \makeatletter
+  \item
+  Scientific notation in the form |1.234e+4| is recognized (but
+  the restriction on the range of values still applies). The exponent
+  symbol can be upper or lower case (i.e., |E| or |e|).
 
-\begin{codeexample}[]
-\pgf@x=12.34pt
-\c@pgf@counta=5
-\pgfmathparse{\pgf@x+\c@pgf@counta*6} \pgfmathresult
-\end{codeexample}
+  \item
+  An integer with a zero-prefix (excluding, of course zero itself),
+  is interpreted as an octal number and is automatically converted
+  to base 10.
 
-\begin{codeexample}[]
-\pgf@x=56.78pt
-\pgfmathparse{\pgf@x+\the\pgf@x} \pgfmathresult
-\end{codeexample}
+  \item
+  An integer with prefix |0x| or |0X| is interpreted as a hexadecimal
+  number and is automatically converted to base 10. Alphabetic digits
+  can be in uppercase or lowercase.
 
-  \item \TeX{} dimension registers can be multiplied without the |*| 
-    operator by preceding them with a number (\emph{not} a function),
-     or a count register.
-	 
-\begin{codeexample}[]
-\c@pgf@counta=-4
-\pgf@x=10pt
-\pgfmathparse{.5\pgf@x-\c@pgf@counta\pgf@x} \pgfmathresult
-\end{codeexample}
+	\item
+  An integer with prefix |0b| or |0B| is interpreted as a binary
+  number and is automatically converted to base 10.
 
-  \item Parenthesis can be used to group operations.
+  \item
+  An expression (or part of an expression) surrounded with double
+  quotes (i.e., the character |"|) will not be evaluated.
+  Obviously this should be used with great care.
 
-\begin{codeexample}[]
-\pgfmathparse{(4pt+0.5)*3} \pgfmathresult
-\end{codeexample}
+\end{itemize}
 
-  \item functions are recognized, so it is possible to parse
-    |sin(.5*pi r)*60|, which means ``the sine of $0.5$ times $\pi$ 
-    radians, multiplied by 60''. The argument of most functions can
-    be any expression.
+\end{command}
 
-\begin{codeexample}[]
-\pgfmathparse{sin(pi/2 r)*60} \pgfmathresult
-\end{codeexample}
 
-  \item Scientific notation in the form |1.234e+4| is recognised (but
-  the restriction on the range of values still applies). The exponent
-  symbol can be upper or lower case (i.e., |E| or |e|). 
-  
-\begin{codeexample}[]
-\pgfmathparse{1.234567891e-2} \pgfmathresult
-\end{codeexample}
-\begin{codeexample}[]
-\pgfmathparse{1.234567891e4} \pgfmathresult
-\end{codeexample}
-  \end{itemize}
-\end{command}
 
 \begin{command}{\pgfmathqparse\marg{expression}}
-  This macro is similar to |\pgfmathparse|: it parses 
-  \meta{expression} and returns the result in the macro 
-  |\pgfmathresult|. It differs in two respects. Firstly, 
-  |\pgfmathqparse| does not parse functions or scientific
-  notation. 
+  This macro is similar to |\pgfmathparse|: it parses
+  \meta{expression} and returns the result in the macro
+  |\pgfmathresult|. It differs in two respects. Firstly,
+  |\pgfmathqparse| does not parse functions, scientific
+  notation, the prefixes for binary octal, or hexadecimal numbers,
+  nor does it accept the special use of |"|, |?| or |:| characters.
   Secondly, numbers in \meta{expression} \emph{must}
-  specify a \TeX{} unit (except in such instances as |0.5\pgf@x|), 
-  which greatly simplifies the problem of parsing 
-  of non-integers. As a result of these restrictions |\pgfmathqparse| 
-  is about twice as fast as |\pgfmathparse|. Note that the result 
-  will still be a number \emph{without} units.	
+  specify a \TeX{} unit (except in such instances as |0.5\pgf@x|),
+  which greatly simplifies the problem of parsing real numbers.
+  As a result of these restrictions |\pgfmathqparse|
+  is about twice as fast as |\pgfmathparse|. Note that the result
+  will still be a number without units.	
 \end{command}
 
-\begin{command}{\pgfmathsetresultunitscale\marg{number or dimension}}
-  Sets the value in |\pgfmathresultunitscale|, which scales the result
-  of an expression parsed with |\pgfmathparse|, if that expression
-  contains no units \emph{at any point}. The argument can be an integer,
-  non-integer or a dimension, but the result will still be a number 
-  \emph{without} units. Note, that this will affect |\pgfmathsetlength| 
-  and friends, but not if the expression starts with |+| (which
-  switches parsing off). By default the value in
-  |\pgfmathresultunitscale| is 1. 
+\begin{command}{\pgfmathpostparse}
+
+  At the end of the parse this command is executed, allowing some
+  custom action to be performed on the result of the parse. When this
+  command is executed the macro |\pgfmathresult| will hold the result
+  of the parse (as ever, without units). The result of the custom
+  action should be to redefined |\pgfmathresult| appropriately.
+  By default, this command is equivalent to |\relax|. This differs
+  from previous versions, where, if the parsed expression contained
+  no units, the result of the parse was scaled according to the value
+  in |\pgfmathresultunitscale| (which by default was |1|).
+
+  This scaling can be  turned on again using:
+  |\let\pgfmathpostparse=\pgfmathscaleresult|.
+  Note, however that by scaling the result, the base conversion
+  functions will not work, and the |"| character should not be
+  used to quote parts of an expression.
+
 \end{command}
 
 Instead of the |\pgfmathparse| macro you can also wrapper commands,
-whose usage is very similar to their cousins in the \calcname{} 
+whose usage is very similar to their cousins in the \calcname{}
 package. The only difference is that the expressions can be any
 expression that is handled by |\pgfmathparse|.
-
 For all of the following commands, if \meta{expression} starts with
 |+|, no parsing is done and a simple assignment or increment is done
 using normal \TeX\ assignments or increments. This will be orders of
-magnitude faster than calling the parser. 
+magnitude faster than calling the parser.
 
 \begin{command}{\pgfmathsetlength\marg{dimension register}\marg{expression}}
   Sets the length of the \TeX{} \meta{dimension register}, to the value
@@ -193,45 +159,37 @@ magnitude faster than calling the parser.
 \end{command}
 
 \begin{command}{\pgfmathaddtolength\marg{dimension register}\marg{expression}}
-  Adds the value (in points) of \meta{expression} to the \TeX{} 
-  \meta{dimension register}. 
+  Adds the value (in points) of \meta{expression} to the \TeX{}
+  \meta{dimension register}.
 \end{command}
 
 \begin{command}{\pgfmathsetcount\marg{count register}\marg{expression}}
-  Sets the value of the \TeX{} \meta{count register}, to the 
-  \emph{truncated} value specified by \meta{expression}. 
+  Sets the value of the \TeX{} \meta{count register}, to the
+  \emph{truncated} value specified by \meta{expression}.
 \end{command}
 
 \begin{command}{\pgfmathaddtocount\marg{count register}\marg{expression}}
-  Adds the \emph{truncated} value  of \meta{expression} to the \TeX{} 
+  Adds the \emph{truncated} value  of \meta{expression} to the \TeX{}
   \meta{count register}.
 \end{command}
 
 \begin{command}{\pgfmathsetcounter\marg{counter}\marg{expression}}
-  Sets the value of the \LaTeX{} \meta{counter}, to the \emph{truncated} 
-  value specified by \meta{expression}. 
+  Sets the value of the \LaTeX{} \meta{counter}, to the \emph{truncated}
+  value specified by \meta{expression}.
 \end{command}
 
 \begin{command}{\pgfmathaddtocounter\marg{counter}\marg{expression}}
-  Adds the \emph{truncated} value  of \meta{expression} to 
+  Adds the \emph{truncated} value  of \meta{expression} to
   \meta{counter}.
 \end{command}
 
-% \begin{command}{\pgfmathnewcounter\marg{counter}}
-%   This is simply a version of the \LaTeX{} macro |\newcounter|, 
-%   implemented to maintain consistency (consistency is good,
-%   inconsistency is evil). Considering |\pgfmathnewcounter{foo}|, this
-%   creates a new count register |\c@foo|, and a macro |\thefoo|, which
-%   returns the value in |\c@foo|.
-% \end{command}
-
 \begin{command}{\pgfmathsetmacro\marg{macro}\marg{expression}}
   Defines \meta{macro} as the  value of \meta{expression}. The result
-  is a decimal \emph{without} units.
+  is a decimal without units.
 \end{command}
 
 \begin{command}{\pgfmathsetlengthmacro\marg{macro}\marg{expression}}
-  Defines \meta{macro} as the value of \meta{expression} 
+  Defines \meta{macro} as the value of \meta{expression}
   \LaTeX{}\emph{in points}.
 \end{command}
 
@@ -241,200 +199,351 @@ magnitude faster than calling the parser.
 
 
 
-\subsection{Syntax for mathematical expressions}
+\section{Syntax for mathematical expressions}
 
 \label{pgfmath-syntax}
 
-The syntax for the expressions recognized by |\pgfmathparse| and
-friends is straightfoward, and the following operations and 
-functions are currently recognized:
+  The syntax for the expressions recognized by |\pgfmathparse| and
+  friends is straightforward, and the following sections describe the
+  operators and functions that are recognized by default.
 
-\begin{math-operator}{\mvar{x}\ +\ \mvar{y}}
-	Adds \mvar{y} to \mvar{x}.
-	
-\begin{codeexample}[]
-\pgfmathparse{4+2pt} \pgfmathresult
-\end{codeexample}
+\subsection{Operators}
+
+\label{pgfmath-operators}
+
+  The following operators (presented in the context in which they are used)
+  are recognized:
+
+\begin{math-operator}{+}{infix}{add}
+ Adds \mvar{x} to \mvar{y}.
 \end{math-operator}
 
-\begin{math-operator}{\mvar{x}\ -\ \mvar{y}}
-	Subtracts \mvar{y} from  \mvar{x}.
-	
-\begin{codeexample}[]
-\pgfmathparse{155.35-4cm} \pgfmathresult
-\end{codeexample}
+\begin{math-operator}{-}{infix}{subtract}
+  Subtracts \mvar{y} from \mvar{x}.
 \end{math-operator}
-\begin{math-operator}{\mvar{x}\ *\ \mvar{y}}
-	Multiplies \mvar{x} by  \mvar{y}.
-	
-\begin{codeexample}[]
-\pgfmathparse{3.9pt*4.56} \pgfmathresult
-\end{codeexample}
 
+\begin{math-operator}{-}{prefix}{neg}
+  Reverses the sign of \mvar{x}.
 \end{math-operator}
-\begin{math-operator}{\mvar{x}\ /\ \mvar{y}}
-	Divides \mvar{x} by  \mvar{y}.
-	
-\begin{codeexample}[]
-\pgfmathparse{-31.6pt/17} \pgfmathresult
-\end{codeexample}
 
+\begin{math-operator}{*}{infix}{multiply}
+  Multiples \mvar{x} by \mvar{y}.
 \end{math-operator}
-\begin{math-operator}{\mvar{x}\ {\char94}\ \mvar{y}} 
 
-Raises \mvar{x} to the power \mvar{y}. For greatest accuracy \mvar{y}
-should be an integer. If \mvar{y} is not an integer the actual
-calculation will be an approximation of $e^{y\ln(x)}$.
+\begin{math-operator}{/}{infix}{divide}
+  Divides \mvar{x} by \mvar{y}. An error will result if \mvar{y} is 0,
+  or if the result of the division is too big for the mathematical
+  engine. Please remember when using this command that accurate (and
+  reasonably quick) division of real numbers that are not integers
+  is particularly tricky in \TeX.
+\end{math-operator}
 
-{
-\catcode`\^=7
+\begin{math-operator}{\char`\^}{infix}{pow}
+  Raises \mvar{x} to the power \mvar{y}.
+\end{math-operator}
 
-\begin{codeexample}[]
-\pgfmathparse{2.3^4} \pgfmathresult
-\end{codeexample}
+\begin{math-operator}{!}{postfix}{factorial}
+  Calculates the factorial of \mvar{x}.
+\end{math-operator}
 
-\begin{codeexample}[]
-\pgfmathparse{2^-4} \pgfmathresult
-\end{codeexample}
+\begin{math-operator}{r}{postfix}{deg}
+  Converts \mvar{x} to degrees (\mvar{x} is assumed to be in radians).
+  This operator has the same precedence as multiplication.
+\end{math-operator}
+
+\begin{math-operators}{?}{:}{conditional}{ifthenelse}
+
+  |?| and |:| are special operators which can be used as a shorthand
+  for |if| \mvar{x} |then| \mvar{y} |else| \mvar{z} inside the parser.
+  The expression \mvar{x} is taken to be true if it evaluates to any
+  non-zero value.
+
+\end{math-operators}
+
+\begin{math-operator}{==}{infix}{equal}
+  Returns |1| if \mvar{x}$=$\mvar{y}, |0| otherwise.
+\end{math-operator}
+
+\begin{math-operator}{>}{infix}{greater}
+  Returns |1| if \mvar{x}$>$\mvar{y}, |0| otherwise.
+\end{math-operator}
+
+\begin{math-operator}{<}{infix}{less}
+  Returns |1| if \mvar{x}$<$\mvar{y}, |0| otherwise.
+\end{math-operator}
+
+\begin{math-operator}{!=}{infix}{notequal}
+  Returns |1| if \mvar{x}$\neq$\mvar{y}, |0| otherwise.
+\end{math-operator}
+
+\begin{math-operator}{>=}{infix}{notless}
+  Returns |1| if \mvar{x}$\geq$\mvar{y}, |0| otherwise.
+\end{math-operator}
+
+\begin{math-operator}{<=}{infix}{notgreater}
+  Returns |1| if \mvar{x}$\leq$\mvar{y}, |0| otherwise.
+\end{math-operator}
+
+\begin{math-operator}{{\char`\&}{\char`\&}}{infix}{and}
+  Returns |1| if both \mvar{x} and \mvar{y} evaluate to some
+  non-zero value. Both arguments are evaluated.
+\end{math-operator}
+
+
+
+{
+ \catcode`\|=12
+\begin{math-operator}[no index]{||}{infix}{or}
+	\index{*pgfmanualvbarvbarr@\protect\texttt{\protect\pgfmanualvbarvbar} math operator}%
+  \index{Math operators!*pgfmanualvbarvbar@\protect\texttt{\protect\pgfmanualvbarvbar}}%
+  Returns {\tt 1} if either \mvar{x} or \mvar{y} evaluate to some
+  non-zero value.
+\end{math-operator}
 }
+
+\begin{math-operator}{!}{prefix}{not}
+  Returns |1| if \mvar{x} evaluates to zero, |0| otherwise.
 \end{math-operator}
 
-\begin{math-operator}{\mvar{x}\ ==\ \mvar{y}} 
 
-	This evaluates to |1| if \mvar{x} equals \mvar{y}, or |0| if \mvar{x}
-	does not equal \mvar{y}. 
-	Note that equalities (and inequalities) are evaluated left to right, 
-	and are only evaluated when another equality (or inequality) operator 
-	is scanned, or the end of the current group or parse is reached. So 
-	|5+4==3+2==9| results in |0| because |5+4| does not equal |3+2|, 
-	resulting in zero, and the second equality is therefore evaluating 
-	|0==9|.
+\begin{math-operators}{(}{)}{group}{}
+
+These operators act in the usual way, that is, to control the order
+in which operators are executed, for example, |(1+2)*3|. This
+includes the grouping of arguments for functions, for example,
+|sin(30*10)| or |mod(72,3)| (the comma character is also treated
+as an operator).
+
+Parentheses for functions with one argument are not always
+necessary, |sin 30| (note the space) is the same as |sin(30)|.
+However, functions have the highest precedence so, |sin 30*10|
+is the same as |sin(30)*10|.
+
+\end{math-operators}
+
+
+\begin{math-operators}{\char`\{}{\char`\}}{array}{}
+
+These operators are used to process array-like structures (within an
+expression these characters do not act like \TeX{} grouping tokens).
+The \meta{array specification} consists of comma separated elements,
+for example, |{1, 2, 3, 4, 5}|. Each element in the array will be
+evaluated as it is parsed, so expressions can be used.
+In addition, an element of an array can be an array itself,
+allowing multiple dimension arrays to be simulated:
+|{1, {2,3}, {4,5}, 6}|.
+When storing an array in a macro, do not forget the surrounding
+braces: |\def\myarray{{1,2,3}}| not |\def\myarray{1,2,3}|.
 
 \begin{codeexample}[]
-\pgfmathparse{3*5==15} \pgfmathresult
+\def\myarray{{1,"two",2+1,"IV","cinq","sechs",sin(\i*5)*14}}
+\foreach \i in  {0,...,6}{\pgfmathparse{\myarray[\i]}\pgfmathresult, }
 \end{codeexample}
 
-\end{math-operator}
+\end{math-operators}
 
+\begin{math-operators}{\char`\[}{\char`\]}{array access}{array}
 
-\begin{math-operator}{\mvar{x}\ >\ \mvar{y}} 
+|[| and |]| are two operators used in one particular circumstance: to
+access an array (specified using the |{| and |}| operators)
+using the index \mvar{x}. Indexing starts from zero,
+so, if the index is greater than, or equal to, the number of values in
+the array, an error will occur, and zero will be returned.
 
-	This evaluates to |1| if \mvar{x} is greater than \mvar{y}, or |0| if 
-	\mvar{x} is smaller or equal to \mvar{y}.
-	
 \begin{codeexample}[]
-\pgfmathparse{17>4.2*1.97+4} \pgfmathresult
+\def\myarray{{7,-3,4,-9,11}}
+\pgfmathparse{\myarray[3]} \pgfmathresult
 \end{codeexample}
 
-\end{math-operator}
+If the array is defined to have multiple dimensions then the array
+access operators can be immediately repeated.
 
-\begin{math-operator}{\mvar{x}\ <\ \mvar{y}}
-
-	This evaluates to |1| if \mvar{x} is smaller than \mvar{y}, or |0| if
-	\mvar{x} is greater or equal to \mvar{y}.
-	
 \begin{codeexample}[]
-\pgfmathparse{2<-5.2/-3.6-2} \pgfmathresult
+\def\print#1{\pgfmathparse{#1}\pgfmathresult}
+\def\identitymatrix{{{1,0,0},{0,1,0},{0,0,1}}}
+\tikz[x=0.5cm,y=0.5cm]\foreach \i in {0,1,2} \foreach \j in {0,1,2}
+  \node at (\j,-\i) [anchor=base] {\print{\identitymatrix[\i][\j]}};
 \end{codeexample}
 
-\end{math-operator}
+\end{math-operators}
 
-\begin{math-function}{mod(\mvar{x},\mvar{y})}
-	This evaluates \mvar{x} modulo \mvar{y} (using truncated division).
-	This function cannot be nested inside itself or the functions |max|, 
-	|min| or |pow|.
+
+\begin{math-operators}{"}{"}{group}{}
+
+These operators are used to quote \mvar{x}. However, as every
+expression is expanded with |\edef| before it is parsed, macros
+(e.g., font commands like |\tt| or |\Huge|) may need to be
+``protected'' from this expansion (e.g., |\noexpand\Huge|). Ideally,
+you should avoid such macros anyway.
+Obviously, these operators should be used with great care as further
+calculations are unlikely to be possible with the result.
 
 \begin{codeexample}[]
-\pgfmathparse{mod(20,6)} \pgfmathresult
+\def\x{5}
+\foreach \y in {0,10}{
+  \pgfmathparse{\x > \y ? "\noexpand\Large Bigger" : "\noexpand\tiny smaller"}
+  \x\ is \pgfmathresult\ than \y.
+}
 \end{codeexample}
 
-\end{math-function}
+\end{math-operators}
+
+
+
+
+\subsection{Functions}
+
+\label{pgfmath-functions}
+
+The following functions are recognized:
+
+\medskip
+\def\mathlink#1{\hyperlink{math:#1}{\tt#1}}
+\begin{tikzpicture}
+\foreach \f [count=\i from 0] in
+{abs,acos,add,and,array,asin,atan,atan2,bin,ceil,cos,
+ cosec,cosh,cot,deg,depth,div,divide,e,equal,factorial, false,
+ floor,frac,greater,height,hex,Hex,int,ifthenelse,
+ less,ln,log10,log2,max,min,mod,Mod,multiply,
+ neg,not,notequal,notgreater,notless,
+ oct,or,pi,pow,rad,rand,random,real,rnd,round,
+ sec,sin,sinh,sqrt,subtract,tan,tanh,true, veclen,width}
+\node [anchor=base west] at ({int(\i/11)*2.5cm},{-mod(\i,11)*1.1*\baselineskip}) {\mathlink{\f}};
+\end{tikzpicture}
+\bigskip
+
 
-\begin{math-function}{max(\mvar{x},\mvar{y})}
-	This evaluates to the maximum of \mvar{x} or \mvar{y}. This function 
-	cannot be nested inside itself or the functions |min|, |mod| or 
-	|pow|.
+Each function has a \pgfname{} command associated with it (which is
+also shown with the function below). In general the command
+is simply the name of the function prefixed with |\pgfmath|, for
+example, |\pgfmathadd|, but there are some notable exceptions.
+
+\subsubsection{Basic arithmetic functions}
+
+\label{pgfmath-functions-basic}
+
+\begin{math-function}{add(\mvar{x},\mvar{y})}
+\mathcommand
+
+  Adds $x$ and $y$.
 
 \begin{codeexample}[]
-\pgfmathparse{max(17,23)} \pgfmathresult
+\pgfmathparse{add(75,6)} \pgfmathresult
 \end{codeexample}
-
 \end{math-function}
 
-\begin{math-function}{min(\mvar{x},\mvar{y})}
-	This evaluates to the minimum of \mvar{x} or \mvar{y}. This function 
-	cannot be nested inside itself or the functions |max|, |mod| or 
-	|pow|.
+\begin{math-function}{subtract(\mvar{x},\mvar{y})}
+\mathcommand
+
+  Subtract $x$ from $y$.
 
 \begin{codeexample}[]
-\pgfmathparse{min(17,23)} \pgfmathresult
+\pgfmathparse{subtract(75,6)} \pgfmathresult
 \end{codeexample}
-
 \end{math-function}
 
-\begin{math-function}{abs(\mvar{x})} 
+\begin{math-function}{neg(\mvar{x})}
+\mathcommand
 
-	Evaluates the absolute value of $x$.
+	This returns $-\mvar{x}$.
 	
 \begin{codeexample}[]
-\pgfmathparse{abs(-5)} \pgfmathresult
+\pgfmathparse{neg(50)} \pgfmathresult
 \end{codeexample}
 
+\end{math-function}
+
+\begin{math-function}{multiply(\mvar{x},\mvar{y})}
+\mathcommand
+
+  Multiply $x$ by $y$.
+
 \begin{codeexample}[]
-\pgfmathparse{-abs(4*-3)} \pgfmathresult
+\pgfmathparse{multiply(75,6)} \pgfmathresult
 \end{codeexample}
+\end{math-function}
 
+\begin{math-function}{divide(\mvar{x},\mvar{y})}
+\mathcommand
+
+  Divide $x$ by $y$.
+
+\begin{codeexample}[]
+\pgfmathparse{divide(75,6)} \pgfmathresult
+\end{codeexample}
 \end{math-function}
 
-\begin{math-function}{round(\mvar{x})}
+\begin{math-function}{div(\mvar{x},\mvar{y})}
+\mathcommand
 
-	Rounds \mvar{x} to the nearest integer. It uses ``asymmetric half-up'' 
-	rounding. So |1.5| is rounded to |2|, but |-1.5| is rounded to |-2| 
-	(\emph{not} |0|).
+  Divide $x$ by $y$ and round to the nearest integer
 
 \begin{codeexample}[]
-\pgfmathparse{round(32.5/17)} \pgfmathresult
+\pgfmathparse{div(75,9)} \pgfmathresult
 \end{codeexample}
+\end{math-function}
+
+\begin{math-function}{factorial(\mvar{x})}
+\mathcommand
+
+  Return \mvar{x}!.
 
 \begin{codeexample}[]
-\pgfmathparse{round(398/12)} \pgfmathresult
+\pgfmathparse{factorial(5)} \pgfmathresult
 \end{codeexample}
 
 \end{math-function}
 
-\begin{math-function}{floor(\mvar{x})}
+\begin{math-function}{sqrt(\mvar{x})}
+\mathcommand
+
+ Calculates $\sqrt{\textrm{\mvar{x}}}$.
 
-	Rounds \mvar{x} down to the nearest integer. 
-	
 \begin{codeexample}[]
-\pgfmathparse{floor(32.5/17)} \pgfmathresult
+\pgfmathparse{sqrt(10)} \pgfmathresult
 \end{codeexample}
 
 \begin{codeexample}[]
-\pgfmathparse{floor(398/12)} \pgfmathresult
+\pgfmathparse{sqrt(8765.432)}  \pgfmathresult
 \end{codeexample}
 
 \end{math-function}
 
-\begin{math-function}{ceil(\mvar{x})}
+\begin{math-function}{pow(\mvar{x},\mvar{y})}
+\mathcommand
 
-	Rounds \mvar{x} up to the nearest integer. 
+ Raises \mvar{x} to the power \mvar{y}. For greatest accuracy
+ \mvar{y} should be an integer. If \mvar{y} is not an integer
+ the actual calculation will be an approximation of $e^{yln(x)}$.
 
 \begin{codeexample}[]
-\pgfmathparse{ceil(32.5/17)} \pgfmathresult
+\pgfmathparse{pow(2,7)} \pgfmathresult
 \end{codeexample}
 
+\end{math-function}
+
+
+\begin{math-function}{e}
+\mathcommand
+
+  Returns the value 2.718281828.
+{
+\catcode`\^=7
+
 \begin{codeexample}[]
-\pgfmathparse{ceil(398/12)} \pgfmathresult
+\pgfmathparse{(e^2-e^-2)/2} \pgfmathresult
 \end{codeexample}
 
+}
 \end{math-function}
 
 \begin{math-function}{exp(\mvar{x})}
+\mathcommand
+
 {
 \catcode`\^=7
 
-	Maclaurin series for $e^x$. 
+	Maclaurin series for $e^x$.
 }	
 \begin{codeexample}[]
 \pgfmathparse{exp(1)} \pgfmathresult
@@ -448,10 +557,14 @@ calculation will be an approximation of $e^{y\ln(x)}$.
 
 
 \begin{math-function}{ln(\mvar{x})}
+\mathcommand
+
 {
 \catcode`\^=7
 
-	An approximation for for $\ln(\textrm{\mvar{x}})$. 
+	An approximation for $\ln(\textrm{\mvar{x}})$.
+	This uses an algorithm due to Rouben Rostamian, and coefficients
+	suggested by Alain Matthes.
 }	
 \begin{codeexample}[]
 \pgfmathparse{ln(10)} \pgfmathresult
@@ -463,77 +576,183 @@ calculation will be an approximation of $e^{y\ln(x)}$.
 
 \end{math-function}
 
-\begin{math-function}{pow(\mvar{x},\mvar{y})}
+\begin{math-function}{log10(\mvar{x})}
+\mathcommand[logten(\mvar{x})]
 
- Raises \mvar{x} to the power \mvar{y}. 
+	An approximation for $\log_{10}(\textrm{\mvar{x}})$.
 
 \begin{codeexample}[]
-\pgfmathparse{pow(2,7)} \pgfmathresult
+\pgfmathparse{log10(100)} \pgfmathresult
 \end{codeexample}
 
 \end{math-function}
 
-\begin{math-function}{sqrt(\mvar{x})}
+\begin{math-function}{log2(\mvar{x})}
+\mathcommand[logtwo(\mvar{x})]
 
- Calculates $\sqrt{\textrm{\mvar{x}}}$.
+	An approximation for $\log_2(\textrm{\mvar{x}})$.
 
 \begin{codeexample}[]
-\pgfmathparse{sqrt(10)} \pgfmathresult
+\pgfmathparse{log2(128)} \pgfmathresult
 \end{codeexample}
 
+\end{math-function}
+
+\begin{math-function}{abs(\mvar{x})}
+\mathcommand
+
+	Evaluates the absolute value of $x$.
+	
 \begin{codeexample}[]
-\pgfmathparse{sqrt(8765.432)}  \pgfmathresult
+\pgfmathparse{abs(-5)} \pgfmathresult
 \end{codeexample}
 
+\begin{codeexample}[]
+\pgfmathparse{-abs(4*-3)} \pgfmathresult
+\end{codeexample}
 \end{math-function}
 
-\begin{math-function}{veclen(\mvar{x},\mvar{y})}
+\begin{math-function}{mod(\mvar{x},\mvar{y})}
+\mathcommand
 
- Calculates $\sqrt{\left(\textrm{\mvar{x}}^2+\textrm{\mvar{y}}^2\right)}$.
+	This evaluates \mvar{x} modulo \mvar{y}, using truncated division.
+	The sign of the result is the same as the sign of
+	$\frac{\textrm{\mvar{x}}}{\textrm{\mvar{y}}}$.
 
 \begin{codeexample}[]
-\pgfmathparse{veclen(12,5)} \pgfmathresult
+\pgfmathparse{mod(20,6)} \pgfmathresult
+\end{codeexample}
+
+\begin{codeexample}[]
+\pgfmathparse{mod(-100,30)} \pgfmathresult
+\end{codeexample}
+
+\end{math-function}
+
+\begin{math-function}{Mod(\mvar{x},\mvar{y})}
+\mathcommand
+
+	This evaluates \mvar{x} modulo \mvar{y}, using floored division.
+	The sign of the result is never negative.
+
+\begin{codeexample}[]
+\pgfmathparse{Mod(-100,30)} \pgfmathresult
+\end{codeexample}
+
+\end{math-function}
+
+
+
+
+
+\subsubsection{Rounding functions}
+
+\label{pgfmath-functions-rounding}
+
+\begin{math-function}{round(\mvar{x})}
+\mathcommand
+
+	Rounds \mvar{x} to the nearest integer. It uses ``asymmetric half-up''
+	rounding. So |1.5| is rounded to |2|, but |-1.5| is rounded to |-2|
+	(\emph{not} |1|).
+
+\begin{codeexample}[]
+\pgfmathparse{round(32.5/17)} \pgfmathresult
+\end{codeexample}
+
+\begin{codeexample}[]
+\pgfmathparse{round(398/12)} \pgfmathresult
 \end{codeexample}
 
 \end{math-function}
 
-\begin{math-constant}{pi}
+\begin{math-function}{floor(\mvar{x})}
+\mathcommand
 
-	The constant $\pi=3.14159$.
+	Rounds \mvar{x} down to the nearest integer.
 	
 \begin{codeexample}[]
-\pgfmathparse{pi} \pgfmathresult
+\pgfmathparse{floor(32.5/17)} \pgfmathresult
 \end{codeexample}
 
 \begin{codeexample}[]
-\pgfmathparse{pi r} \pgfmathresult
+\pgfmathparse{floor(398/12)} \pgfmathresult
 \end{codeexample}
 
-\end{math-constant}
+\end{math-function}
 
-\begin{math-operator}{\mvar{x}\ r}
+\begin{math-function}{ceil(\mvar{x})}
+\mathcommand
 
-	This converts \mvar{x} from radians to degrees. Note that |r| will 
-	evaluate any preceding series of multiplication or division 
-	\emph{before} conversion, but not other operations. So |3*4/6r| 
-	converts 2 radians to degrees, but |3-4+6r|, converts 6 radians to
-	degrees and adds the result to |-1|.
+	Rounds \mvar{x} up to the nearest integer.
 
 \begin{codeexample}[]
-\pgfmathparse{2*pi r-pi r} \pgfmathresult
+\pgfmathparse{ceil(32.5/17)} \pgfmathresult
 \end{codeexample}
 
 \begin{codeexample}[]
-\pgfmathparse{2*pi/8 r} \pgfmathresult
+\pgfmathparse{ceil(398/12)} \pgfmathresult
 \end{codeexample}
 
+\end{math-function}
+
+\begin{math-function}{int(\mvar{x})}
+\mathcommand
+
+	Returns the integer part of \mvar{x}.
+
 \begin{codeexample}[]
-\pgfmathparse{sin(3*pi/2r)*60} \pgfmathresult
+\pgfmathparse{int(32.5/17)} \pgfmathresult
 \end{codeexample}
 
-\end{math-operator}
+\end{math-function}
+
+\begin{math-function}{frac(\mvar{x})}
+\mathcommand
+
+	Returns the fractional part of \mvar{x}.
+
+\begin{codeexample}[]
+\pgfmathparse{frac(32.5/17)} \pgfmathresult
+\end{codeexample}
+
+\end{math-function}
+
+\begin{math-function}{real(\mvar{x})}
+\mathcommand
+
+	Ensures \mvar{x} contains a decimal point.
+
+\begin{codeexample}[]
+\pgfmathparse{real(4)} \pgfmathresult
+\end{codeexample}
+
+\end{math-function}
+
+
+
+
+\subsubsection{Trigonometric functions}
+
+\label{pgfmath-functions-trigonometric}
+
+\begin{math-function}{pi}
+\mathcommand
+
+	Returns the value $\pi=3.141592654$.
+	
+\begin{codeexample}[]
+\pgfmathparse{pi} \pgfmathresult
+\end{codeexample}
+
+\begin{codeexample}[]
+\pgfmathparse{pi r} \pgfmathresult
+\end{codeexample}
+
+\end{math-function}
 
 \begin{math-function}{rad(\mvar{x})}
+\mathcommand
 
 	Convert \mvar{x} to radians. \mvar{x} is assumed to be in degrees.
 	
@@ -544,6 +763,7 @@ calculation will be an approximation of $e^{y\ln(x)}$.
 \end{math-function}
 
 \begin{math-function}{deg(\mvar{x})}
+\mathcommand
 
 	Convert \mvar{x} to degrees. \mvar{x} is assumed to be in radians.
 	
@@ -554,8 +774,9 @@ calculation will be an approximation of $e^{y\ln(x)}$.
 \end{math-function}
 
 \begin{math-function}{sin(\mvar{x})}
+\mathcommand
 
-	Sine of \mvar{x}. By employing the |r| operator, \mvar{x} can be in 
+	Sine of \mvar{x}. By employing the |r| operator, \mvar{x} can be in
 	radians.
 	
 \begin{codeexample}[]
@@ -563,14 +784,15 @@ calculation will be an approximation of $e^{y\ln(x)}$.
 \end{codeexample}
 
 \begin{codeexample}[]
-\pgfmathparse{sin(pi/3 r)}
+\pgfmathparse{sin(pi/3 r)} \pgfmathresult
 \end{codeexample}
 
 \end{math-function}
 
 \begin{math-function}{cos(\mvar{x})}
+\mathcommand
 
-	Cosine of \mvar{x}. By employing the |r| operator, \mvar{x} can be in 
+	Cosine of \mvar{x}. By employing the |r| operator, \mvar{x} can be in
 	radians.
 
 \begin{codeexample}[]
@@ -584,8 +806,9 @@ calculation will be an approximation of $e^{y\ln(x)}$.
 \end{math-function}
 
 \begin{math-function}{tan(\mvar{x})}
+\mathcommand
 
-	Tangent of \mvar{x}. By employing the |r| operator, \mvar{x} can be in 
+	Tangent of \mvar{x}. By employing the |r| operator, \mvar{x} can be in
 	radians.
 	
 \begin{codeexample}[]
@@ -600,8 +823,9 @@ calculation will be an approximation of $e^{y\ln(x)}$.
 
 
 \begin{math-function}{sec(\mvar{x})}
+\mathcommand
 
-	Secant of \mvar{x}. By employing the |r| operator, \mvar{x} can be in 
+	Secant of \mvar{x}. By employing the |r| operator, \mvar{x} can be in
 	radians.
 
 \begin{codeexample}[]
@@ -611,8 +835,9 @@ calculation will be an approximation of $e^{y\ln(x)}$.
 \end{math-function}
 
 \begin{math-function}{cosec(\mvar{x})}
+\mathcommand
 
-	Cosecant of \mvar{x}. By employing the |r| operator, \mvar{x} can be in 
+	Cosecant of \mvar{x}. By employing the |r| operator, \mvar{x} can be in
 	radians.
 	
 \begin{codeexample}[]
@@ -622,8 +847,9 @@ calculation will be an approximation of $e^{y\ln(x)}$.
 \end{math-function}
 
 \begin{math-function}{cot(\mvar{x})}
+\mathcommand
 
-	Cotangent of \mvar{x}. By employing the |r| operator, \mvar{x} can be in 
+	Cotangent of \mvar{x}. By employing the |r| operator, \mvar{x} can be in
 	radians.
 	
 \begin{codeexample}[]
@@ -633,6 +859,7 @@ calculation will be an approximation of $e^{y\ln(x)}$.
 \end{math-function}
 
 \begin{math-function}{asin(\mvar{x})}
+\mathcommand
 
 	Arcsine of \mvar{x}. The result is in degrees and in the range $\pm90^\circ$.
 
@@ -643,9 +870,9 @@ calculation will be an approximation of $e^{y\ln(x)}$.
 \end{math-function}
 
 \begin{math-function}{acos(\mvar{x})}
+\mathcommand
 
-	Arccosine of \mvar{x} in degrees. The result is in the range $\pm90^\circ$.
-
+	Arccosine of \mvar{x} in degrees. The result is in the range $[0^\circ,180^\circ]$.
 
 \begin{codeexample}[]
 \pgfmathparse{acos(0.5)} \pgfmathresult
@@ -654,8 +881,9 @@ calculation will be an approximation of $e^{y\ln(x)}$.
 \end{math-function}
 
 \begin{math-function}{atan(\mvar{x})}
+\mathcommand
 
-	Arctangent of $x$ in degrees. 
+	Arctangent of $x$ in degrees.
 
 \begin{codeexample}[]
 \pgfmathparse{atan(1)} \pgfmathresult
@@ -663,34 +891,392 @@ calculation will be an approximation of $e^{y\ln(x)}$.
 
 \end{math-function}
 
-\begin{math-function}{rnd}
+\begin{math-function}{atan2(\mvar{x},\mvar{y})}
+\mathcommand[atantwo(\mvar{x},\mvar{y})]
 
-	Generates a pseudo-random number between 0 and 1.
+	Arctangent of $y\div x$ in degrees. This also takes into account the
+	quadrants.
+
+\begin{codeexample}[]
+\pgfmathparse{atan2(-4,3)} \pgfmathresult
+\end{codeexample}
+
+\end{math-function}
+
+\subsubsection{Comparison and logical functions}
+
+\label{pgfmath-functions-comparison}
+
+\begin{math-function}{equal(\mvar{x},\mvar{y})}
+\mathcommand
+
+	This returns |1| if $\mvar{x}=\mvar{y}$ and |0| otherwise.
+	
+\begin{codeexample}[]
+\pgfmathparse{equal(20,20)} \pgfmathresult
+\end{codeexample}
+
+\end{math-function}
+
+\begin{math-function}{greater(\mvar{x},\mvar{y})}
+\mathcommand
+
+	This returns |1| if $\mvar{x}>\mvar{y}$ and |0| otherwise.
+	
+\begin{codeexample}[]
+\pgfmathparse{greater(20,25)} \pgfmathresult
+\end{codeexample}
+
+\end{math-function}
+
+\begin{math-function}{less(\mvar{x},\mvar{y})}
+\mathcommand
+
+	This returns |1| if $\mvar{x}<\mvar{y}$ and |0| otherwise.
+	
+\begin{codeexample}[]
+\pgfmathparse{greater(20,25)} \pgfmathresult
+\end{codeexample}
+\end{math-function}
+
+\begin{math-function}{notequal(\mvar{x},\mvar{y})}
+\mathcommand
+
+	This returns |0| if $\mvar{x}=\mvar{y}$ and |1| otherwise.
+	
+\begin{codeexample}[]
+\pgfmathparse{notequal(20,25)} \pgfmathresult
+\end{codeexample}
+
+\end{math-function}
+
+\begin{math-function}{notgreater(\mvar{x},\mvar{y})}
+\mathcommand
+
+	This returns |1| if $\mvar{x}\leq\mvar{y}$ and |0| otherwise.
+	
+\begin{codeexample}[]
+\pgfmathparse{notgreater(20,25)} \pgfmathresult
+\end{codeexample}
+\end{math-function}
+
+\begin{math-function}{notless(\mvar{x},\mvar{y})}
+\mathcommand
+
+	This returns |1| if $\mvar{x}\geq\mvar{y}$ and |0| otherwise.
+	
+\begin{codeexample}[]
+\pgfmathparse{notless(20,25)} \pgfmathresult
+\end{codeexample}
+
+\end{math-function}
+
+\begin{math-function}{and(\mvar{x},\mvar{y})}
+\mathcommand
 
+	This returns |1| if \mvar{x} and \mvar{y} both evaluate to
+	non-zero values. Otherwise |0| is returned.
+	
 \begin{codeexample}[]
-\pgfmathparse{rnd} \pgfmathresult
+\pgfmathparse{and(5>4,6>7)} \pgfmathresult
 \end{codeexample}
 
+\end{math-function}
+
+\begin{math-function}{or(\mvar{x},\mvar{y})}
+\mathcommand
+
+	This returns |1| if either \mvar{x} or \mvar{y} evaluate to
+	non-zero values. Otherwise |0| is returned.
+	
 \begin{codeexample}[]
-\pgfmathparse{2*rnd} \pgfmathresult
+\pgfmathparse{and(5>4,6>7)} \pgfmathresult
 \end{codeexample}
 
+\end{math-function}
+
+\begin{math-function}{not(\mvar{x})}
+\mathcommand
+
+	This returns |1| if $\mvar{x}=0$, otherwise |0|.
+	
 \begin{codeexample}[]
-\pgfmathparse{-rnd+5} \pgfmathresult
+\pgfmathparse{not(true)} \pgfmathresult
+\end{codeexample}
+
+\end{math-function}
+
+
+\begin{math-function}{ifthenelse(\mvar{x},\mvar{y},\mvar{z})}
+\mathcommand
+
+	This returns \mvar{y} if \mvar{x} evaluates to some non-zero value,
+	otherwise \mvar{z} is returned.
+	
+\begin{codeexample}[]
+\pgfmathparse{ifthenelse(5==4,"yes","no")} \pgfmathresult
+\end{codeexample}
+
+\end{math-function}
+
+\begin{math-function}{true}
+\mathcommand
+
+	This evaluates to |1|.
+	
+\begin{codeexample}[]
+\pgfmathparse{true ? "yes" : "no"} \pgfmathresult
+\end{codeexample}
+
+\end{math-function}
+
+\begin{math-function}{false}
+\mathcommand
+
+	This evaluates to |0|.
+	
+\begin{codeexample}[]
+\pgfmathparse{false ? "yes" : "no"} \pgfmathresult
+\end{codeexample}
+
+\end{math-function}
+
+
+
+\subsubsection{Pseudo-random functions}
+
+\label{pgfmath-functions-random}
+
+\begin{math-function}{rnd}
+\mathcommand
+
+	Generates a pseudo-random number between 0 and 1.
+
+\begin{codeexample}[]
+\foreach \x in {1,...,10}{\pgfmathparse{rnd}\pgfmathresult, }
 \end{codeexample}
 
 \end{math-function}
 
 \begin{math-function}{rand}
+\mathcommand
 
 	Generates a pseudo-random number between -1 and 1.
 
 \begin{codeexample}[]
-\pgfmathparse{rand} \pgfmathresult
+\foreach \x in {1,...,10}{\pgfmathparse{rand}\pgfmathresult, }
+\end{codeexample}
+
+\end{math-function}
+
+\begin{math-function}{random(\opt{\mvar{x},\mvar{y}})}
+\mathcommand
+  This function takes zero, one or two arguments. If there are zero
+  arguments, a random number between 0 and 1 is generated. If there is
+  one argument \mvar{x}, a random integer between 1 and \mvar{x} is
+  generated. Finally, if there are two arguments, a random integer
+  between \mvar{x} and \mvar{y} is generated. If there are no
+  arguments the \pgfname{} command should be called as follows:
+  |\pgfmathrandom{}|.
+
+\begin{codeexample}[]
+\foreach \x in {1,...,10}{\pgfmathparse{random()}\pgfmathresult, }
+\end{codeexample}
+
+\begin{codeexample}[]
+\foreach \x in {1,...,10}{\pgfmathparse{random(100)}\pgfmathresult, }
+\end{codeexample}
+
+\begin{codeexample}[]
+\foreach \x in {1,...,10}{\pgfmathparse{random(232,762)}\pgfmathresult, }
 \end{codeexample}
+\end{math-function}
+
+\subsubsection{Base conversion functions}
+
+\label{pgfmath-functions-base}
 
+\begin{math-function}{hex(\mvar{x})}
+\mathcommand
+
+  Convert \mvar{x}{} (assumed to be an integer in base 10) to a
+  hexadecimal representation, using lower case alphabetic digits.
+	No further calculation will be possible with the result.
+	
 \begin{codeexample}[]
-\pgfmathparse{rand*15} \pgfmathresult
-\end{codeexample} 
+\pgfmathparse{hex(65535)} \pgfmathresult
+\end{codeexample}
+\end{math-function}
+
+\begin{math-function}{Hex(\mvar{x})}
+\mathcommand
+
+  Convert \mvar{x}{} (assumed to be an integer in base 10) to a
+  hexadecimal representation, using upper case alphabetic digits.
+  No further calculation will be possible with the result.
+
+\begin{codeexample}[]
+\pgfmathparse{Hex(65535)} \pgfmathresult
+\end{codeexample}
+\end{math-function}
+
+\begin{math-function}{oct(\mvar{x})}
+\mathcommand
 
+  Convert \mvar{x}{} (assumed to be an integer in base 10) to a
+  octal representation.
+  No further calculation should be attempted with the result, as
+  the parser can only process numbers converted to base 10.
+\begin{codeexample}[]
+\pgfmathparse{oct(63)} \pgfmathresult
+\end{codeexample}
+\end{math-function}
+
+\begin{math-function}{bin(\mvar{x})}
+\mathcommand
+
+  Convert \mvar{x}{} (assumed to be an integer in base 10) to a
+  binary representation.
+  No further calculation should be attempted with the result, as
+  the parser can only process numbers converted to base 10.
+
+\begin{codeexample}[]
+\pgfmathparse{bin(185)} \pgfmathresult
+\end{codeexample}
+\end{math-function}
+
+\subsubsection{Miscellaneous functions}
+
+\label{pgfmath-functions-misc}
+
+\begin{math-function}{min(\mvar{x$_1$},\mvar{x$_2$},\ldots,\mvar{x$_n$})}
+\mathcommand[min({\mvar{x$_1$},\mvar{x$_2$},\ldots},{\ldots,\mvar{x$_{n-1}$},\mvar{x$_n$}})]
+
+  Return the minimum value from \mvar{x$_1$}\ldots\mvar{x$_n$}.
+  For historical reasons, the command |\pgfmathmin| takes two
+  arguments, but each of these can contain an arbitrary number
+  of comma separated values.
+
+\begin{codeexample}[]
+\pgfmathparse{min(3,4,-2,250,-8,100)} \pgfmathresult
+\end{codeexample}
+
+\end{math-function}
+
+
+\begin{math-function}{max(\mvar{x$_1$},\mvar{x$_2$},\ldots,\mvar{x$_n$})}
+\mathcommand[max({\mvar{x$_1$},\mvar{x$_2$},\ldots},{\ldots,\mvar{x$_{n-1}$},\mvar{x$_n$}})]
+
+  Return the maximum value from \mvar{x$_1$}\ldots\mvar{x$_n$}.
+  Again, for historical reasons, the command |\pgfmathmax| takes two
+  arguments, but each of these can contain an arbitrary number
+  of comma separated values.
+
+\begin{codeexample}[]
+\pgfmathparse{max(3,4,-2,250,-8,100)} \pgfmathresult
+\end{codeexample}
+
+\end{math-function}
+
+
+\begin{math-function}{veclen(\mvar{x},\mvar{y})}
+\mathcommand
+
+ Calculates $\sqrt{\left(\textrm{\mvar{x}}^2+\textrm{\mvar{y}}^2\right)}$.
+ This uses a polynomial approximation, based on ideas due
+ to Rouben Rostamian
+\begin{codeexample}[]
+\pgfmathparse{veclen(12,5)} \pgfmathresult
+\end{codeexample}
+
+\end{math-function}
+
+
+
+
+
+\begin{math-function}{array(\mvar{x},\mvar{y})}
+\mathcommand
+
+	This accesses the array \mvar{x} at the index \mvar{y}. The
+	array must begin and end with braces (e.g., |{1,2,3,4}|) and
+	array indexing starts at |0|.
+	
+\begin{codeexample}[]
+\pgfmathparse{array({9,13,17,21},2)} \pgfmathresult
+\end{codeexample}
+
+\end{math-function}
+
+
+The following hyperbolic functions were adapted from code
+suggested by Martin Heller:
+
+\begin{math-function}{sinh(\mvar{x})}
+\mathcommand
+
+	The hyperbolic sine of \mvar{x}%
+	
+\begin{codeexample}[]
+\pgfmathparse{sinh(0.5)} \pgfmathresult
+\end{codeexample}
+
+\end{math-function}
+
+\begin{math-function}{cosh(\mvar{x})}
+\mathcommand
+
+	The hyperbolic cosine of \mvar{x}%
+	
+\begin{codeexample}[]
+\pgfmathparse{cosh(0.5)} \pgfmathresult
+\end{codeexample}
+
+\end{math-function}
+
+\begin{math-function}{tanh(\mvar{x})}
+\mathcommand
+
+	The hyperbolic tangent of \mvar{x}%
+	
+\begin{codeexample}[]
+\pgfmathparse{tanh(0.5)} \pgfmathresult
+\end{codeexample}
+
+\end{math-function}
+
+\begin{math-function}{width("\mvar{x}")}
+\mathcommand
+
+  Return the width of a \TeX{} (horizontal) box containing \mvar{x}.
+  The quote characters are necessary to prevent \mvar{x}{} being
+  parsed.
+  It is important to remember that any expression is expanded with
+  |\edef| before being parsed, so any macros (e.g., font commands
+  like |\tt| or |\Huge|) will need to be ``protected'' (e.g.,
+  |\noexpand\Huge| is usually sufficient).
+
+\begin{codeexample}[]
+\pgfmathparse{width("Some Lovely Text")} \pgfmathresult
+\end{codeexample}
+\end{math-function}
+
+\begin{math-function}{height("\mvar{x}")}
+\mathcommand
+
+  Return the height of a box containing \mvar{x}.
+
+\begin{codeexample}[]
+\pgfmathparse{height("Some Lovely Text")} \pgfmathresult
+\end{codeexample}
+\end{math-function}
+
+\begin{math-function}{depth("\mvar{x}")}
+\mathcommand
+
+  Returns the depth of a box containing \mvar{x}.
+
+\begin{codeexample}[]
+\pgfmathparse{depth("Some Lovely Text")} \pgfmathresult
+\end{codeexample}
 \end{math-function}