summaryrefslogtreecommitdiff
path: root/graphics/pgf/base/doc/pgfmanual-en-tikz-graphs.tex
diff options
context:
space:
mode:
Diffstat (limited to 'graphics/pgf/base/doc/pgfmanual-en-tikz-graphs.tex')
-rw-r--r--graphics/pgf/base/doc/pgfmanual-en-tikz-graphs.tex3703
1 files changed, 3703 insertions, 0 deletions
diff --git a/graphics/pgf/base/doc/pgfmanual-en-tikz-graphs.tex b/graphics/pgf/base/doc/pgfmanual-en-tikz-graphs.tex
new file mode 100644
index 0000000000..0135679c6e
--- /dev/null
+++ b/graphics/pgf/base/doc/pgfmanual-en-tikz-graphs.tex
@@ -0,0 +1,3703 @@
+% Copyright 2019 by Till Tantau
+% Copyright 2019 by Jannis Pohlmann
+%
+% This file may be distributed and/or modified
+%
+% 1. under the LaTeX Project Public License and/or
+% 2. under the GNU Free Documentation License.
+%
+% See the file doc/generic/pgf/licenses/LICENSE for more details.
+
+
+\section{Specifying Graphs}
+\label{section-library-graphs}
+
+\subsection{Overview}
+
+\tikzname\ offers a powerful path command for specifying how the nodes in a
+graph are connected by edges and arcs: The |graph| path command, which becomes
+available when you load the |graphs| library.
+
+\begin{tikzlibrary}{graphs}
+ The package must be loaded to use the |graph| path command.
+\end{tikzlibrary}
+
+In this section, by \emph{graph} we refer to a set of nodes together with some
+edges (sometimes also called arcs, in case they are directed) such as the
+following:
+%
+\begin{codeexample}[preamble={\usetikzlibrary{graphs}}]
+\tikz \graph { a -> {b, c} -> d };
+\end{codeexample}
+
+\begin{codeexample}[preamble={\usetikzlibrary{graphs.standard}}]
+\tikz \graph {
+ subgraph I_nm [V={a, b, c}, W={1,...,4}];
+
+ a -> { 1, 2, 3 };
+ b -> { 1, 4 };
+ c -> { 2 [>green!75!black], 3, 4 [>red]}
+};
+\end{codeexample}
+
+\begin{codeexample}[preamble={\usetikzlibrary{graphs}}]
+\tikz
+ \graph [nodes={draw, circle}, clockwise, radius=.5cm, empty nodes, n=5] {
+ subgraph I_n [name=inner] --[complete bipartite]
+ subgraph I_n [name=outer]
+ };
+\end{codeexample}
+
+\begin{codeexample}[
+ preamble={\usetikzlibrary{graphs}},
+ pre={\definecolor{graphicbackground}{rgb}{0.96,0.96,0.8}},
+]
+\tikz
+ \graph [nodes={draw, circle}, clockwise, radius=.75cm, empty nodes, n=8] {
+ subgraph C_n [name=inner] <->[shorten <=1pt, shorten >=1pt]
+ subgraph C_n [name=outer]
+ };
+\end{codeexample}
+
+\begin{codeexample}[width=6.6cm,preamble={\usetikzlibrary{graphs}}]
+\tikz [>={To[sep]}, rotate=90, xscale=-1,
+ mark/.style={fill=black!50}, mark/.default=]
+ \graph [trie, simple,
+ nodes={circle,draw},
+ edges={nodes={
+ inner sep=1pt, anchor=mid,
+ fill=graphicbackground}}, % yellowish background
+ put node text on incoming edges]
+ {
+ root[mark] -> {
+ a -> n -> {
+ g [mark],
+ f -> a -> n -> g [mark]
+ },
+ f -> a -> n -> g [mark],
+ g[mark],
+ n -> {
+ g[mark],
+ f -> a -> n -> g[mark]
+ }
+ },
+ { [edges=red] % highlight one path
+ root -> f -> a -> n
+ }
+ };
+\end{codeexample}
+
+The nodes of a graph are normal \tikzname\ nodes, the edges are normal lines
+drawn between nodes. There is nothing in the |graphs| library that you cannot
+do using the normal |\node| and the |edge| commands. Rather, its purpose is to
+offer a concise and powerful way of \emph{specifying} which nodes are present
+and how they are connected. The |graphs| library only offers simple methods for
+specifying \emph{where} the nodes should be shown, its main strength is in
+specifying which nodes and edges are present in principle. The problem of
+finding ``good positions on the canvas'' for the nodes of a graph is left to
+\emph{graph drawing algorithms}, which are covered in Part~\ref{part-gd} of
+this manual and which are not part of the |graphs| library; indeed, these
+algorithms can be used also with graphs specified using |node| and |edge|
+commands.
+%
+\ifluatex
+As an example, consider the above drawing of a trie, which is drawn without
+using the graph drawing libraries. Its layout can be somewhat improved by
+loading the |layered| graph drawing library, saying |\tikz[layered layout,...|,
+and then using Lua\TeX, resulting in the following drawing of the same graph:
+\medskip
+
+\tikz [layered layout, >={To[sep]}, rotate=90, xscale=-1,
+ mark/.style={fill=black!50}, mark/.default=]
+ \graph [trie, simple, sibling distance=8mm,
+ nodes={circle,draw},
+ edges={nodes={
+ inner sep=1pt, anchor=mid, fill=white}},
+ put node text on incoming edges]
+ {
+ root[mark] -> {
+ a -> n -> {
+ g [mark],
+ f -> a -> n -> g [mark]
+ },
+ f -> a -> n -> g [mark],
+ g[mark],
+ n -> {
+ g[mark],
+ f -> a -> n -> g[mark]
+ }
+ },
+ { [edges=red] % highlight one path
+ root -> f -> a -> n
+ }
+ };
+\medskip
+\fi
+
+The |graphs| library uses a syntax that is quite different from the normal
+\tikzname\ syntax for specifying nodes. The reason for this is that for many
+medium-sized graphs it can become quite cumbersome to specify all the nodes
+using |\node| repeatedly and then using a great number of |edge| command;
+possibly with complicated |\foreach| statements. Instead, the syntax of the
+|graphs| library is loosely inspired by the \textsc{dot} format, which is quite
+useful for specifying medium-sized graphs, with some extensions on top.
+
+
+\subsection{Concepts}
+
+The present section aims at giving a quick overview of the main concepts behind
+the |graph| command. The exact syntax is explained in more detail in later
+sections.
+
+
+\subsubsection{Concept: Node Chains}
+
+The basic way of specifying a graph is to write down a \emph{node chain} as in
+the following example:
+%
+\begin{codeexample}[preamble={\usetikzlibrary{graphs}}]
+\tikz [every node/.style = draw]
+ \graph { foo -> bar -> blub };
+\end{codeexample}
+
+As can be seen, the text |foo -> bar -> blub| creates three nodes, one with
+the text |foo|, one with |bar| and one with the text |blub|. These nodes are
+connected by arrows, which are caused by the |->| between the node texts. Such
+a sequence of node texts and arrows between them is called a \emph{chain} in
+the following.
+
+Inside a graph there can be more than one chain:
+%
+\begin{codeexample}[preamble={\usetikzlibrary{graphs}}]
+\tikz \graph {
+ a -> b -> c;
+ d -> e -> f;
+ g -> f;
+};
+\end{codeexample}
+
+Multiple chains are separated by a semicolon or a comma (both have exactly the
+same effect). As the example shows, when a node text is seen for the second
+time, instead of creating a new node, a connection is created to the already
+existing node.
+
+When a node like |f| is created, both the node name and the node text are
+identical by default. This is not always desirable and can be changed by using
+the |as| key or by providing another text after a slash:
+%
+\begin{codeexample}[preamble={\usetikzlibrary{graphs}}]
+\tikz \graph {
+ x1/$x_1$ -> x2 [as=$x_2$, red] -> x34/{$x_3,x_4$};
+ x1 -> [bend left] x34;
+};
+\end{codeexample}
+
+When you wish to use a node name that contains special symbols like commas or
+dashes, you must surround the node name by quotes. This allows you to use quite
+arbitrary text as a ``node name'':
+%
+\begin{codeexample}[preamble={\usetikzlibrary{graphs}}]
+\tikz \graph {
+ "$x_1$" -> "$x_2$"[red] -> "$x_3,x_4$";
+ "$x_1$" ->[bend left] "$x_3,x_4$";
+};
+\end{codeexample}
+
+
+\subsubsection{Concept: Chain Groups}
+
+Multiple chains that are separated by a semicolon or a comma and that are
+surrounded by curly braces form what will be called a \emph{chain group} or
+just a \emph{group}. A group in itself has no special effect. However, things
+get interesting when you write down a node or even a whole group and connect it
+to another group. In this case, the ``exit points'' of the first node or group
+get connected to the ``entry points'' of the second node or group:
+%
+\begin{codeexample}[preamble={\usetikzlibrary{graphs}}]
+\tikz \graph {
+ a -> {
+ b -> c,
+ d -> e
+ } -> f
+};
+\end{codeexample}
+
+Chain groups make it easy to create tree structures:
+%
+\begin{codeexample}[width=10cm,preamble={\usetikzlibrary{graphs}}]
+\tikz
+ \graph [grow down,
+ branch right=2.5cm] {
+ root -> {
+ child 1,
+ child 2 -> {
+ grand child 1,
+ grand child 2
+ },
+ child 3 -> {
+ grand child 3
+ }
+ }
+};
+\end{codeexample}
+
+As can be seen, the placement is not particularly nice by default, use the
+algorithms from the graph drawing libraries to get a better layout. For
+instance, adding |tree layout| to the above code (and
+|\usetikzlibrary{graphdrawing}| as well as |\usegdlibrary{trees}| to the
+preamble) results in the following somewhat more pleasing rendering:
+%
+\ifluatex
+\medskip
+
+\tikz \graph [grow down, branch right=2.5cm, tree layout] {
+ root -> {
+ child 1,
+ child 2 -> {
+ grand child 1,
+ grand child 2
+ },
+ child 3 -> {
+ grand child 3
+ }
+ }
+};
+\else
+ (You need to use Lua\TeX\ to typeset this graphic.)
+\fi
+
+
+\subsubsection{Concept: Edge Labels and Styles}
+
+When connectors like |->| or |--| are used to connect nodes or whole chain
+groups, one or more edges will typically be created. These edges can be styled
+easily by providing options in square brackets directly after these connectors:
+%
+\begin{codeexample}[preamble={\usetikzlibrary{graphs}}]
+\tikz \graph {
+ a ->[red] b --[thick] {c, d};
+};
+\end{codeexample}
+
+Using the quotes syntax, see Section~\ref{section-label-quotes}, you can even
+add labels to the edges easily by putting the labels in quotes:
+%
+\begin{codeexample}[preamble={\usetikzlibrary{graphs,quotes}}]
+\tikz \graph {
+ a ->[red, "foo"] b --[thick, "bar"] {c, d};
+};
+\end{codeexample}
+
+For the first edge, the effect is as desired, however between |b| and the group
+|{c,d}| two edges are inserted and the options |thick| and the label option
+|"bar"| is applied to both of them. While this is the correct and consistent
+behavior, we typically might wish to specify different labels for the edge
+going from |b| to |c| and the edge going from |b| to |d|. To achieve this
+effect, we can no longer specify the label as part of the options of |--|.
+Rather, we must pass the desired label to the nodes |c| and |d|, but we must
+somehow also indicate that these options actually ``belong'' to the edge
+``leading'' to nodes. This is achieved by preceding the options with a
+greater-than sign:
+%
+\begin{codeexample}[preamble={\usetikzlibrary{graphs,quotes}}]
+\tikz \graph {
+ a -> b -- {c [> "foo"], d [> "bar"']};
+};
+\end{codeexample}
+
+Symmetrically, preceding the options by |<| causes the options and labels to
+apply to the ``outgoing'' edges of the node:
+%
+\begin{codeexample}[preamble={\usetikzlibrary{graphs,quotes}}]
+\tikz \graph {
+ a [< red] -> b -- {c [> blue], d [> "bar"']};
+};
+\end{codeexample}
+
+This syntax allows you to easily create trees with special edge labels as in
+the following example of a treap:
+%
+\begin{codeexample}[preamble={\usetikzlibrary{graphs,quotes}}]
+\tikz
+ \graph [edge quotes={fill=white,inner sep=1pt},
+ grow down, branch right, nodes={circle,draw}] {
+ "" -> h [>"9"] -> {
+ c [>"4"] -> {
+ a [>"2"],
+ e [>"0"]
+ },
+ j [>"7"]
+ }
+ };
+\end{codeexample}
+
+
+\subsubsection{Concept: Node Sets}
+
+When you write down some node text inside a |graph| command, a new node is
+created by default unless this node has already been created inside the same
+|graph| command. In particular, if a node has already been declared outside of
+the current |graph| command, a new node of the same name gets created.
+
+This is not always the desired behavior. Often, you may wish to make nodes part
+of a graph than have already been defined prior to the use of the |graph|
+command. For this, simply surround a node name by parentheses. This will cause
+a reference to be created to an already existing node:
+%
+\begin{codeexample}[preamble={\usetikzlibrary{graphs}}]
+\tikz {
+ \node (a) at (0,0) {A};
+ \node (b) at (1,0) {B};
+ \node (c) at (2,0) {C};
+
+ \graph { (a) -> (b) -> (c) };
+}
+\end{codeexample}
+
+You can even go a step further: A whole collection of nodes can all be flagged
+to belong to a \emph{node set} by adding the option |set=|\meta{node set name}.
+Then, inside a |graph| command, you can collectively refer to these nodes by
+surrounding the node set name in parentheses:
+%
+\begin{codeexample}[preamble={\usetikzlibrary{graphs,shapes.geometric}}]
+\tikz [new set=my nodes] {
+ \node [set=my nodes, circle, draw] at (1,1) {A};
+ \node [set=my nodes, rectangle, draw] at (1.5,0) {B};
+ \node [set=my nodes, diamond, draw] at (1,-1) {C};
+ \node (d) [star, draw] at (3,0) {D};
+
+ \graph { X -> (my nodes) -> (d) };
+}
+\end{codeexample}
+
+
+\subsubsection{Concept: Graph Macros}
+
+Often, a graph will consist -- at least in parts -- of standard parts. For
+instance, a graph might contain a cycle of certain size or a path or a clique.
+To facilitate specifying such graphs, you can define a \emph{graph macro}. Once
+a graph macro has been defined, you can use the name of the graph to make a
+copy of the graph part of the graph currently being specified:
+%
+\begin{codeexample}[preamble={\usetikzlibrary{graphs.standard}}]
+\tikz \graph { subgraph K_n [n=6, clockwise] };
+\end{codeexample}
+
+\begin{codeexample}[preamble={\usetikzlibrary{graphs.standard}}]
+\tikz \graph { subgraph C_n [n=5, clockwise] -> mid };
+\end{codeexample}
+
+The library |graphs.standard| defines a number of such graphs, including the
+complete clique $K_n$ on $n$ nodes, the complete bipartite graph $K_{n,m}$ with
+shores sized $n$ and $m$, the cycle $C_n$ on $n$ nodes, the path $P_n$ on $n$
+nodes, and the independent set $I_n$ on $n$ nodes.
+
+
+\subsubsection{Concept: Graph Expressions and Color Classes}
+
+When a graph is being constructed using the |graph| command, it is constructed
+recursively by uniting smaller graphs to larger graphs. During this recursive
+union process the nodes of the graph get implicitly \emph{colored}
+(conceptually) and you can also explicitly assign colors to individual nodes
+and even change the colors as the graph is being specified. All nodes having
+the same color form what is called a \emph{color class}.
+
+The power of color class is that special \emph{connector operators} allow you
+to add edges between nodes having certain colors. For instance, saying
+|clique=red| at the beginning of a group will cause all nodes that have been
+flagged as being (conceptually) ``red'' to be connected as a clique. Similarly,
+saying |complete bipartite={red}{green}| will cause edges to be added between
+all red and all green nodes. More advanced connectors, like the |butterfly|
+connector, allow you to add edges between color classes in a fancy manner.
+%
+\begin{codeexample}[preamble={\usetikzlibrary{graphs}}]
+\tikz [x=8mm, y=6mm, circle]
+ \graph [nodes={fill=blue!70}, empty nodes, n=8] {
+ subgraph I_n [name=A] --[butterfly={level=4}]
+ subgraph I_n [name=B] --[butterfly={level=2}]
+ subgraph I_n [name=C] --[butterfly]
+ subgraph I_n [name=D] --
+ subgraph I_n [name=E]
+ };
+\end{codeexample}
+
+
+\subsection{Syntax of the Graph Path Command}
+
+\subsubsection{The Graph Command}
+
+In order to construct a graph, you should use the |graph| path command, which
+can be used anywhere on a path at any place where you could also use a command
+like, say, |plot| or |--|.
+
+\begin{command}{\graph}
+ Inside a |{tikzpicture}| this is an abbreviation for |\path graph|.
+\end{command}
+
+\begin{pathoperation}{graph}{\opt{\oarg{options}}\meta{group specification}}
+ When this command is encountered on a path, the construction of the current
+ path is suspended (similarly to an |edge| command or a |node| command). In
+ a local scope, the \meta{options} are first executed with the key path
+ |/tikz/graphs| using the following command:
+ %
+ \begin{command}{\tikzgraphsset\marg{options}}
+ Executes the \meta{options} with the path prefix |/tikz/graphs|.
+ \end{command}
+ %
+ Apart from the keys explained in the following, further permissible keys
+ will be listed during the course of the rest of this section.
+
+ \begin{stylekey}{/tikz/graphs/every graph}
+ This style is executed at the beginning of every |graph| path command
+ prior to the \meta{options}.
+ \end{stylekey}
+
+ Once the scope has been set up and once the \meta{options} have been
+ executed, a parser starts to parse the \meta{group specification}. The
+ exact syntax of such a group specification in explained in detail in
+ Section~\ref{section-library-graphs-group-spec}. Basically, a group
+ specification is a list of chain specifications, separated by commas or
+ semicolons.
+
+ Depending on the content of the \meta{group specification}, two things will
+ happen:
+ %
+ \begin{enumerate}
+ \item A number of new nodes may be created. These will be inserted into
+ the picture in the same order as if they had been created using
+ multiple |node| path commands at the place where the |graph| path
+ command was used. In other words, all nodes created in a |graph|
+ path command will be painted on top of any nodes created earlier in
+ the path and behind any nodes created later in the path. Like
+ normal nodes, the newly created nodes always lie on top of the path
+ that is currently being created (which is often empty, for instance
+ when the |\graph| command is used).
+ \item Edges between the nodes may be added. They are added in the same
+ order as if the |edge| command had been used at the position where
+ the |graph| command is being used.
+ \end{enumerate}
+
+ Let us now have a look at some common keys that may be used inside the
+ \meta{options}:
+ %
+ \begin{key}{/tikz/graphs/nodes=\meta{options}}
+ This option causes the \meta{options} to be applied to each newly
+ created node inside the \meta{group specification}.
+ %
+\begin{codeexample}[preamble={\usetikzlibrary{graphs}}]
+\tikz \graph [nodes=red] { a -> b -> c };
+\end{codeexample}
+ %
+ Multiple uses of this key accumulate.
+ \end{key}
+ %
+ \begin{key}{/tikz/graphs/edges=\meta{options}}
+ This option causes the \meta{options} to be applied to each newly
+ created edge inside the \meta{group specification}.
+ %
+\begin{codeexample}[preamble={\usetikzlibrary{graphs}}]
+\tikz \graph [edges={red,thick}] { a -> b -> c };
+\end{codeexample}
+ %
+ Again, multiple uses of this key accumulate.
+ \end{key}
+ %
+ \begin{key}{/tikz/graphs/edge=\meta{options}}
+ This is an alias for |edges|.
+ \end{key}
+
+ \begin{key}{/tikz/graphs/edge node=\meta{node specification}}
+ This key specifies that the \meta{node specification} should be added
+ to each newly created edge as an implicitly placed node.
+ %
+\begin{codeexample}[preamble={\usetikzlibrary{graphs}}]
+\tikz \graph [edge node={node [red, near end] {X}}] { a -> b -> c };
+\end{codeexample}
+ %
+ Again, multiple uses of this key accumulate.
+ %
+\begin{codeexample}[preamble={\usetikzlibrary{graphs}}]
+\tikz \graph [edge node={node [near end] {X}},
+ edge node={node [near start] {Y}}] { a -> b -> c };
+\end{codeexample}
+ \end{key}
+
+ \begin{key}{/tikz/graphs/edge label=\meta{text}}
+ This key is an abbreviation for |edge node=node[auto]{|\meta{text}|}|.
+ The net effect is that the |text| is placed next to the newly created
+ edges.
+ %
+\begin{codeexample}[preamble={\usetikzlibrary{graphs}}]
+\tikz \graph [edge label=x] { a -> b -> {c,d} };
+\end{codeexample}
+ \end{key}
+
+ \begin{key}{/tikz/graphs/edge label'=\meta{text}}
+ This key is an abbreviation for |edge node=node[auto,swap]{|\meta{text}|}|.
+ %
+\begin{codeexample}[preamble={\usetikzlibrary{graphs.standard}}]
+\tikz \graph [edge label=out, edge label'=in]
+ { subgraph C_n [clockwise, n=5] };
+\end{codeexample}
+ \end{key}
+\end{pathoperation}
+
+
+\subsubsection{Syntax of Group Specifications}
+\label{section-library-graphs-group-spec}
+
+A \meta{group specification} inside a |graph| path command has the following
+syntax:
+%
+\begin{quote}
+ |{|\opt{\oarg{options}}\meta{list of chain specifications}|}|
+\end{quote}
+%
+The \meta{chain specifications} must contain chain specifications, whose syntax
+is detailed in the next section, separated by either commas or semicolons; you
+can freely mix them. It is permissible to use empty lines (which are mapped to
+|\par| commands internally) to structure the chains visually, they are simply
+ignored by the parser.
+
+In the following example, the group specification consists of three chain
+specifications, namely of |a -> b|, then |c| alone, and finally |d -> e -> f|:
+%
+\begin{codeexample}[preamble={\usetikzlibrary{graphs}}]
+\tikz \graph {
+ a -> b,
+ c;
+
+ d -> e -> f
+};
+\end{codeexample}
+%
+The above has the same effect as the more compact group specification
+|{a->b,c,d->e->f}|.
+
+Commas are used to detect where chain specifications end. However, you will
+often wish to use a comma also inside the options of a single node like in the
+following example:
+%
+\begin{codeexample}[preamble={\usetikzlibrary{graphs}}]
+\tikz \graph {
+ a [red, draw] -> b [blue, draw],
+ c [brown, draw, circle]
+};
+\end{codeexample}
+
+Note that the above example works as expected: The first comma inside the
+option list of |a| is \emph{not} interpreted as the end of the chain
+specification ``|a [red|''. Rather, commas inside square brackets are
+``protected'' against being interpreted as separators of group specifications.
+
+The \meta{options} that can be given at the beginning of a group specification
+are local to the group. They are executed with the path prefix |/tikz/graphs|.
+Note that for the outermost group specification of a graph it makes no
+difference whether the options are passed to the |graph| command or whether
+they are given at the beginning of this group. However, for groups nested
+inside other groups, it does make a difference:
+%
+\begin{codeexample}[preamble={\usetikzlibrary{graphs}}]
+\tikz \graph {
+ a -> { [nodes=red] % the option is local to these nodes:
+ b, c
+ } ->
+ d
+};
+\end{codeexample}
+
+\medskip
+\textbf{Using foreach.}
+There is special support for the |\foreach| statement inside groups: You may
+use the statement inside a group specification at any place where a \meta{chain
+specification} would normally go. In this case, the |\foreach| statement is
+executed and for each iteration the content of the statement's body is treated
+and parsed as a new chain specification.
+%
+\begin{codeexample}[preamble={\usetikzlibrary{graphs}}]
+\tikz \graph [math nodes, branch down=5mm] {
+ a -> {
+ \foreach \i in {1,2,3} {
+ a_\i -> { x_\i, y_\i }
+ },
+ b
+ }
+};
+\end{codeexample}
+
+\medskip
+\textbf{Using macros.}
+In some cases you may wish to use macros and \TeX\ code to compute which nodes
+and edges are present in a group. You cannot use macros in the normal way
+inside a graph specification since the parser does not expand macros as it
+scans for the start and end of groups and node names. Rather, only after
+commas, semicolons, and hyphens have already been detected and only after all
+other parsing decisions have been made will macros be expanded. At this point,
+when a macro expands to, say |a,b|, this will not result in two nodes to be
+created since the parsing is already done. For these reasons, a special key is
+needed to make it possible to ``compute'' which nodes should be present in a
+group.
+
+\begin{key}{/tikz/graph/parse=\meta{text}}
+ This key can only be used inside the \meta{options} of a \meta{group
+ specification}. Its effect is that the \meta{text} is inserted at the
+ beginning of the current group as if you had entered it there. Naturally,
+ it makes little sense to just write down some static \meta{text} since you
+ could just as well directly place it at the beginning of the group. The
+ real power of this command stems from the fact that the keys mechanism
+ allows you to say, for instance, |parse/.expand once| to insert the text
+ stored in some macro into the group.
+ %
+\begin{codeexample}[preamble={\usetikzlibrary{graphs}}]
+\def\mychain{ a -> b -> c; }
+\tikz \graph { [parse/.expand once=\mychain] d -> e };
+\end{codeexample}
+ %
+ In the following, more fancy example we use a loop to create a chain of
+ dynamic length.
+ %
+\begin{codeexample}[preamble={\usetikzlibrary{graphs}}]
+\def\mychain#1{
+ \def\mytext{1}
+ \foreach \i in {2,...,#1} {
+ \xdef\mytext{\mytext -> \i}
+ }
+}
+\tikzgraphsset{my chain/.style={
+ /utils/exec=\mychain{#1},
+ parse/.expand once=\mytext}
+}
+\tikz \graph { [my chain=4] };
+\end{codeexample}
+ %
+ Multiple uses of this key accumulate, that is, all the \text{text}s given
+ in the different uses is inserted in the order it is given.
+\end{key}
+
+
+\subsubsection{Syntax of Chain Specifications}
+
+A \meta{chain specification} has the following syntax: It consists of a
+sequence of \meta{node specifications}, where subsequent node specifications
+are separated by \meta{edge specifications}. Node specifications, which
+typically consist of some text, are discussed in the next section in more
+detail. They normally represent a single node that is either newly created or
+exists already, but they may also specify a whole set of nodes.
+
+An \meta{edge specification} specifies \emph{which} of the node(s) to the left
+of the edge specification should be connected to which node(s) to the right of
+it and it also specifies in which direction the connections go. In the
+following, we only discuss how the direction is chosen, the powerful mechanism
+behind choosing which nodes should be connect is detailed in
+Section~\ref{section-library-graphs-color-classes}.
+
+The syntax of an edge specification is always one of the following five
+possibilities:
+%
+\begin{quote}
+ |->| \opt{\oarg{options}}\\
+ |--| \opt{\oarg{options}}\\
+ |<-| \opt{\oarg{options}}\\
+ |<->| \opt{\oarg{options}}\\
+ |-!-| \opt{\oarg{options}}
+\end{quote}
+
+The first four correspond to a directed edge, an undirected edge, a
+``backward'' directed edge, and a bidirected edge, respectively. The fifth edge
+specification means that there should be no edge (this specification can be
+used together with the |simple| option to remove edges that have previously
+been added, see Section~\ref{section-library-graphs-simple}).
+
+Suppose the nodes \meta{left nodes} are to the left of the \meta{edge
+specification} and \meta{right nodes} are to the right and suppose we have
+written |->| between them. Then the following happens:
+%
+\begin{enumerate}
+ \item The \meta{options} are executed (inside a local scope) with the path
+ |/tikz/graphs|. These options may setup the connector algorithm (see
+ below) and may also use keys like |edge| or |edge label| to specify how
+ the edge should look like. As a convenience, whenever an unknown key is
+ encountered for the path |/tikz/graphs|, the key is passed to the
+ |edge| key. This means that you can directly use options like |thick|
+ or |red| inside the \meta{options} and they will apply to the edge as
+ expected.
+ \item The chosen connector algorithm, see
+ Section~\ref{section-library-graphs-color-classes}, is used to compute
+ from which of the \meta{left nodes} an edge should lead to which of the
+ \meta{right nodes}. Suppose that $(l_1,r_1)$, \dots, $(l_n,r_n)$ is the
+ list of node pairs that result (so there should be an edge between
+ $l_1$ and $r_1$ and another edge between $l_2$ and $r_2$ and so on).
+ \item For each pair $(l_i,r_i)$ an edge is created. This is done by calling
+ the following key (for the edge specification |->|, other keys are
+ executed for the other kinds of specifications):
+ %
+ \begin{key}{/tikz/graphs/new ->=\marg{left node}\marg{right node}\marg{edge options}\marg{edge nodes}}
+ This key will be called for a |->| edge specification with the
+ following four parameters:
+ %
+ \begin{enumerate}
+ \item \meta{left node} is the name of the ``left'' node, that
+ is, the name of $l_i$.
+ \item \meta{right node} is the name of the right node.
+ \item \meta{edge options} are the accumulated options from all
+ calls of |/tikz/graph/edges| in groups that surround the
+ edge specification.
+ \item \meta{edge nodes} is text like |node {A} node {B}| that
+ specifies some nodes that should be put as labels on the
+ edge using \tikzname's implicit positioning mechanism.
+ \end{enumerate}
+ %
+ By default, the key executes the following code:
+ %
+ \begin{quote}
+ |\path [->,every new ->]|\\
+ \hbox{}\quad|(|\meta{left node}|\tikzgraphleftanchor) edge [|%
+ \meta{edge options}|]| \meta{edge nodes}||\\
+ \hbox{}\quad|(|\meta{right node}|\tikzgraphrightanchor);|
+ \end{quote}
+ %
+ You are welcome to change the code underlying the key.
+ %
+ \begin{stylekey}{/tikz/every new ->}
+ This key gets executed by default for a |new ->|.
+ \end{stylekey}
+ \end{key}
+ %
+ \begin{key}{/tikz/graphs/left anchor=\meta{anchor}}
+ This anchor is used for the node that is to the left of an edge
+ specification. Setting this anchor to the empty string means that
+ no special anchor is used (which is the default). The \meta{anchor}
+ is stored in the macro |\tikzgraphleftanchor| with a leading dot.
+ %
+\begin{codeexample}[preamble={\usetikzlibrary{graphs}}]
+\tikz \graph {
+ {a,b,c} -> [complete bipartite] {e,f,g}
+};
+\end{codeexample}
+ %
+\begin{codeexample}[preamble={\usetikzlibrary{graphs}}]
+\tikz \graph [left anchor=east, right anchor=west] {
+ {a,b,c} -- [complete bipartite] {e,f,g}
+};
+\end{codeexample}
+ \end{key}
+ %
+ \begin{key}{/tikz/graphs/right anchor=\meta{anchor}}
+ Works like |left anchor|, only for |\tikzgraphrightanchor|.
+ \end{key}
+ %
+ For the other three kinds of edge specifications, the following keys
+ will be called:
+ %
+ \begin{key}{/tikz/graphs/new --=\marg{left node}\marg{right node}\marg{edge options}\marg{edge nodes}}
+ This key is called for |--| with the same parameters as above. The
+ only difference in the definition is that in the |\path| command
+ the |->| gets replaced by |-|.
+ %
+ \begin{stylekey}{/tikz/every new --}
+ \end{stylekey}
+ \end{key}
+ %
+ \begin{key}{/tikz/graphs/new <->=\marg{left node}\marg{right node}\marg{edge options}\marg{edge nodes}}
+ Called for |<->| with the same parameters as above. The |->| is
+ replaced by |<-|
+ %
+ \begin{stylekey}{/tikz/every new <->}
+ \end{stylekey}
+ \end{key}
+ %
+ \begin{key}{/tikz/graphs/new <-=\marg{left node}\marg{right node}\marg{edge options}\marg{edge nodes}}
+ Called for |<-| with the same parameters as above.%
+ \footnote{%
+ You might wonder why this key is needed: It seems more logical
+ at first sight to just call |new edge directed| with swapped
+ first parameters. However, a positioning algorithm might wish
+ to take the fact into account that an edge is ``backward''
+ rather than ``forward'' in order to improve the layout. Also,
+ different arrow heads might be used.
+ }
+ %
+ \begin{stylekey}{/tikz/every new <-}
+ \end{stylekey}
+ \end{key}
+ %
+ \begin{key}{/tikz/graphs/new -\protect\exclamationmarktext-=\marg{left node}\marg{right node}\marg{edge options}\marg{edge nodes}}
+ Called for |-!-| with the same parameters as above. Does nothing by
+ default.
+ \end{key}
+\end{enumerate}
+
+Here is an example that shows the default rendering of the different edge
+specifications:
+%
+\begin{codeexample}[preamble={\usetikzlibrary{graphs}}]
+\tikz \graph [branch down=5mm] {
+ a -> b;
+ c -- d;
+ e <- f;
+ g <-> h;
+ i -!- j;
+};
+\end{codeexample}
+
+
+\subsubsection{Syntax of Node Specifications}
+\label{section-library-graphs-node-spec}
+
+Node specifications are the basic building blocks of a graph specification.
+There are three different possible kinds of node specifications, each of which
+has a different syntax:
+%
+\begin{description}
+ \item[Direct Node Specification]
+ \ \\
+ \opt{|"|}\meta{node name}\opt{|"|}\opt{|/|\opt{|"|}\meta{text}\opt{|"|}} \opt{\oarg{options}}\\
+ (note that the quotation marks are optional and only needed when the
+ \meta{node name} contains special symbols)
+ \item[Reference Node Specification]
+ \ \\
+ |(|\meta{node name or node set name}|)|
+ \item[Group Node Specification]
+ \ \\
+ \meta{group specification}
+\end{description}
+
+The rule for determining which of the possible kinds is meant is as follows: If
+the node specification starts with an opening parenthesis, a reference node
+specification is meant; if it starts with an opening curly brace, a group
+specification is meant; and in all other cases a direct node specification is
+meant.
+
+\medskip
+\textbf{Direct Node Specifications.} If after reading the first symbol of a
+node specification is has been detected to be \emph{direct}, \tikzname\ will
+collect all text up to the next edge specification and store it as the
+\meta{node name}; however, square brackets are used to indicate options and a
+slash ends the \meta{node name} and start a special \meta{text} that is used as
+a rendering text instead of the original \meta{node name}.
+
+Due to the way the parsing works and due to the restrictions on node names,
+most special characters are forbidding inside the \meta{node name}, including
+commas, semicolons, hyphens, braces, dots, parentheses, slashes, dashes, and
+more (but spaces, single underscores, and the hat character \emph{are}
+allowed). To use special characters in the name of a node, you can optionally
+surround the \meta{node name} and/or the \meta{text} by quotation marks. In
+this case, you can use all of the special symbols once more. The details of
+what happens, exactly, when the \meta{node name} is surrounded by quotation
+marks is explained later; surrounding the \meta{text} by quotation marks has
+essentially the same effect as surrounding it by curly braces.
+
+Once the node name has been determined, it is checked whether the same node
+name was already used inside the current graph. If this is the case, then we
+say that the already existing node is \emph{referenced}; otherwise we say that
+the node is \emph{fresh}.
+%
+\begin{codeexample}[preamble={\usetikzlibrary{graphs}}]
+\tikz \graph {
+ a -> b; % both are fresh
+ c -> a; % only c is fresh, a is referenced
+};
+\end{codeexample}
+
+This behavior of deciding whether a node is fresh or referenced can, however,
+be modified by using the following keys:
+%
+\begin{key}{/tikz/graphs/use existing nodes=\opt{\meta{true or false}} (default true)}
+ When this key is set to |true|, all nodes will be considered to the
+ referenced, no node will be fresh. This option is useful if you have
+ already created all the nodes of a graph prior to using the |graph| command
+ and you now only wish to connect the nodes. It also implies that an error
+ is raised if you reference a node which has not been defined previously.
+\end{key}
+
+\begin{key}{/tikz/graphs/fresh nodes=\opt{\meta{true or false}} (default true)}
+ When this key is set to |true|, all nodes will be considered to be fresh.
+ This option is useful when you create for instance a tree with many
+ identical nodes.
+
+ When a node name is encountered that was already used previously, a new
+ name is chosen is follows: An apostrophe (|'|) is appended repeatedly until
+ a node name is found that has not yet been used:
+ %
+\begin{codeexample}[preamble={\usetikzlibrary{graphs}}]
+\tikz \graph [branch down=5mm] {
+ { [fresh nodes]
+ a -> {
+ b -> {c, c},
+ b -> {c, c},
+ b -> {c, c},
+ }
+ },
+ b' -- b''
+};
+\end{codeexample}
+ %
+\end{key}
+
+\begin{key}{/tikz/graphs/number nodes=\opt{\meta{start number}} (default 1)}
+ When this key is used in a scope, each encountered node name will get
+ appended a new number, starting with \meta{start}. Typically, this ensures
+ that all node names are different. Between the original node name and the
+ appended number, the setting of the following will be inserted:
+ %
+ \begin{key}{/tikz/graphs/number nodes sep=\meta{text} (initially \normalfont space)}
+ \end{key}
+ %
+\begin{codeexample}[preamble={\usetikzlibrary{graphs}}]
+\tikz \graph [branch down=5mm] {
+ { [number nodes]
+ a -> {
+ b -> {c, c},
+ b -> {c, c},
+ b -> {c, c},
+ }
+ },
+ b 2 -- b 5
+};
+\end{codeexample}
+ %
+\end{key}
+
+When a fresh node has been detected, a new node is created in the inside a
+protecting scope. For this, the current placement strategy is asked to compute
+a default position for the node, see
+Section~\ref{section-library-graphs-placement} for details. Then, the command
+%
+\begin{quote}
+ |\node (|\meta{full node name}|) [|\meta{node options}|] {|\meta{text}|};|
+\end{quote}
+%
+is called. The different parameters are as follows:
+%
+\begin{itemize}
+ \item The \meta{full node name} is normally the \meta{node name} that has
+ been determined as described before. However, there are two exceptions:
+
+ First, if the \meta{node name} is empty (which happens when there is no
+ \meta{node name} before the slash), then a fresh internal node name is
+ created and used as \meta{full node name}. This name is guaranteed to
+ be different from all node names used in this or any other graph. Thus,
+ a direct node starting with a slash represents an anonymous fresh node.
+
+ Second, you can use the following key to prefix the \meta{node name}
+ inside the \meta{full node name}:
+
+ \begin{key}{/tikz/graphs/name=\meta{text}}
+ This key prepends the \meta{text}, followed by a separating symbol
+ (a space by default), to all \meta{node name}s inside a \meta{full
+ node name}. Repeated calls of this key accumulate, leading to
+ ever-longer ``name paths'':
+ %
+\begin{codeexample}[preamble={\usetikzlibrary{graphs}}]
+\begin{tikzpicture}
+ \graph {
+ { [name=first] 1, 2, 3} --
+ { [name=second] 1, 2, 3}
+ };
+ \draw [red] (second 1) circle [radius=3mm];
+\end{tikzpicture}
+\end{codeexample}
+ %
+ Note that, indeed, in the above example six nodes are created even
+ though the first and second set of nodes have the same \meta{node
+ name}. The reason is that the full names of the six nodes are all
+ different. Also note that only the \meta{node name} is used as the
+ node text, not the full name. This can be changed as described
+ later on.
+
+ This key can be used repeatedly, leading to ever longer node names.
+ \end{key}
+
+ \begin{key}{/tikz/graphs/name separator=\meta{symbols} (initially \string\space)}
+ Changes the symbol that is used to separate the \meta{text} from
+ the \meta{node name}. The default is |\space|, resulting in a
+ space.
+ %
+\begin{codeexample}[preamble={\usetikzlibrary{graphs}}]
+\begin{tikzpicture}
+ \graph [name separator=] { % no separator
+ { [name=first] 1, 2, 3} --
+ { [name=second] 1, 2, 3}
+ };
+ \draw [red] (second1) circle [radius=3mm];
+\end{tikzpicture}
+\end{codeexample}
+ %
+\begin{codeexample}[preamble={\usetikzlibrary{graphs}}]
+\begin{tikzpicture}
+ \graph [name separator=-] {
+ { [name=first] 1, 2, 3} --
+ { [name=second] 1, 2, 3}
+ };
+ \draw [red] (second-1) circle [radius=3mm];
+\end{tikzpicture}
+\end{codeexample}
+ \end{key}
+ \item The \meta{node options} are
+ %
+ \begin{enumerate}
+ \item The options that have accumulated in calls to |nodes| from
+ the surrounding scopes.
+ \item The local \meta{options}.
+ \end{enumerate}
+ %
+ The options are executed with the path prefix |/tikz/graphs|, but any
+ unknown key is executed with the prefix |/tikz|. This means, in
+ essence, that some esoteric keys are more difficult to use inside the
+ options and that any key with the prefix |/tikz/graphs| will take
+ precedence over a key with the prefix |/tikz|.
+ \item The \meta{text} that is passed to the |\node| command is computed as
+ follows: First, you can use the following key to directly set the
+ \meta{text}:
+ %
+ \begin{key}{/tikz/graphs/as=\meta{text}}
+ The \meta{text} is used as the text of the node. This allows you to
+ provide a text for the node that differs arbitrarily from the name
+ of the node.
+ %
+\begin{codeexample}[preamble={\usetikzlibrary{graphs}}]
+\tikz \graph { a [as=$x$] -- b [as=$y_5$] -> c [red, as={a--b}] };
+\end{codeexample}
+ %
+ This key always takes precedence over all of the mechanisms
+ described below.
+ \end{key}
+ %
+ In case the |as| key is not used, a default text is chosen as follows:
+ First, when a direct node specification contains a slash (or, for
+ historical reasons, a double underscore), the text to the right of the
+ slash (or double underscore) is stored in the macro
+ |\tikzgraphnodetext|; if there is no slash, the \meta{node name} is
+ stored in |\tikzgraphnodetext|, instead. Then, the current value of the
+ following key is used as \meta{text}:
+ %
+ \begin{key}{/tikz/graphs/typeset=\meta{code}}
+ The macro or code stored in this key is used as the \meta{text} of
+ the node. Inside the \meta{code}, the following macros are
+ available:
+ %
+ \begin{command}{\tikzgraphnodetext}
+ This macro expands to the \meta{text} to the right of the
+ double underscore or slash in a direct node specification or,
+ if there is no slash, to the \meta{node name}.
+ \end{command}
+ %
+ \begin{command}{\tikzgraphnodename}
+ This macro expands to the name of the current node without the
+ path.
+ \end{command}
+ %
+ \begin{command}{\tikzgraphnodepath}
+ This macro expands to the current path of the node. These paths
+ result from the use of the |name| key as described above.
+ \end{command}
+ %
+ \begin{command}{\tikzgraphnodefullname}
+ This macro contains the concatenation of the above two.
+ \end{command}
+ \end{key}
+ %
+ By default, the typesetter is just set to |\tikzgraphnodetext|, which
+ means that the default text of a node is its name. However, it may be
+ useful to change this: For instance, you might wish that the text of
+ all graph nodes is, say, surrounded by parentheses:
+ %
+\begin{codeexample}[preamble={\usetikzlibrary{graphs}}]
+\tikz \graph [typeset=(\tikzgraphnodetext)]
+ { a -> b -> c };
+\end{codeexample}
+ %
+ A more advanced macro might take apart the node text and render it
+ differently:
+ %
+\begin{codeexample}[preamble={\usetikzlibrary{graphs}}]
+\def\mytypesetter{\expandafter\myparser\tikzgraphnodetext\relax}
+\def\myparser#1 #2 #3\relax{%
+ $#1_{#2,\dots,#3}$
+}
+\tikz \graph [typeset=\mytypesetter, grow down]
+ { a 1 n -> b 2 m -> c 4 nm };
+\end{codeexample}
+ %
+ The following styles install useful predefined typesetting macros:
+ %
+ \begin{key}{/tikz/graphs/empty nodes}
+ Just sets |typeset| to nothing, which causes all nodes to have an
+ empty text (unless, of course, the |as| option is used):
+ %
+\begin{codeexample}[preamble={\usetikzlibrary{graphs}}]
+\tikz \graph [empty nodes, nodes={circle, draw}] { a -> {b, c} };
+\end{codeexample}
+ \end{key}
+ %
+ \begin{key}{/tikz/graphs/math nodes}
+ Sets |typeset| to |$\tikzgraphnodetext$|, which causes all nodes
+ names to be typeset in math mode:
+ %
+\begin{codeexample}[preamble={\usetikzlibrary{graphs}}]
+\tikz \graph [math nodes, nodes={circle, draw}] { a_1 -> {b^2, c_3^n} };
+\end{codeexample}
+ \end{key}
+\end{itemize}
+
+If a node is referenced instead of fresh, then this node becomes the node that
+will be connected by the preceding or following edge specification to other
+nodes. The \meta{options} are executed even for a referenced node, but they
+cannot be used to change the appearance of the node (because the node exists
+already). Rather, the \meta{options} can only be used to change the logical
+coloring of the node, see Section~\ref{section-library-graphs-color-classes}
+for details.
+
+\medskip
+\textbf{Quoted Node Names.} When the \meta{node name} and/or the \meta{text} of
+a node is surrounded by quotation marks, you can use all sorts of special
+symbols as part of the text that are normally forbidden:
+%
+\begin{codeexample}[preamble={\usetikzlibrary{graphs}}]
+\begin{tikzpicture}
+ \graph [grow right=2cm] {
+ "Hi, World!" -> "It's \emph{important}!"[red,rotate=-45];
+ "name"/actual text -> "It's \emph{important}!";
+ };
+ \draw (name) circle [radius=3pt];
+\end{tikzpicture}
+\end{codeexample}
+
+In detail, for the following happens when quotation marks are encountered at
+the beginning of a node name or its text:
+%
+\begin{itemize}
+ \item Everything following the quotation mark up to the next single
+ quotation mark is collected into a macro \meta{collected}. All sorts of
+ special characters, including commas, square brackets, dashes, and even
+ backslashes are allowed here. Basically, the only restriction is that
+ braces must be balanced.
+ \item A double quotation mark (|""|) does not count as the ``next single
+ quotation mark''. Rather, it is replaced by a single quotation mark.
+ For instance, |"He said, ""Hello world."""| would be stored inside
+ \meta{collected} as |He said, "Hello world."| However, this rule
+ applies only on the outer-most level of braces. Thus, in
+ %
+\begin{codeexample}[code only]
+"He {said, ""Hello world.""}"
+\end{codeexample}
+ %
+ we would get |He {said, ""Hello world.""}| as \meta{collected}.
+ \item ``The next single quotation mark'' refers to the next quotation mark
+ on the current level of braces, so in |"hello {"} world"|, the next
+ quotation mark would be the one following |world|.
+\end{itemize}
+
+Now, once the \meta{collected} text has been gather, it is used as follows:
+When used as \meta{text} (what is actually displayed), it is just used ``as
+is''. When it is used as \meta{node name}, however, the following happens:
+Every ``special character'' in \meta{collected} is replaced by its Unicode
+name, surrounded by |@|-signs. For instance, if \meta{collected} is
+|Hello, world!|, the \meta{node name} is the somewhat longer text
+|Hello@COMMA@ world@EXCLAMATION MARK@|. Admittedly, referencing such a node
+from outside the graph is cumbersome, but when you use exactly the same
+\meta{collected} text once more, the same \meta{node name} will result. The
+following characters are considered ``special'':
+%
+\begin{quote}
+ \texttt{\char`\|}|$&^~_[](){}/.-,+*'`!":;<=>?@#%\{}|%$
+\end{quote}
+%
+These are exactly the Unicode character with a decimal code number between 33
+and 126 that are neither digits nor letters.
+
+\medskip
+\textbf{Reference Node Specifications.} A reference node specification is a
+node specification that starts with an opening parenthesis. In this case,
+parentheses must surround a \meta{name} as in |(foo)|, where |foo| is the
+\meta{name}. The following will now happen:
+%
+\begin{enumerate}
+ \item It is tested whether \meta{name} is the name of a currently active
+ \emph{node set}. This case will be discussed in a moment.
+ \item Otherwise, the \meta{name} is interpreted and treated as a referenced
+ node, but independently of whether the node has already been fresh in
+ the current graph or not. In other words, the node must have been
+ defined either already inside the graph (in which case the parenthesis
+ are more or less superfluous) or it must have been defined outside the
+ current picture.
+
+ The way the referenced node is handled is the same way as for a direct
+ node that is a referenced node.
+
+ If the node does not already exist, an error message is printed.
+\end{enumerate}
+
+Let us now have a look at node sets. Inside a |{tikzpicture}| you can locally
+define a \emph{node set} by using the following key:
+%
+\begin{key}{/tikz/new set=\meta{set name}}
+ This will setup a node set named \meta{set name} within the current scope.
+ Inside the scope, you can add nodes to the node set using the |set| key. If
+ a node set of the same name already exists in the current scope, it will be
+ reset and made empty for the current scope.
+
+ Note that this command has the path |/tikz| and is normally used
+ \emph{outside} the |graph| command.
+\end{key}
+%
+\begin{key}{/tikz/set=\meta{set name}}
+ This key can be used as an option with a |node| command. The \meta{set
+ name} must be the name of a node set that has previously been created
+ inside some enclosing scope via the |new set| key. The effect is that the
+ current node is added to the node set.
+\end{key}
+
+When you use a |graph| command inside a scope where some node set called
+\meta{set name} is defined, then inside this |graph| command you use
+|(|\meta{set name}|)| to reference \emph{all} of the nodes in the node set. The
+effect is the same as if instead of the reference to the set name you had
+created a group specification containing a list of references to all the nodes
+that are part of the node set.
+%
+\begin{codeexample}[preamble={\usetikzlibrary{graphs}}]
+\begin{tikzpicture}[new set=red, new set=green, shorten >=2pt]
+ \foreach \i in {1,2,3} {
+ \node [draw, red!80, set=red] (r\i) at (\i,1) {$r_\i$};
+ \node [draw, green!50!black, set=green] (g\i) at (\i,2) {$g_\i$};
+ }
+ \graph {
+ root [xshift=2cm] ->
+ (red) -> [complete bipartite, right anchor=south]
+ (green)
+ };
+\end{tikzpicture}
+\end{codeexample}
+
+There is an interesting caveat with referencing node sets: Suppose that at the
+beginning of a graph you just say |(foo);| where |foo| is a set name. Unless
+you have specified special options, this will cause the following to happen: A
+group is created whose members are all the nodes of the node set |foo|. These
+nodes become referenced nodes, but otherwise nothing happens since, by default,
+the nodes of a group are not connected automatically. However, the referenced
+nodes have now been referenced inside the graph, you can thus subsequently
+access them as if they had been defined inside the graph. Here is an example
+showing how you can create nodes outside a |graph| command and then connect
+them inside as if they had been declared inside:
+%
+\begin{codeexample}[preamble={\usetikzlibrary{graphs}}]
+\begin{tikzpicture}[new set=import nodes]
+ \begin{scope}[nodes={set=import nodes}] % make all nodes part of this set
+ \node [red] (a) at (0,1) {$a$};
+ \node [red] (b) at (1,1) {$b$};
+ \node [red] (d) at (2,1) {$d$};
+ \end{scope}
+
+ \graph {
+ (import nodes); % "import" the nodes
+
+ a -> b -> c -> d -> e; % only c and e are new
+ };
+\end{tikzpicture}
+\end{codeexample}
+
+\medskip
+\textbf{Group Node Specifications.} At a place where a node specification
+should go, you can also instead provide a group specification. Since nodes
+specifications are part of chain specifications, which in turn are part of
+group specifications, this is a recursive definition.
+%
+\begin{codeexample}[preamble={\usetikzlibrary{graphs}}]
+\tikz \graph { a -> {b,c,d} -> {e -> {f,g}, h} };
+\end{codeexample}
+
+As can be seen in the above example, when two groups of nodes are connected via
+an edge specification, it is not immediately obvious which connecting edges are
+added. This is detailed in Section~\ref{section-library-graphs-color-classes}.
+
+
+\subsubsection{Specifying Tries}
+
+In computer science, a \emph{trie} is a special kind of tree, where for each
+node and each symbol of an alphabet, there is at most one child of the node
+labeled with this symbol.
+
+The |trie| key is useful for drawing tries, but it can also be used in other
+situations. What it does, essentially, is to prepend the node names of all
+nodes \emph{before} the current node of the current chain to the node's name.
+This will often make it easier or more natural to specify graphs in which
+several nodes have the same label.
+
+\begin{key}{/tikz/graphs/trie=\opt{\meta{true or false}} (default true, initially false)}
+ If this key is set to |true|, after a node has been created on a chain, the
+ |name| key is executed with the node's \meta{node name}. Thus, all nodes
+ later on this chain have the ``path'' of nodes leading to this node as
+ their name. This means, in particular, that
+ %
+ \begin{enumerate}
+ \item two nodes of the same name but in different parts of a chain will
+ be different,
+ \item while if another chain starts with the same nodes, no new nodes
+ get created.
+ \end{enumerate}
+ %
+ In total, this is exactly the behavior you would expect of a trie:
+ %
+\begin{codeexample}[preamble={\usetikzlibrary{graphs}}]
+\tikz \graph [trie] {
+ a -> {
+ a,
+ c -> {a, b},
+ b
+ }
+};
+\end{codeexample}
+ %
+ You can even ``reiterate'' over a path in conjunction with the |simple|
+ option. However, in this case, the default placement strategies will not
+ work and you will need options like |layered layout| from the graph drawing
+ libraries, which need Lua\TeX.
+ %
+\ifluatex
+\begin{codeexample}[preamble={\usetikzlibrary{graphs,graphdrawing}\usegdlibrary{layered}}]
+\tikz \graph [trie, simple, layered layout] {
+ a -> b -> a,
+ a -> b -> c,
+ a -> {d,a}
+};
+\end{codeexample}
+ %
+ In the following example, we setup the |typeset| key so that it shows the
+ complete names of the nodes:
+ %
+\begin{codeexample}[preamble={\usetikzlibrary{graphs,graphdrawing}\usegdlibrary{layered}}]
+\tikz \graph [trie, simple, layered layout,
+ typeset=\tikzgraphnodefullname] {
+ a -> b -> a,
+ a -> b -> c,
+ a -> {d,a}
+};
+\end{codeexample}
+\fi
+ %
+ You can also use the |trie| key locally and later reference nodes using
+ their full name:
+ %
+\begin{codeexample}[preamble={\usetikzlibrary{graphs}}]
+\tikz \graph {
+ { [trie, simple]
+ a -> {
+ b,
+ c -> a
+ }
+ },
+ a b ->[red] a c a
+};
+\end{codeexample}
+ %
+\end{key}
+
+
+\subsection{Quick Graphs}
+\label{section-library-graphs-quick}
+
+The graph syntax is powerful, but this power comes at a price: parsing the
+graph syntax, which is done by \TeX, can take some time. Normally, the parsing
+is fast enough that you will not notice it, but it can be bothersome when you
+have graphs with hundreds of nodes as happens frequently when nodes are
+generated algorithmically by some other program. Fortunately, when another
+program generated a graph specification, we typically do not need the full
+power of the graph syntax. Rather, a small subset of the graph syntax would
+suffice that allows to specify nodes and edges. For these reasons, the is a
+special ``quick'' version of the graph syntax.
+
+Note, however, that using this syntax will usually at most halve the time
+needed to parse a graph. Thus, it really mostly makes sense in conjunction with
+large, algorithmically generated graphs.
+
+\begin{key}{/tikz/graphs/quick}
+ When you provide this key with a graph, the syntax of graph specifications
+ gets restricted. You are no longer allowed to use certain features of the
+ graph syntax; but all features that are still allowed are also allowed in
+ the same way when you do not provide the |quick| option. Thus, leaving out
+ the |quick| option will never hurt.
+
+ Since the syntax is so severely restricted, it is easier to explain which
+ aspects of the graph syntax \emph{will} still work:
+ %
+ \begin{enumerate}
+ \item A quick graph consists of a sequence of either nodes, edges
+ sequences, or groups. These are separated by commas or semicolons.
+ \item Every node is of the form
+ %
+ \begin{quote}
+ |"|\meta{node name}|"|\opt{|/"|\meta{node text}|"[|\meta{options}|]|}
+ \end{quote}
+
+ The quotation marks are mandatory. The part |/"|\meta{node text}|"|
+ may be missing, in which case the node name is used as the node
+ text. The \meta{options} may also be missing. The \meta{node name}
+ may not contain any ``funny'' characters (unlike in the normal
+ graph command).
+ \item Every chain is of the form
+ %
+ \begin{quote}
+ \meta{node spec} \meta{connector} \meta{node spec}
+ \meta{connector} \dots \meta{connector} \meta{node spec}|;|
+ \end{quote}
+
+ Here, the \meta{node spec} are node specifications as described
+ above, the \meta{connector} is one of the four connectors |->|,
+ |<-|, |--|, and |<->| (the connector |-!-| is not allowed since the
+ |simple| option is also not allowed). Each connector may be
+ followed by options in square brackets. The semicolon may be
+ replaced by a comma.
+ \item Every group is of the form
+ %
+ \begin{quote}
+ |{ [|\meta{options}|]| \meta{chains and groups} |};|
+ \end{quote}
+ %
+ The \meta{options} are compulsory. The semicolon can, again, be
+ replaced by a comma.
+ \item The |number nodes| option will work as expected.
+ \end{enumerate}
+
+ Here is a typical way this syntax might be used:
+ %
+\begin{codeexample}[preamble={\usetikzlibrary{graphs,quotes}}]
+\tikz \graph [quick] { "a" --["foo"] "b"[x=1] };
+\end{codeexample}
+
+\begin{codeexample}[preamble={\usetikzlibrary{graphs}}]
+\tikz \graph [quick] {
+ "a"/"$a$" -- "b"[x=1] --[red] "c"[x=2];
+ { [nodes=blue] "a" -- "d"[y=1]; };
+};
+\end{codeexample}
+
+ Let us now have a look at the most important things that will \emph{not}
+ work when the |quick| option is used:
+
+ \begin{itemize}
+ \item Connecting a node and a group as in |a->{b,c}|.
+ \item Node names without quotation marks as in |a--b|.
+ \item Everything described in subsequent subsections, which includes
+ subgraphs (graph macros), graph sets, graph color classes,
+ anonymous nodes, the |fresh nodes| option, sublayouts, simple
+ graphs, edge annotations.
+ \item Placement strategies -- you either have to define all node
+ positions explicitly using |at=| or |x=| and |y=| or you must use a
+ graph drawing algorithm like |layered layout|.
+ \end{itemize}
+\end{key}
+
+
+\subsection{Simple Versus Multi-Graphs}
+\label{section-library-graphs-simple}
+
+The |graphs| library allows you to construct both simple graphs and
+multi-graphs. In a simple graph there can be at most one edge between any two
+vertices, while in a multi-graph there can be multiple edges (hence the name).
+The two keys |multi| and |simple| allow you to switch (even locally inside on
+of the graph's scopes) between which kind of graph is being constructed. By
+default, the |graph| command produces a multi-graph since these are faster to
+construct.
+
+\begin{key}{/tikz/graphs/multi}
+ When this edge is set for a whole graph (which is the default) or just for
+ a group (which is useful if the whole graph is simple in general, but a
+ part is a multi-graph), then when you specify an edge between two nodes
+ several times, several such edges get created:
+ %
+\begin{codeexample}[preamble={\usetikzlibrary{graphs}}]
+\tikz \graph [multi] { % "multi" is not really necessary here
+ a ->[bend left, red] b;
+ a ->[bend right, blue] b;
+};
+\end{codeexample}
+ %
+ In case |multi| is used for a scope inside a larger scope where the
+ |simple| option is specified, then inside the local |multi| scope edges are
+ immediately created and they are completely ignored when it comes to
+ deciding which kind of edges should be present in the surrounding simple
+ graph. From the surrounding scope's point of view it is as if the local
+ |multi| graph contained no edges at all.
+
+ This means, in particular, that you can use the |multi| option with a
+ single edge to ``enforce'' this edge to be present in a simple graph.
+\end{key}
+
+\begin{key}{/tikz/graphs/simple}
+ In contrast a multi-graph, in a simple graph, at most one edge gets created
+ for every pair of vertices:
+ %
+\begin{codeexample}[preamble={\usetikzlibrary{graphs}}]
+\tikz \graph [simple]{
+ a ->[bend left, red] b;
+ a ->[bend right, blue] b;
+};
+\end{codeexample}
+ %
+ As can be seen, the second edge ``wins'' over the first edge. The general
+ rule is as follows: In a simple graph, whenever an edge between two
+ vertices is specified multiple times, only the very last specification and
+ its options will actually be executed.
+
+ The real power of the |simple| option lies in the fact that you can first
+ create a complicated graph and then later redirect and otherwise modify
+ edges easily:
+ %
+\begin{codeexample}[preamble={\usetikzlibrary{graphs}}]
+\tikz \graph [simple, grow right=2cm] {
+ {a,b,c,d} ->[complete bipartite] {e,f,g,h};
+
+ { [edges={red,thick}] a -> e -> d -> g -> a };
+};
+\end{codeexample}
+
+ One particularly interesting kind of edge specification for a simple graph
+ is |-!-|. Recall that this is used to indicate that ``no edge'' should be
+ added between certain nodes. In a multi-graph, this key usually has no
+ effect (unless the key |new -!-| has been redefined) and is pretty
+ superfluous. In a simple graph, however, it counts as an edge kind and you
+ can thus use it to remove an edge that been added previously:
+ %
+\begin{codeexample}[preamble={\usetikzlibrary{graphs.standard}}]
+\tikz \graph [simple] {
+ subgraph K_n [n=8, clockwise];
+ % Get rid of the following edges:
+ 1 -!- 2;
+ 3 -!- 4;
+ 6 -!- 8;
+ % And make one edge red:
+ 1 --[red] 3;
+};
+\end{codeexample}
+
+ Creating a graph such as the above in other fashions is pretty awkward.
+
+ For every unordered pair $\{u,v\}$ of vertices at most one edge will be
+ created in a simple graph. In particular, when you say |a -> b| and later
+ also |a <- b|, then only the edge |a <- b| will be created. Similarly, when
+ you say |a -> b| and later |b -> a|, then only the edge |b -> a| will be
+ created.
+
+ The power of the |simple| command comes at a certain cost: As the graph is
+ being constructed, a (sparse) array is created that keeps track for each
+ edge of the last edge being specified. Then, at the end of the scope
+ containing the |simple| command, for every pair of vertices the edge is
+ created. This is implemented by two nested loops iterating over all
+ possible pairs of vertices -- which may take quite a while in a graph of,
+ say, 1000 vertices. Internally, the |simple| command is implemented as an
+ operator that adds the edges when it is called, but this should be
+ unimportant in normal situations.
+\end{key}
+
+
+\subsection{Graph Edges: Labeling and Styling}
+
+When the |graphs| library creates an edge between two nodes in a graph, the
+appearance (called ``styling'' in \tikzname) can be specified in different
+ways. Sometimes you will simply wish to say ``the edges between these two
+groups of node should be red'', but sometimes you may wish to say ``this
+particular edge going into this node should be red''. In the following,
+different ways of specifying such styling requirements are discussed. Note that
+adding labels to edges is, from \tikzname's point of view, almost the same as
+styling edges, since they are also specified using options.
+
+
+\subsubsection{Options For All Edges Between Two Groups}
+
+When you write |... ->[options] ...| somewhere inside your graph specification,
+this typically cause one or more edges to be created between the nodes in the
+chain group before the |->| and the nodes in the chain group following it. The
+|options| are applied to all of them. In particular, if you use the |quotes|
+library and you write some text in quotes inside the |options|, this text will
+be added as a label to each edge:
+%
+\begin{codeexample}[preamble={\usetikzlibrary{graphs,quotes}}]
+\tikz
+ \graph [edge quotes=near start] {
+ { a, b } -> [red, "x", complete bipartite] { c, d };
+ };
+\end{codeexample}
+
+As documented in the |quotes| library in more detail, you can easily modify the
+appearance of edge labels created using the quotes syntax by adding options
+after the closing quotes:
+%
+\begin{codeexample}[preamble={\usetikzlibrary{graphs,quotes}}]
+\tikz \graph {
+ a ->["x"] b ->["y"'] c ->["z" red] d;
+};
+\end{codeexample}
+
+The following options make it easy to setup the styling of nodes created in
+this way:
+%
+\begin{key}{/tikz/graphs/edge quotes=\opt{\meta{options}}}
+ A shorthand for setting the style |every edge quotes| to \meta{options}.
+ %
+\begin{codeexample}[preamble={\usetikzlibrary{graphs,quotes}}]
+ \tikz \graph [edge quotes={blue,auto}] {
+ a ->["x"] b ->["y"'] c ->["b" red] d;
+};
+\end{codeexample}
+ %
+\end{key}
+
+\begin{key}{/tikz/graphs/edge quotes center}
+ A shorthand for |edge quotes| to |anchor=center|.
+ %
+\begin{codeexample}[preamble={\usetikzlibrary{graphs,quotes}}]
+\tikz \graph [edge quotes center] {
+ a ->["x"] b ->["y"] c ->["z" red] d;
+};
+\end{codeexample}
+ %
+\end{key}
+
+\begin{key}{/tikz/graphs/edge quotes mid}
+ A shorthand for |edge quotes| to |anchor=mid|.
+ %
+\begin{codeexample}[preamble={\usetikzlibrary{graphs,quotes}}]
+\tikz \graph [edge quotes mid] {
+ a ->["x"] b ->["y"] c ->["z" red] d;
+};
+\end{codeexample}
+ %
+\end{key}
+
+
+\subsubsection{Changing Options For Certain Edges}
+
+Consider the following tree-like graph:
+%
+\begin{codeexample}[preamble={\usetikzlibrary{graphs}}]
+\tikz \graph { a -> {b,c} };
+\end{codeexample}
+
+Suppose we wish to specify that the edge from |a| to |b| should be red, while
+the edge from |a| to |c| should be blue. The difficulty lies in the fact that
+\emph{both} edges are created by the single |->| operator and we can only add
+one of these option |red| or |blue| to the operator.
+
+There are several ways to solve this problem. First, we can simply split up the
+specification and specify the two edges separately:
+%
+\begin{codeexample}[preamble={\usetikzlibrary{graphs}}]
+\tikz \graph {
+ a -> [red] b;
+ a -> [blue] c;
+};
+\end{codeexample}
+%
+While this works quite well, we can no longer use the nice chain group syntax
+of the |graphs| library. For the rather simple graph |a->{b,c}| this is not a
+big problem, but if you specify a tree with, say, 30 nodes it is really
+worthwhile being able to specify the tree ``in its natural form in the \TeX\
+code'' rather than having to list all of the edges explicitly. Also, as can be
+seen in the above example, the node placement is changed, which is not always
+desirable.
+
+One can sidestep this problem using the |simple| option: This option allows you
+to first specify a graph and then, later on, replace edges by other edges and,
+thereby, provide new options:
+%
+\begin{codeexample}[preamble={\usetikzlibrary{graphs}}]
+\tikz \graph [simple] {
+ a -> {b,c};
+ a -> [red] b;
+ a -> [blue] c;
+};
+\end{codeexample}
+
+The first line is the original specification of the tree, while the following
+two lines replace some edges of the tree (in this case, all of them) by edges
+with special options. While this method is slower and in the above example
+creates even longer code, it is very useful if you wish to, say, highlight a
+path in a larger tree: First specify the tree normally and, then, ``respecify''
+the path or paths with some other edge options in force. In the following
+example, we use this to highlight a whole subtree of a larger tree:
+ %
+\begin{codeexample}[preamble={\usetikzlibrary{graphs}}]
+\tikz \graph [simple] {
+ % The larger tree, no special options in force
+ a -> {
+ b -> {c,d},
+ e -> {f,g},
+ h
+ },
+ { [edges=red] % Now highlight a part of the tree
+ a -> e -> {f,g}
+ }
+};
+\end{codeexample}
+
+
+\subsubsection{Options For Incoming and Outgoing Edges}
+
+When you use the syntax |... ->[options] ...| to specify options, you specify
+options for the ``connections between two sets of nodes''. In many cases,
+however, it will be more natural to specify options ``for the edges lead to or
+coming from a certain node'' and you will want to specify these options ``at
+the node''. Returning to the example of the graph |a->{b,c}| where we want a
+red edge between |a| and |b| and a blue edge between |a| and |c|, this could
+also be phrased as follows: ``Make the edge leading to |b| red and make the
+edge leading to |c| blue''.
+
+For this situation, the |graphs| library offers a number of special keys, which
+are documented in the following. However, most of the time you will not use
+these keys directly, but, rather, use a special syntax explained in
+Section~\ref{section-syntax-outgoing-incoming}.
+
+\begin{key}{/tikz/graphs/target edge style=\meta{options}}
+ This key can (only) be used with a \emph{node} inside a graph
+ specification. When used, the \meta{options} will be added to every edge
+ that is created by a connector like |->| in which the node is a
+ \emph{target}. Consider the following example:
+ %
+\begin{codeexample}[preamble={\usetikzlibrary{graphs}}]
+\tikz \graph {
+ { a, b } ->
+ { c [target edge style=red], d } ->
+ { e, f }
+};
+\end{codeexample}
+ %
+ In the example, only when the edge from |a| to |c| is created, |c| is the
+ ``target'' of the edge. Thus, only this edge becomes red.
+
+ When an edge already has options set directly, the \meta{options} are
+ executed after these direct options, thus, they ``overrule'' them:
+ %
+\begin{codeexample}[preamble={\usetikzlibrary{graphs}}]
+\tikz \graph {
+ { a, b } -> [blue, thick]
+ { c [target edge style=red], d } ->
+ { e, f }
+};
+\end{codeexample}
+
+ The \meta{options} set in this way will stay attached to the node, so also
+ for edges created later on that lead to the node will have these options
+ set:
+ %
+\begin{codeexample}[preamble={\usetikzlibrary{graphs}}]
+\tikz \graph {
+ { a, b } ->
+ { c [target edge style=red], d } ->
+ { e, f },
+ b -> c
+};
+\end{codeexample}
+
+ Multiple uses of this key accumulate. However, you may sometimes also wish
+ to ``clear'' these options for a key since at some later point you no
+ longer wish the \meta{options} to be added when some further edges are
+ added. This can be achieved using the following key:
+ %
+ \begin{key}{/tikz/graphs/target edge clear}
+ Clears all \meta{options} for edges with the node as a target and
+ also edge labels (see below) for this node.
+ \end{key}
+ %
+\begin{codeexample}[preamble={\usetikzlibrary{graphs}}]
+\tikz \graph {
+ { a, b } ->
+ { c [target edge style=red], d },
+ b -> c[target edge clear]
+};
+\end{codeexample}
+ %
+\end{key}
+
+\begin{key}{/tikz/graphs/target edge node=\meta{node specification}}
+ This key works like |target edge style|, only the \meta{node specification}
+ will not be added as options to any newly created edges with the current
+ node as their target, but rather it will be added as a node specification.
+ %
+\begin{codeexample}[preamble={\usetikzlibrary{graphs}}]
+\tikz \graph {
+ { a, b } ->
+ { c [target edge node=node{X}], d } ->
+ { e, f }
+};
+\end{codeexample}
+ %
+ As for |target edge style| multiple uses of this key accumulate and the key
+ |target edge clear| will (also) clear all target edge nodes that have been
+ set for a node earlier on.
+\end{key}
+
+\begin{key}{/tikz/graphs/source edge style=\meta{options}}
+ Works exactly like |target edge style|, only now the \meta{options} are
+ only added when the node is a source of a newly created edge:
+ %
+\begin{codeexample}[preamble={\usetikzlibrary{graphs}}]
+\tikz \graph {
+ { a, b } ->
+ { c [source edge style=red], d } ->
+ { e, f }
+};
+\end{codeexample}
+ %
+ If both for the source and also for the target of an edge \meta{options}
+ have been specified, the options are applied in the following order:
+ %
+ \begin{enumerate}
+ \item First come the options from the edge itself.
+ \item Then come the options contributed by the source node using this
+ key.
+ \item Then come the options contributed by the target node using
+ |target node style|.
+ \end{enumerate}
+ %
+\begin{codeexample}[preamble={\usetikzlibrary{graphs}}]
+\tikz \graph {
+ a [source edge style=red] ->[green]
+ b [target edge style=blue] % blue wins
+};
+\end{codeexample}
+ %
+\end{key}
+
+\begin{key}{/tikz/graphs/source edge node=\meta{node specification}}
+ Works like |source edge style| and |target edge node|.
+\end{key}
+
+\begin{key}{/tikz/graphs/source edge clear=\meta{node specification}}
+ Works like |target edge clear|.
+\end{key}
+
+
+\subsubsection{Special Syntax for Options For Incoming and Outgoing Edges}
+\label{section-syntax-outgoing-incoming}
+
+The keys |target node style| and its friends are powerful, but a bit cumbersome
+to write down. For this reason, the |graphs| library introduces a special
+syntax that is based on what I call the ``first-char syntax'' of keys. Inside
+the options of a node inside a graph, the following special rules apply:
+%
+\begin{enumerate}
+ \item Whenever an option starts with |>|, the rest of the options are
+ passed to |target edge style|. For instance, when you write |a[>red]|,
+ then this has the same effect as if you had written
+ %
+\begin{codeexample}[code only]
+a[target edge style={red}]
+\end{codeexample}
+ %
+ \item Whenever an options starts with |<|, the rest of the options are
+ passed to |source edge style|.
+ \item In both of the above case, in case the options following the |>| or
+ |<| sign start with a quote, the created edge label is passed to
+ |source edge node| or |target edge node|, respectively.
+
+ This is exactly what you want to happen.
+\end{enumerate}
+%
+Additionally, the following styles provide shorthands for ``clearing'' the
+target and source options:
+%
+\begin{key}{/tikz/graphs/clear >}
+ A more easy-to-remember shorthand for |target edge clear|.
+\end{key}
+%
+\begin{key}{/tikz/graphs/clear <}
+ A more easy-to-remember shorthand for |source edge clear|.
+\end{key}
+
+These mechanisms make it especially easy to create trees in which the edges are
+labeled in some special way:
+%
+\begin{codeexample}[preamble={\usetikzlibrary{graphs,quotes}}]
+\tikz
+ \graph [edge quotes={fill=white,inner sep=1pt},
+ grow down, branch right] {
+ / -> h [>"9"] -> {
+ c [>"4" text=red,] -> {
+ a [>"2", >thick],
+ e [>"0"]
+ },
+ j [>"7"]
+ }
+ };
+\end{codeexample}
+
+
+\subsubsection{Placing Node Texts on Incoming Edges}
+
+Normally, the text of a node is shown (only) inside the node. In some case, for
+instance when drawing certain kind of trees, the nodes themselves should not
+get any text, but rather the edge leading to the node should be labeled as in
+the following example:
+%
+\begin{codeexample}[preamble={\usetikzlibrary{graphs,quotes}}]
+\tikz \graph [empty nodes]
+{
+ root -> {
+ a [>"a"],
+ b [>"b"] -> {
+ c [>"c"],
+ d [>"d"]
+ }
+ }
+};
+\end{codeexample}
+%
+As the example shows, it is a bit cumbersome that we have to label the nodes
+and then specify the same text once more using the incoming edge syntax.
+
+For these cases, it would be better if the text of the node where not used with
+the node but, rather, be passed directly to the incoming or the outgoing edge.
+The following styles do exactly this:
+
+\begin{key}{/tikz/graphs/put node text on incoming edges=\opt{\meta{options}}}
+ When this key is used with a node or a group, the following happens:
+ %
+ \begin{enumerate}
+ \item The command
+ |target edge node={node[|\meta{options}|]{\tikzgraphnodetext}}| is
+ executed. This means that all incoming edges of the node get a
+ label with the text that would usually be displayed in the node.
+ You can use keys like |math nodes| normally.
+ \item The command |as={}| is executed. This means that the node itself
+ will display nothing.
+ \end{enumerate}
+ %
+ Here is an example that show how this command is used.
+ %
+\begin{codeexample}[preamble={\usetikzlibrary{graphs}}]
+\tikz \graph [put node text on incoming edges,
+ math nodes, nodes={circle,draw}]
+ { a -> b -> {c, d} };
+\end{codeexample}
+ %
+\end{key}
+
+\begin{key}{/tikz/graphs/put node text on outgoing edges=\opt{\meta{options}}}
+ Works like the previous key, only with |target| replaced by |source|.
+\end{key}
+
+
+\subsection{Graph Operators, Color Classes, and Graph Expressions}
+\label{section-library-graphs-color-classes}
+
+\tikzname's |graph| command employs a powerful mechanism for adding edges
+between nodes and sets of nodes. To a graph theorist, this mechanism may be
+known as a \emph{graph expression}: A graph is specified by starting with small
+graphs and then applying \emph{operators} to them that form larger graphs and
+that connect and recolor colored subsets of the graph's node in different ways.
+
+
+\subsubsection{Color Classes}
+\label{section-library-graph-coloring}
+
+\tikzname\ keeps track of a \emph{(multi)coloring} of the graph as it is being
+constructed. This does not mean that the actual color of the nodes on the page
+will be different, rather, in the following we refer to ``logical'' colors in
+the way graph theoreticians do. These ``logical'' colors are only important
+while the graph is being constructed and they are ``thrown away'' at the end of
+the construction. The actual (``physical'') colors of the nodes are set
+independently of these logical colors.
+
+As a graph is being constructed, each node can be part of one or more
+overlapping \emph{color classes}. So, unlike what is sometimes called a
+\emph{legal coloring}, the logical colorings that \tikzname\ keeps track of may
+assign multiple colors to the same node and two nodes connected by an edge may
+well have the same color.
+
+Color classes must be declared prior to use. This is done using the following
+key:
+%
+\begin{key}{/tikz/graphs/color class=\meta{color class name}}
+ This sets up a new color class called \meta{color class name}. Nodes and
+ whole groups of nodes can now be colored with \meta{color class name}. This
+ is done using the following keys, which become
+ available inside the current scope:
+ %
+ \begin{key}{/tikz/graphs/\meta{color class name}}
+ This key internally uses the |operator| command to setup an operator
+ that will cause all nodes of the current group to get the ``logical
+ color'' \meta{color class name}. Nodes retain this color in all
+ encompassing scopes, unless it is explicitly changed (see below) or
+ unset (again, see below).
+ %
+\begin{codeexample}[preamble={\usetikzlibrary{graphs}}]
+\tikz \graph [color class=red] {
+ [cycle=red] % causes all "logically" red nodes to be connected in
+ % a cycle
+ a,
+ b [red],
+ { [red] c ->[bend right] d },
+ e
+};
+\end{codeexample}
+ %
+\begin{codeexample}[preamble={\usetikzlibrary{graphs}}]
+\tikz \graph [color class=red, color class=green,
+ math nodes, clockwise, n=5] {
+ [complete bipartite={red}{green}]
+ { [red] r_1, r_2 },
+ { [green] g_1, g_2, g_3 }
+};
+\end{codeexample}
+ \end{key}
+ %
+ \begin{key}{/tikz/graphs/not \meta{color class name}}
+ Sets up an operator for the current scope so that all nodes in it loose
+ the color \meta{color class name}. You can also use |!|\meta{color
+ class name} as an alias for this key.
+ %
+\begin{codeexample}[preamble={\usetikzlibrary{graphs}}]
+\tikz \graph [color class=red, color class=green,
+ math nodes, clockwise, n=5] {
+ [complete bipartite={red}{green}]
+ { [red] r_1, r_2 },
+ { [green] g_1, g_2, g_3 },
+ g_2 [not green]
+};
+\end{codeexample}
+ \end{key}
+ %
+ \begin{key}{/tikz/graphs/recolor \meta{color class name} by=\meta{new color}}
+ Causes all keys having color \meta{color class name} to get \meta{new
+ color} instead. They loose having color \meta{color class name}, but
+ other colors are not affected.
+ %
+\begin{codeexample}[preamble={\usetikzlibrary{graphs}}]
+\tikz \graph [color class=red, color class=green,
+ math nodes, clockwise, n=5] {
+ [complete bipartite={red}{green}]
+ { [red] r_1, r_2 },
+ { [green] g_1, g_2, g_3 },
+ g_2 [recolor green by=red]
+};
+\end{codeexample}
+ \end{key}
+\end{key}
+
+The following color classes are available by default:
+%
+\begin{itemize}
+ \item Color class |all|. Every node is part of this class by default. This
+ is useful to access all nodes of a (sub)graph, since you can simply
+ access all nodes of this color class.
+ \item Color classes |source| and |target|. These classes are used to
+ identify nodes that lead ``into'' a group of nodes and nodes from which
+ paths should ``leave'' the group. Details on how these colors are
+ assigned are explained in Section~\ref{section-library-graphs-join}. By
+ saying |not source| or |not target| with a node, you can influence how
+ it is connected:
+ %
+\begin{codeexample}[preamble={\usetikzlibrary{graphs}}]
+\tikz \graph { a -> { b, c, d } -> e };
+\end{codeexample}
+ %
+\begin{codeexample}[preamble={\usetikzlibrary{graphs}}]
+\tikz \graph { a -> { b[not source], c, d[not target] } -> e };
+\end{codeexample}
+ %
+ \item Color classes |source'| and |target'|. These are temporary colors
+ that are also explained in Section~\ref{section-library-graphs-join}.
+\end{itemize}
+
+
+\subsubsection{Graph Operators on Groups of Nodes}
+
+Recall that the |graph| command constructs graphs recursively from nested
+\meta{group specifications}. Each such \meta{group specification} describes a
+subset of the nodes of the final graph. A \emph{graph operator} is an algorithm
+that gets the nodes of a group as input and (typically) adds edges between
+these nodes in some sensible way. For instance, the |clique| operator will
+simply add edges between all nodes of the group.
+
+\begin{key}{/tikz/graphs/operator=\meta{code}}
+ This key has an effect in three places:
+ %
+ \begin{enumerate}
+ \item It can be used in the \meta{options} of a \meta{direct node
+ specification}.
+ \item It can be used in the \meta{options} of a \meta{group
+ specification}.
+ \item It can be used in the \meta{options} of an \meta{edge
+ specification}.
+ \end{enumerate}
+ %
+ The first case is a special case of the second, since it is treated like a
+ group specification containing a single node. The last case is more
+ complicated and discussed in the next section. So, let us focus on the
+ second case.
+
+ Even though the \meta{options} of a group are given at the beginning of the
+ \meta{group specification}, the \meta{code} is only executed when the group
+ has been parsed completely and all its nodes have been identified. If you
+ use the |operator| multiple times in the \meta{options}, the effect
+ accumulates, that is, all code passed to the different calls of |operator|
+ gets executed in the order it is encountered.
+
+ The \meta{code} can do ``whatever it wants'', but it will typically add
+ edges between certain nodes. You can configure what kind of edges
+ (directed, undirected, etc.) are created by using the following keys:
+ %
+ \begin{key}{/tikz/graphs/default edge kind=\meta{value} (initially -\/-)}
+ This key stores one of the five edge kinds |--|, |<-|, |->|, |<->|, and
+ |-!-|. When an operator wishes to create a new edge, it should
+ typically set
+ %
+\begin{codeexample}[code only]
+\tikzgraphsset{new \pfkeysvalueof{/tikz/graphs/default edge kind}=...}
+\end{codeexample}
+ %
+ While this key can be set explicitly, it may be more convenient to use
+ the abbreviating keys listed below. Also, this key is automatically set
+ to the current value of \meta{edge specification} when a joining
+ operator is called, see the discussion of joining operators in
+ Section~\ref{section-library-graphs-join}.
+ \end{key}
+ %
+ \begin{key}{/tikz/graphs/--}
+ Sets the |default edge kind| to |--|.
+ %
+\begin{codeexample}[preamble={\usetikzlibrary{graphs.standard}}]
+\tikz \graph { subgraph K_n [--, n=5, clockwise, radius=6mm] };
+\end{codeexample}
+ \end{key}
+ %
+ \begin{key}{/tikz/graphs/->}
+ Sets the |default edge kind| to |->|.
+ %
+\begin{codeexample}[preamble={\usetikzlibrary{graphs.standard}}]
+\tikz \graph { subgraph K_n [->, n=5, clockwise, radius=6mm] };
+\end{codeexample}
+ \end{key}
+ %
+ \begin{key}{/tikz/graphs/<-}
+ Sets the |default edge kind| to |<-|.
+ %
+\begin{codeexample}[preamble={\usetikzlibrary{graphs.standard}}]
+\tikz \graph { subgraph K_n [<-, n=5, clockwise, radius=6mm] };
+\end{codeexample}
+ \end{key}
+ %
+ \begin{key}{/tikz/graphs/<->}
+ Sets the |default edge kind| to |<->|.
+ %
+\begin{codeexample}[preamble={\usetikzlibrary{graphs.standard}}]
+\tikz \graph { subgraph K_n [<->, n=5, clockwise, radius=6mm] };
+\end{codeexample}
+ \end{key}
+ %
+ \begin{key}{/tikz/graphs/-\protect\exclamationmarktext-}
+ Sets the |default edge kind| to |-!-|.
+ \end{key}
+
+ When the \meta{code} of an operator is executed, the following commands can
+ be used to find the nodes that should be connected:
+ %
+ \begin{command}{\tikzgraphforeachcolorednode\marg{color name}\marg{macro}}
+ When this command is called inside \meta{code}, the following will
+ happen: \tikzname\ will iterate over all nodes inside the
+ just-specified group that have the color \meta{color name}. The order
+ in which they are iterated over is the order in which they appear
+ inside the group specification (if a node is encountered several times
+ inside the specification, only the first occurrence counts). Then, for
+ each node the \meta{macro} is executed with the node's name as the only
+ argument.
+
+ In the following example we use an operator to connect every node
+ colored |all| inside the subgroup to he node |root|.
+ %
+\begin{codeexample}[preamble={\usetikzlibrary{graphs}}]
+\def\myconnect#1{\tikzset{graphs/new ->={root}{#1}{}{}}}
+
+\begin{tikzpicture}
+ \node (root) at (-1,-1) {root};
+
+ \graph {
+ x,
+ {
+ [operator=\tikzgraphforeachcolorednode{all}{\myconnect}]
+ a, b, c
+ }
+ };
+\end{tikzpicture}
+\end{codeexample}
+ \end{command}
+
+ \begin{command}{\tikzgraphpreparecolor\marg{color name}\marg{counter}\marg{prefix}}
+ This command is used to ``prepare'' the nodes of a certain color for
+ random access. The effect is the following: It is counted how many
+ nodes there are having color \meta{color name} in the current group and
+ the result is stored in \meta{counter}. Next, macros named
+ \meta{prefix}|1|, \meta{prefix}|2|, and so on are defined, that store
+ the names of the first, second, third, and so on node having the color
+ \meta{color name}.
+
+ The net effect is that after you have prepared a color, you can quickly
+ iterate over them. This is especially useful when you iterate over
+ several color at the same time.
+
+ As an example, let us create an operator then adds a zig-zag path
+ between two color classes:
+ %
+\begin{codeexample}[preamble={\usetikzlibrary{graphs}}]
+\newcount\leftshorecount \newcount\rightshorecount
+\newcount\mycount \newcount\myothercount
+\def\zigzag{
+ \tikzgraphpreparecolor{left shore}\leftshorecount{left shore prefix}
+ \tikzgraphpreparecolor{right shore}\rightshorecount{right shore prefix}
+ \mycount=0\relax
+ \loop
+ \advance\mycount by 1\relax%
+ % Add the "forward" edge
+ \tikzgraphsset{new ->=
+ {\csname left shore prefix\the\mycount\endcsname}
+ {\csname right shore prefix\the\mycount\endcsname}{}{}}
+ \myothercount=\mycount\relax%
+ \advance\myothercount by1\relax%
+ \tikzgraphsset{new <-=
+ {\csname left shore prefix\the\myothercount\endcsname}
+ {\csname right shore prefix\the\mycount\endcsname}{}{}}
+ \ifnum\myothercount<\leftshorecount\relax
+ \repeat
+}
+\begin{tikzpicture}
+ \graph [color class=left shore, color class=right shore]
+ { [operator=\zigzag]
+ { [left shore, Cartesian placement] a, b, c },
+ { [right shore, Cartesian placement, nodes={xshift=1cm}] d, e, f }
+ };
+\end{tikzpicture}
+\end{codeexample}
+ %
+ Naturally, in order to turn the above code into a usable operator, some
+ more code would be needed (like default values and taking care of
+ shores of different sizes).
+ \end{command}
+\end{key}
+
+There are a number of predefined operators, like |clique| or |cycle|, see the
+reference Section~\ref{section-library-graphs-reference} for a complete list.
+
+
+\subsubsection{Graph Operators for Joining Groups}
+\label{section-library-graphs-join}
+
+When you join two nodes |foo| and |bar| by the edge specification |->|, it is
+fairly obvious, what should happen: An edge from |(foo)| to |(bar)| should be
+created. However, suppose we use an edge specification between two node sets
+like |{a,b,c}| and |{d,e,f}|. In this case, it is not so clear which edges
+should be created. One might argue that all possible edges from any node in the
+first set to any node in the second set should be added. On the other hand, one
+might also argue that only a matching between these two sets should be created.
+Things get even more muddy when a longer chain of node sets are joined.
+
+Instead of fixing how edges are created between two node sets, \tikzname\ takes
+a somewhat more general, but also more complicated approach, which can be
+broken into two parts. In the following, assume that the following chain
+specification is given:
+%
+\begin{quote}
+ \meta{spec$_1$} \meta{edge specification} \meta{spec$_2$}
+\end{quote}
+%
+An example might be |{a,b,c} -> {d, e->f}|.
+
+\medskip
+\textbf{The source and target vertices.} Let us start with the question of
+which vertices of the first node set should be connected to vertices in the
+second node set.
+
+There are two predefined special color classes that are used for this: |source|
+and |target|. For every group specification, some vertices are colored as
+|source| vertices and some vertices are |target| vertices (a node can both be a
+target and a source). Initially, every vertex is both a source and a target,
+but that can change as we will see in a moment.
+
+The intuition behind source and target vertices is that, in some sense, edges
+``from the outside'' lead into the group via the source vertices and lead out
+of the group via the target vertices. To be more precise, the following
+happens:
+%
+\begin{enumerate}
+ \item The target vertices of the first group are connected to the source
+ vertices of the second group.
+ \item In the group resulting from the union of the nodes from
+ \meta{spec$_1$} and \meta{spec$_2$}, the source vertices are only those
+ from the first group, and the target vertices are only those from the
+ second group.
+\end{enumerate}
+
+Let us go over the effect of these rules for the example
+|{a,b,c} -> {d, e->f}|. First, each individual node is initially both a
+|source| and a |target| vertex. Then, in |{a,b,c}| all nodes are still both
+source and target vertices since just grouping vertices does not change their
+colors. Now, in |e->f| something interesting happens for the first time: the
+target vertices of the ``group'' |e| (which is just the node |e|) are connected
+to the source vertices of the ``group'' |f|. This means, that an edge is added
+from |e| to |f|. Then, in the resulting group |e->f| the only source vertex is
+|e| and the only target vertex is |f|. This implies that in the group
+|{d,e->f}| the sources are |d| and |e| and the targets are |d| and~|f|.
+
+Now, in |{a,b,c} -> {d,e->f}| the targets of |{a,b,c}| (which are all three of
+them) are connected to the sources of |{d,e->f}| (which are just |d| and~|e|).
+Finally, in the whole graph only |a|, |b|, and |c| are sources while only |d|
+and |f| are targets.
+%
+\begin{codeexample}[preamble={\usetikzlibrary{graphs}}]
+\def\hilightsource#1{\fill [green, opacity=.25] (#1) circle [radius=2mm]; }
+\def\hilighttarget#1{\fill [red, opacity=.25] (#1) circle [radius=2mm]; }
+\tikz \graph
+ [operator=\tikzgraphforeachcolorednode{source}{\hilightsource},
+ operator=\tikzgraphforeachcolorednode{target}{\hilighttarget}]
+ { {a,b,c} -> {d, e->f} };
+\end{codeexample}
+
+The next objective is to make more precise what it means that ``the targets of
+the first graph'' and the ``sources of the second graph'' should be connected.
+We know already of a general way of connecting nodes of a graph: operators!
+Thus, we use an operator for this job. For instance, the |complete bipartite|
+operator adds an edge from every node having a certain color to every node have
+a certain other color. This is exactly what we need here: The first color is
+``the color |target| restricted to the nodes of the first graph'' and the
+second color is ``the color |source| restricted to the nodes of the second
+graph''.
+
+However, we cannot really specify that only nodes from a certain subgraph are
+meant -- the |operator| machinery only operates on all nodes of the current
+graph. For this reason, what really happens is the following: When the |graph|
+command encounters \meta{spec$_1$} \meta{edge specification} \meta{spec$_2$},
+it first computes and colors the nodes of the first and the second
+specification independently. Then, the |target| nodes of the first graph are
+recolored to |target'| and the |source| nodes of the second graph are recolored
+to |source'|. Then, the two graphs are united into one graph and a
+\emph{joining operator} is executed, which should add edges between |target'|
+and |source'|. Once this is done, the colors |target'| and |source'| get
+erased. Note that in the resulting graph only the |source| nodes from the first
+graph are still |source| nodes and likewise for the |target| nodes of the
+second graph.
+
+\medskip
+\textbf{The joining operators.} The job of a joining operator is to add edges
+between nodes colored |target'| and |source'|. The following rule is used to
+determine which operator should be chosen for performing this job:
+%
+\begin{enumerate}
+ \item If the \meta{edge specification} explicitly sets the |operator| key
+ to something non-empty (and also not to |\relax|), then the \meta{code}
+ of this |operator| call is used.
+ \item Otherwise, the current value of the following key is used:
+ %
+ \begin{key}{/tikz/graphs/default edge operator=\meta{key} (initially matching and star)}
+ This key stores the name of a \meta{key} that is executed for every
+ \meta{edge specification} whose \meta{options} do not contain the
+ |operator| key.
+ %
+\begin{codeexample}[preamble={\usetikzlibrary{graphs}}]
+\tikz \graph [default edge operator=matching] {
+ {a, b} ->[matching and star]
+ {c, d, e} --[complete bipartite]
+ {f, g, h} --
+ {i, j, k}
+};
+\end{codeexample}
+ \end{key}
+\end{enumerate}
+
+A typical joining operator is |complete bipartite|. It takes the names of two
+color classes as input and adds edges from all vertices of the first class to
+all vertices of the second class. Now, the trick is that the default value for
+the |complete bipartite| key is |{target'}{source'}|. Thus, if you just write
+|->[complete bipartite]|, the same happens as if you had written
+%
+\begin{quote}
+ |->[complete bipartite={target'}{source'}]|
+\end{quote}
+%
+This is exactly what we want to happen. The same default values are also set
+for other joining operators like |matching| or |butterfly|.
+
+Even though an operator like |complete bipartite| is typically used together
+with an edge specification, it can also be used as a normal operator together
+with a group specification. In this case, however, the color classes must be
+named explicitly:
+%
+\begin{codeexample}[preamble={\usetikzlibrary{graphs}}]
+\begin{tikzpicture}
+ \graph [color class=red, color class=green, math nodes]
+ { [complete bipartite={red}{green}]
+ { [red, Cartesian placement] r_1, r_2, r_3 },
+ { [green, Cartesian placement, nodes={xshift=1cm}] g_1, g_2, g_3 }
+ };
+\end{tikzpicture}
+\end{codeexample}
+
+A list of predefined joining operators can be found in the reference
+Section~\ref{section-library-graphs-reference}.
+
+The fact that joining operators can also be used as normal operators leads to a
+subtle problem: A normal operator will typically use the current value of
+|default edge kind| to decide which kind of edges should be put between the
+identified vertices, while a joining operator should, naturally, use the kind
+of edge specified by the \meta{edge specification}. This problem is solved as
+follows: Like a normal operator, a joining operator should also use the current
+value of |default edge kind| for the edges it produces. The trick is that this
+will automatically be set to the current \meta{edge specification} when the
+operator explicitly in the \meta{options} of the edge specification or
+implicitly in the |default edge operator|.
+
+
+\subsection{Graph Macros}
+\label{section-library-graphs-macros}
+
+A \emph{graph macro} is a small graph that is inserted at some point into the
+graph that is currently being constructed. There is special support for such
+graph macros in \tikzname. You might wonder why this is necessary -- can't one
+use \TeX's normal macro mechanism? The answer is ``no'': one cannot insert new
+nodes into a graph using normal macros because the chains, groups, and nodes
+are determined prior to macro expansion. Thus, any macro encountered where some
+node text should go will only be expanded when this node is being named and
+typeset.
+
+A graph macro is declared using the following key:
+
+\begin{key}{/tikz/graphs/declare=\marg{graph name}\marg{specification}}
+ This key declares that \meta{graph name} can subsequently be used as a
+ replacement for a \meta{node name}. Whenever the \meta{graph name} is used
+ in the following, a graph group will be inserted instead whose content is
+ exactly \meta{specification}. In case \meta{graph name} is used together
+ with some \meta{options}, they are executed prior to inserting the
+ \meta{specification}.
+ %
+\begin{codeexample}[preamble={\usetikzlibrary{graphs}}]
+\tikz \graph [branch down=4mm, declare={claw}{1 -- {2,3,4}}] {
+ a;
+ claw;
+ b;
+};
+\end{codeexample}
+ %
+ In the next example, we use a key to configure a subgraph:
+ %
+\begin{codeexample}[preamble={\usetikzlibrary{graphs}}]
+\tikz \graph [ n/.code=\def\n{#1}, branch down=4mm,
+ declare={star}{root -- { \foreach \i in {1,...,\n} {\i} }}]
+{ star [n=5]; };
+\end{codeexample}
+ %
+ Actually, the |n| key is already defined internally for a similar purpose.
+
+ As a last example, let us define a somewhat more complicated graph macro.
+ %
+\begin{codeexample}[preamble={\usetikzlibrary{graphs}}]
+\newcount\mycount
+\tikzgraphsset{
+ levels/.store in=\tikzgraphlevel,
+ levels=1,
+ declare={bintree}{%
+ [/utils/exec={%
+ \ifnum\tikzgraphlevel=1\relax%
+ \def\childtrees{ / }%
+ \else%
+ \mycount=\tikzgraphlevel%
+ \advance\mycount by-1\relax%
+ \edef\childtrees{
+ / -> {
+ bintree[levels=\the\mycount],
+ bintree[levels=\the\mycount]
+ }}
+ \fi%
+ },
+ parse/.expand once=\childtrees
+ ]
+ % Everything is inside the \childtrees...
+ }
+}
+\tikz \graph [grow down=5mm, branch right=5mm] { bintree [levels=5] };
+\end{codeexample}
+ %
+\end{key}
+
+Note that when you use a graph macro several time inside the same graph, you
+will typically have to use the |name| option so that different copies of the
+subgraph are created:
+%
+\begin{codeexample}[preamble={\usetikzlibrary{graphs}}]
+\tikz \graph [branch down=4mm, declare={claw}{1 -- {2,3,4}}] {
+ claw [name=left],
+ claw [name=right]
+};
+\end{codeexample}
+
+You will find a list of useful graph macros in the reference section,
+Section~\ref{section-library-graphs-reference-macros}.
+
+
+\subsection{Online Placement Strategies}
+\label{section-library-graphs-placement}
+
+The main job of the |graphs| library is to make it easy to specify which nodes
+are present in a graph and how they are connected. In contrast, it is
+\emph{not} the primary job of the library to compute good positions for nodes
+in a graph -- use for instance a |\matrix|, specify good positions ``by hand''
+or use the graph drawing facilities. Nevertheless, some basic support for
+automatic node placement is provided for simple cases. The |graphs| library
+will provide you with information about the position of nodes inside their
+groups and chains.
+
+As a graph is being constructed, a \emph{placement strategy} is used to
+determine a (reasonably good) position for the nodes as they are created. These
+placement strategies get some information about what \tikzname\ has already
+seen concerning the already constructed nodes, but it gets no information
+concerning the upcoming nodes. Because of this lack of information concerning
+the future, the strategies need to be what is called an \emph{online strategy}
+in computer science. (The opposite are \emph{offline strategies}, which get
+information about the whole graph and all the sizes of the nodes in it. The
+graph drawing libraries employ such offline strategies.)
+
+Strategies are selected using keys like |no placement| or
+|Cartesian placement|. It is permissible to use different strategies inside
+different parts of a graph, even though the different strategies do not always
+work together in perfect harmony.
+
+
+\subsubsection{Manual Placement}
+\label{section-graphs-xy}
+
+\begin{key}{/tikz/graphs/no placement}
+ This strategy simply ``switches off'' the whole placement mechanism,
+ causing all nodes to be placed at the origin by default. You need to use
+ this strategy if you position nodes ``by hand''. For this, you can use the
+ |at| key, the |shift| keys:
+ %
+\begin{codeexample}[preamble={\usetikzlibrary{graphs}}]
+\tikz \graph [no placement]
+{
+ a[at={(0:0)}] -> b[at={(1,0)}] -> c[yshift=1cm];
+};
+\end{codeexample}
+ %
+ Since the syntax and the many braces and parentheses are a bit cumbersome,
+ the following two keys might also be useful:
+ %
+ \begin{key}{/tikz/graphs/x=\meta{x dimension}}
+ When you use this key, it will have the same effect as if you had
+ written |at={(|\meta{x dimension}|,|\meta{y dimension}|)}|, where
+ \meta{y dimension} is a value set using the |y| key:
+ %
+\begin{codeexample}[preamble={\usetikzlibrary{graphs}}]
+\tikz \graph [no placement]
+{
+ a[x=0,y=0] -> b[x=1,y=0] -> c[x=0,y=1];
+};
+\end{codeexample}
+ %
+ Note that you can specify an |x| or a |y| key for a whole scope and
+ then vary only the other key:
+ %
+\begin{codeexample}[preamble={\usetikzlibrary{graphs}}]
+\tikz \graph [no placement]
+{
+ a ->
+ { [x=1] % group option
+ b [y=0] -> c[y=1]
+ };
+};
+\end{codeexample}
+ %
+ Note that these keys have the path |/tikz/graphs/|, so they will be
+ available inside |graph|s and will not clash with the usual |x| and |y|
+ keys of \tikzname, which are used to specify the basic lengths of
+ vectors.
+ \end{key}
+ %
+ \begin{key}{/tikz/graphs/y=\meta{y dimension}}
+ See above.
+ \end{key}
+\end{key}
+
+
+\subsubsection{Placement on a Grid}
+
+\begin{key}{/tikz/graphs/Cartesian placement}
+ This strategy is the default strategy. It works, roughly, as follows: For
+ each new node on a chain, advance a ``logical width'' counter and for each
+ new node in a group, advance a ``logical depth'' counter. When a chain
+ contains a whole group, then the ``logical width'' taken up by the group is
+ the maximum over the logical widths taken up by the chains inside the
+ group; and symmetrically the logical depth of a chain is the maximum of the
+ depths of the groups inside it.
+
+ This slightly confusing explanation is perhaps best exemplified. In the
+ below example, the two numbers indicate the two logical width and depth of
+ each node as computed by the |graphs| library. Just ignore the arcane code
+ that is used to print these numbers.
+ %
+\begin{codeexample}[preamble={\usetikzlibrary{graphs}}]
+\tikz
+ \graph [nodes={align=center, inner sep=1pt}, grow right=7mm,
+ typeset={\tikzgraphnodetext\\[-4pt]
+ \tiny\mywidth\\[-6pt]\tiny\mydepth},
+ placement/compute position/.append code=
+ \pgfkeysgetvalue{/tikz/graphs/placement/width}{\mywidth}
+ \pgfkeysgetvalue{/tikz/graphs/placement/depth}{\mydepth}]
+{
+ a,
+ b,
+ c -> d -> {
+ e -> f -> g,
+ h -> i
+ } -> j,
+ k -> l
+};
+\end{codeexample}
+ %
+ You will find a detailed description of how these logical units are
+ computed, exactly, in Section~\ref{section-library-graphs-new-online}.
+
+ Now, even though we talk about ``widths'' and ``depths'' and even though by
+ default a graph ``grows'' to the right and down, this is by no means fixed.
+ Instead, you can use the following keys to change how widths and heights
+ are interpreted:
+ %
+ \begin{key}{/tikz/graphs/chain shift=\meta{coordinate} (initially {(1,0)})}
+ Under the regime of the |Cartesian placement| strategy, each node is
+ shifted by the current logical width times this \meta{coordinate}.
+ %
+\begin{codeexample}[preamble={\usetikzlibrary{graphs}}]
+\tikz \graph [chain shift=(45:1)] {
+ a -> b -> c;
+ d -> e;
+ f -> g -> h;
+};
+\end{codeexample}
+ \end{key}
+ %
+ \begin{key}{/tikz/graphs/group shift=\meta{coordinate} (initially {(0,-1)})}
+ Like for |chain shift|, each node is shifted by the current logical
+ depth times this \meta{coordinate}.
+ %
+\begin{codeexample}[preamble={\usetikzlibrary{graphs}}]
+\tikz \graph [chain shift=(45:7mm), group shift=(-45:7mm)] {
+ a -> b -> c;
+ d -> e;
+ f -> g -> h;
+};
+\end{codeexample}
+ \end{key}
+\end{key}
+
+\begin{key}{/tikz/graphs/grow up=\meta{distance} (default 1)}
+ Sets the |chain shift| to |(0,|\meta{distance}|)|, so that chains ``grow
+ upward''. The distance by which the center of each new element is removed
+ from the center of the previous one is \meta{distance}.
+ %
+\begin{codeexample}[preamble={\usetikzlibrary{graphs}}]
+\tikz \graph [grow up=7mm] { a -> b -> c};
+\end{codeexample}
+ %
+\end{key}
+
+\begin{key}{/tikz/graphs/grow down=\meta{distance} (default 1)}
+ Like |grow up|.
+ %
+\begin{codeexample}[preamble={\usetikzlibrary{graphs}}]
+\tikz \graph [grow down=7mm] { a -> b -> c};
+\end{codeexample}
+ %
+\end{key}
+
+\begin{key}{/tikz/graphs/grow left=\meta{distance} (default 1)}
+ Like |grow up|.
+ %
+\begin{codeexample}[preamble={\usetikzlibrary{graphs}}]
+\tikz \graph [grow left=7mm] { a -> b -> c};
+\end{codeexample}
+ %
+\end{key}
+
+\begin{key}{/tikz/graphs/grow right=\meta{distance} (default 1)}
+ Like |grow up|.
+ %
+\begin{codeexample}[preamble={\usetikzlibrary{graphs}}]
+\tikz \graph [grow right=7mm] { a -> b -> c};
+\end{codeexample}
+ %
+\end{key}
+
+\begin{key}{/tikz/graphs/branch up=\meta{distance} (default 1)}
+ Sets the |group shift| so that groups ``branch upward''. The distance by
+ which the center of each new element is removed from the center of the
+ previous one is \meta{distance}.
+ %
+\begin{codeexample}[preamble={\usetikzlibrary{graphs}}]
+\tikz \graph [branch up=7mm] { a -> b -> {c, d, e} };
+\end{codeexample}
+ %
+ Note that when you draw a tree, the |branch ...| keys specify how siblings
+ (or adjacent branches) are arranged, while the |grow ...| keys specify in
+ which direction the branches ``grow''.
+\end{key}
+
+\begin{key}{/tikz/graphs/branch down=\meta{distance} (default 1)}
+%
+\begin{codeexample}[preamble={\usetikzlibrary{graphs}}]
+\tikz \graph [branch down=7mm] { a -> b -> {c, d, e}};
+\end{codeexample}
+%
+\end{key}
+
+\begin{key}{/tikz/graphs/branch left=\meta{distance} (default 1)}
+%
+\begin{codeexample}[preamble={\usetikzlibrary{graphs}}]
+\tikz \graph [branch left=7mm, grow down=7mm] { a -> b -> {c, d, e}};
+\end{codeexample}
+%
+\end{key}
+
+\begin{key}{/tikz/graphs/branch right=\meta{distance} (default 1)}
+%
+\begin{codeexample}[preamble={\usetikzlibrary{graphs}}]
+\tikz \graph [branch right=7mm, grow down=7mm] { a -> b -> {c, d, e}};
+\end{codeexample}
+%
+\end{key}
+
+The following keys place nodes in a $N\times M$ grid.
+%
+\begin{key}{/tikz/graphs/grid placement}
+ This key works similar to |Cartesian placement|. As for that placement
+ strategy, a node has logical width and depth 1. However, the computed total
+ width and depth are mapped to a $N\times M$ grid. The values of $N$ and $M$
+ depend on the size of the graph and the value of |wrap after|. The number
+ of columns $M$ is either set to |wrap after| explicitly or computed
+ automatically as $\sqrt{\texttt{\string|V\string|}}$. $N$ is the number of
+ rows needed to lay out the graph in a grid with $M$ columns.
+ %
+\begin{codeexample}[preamble={\usetikzlibrary{graphs.standard}}]
+% An example with 6 nodes, 3 columns and therefor 2 rows
+\tikz \graph [grid placement] { subgraph I_n[n=6, wrap after=3] };
+\end{codeexample}
+ %
+\begin{codeexample}[preamble={\usetikzlibrary{graphs.standard}}]
+% An example with 9 nodes with columns and rows computed automatically
+\tikz \graph [grid placement] { subgraph Grid_n [n=9] };
+\end{codeexample}
+ %
+\begin{codeexample}[preamble={\usetikzlibrary{graphs.standard}}]
+% Directions can be changed
+\tikz \graph [grid placement, branch up, grow left] { subgraph Grid_n [n=9] };
+\end{codeexample}
+ %
+ In case a user-defined graph instead of a pre-defined |subgraph| is to be
+ laid out using |grid placement|, |n| has to be specified explicitly:
+ %
+\begin{codeexample}[preamble={\usetikzlibrary{graphs}}]
+\tikz \graph [grid placement] {
+ [n=6, wrap after=3]
+ a -- b -- c -- d -- e -- f
+};
+\end{codeexample}
+ %
+\end{key}
+
+
+\subsubsection{Placement Taking Node Sizes Into Account}
+
+Options like |grow up| or |branch right| do not take the sizes of the
+to-be-positioned nodes into account -- all nodes are placed quite ``dumbly'' at
+grid positions. It turns out that the |Cartesian placement| can also be used to
+place nodes in such a way that their height and/or width is taken into account.
+Note, however, that while the following options may yield an adequate placement
+in many situations, when you need advanced alignments you should use a |matrix|
+or advanced offline strategies to place the nodes.
+
+\begin{key}{/tikz/graphs/grow right sep=\meta{distance} (default 1em)}
+ This key has several effects, but let us start with the bottom line: Nodes
+ along a chain are placed in such a way that the left end of a new node is
+ \meta{distance} from the right end of the previous node:
+ %
+\begin{codeexample}[preamble={\usetikzlibrary{graphs}}]
+\tikz \graph [grow right sep, left anchor=east, right anchor=west] {
+ start -- {
+ long text -- {short, very long text} -- more text,
+ long -- longer -- longest
+ } -- end
+};
+\end{codeexample}
+ %
+ What happens internally is the following: First, the |anchor| of the nodes
+ is set to |west| (or |north west| or |south west|, see below). Second, the
+ logical width of a node is no longer |1|, but set to the actual width of
+ the node (which we define as the horizontal difference between the |west|
+ anchor and the |east| anchor) in points. Third, the |chain shift| is set to
+ |(1pt,0pt)|.
+\end{key}
+
+\begin{key}{/tikz/graphs/grow left sep=\meta{distance} (default 1em)}
+%
+\begin{codeexample}[preamble={\usetikzlibrary{graphs}}]
+\tikz \graph [grow left sep] { long -- longer -- longest };
+\end{codeexample}
+%
+\end{key}
+
+\begin{key}{/tikz/graphs/grow up sep=\meta{distance} (default 1em)}
+%
+\begin{codeexample}[preamble={\usetikzlibrary{graphs}}]
+\tikz \graph [grow up sep] {
+ a / $a=x$ --
+ b / {$b=\displaystyle \int_0^1 x dx$} --
+ c [draw, circle, inner sep=7mm]
+};
+\end{codeexample}
+%
+\end{key}
+
+\begin{key}{/tikz/graphs/grow down sep=\meta{distance} (default 1em)}
+ As above.
+\end{key}
+
+\begin{key}{/tikz/graphs/branch right sep=\meta{distance} (default 1em)}
+ This key works like |grow right sep|, only it affects groups rather than
+ chains.
+ %
+\begin{codeexample}[preamble={\usetikzlibrary{graphs}}]
+\tikz \graph [grow down, branch right sep] {
+ start -- {
+ an even longer text -- {short, very long text} -- more text,
+ long -- longer -- longest,
+ some text -- a -- b
+ } -- end
+};
+\end{codeexample}
+ %
+ When both this key and, say, |grow down sep| are set, instead of the |west|
+ anchor, the |north west| anchor will be selected automatically.
+\end{key}
+
+\begin{key}{/tikz/graphs/branch left sep=\meta{distance} (default 1em)}
+%
+\begin{codeexample}[preamble={\usetikzlibrary{graphs}}]
+\tikz \graph [grow down sep, branch left sep] {
+ start -- {
+ an even longer text -- {short, very long text} -- more text,
+ long -- longer,
+ some text -- a -- b
+ } -- end
+};
+\end{codeexample}
+%
+\end{key}
+
+\begin{key}{/tikz/graphs/branch up sep=\meta{distance} (default 1em)}
+%
+\begin{codeexample}[preamble={\usetikzlibrary{graphs}}]
+\tikz \graph [branch up sep] { a, b, c[draw, circle, inner sep=7mm] };
+\end{codeexample}
+%
+\end{key}
+
+\begin{key}{/tikz/graphs/branch down sep=\meta{distance} (default 1em)}
+\end{key}
+
+
+\subsubsection{Placement On a Circle}
+
+The following keys place nodes on circles. Note that, typically, you do not use
+|circular placement| directly, but rather use one of the two keys |clockwise|
+or |counterclockwise|.
+
+\begin{key}{/tikz/graphs/circular placement}
+ This key works quite similar to |Cartesian placement|. As for that
+ placement strategy, a node has logical width and depth |1|. However, the
+ computed total width and depth are mapped to polar coordinates rather than
+ Cartesian coordinates.
+
+ \begin{key}{/tikz/graphs/chain polar shift=|(|\meta{angle}|:|\meta{radius}|)| (initially {(0:1)})}
+ Under the regime of the |circular placement| strategy, each node on a
+ chain is shifted by
+ |(|\meta{logical width}\meta{angle}|:|\meta{logical width}\meta{angle}|)|.
+ %
+\begin{codeexample}[preamble={\usetikzlibrary{graphs}}]
+\tikz \graph [circular placement] {
+ a -> b -> c;
+ d -> e;
+ f -> g -> h;
+};
+\end{codeexample}
+ %
+ \end{key}
+ %
+ \begin{key}{/tikz/graphs/group polar shift=|(|\meta{angle}|:|\meta{radius}|)| (initially {(45:0)})}
+ Like for |group shift|, each node on a chain is shifted by
+ |(|\meta{logical depth}\meta{angle}|:|\meta{logical depth}\meta{angle}|)|.
+ %
+\begin{codeexample}[preamble={\usetikzlibrary{graphs}}]
+\tikz \graph [circular placement, group polar shift=(30:0)] {
+ a -> b -> c;
+ d -> e;
+ f -> g -> h;
+};
+\end{codeexample}
+ %
+\begin{codeexample}[preamble={\usetikzlibrary{graphs}}]
+\tikz \graph [circular placement,
+ chain polar shift=(30:0),
+ group polar shift=(0:1cm)] {
+ a -- b -- c;
+ d -- e;
+ f -- g -- h;
+};
+\end{codeexample}
+ \end{key}
+ %
+ \begin{key}{/tikz/graphs/radius=\meta{dimension} (initially 1cm)}
+ This is an initial value that is added to the total computed radius
+ when the polar shift of a node has been calculated. Essentially, this
+ key allows you to set the \meta{radius} of the innermost circle.
+ %
+\begin{codeexample}[preamble={\usetikzlibrary{graphs}}]
+\tikz \graph [circular placement, radius=5mm] { a, b, c, d };
+\end{codeexample}
+ %
+\begin{codeexample}[preamble={\usetikzlibrary{graphs}}]
+\tikz \graph [circular placement, radius=1cm] { a, b, c, d };
+\end{codeexample}
+ \end{key}
+ %
+ \begin{key}{/tikz/graphs/phase=\meta{angle} (initially 90)}
+ This is an initial value that is added to the total computed angle when
+ the polar shift of a node has been calculated.
+ %
+\begin{codeexample}[preamble={\usetikzlibrary{graphs}}]
+\tikz \graph [circular placement] { a, b, c, d };
+\end{codeexample}
+ %
+\begin{codeexample}[preamble={\usetikzlibrary{graphs}}]
+\tikz \graph [circular placement, phase=0] { a, b, c, d };
+\end{codeexample}
+ \end{key}
+\end{key}
+
+\label{key-graphs-clockwise}%
+\begin{key}{/tikz/graphs/clockwise=\meta{number} (default \string\tikzgraphVnum)}
+ This key sets the |group shift| so that if there are exactly \meta{number}
+ many nodes in a group, they will form a complete circle. If you do not
+ provide a \meta{number}, the current value of |\tikzgraphVnum| is used,
+ which is exactly what you want when you use predefined graph macros like
+ |subgraph K_n|.
+ %
+\begin{codeexample}[preamble={\usetikzlibrary{graphs}}]
+\tikz \graph [clockwise=4] { a, b, c, d };
+\end{codeexample}
+ %
+\begin{codeexample}[preamble={\usetikzlibrary{graphs.standard}}]
+\tikz \graph [clockwise] { subgraph K_n [n=5] };
+\end{codeexample}
+ %
+\end{key}
+
+\label{key-graphs-counterclockwise}%
+\begin{key}{/tikz/graphs/counterclockwise=\meta{number} (default \string\tikzgraphVnum)}
+ Works like |clockwise|, only the direction is inverted.
+\end{key}
+
+
+\subsubsection{Levels and Level Styles}
+
+As a graph is being parsed, the |graph| command keeps track of a parameter
+called the \emph{level} of a node. Provided that the graph is actually
+constructed in a tree-like manner, the level is exactly equal to the level of
+the node inside this tree.
+
+\begin{key}{/tikz/graphs/placement/level}
+ This key stores a number that is increased for each element on a chain, but
+ gets reset at the end of a group:
+ %
+\begin{codeexample}[preamble={\usetikzlibrary{graphs}}]
+\tikz \graph [ branch down=5mm, typeset=
+ \tikzgraphnodetext:\pgfkeysvalueof{/tikz/graphs/placement/level}]
+{
+ a -> {
+ b,
+ c -> {
+ d,
+ e -> {f,g},
+ h
+ },
+ j
+ }
+};
+\end{codeexample}
+ %
+ Unlike the parameters |depth| and |width| described in the next section,
+ the key |level| is always available.
+\end{key}
+
+In addition to keeping track of the value of the |level| key, the |graph|
+command also executes the following keys whenever it creates a node:
+
+\begin{stylekey}{/tikz/graph/level=\meta{level}}
+ This key gets executed for each newly created node with \meta{level} set to
+ the current level of the node. You can use this key to, say, reconfigure
+ the node distance or the node color.
+\end{stylekey}
+
+\begin{stylekey}{/tikz/graph/level \meta{level}}
+ This key also gets executed for each newly created node with \meta{level}
+ set to the current level of the node.
+ %
+\begin{codeexample}[preamble={\usetikzlibrary{graphs}}]
+\tikz \graph [
+ branch down=5mm,
+ level 1/.style={nodes=red},
+ level 2/.style={nodes=green!50!black},
+ level 3/.style={nodes=blue}]
+{
+ a -> {
+ b,
+ c -> {
+ d,
+ e -> {f,g},
+ h
+ },
+ j
+ }
+};
+\end{codeexample}
+ %
+\begin{codeexample}[preamble={\usetikzlibrary{graphs}}]
+\tikz \graph [
+ branch down=5mm,
+ level 1/.style={grow right=2cm},
+ level 2/.style={grow right=1cm},
+ level 3/.style={grow right=5mm}]
+{
+ a -> {
+ b,
+ c -> {
+ d,
+ e -> {f,g},
+ h
+ },
+ j
+ }
+};
+\end{codeexample}
+ %
+\end{stylekey}
+
+
+\subsubsection{Defining New Online Placement Strategies}
+\label{section-library-graphs-new-online}
+
+In the following the details of how to define a new placement strategy are
+explained. Most readers may wish to skip this section.
+
+As a graph specification is being parsed, the |graphs| library will keep track
+of different numbers that identify the positions of the nodes. Let us start
+with what happens on a chain. First, the following counter is increased for
+each element of the chain:
+%
+\begin{key}{/tikz/graphs/placement/element count}
+ This key stores a number that tells us the position of the node on the
+ current chain. However, you only have access to this value inside the code
+ passed to the macro |compute position|, explained later on.
+ %
+\begin{codeexample}[preamble={\usetikzlibrary{graphs}}]
+\tikz \graph [
+ grow right sep, typeset=\tikzgraphnodetext:\mynum,
+ placement/compute position/.append code=
+ \pgfkeysgetvalue{/tikz/graphs/placement/element count}{\mynum}]
+{
+ a -> b -> c,
+ d -> {e, f->h} -> j
+};
+\end{codeexample}
+ %
+ As can be seen, each group resets the element counter.
+\end{key}
+
+The second value that is computed is more complicated to explain, but it also
+gives more interesting information:
+%
+\begin{key}{/tikz/graphs/placement/width}
+ This key stores the ``logical width'' of the nodes parsed up to now in the
+ current group or chain (more precisely, parsed since the last call of
+ |place| in an enclosing group). This is not necessarily the ``total
+ physical width'' of the nodes, but rather a number representing how ``big''
+ the elements prior to the current element were. This \emph{may} be their
+ width, but it may also be their height or even their number (which,
+ incidentally, is the default). You can use the |width| to perform shifts or
+ rotations of to-be-created nodes (to be explained later).
+
+ The logical width is defined recursively as follows. First, the width of a
+ single node is computed by calling the following key:
+ %
+ \begin{key}{/tikz/graphs/placement/logical node width=\meta{full node name}}
+ This key is called to compute a physical or logical width of the node
+ \meta{full node name}. You can change the code of this key. The code
+ should return the computed value in the macro |\pgfmathresult|. By
+ default, this key returns |1|.
+ \end{key}
+ %
+ The width of a chain is the sum of the widths of its elements. The width of
+ a group is the maximum of the widths of its elements.
+
+ To get a feeling what the above rules imply in practice, let us first have
+ a look at an example where each node has logical width and height |1|
+ (which is the default). The arcane options at the beginning of the code
+ just setup things so that the computed width and depth of each node is
+ displayed at the bottom of each node.
+ %
+\begin{codeexample}[preamble={\usetikzlibrary{graphs}}]
+\tikz
+ \graph [nodes={align=center, inner sep=1pt}, grow right=7mm,
+ typeset={\tikzgraphnodetext\\[-4pt]
+ \tiny\mywidth\\[-6pt]\tiny\mydepth},
+ placement/compute position/.append code=
+ \pgfkeysgetvalue{/tikz/graphs/placement/width}{\mywidth}
+ \pgfkeysgetvalue{/tikz/graphs/placement/depth}{\mydepth}]
+{
+ a,
+ b,
+ c -> d -> {
+ e -> f -> g,
+ h -> i
+ } -> j,
+ k -> l
+};
+\end{codeexample}
+ %
+ In the next example the ``logical'' width and depth actually match the
+ ``physical'' width and height. This is caused by the |grow right sep|
+ option, which internally sets the |logical node width| key so that it
+ returns the width of its parameter in points.
+ %
+\begin{codeexample}[preamble={\usetikzlibrary{graphs}}]
+\tikz
+ \graph [grow right sep, branch down sep, nodes={align=left, inner sep=1pt},
+ typeset={\tikzgraphnodetext\\[-4pt] \tiny Width: \mywidth\\[-6pt] \tiny Depth: \mydepth},
+ placement/compute position/.append code=
+ \pgfkeysgetvalue{/tikz/graphs/placement/width}{\mywidth}
+ \pgfkeysgetvalue{/tikz/graphs/placement/depth}{\mydepth}]
+{
+ a,
+ b,
+ c -> d -> {
+ e -> f -> g,
+ h -> i
+ } -> j,
+ k -> l
+};
+\end{codeexample}
+ %
+\end{key}
+
+Symmetrically to chains, as a group is being constructed, counters are
+available for the number of chains encountered so far in the current group and
+for the logical depth of the current group:
+%
+\begin{key}{/tikz/graphs/placement/chain count}
+ This key stores a number that tells us the sequence number of the
+ chain in the current group.
+ %
+\begin{codeexample}[preamble={\usetikzlibrary{graphs}}]
+\tikz \graph [
+ grow right sep, branch down=5mm, typeset=\tikzgraphnodetext:\mynum,
+ placement/compute position/.append code=
+ \pgfkeysgetvalue{/tikz/graphs/placement/chain count}{\mynum}]
+{
+ a -> b -> {c,d,e},
+ f,
+ g -> h
+};
+\end{codeexample}
+ %
+\end{key}
+
+\begin{key}{/tikz/graphs/placement/depth}
+ Similarly to the |width| key, this key stores the ``logical depth'' of the
+ nodes parsed up to now in the current group or chain and, also similarly,
+ this key may or may not be related to the actual depth/height of the
+ current node. As for the |width|, the exact definition is as follows: For a
+ single node, the depth is computed by the following key:
+ %
+ \begin{key}{/tikz/graphs/placement/logical node depth=\meta{full node name}}
+ The code behind this key should return the ``logical height'' of the
+ node \meta{full node name} in the macro |\pgfmathresult|.
+ \end{key}
+ %
+ Second, the depth of a group is the sum of the depths of its elements.
+ Third, the depth of a chain is the maximum of the depth of its elements.
+\end{key}
+
+The |width|, |depth|, |element count|, and |chain count| keys get updated
+automatically, but do not have an effect by themselves. This is to the
+following two keys:
+
+\begin{key}{/tikz/graphs/placement/compute position=\meta{code}}
+ The \meta{code} is called by the |graph| command just prior to creating a
+ new node (the exact moment when this key is called is detailed in the
+ description of the |place| key). When the \meta{code} is called, all of the
+ keys described above will hold numbers computed in the way described above.
+
+ The job of the \meta{code} is to setup node options appropriately so that
+ the to-be-created node will be placed correctly. Thus, the \meta{code}
+ should typically set the key |nodes={shift=|\meta{coordinate}|}| where
+ \meta{coordinate} is the computed position for the node. The \meta{code}
+ could also set other options like, say, the color of a node depending on
+ its depth.
+
+ The following example appends some code to the standard code of
+ |compute position| so that ``deeper'' nodes of a tree are lighter.
+ (Naturally, the same effect could be achieved much more easily using the
+ |level| key.)
+ %
+\begin{codeexample}[preamble={\usetikzlibrary{graphs}}]
+\newcount\mycount
+\def\lightendeepernodes{
+ \pgfmathsetcount{\mycount}{
+ 100-20*\pgfkeysvalueof{/tikz/graphs/placement/width}
+ }
+ \edef\mydepth{\the\mycount}
+ \tikzset{nodes={fill=red!\mydepth,circle,text=white}}
+}
+\tikz
+ \graph [placement/compute position/.append code=\lightendeepernodes]
+ {
+ a -> {
+ b -> c -> d,
+ e -> {
+ f,
+ g
+ },
+ h
+ }
+ };
+\end{codeexample}
+ %
+\end{key}
+
+\begin{key}{/tikz/graphs/placement/place}
+ Executing this key has two effects: First, the key |compute position| is
+ called to compute a good position for future nodes (usually, these ``future
+ nodes'' are just a single node that is created immediately). Second, all of
+ the above counters like |depth| or |width| are reset (but not |level|).
+
+ There are two places where this key is sensibly called: First, just prior
+ to creating a node, which happens automatically. Second, when you change
+ the online strategy. In this case, the computed width and depth values from
+ one strategy typically make no sense in the other strategy, which is why
+ the new strategy should proceed ``from a fresh start''. In this case, the
+ implicit call of |compute position| ensures that the new strategy gets the
+ last place the old strategy would have used as its starting point, while
+ the computation of its positions is now relative to this new starting
+ point.
+
+ For these reasons, when an online strategy like |Cartesian placement| is
+ called, this key gets called implicitly. You will rarely need to call this
+ key directly, except when you define a new online strategy.
+\end{key}
+
+
+\subsection{Reference: Predefined Elements}
+\label{section-library-graphs-reference}
+
+\subsubsection{Graph Macros}
+\label{section-library-graphs-reference-macros}
+
+\begin{tikzlibrary}{graphs.standard}
+ This library defines a number of graph macros that are often used in the
+ literature. When new graphs are added to this collection, they will follow
+ the definitions in the Mathematica program, see
+ \url{mathworld.wolfram.com/topics/SimpleGraphs.html}.
+\end{tikzlibrary}
+
+\begin{graph}{subgraph I\_n}
+ This graph consists just of $n$ unconnected vertices. The following key is
+ used to specify the set of these vertices:
+ %
+ \begin{key}{/tikz/graphs/V=\marg{list of vertices}}
+ Sets a list of vertex names for use with graphs like |subgraph I_n| and
+ also other graphs. This list is available in the macro |\tikzgraphV|.
+ The number of elements of this list is available in |\tikzgraphVnum|.
+ \end{key}
+ %
+ \begin{key}{/tikz/graphs/n=\meta{number}}
+ This is an abbreviation for
+ |V={1,...,|\meta{number}|}, name shore V/.style={name=V}|.
+ \end{key}
+ %
+\begin{codeexample}[preamble={\usetikzlibrary{graphs.standard}}]
+\tikz \graph [branch right, nodes={draw, circle}]
+ { subgraph I_n [V={a,b,c}] };
+\end{codeexample}
+ %
+ This graph is not particularly exciting by itself. However, it is often
+ used to introduce nodes into a graph that are then connected as in the
+ following example:
+ %
+\begin{codeexample}[preamble={\usetikzlibrary{graphs.standard}}]
+\tikz \graph [clockwise, clique] { subgraph I_n [n=4] };
+\end{codeexample}
+ %
+\end{graph}
+
+\begin{graph}{subgraph I\_nm}
+ This graph consists of two sets of once $n$ unconnected vertices and then
+ $m$ unconnected vertices. The first set consists of the vertices set by the
+ key |V|, the other set consists of the vertices set by the key |W|.
+ %
+\begin{codeexample}[preamble={\usetikzlibrary{graphs.standard}}]
+\tikz \graph { subgraph I_nm [V={1,2,3}, W={a,b,c}] };
+\end{codeexample}
+ %
+ In order to set the graph path name of the two sets, the following keys get
+ executed:
+ %
+ \begin{stylekey}{/tikz/graphs/name shore V (initially \normalfont empty)}
+ Set this style to, say, |name=my V set| in order to set a name for the
+ |V| set.
+ \end{stylekey}
+ %
+ \begin{stylekey}{/tikz/graphs/name shore W (initially \normalfont empty)}
+ Same as for |name shore V|.
+ \end{stylekey}
+ %
+ \begin{key}{/tikz/graphs/W=\marg{list of vertices}}
+ Sets the list of vertices for the |W| set. The elements and their
+ number are available in the macros |\tikzgraphW| and |\tikzgraphWnum|,
+ respectively.
+ \end{key}
+ %
+ \begin{key}{/tikz/graphs/m=\meta{number}}
+ This is an abbreviation for
+ |W={1,...,|\meta{number}|}, name shore W/.style={name=W}|.
+ \end{key}
+ %
+ The main purpose of this subgraph is to setup the nodes in a bipartite
+ graph:
+ %
+\begin{codeexample}[preamble={\usetikzlibrary{graphs.standard}}]
+\tikz \graph {
+ subgraph I_nm [n=3, m=4];
+
+ V 1 -- { W 2, W 3 };
+ V 2 -- { W 1, W 3 };
+ V 3 -- { W 1, W 4 };
+};
+\end{codeexample}
+ %
+\end{graph}
+
+\begin{graph}{subgraph K\_n}
+ This graph is the complete clique on the vertices from the |V| key.
+ %
+\begin{codeexample}[preamble={\usetikzlibrary{graphs.standard}}]
+\tikz \graph [clockwise] { subgraph K_n [n=7] };
+\end{codeexample}
+ %
+\end{graph}
+
+\begin{graph}{subgraph K\_nm}
+ This graph is the complete bipartite graph with the two shores |V| and |W|
+ as in |subgraph I_nm|.
+ %
+\begin{codeexample}[preamble={\usetikzlibrary{graphs.standard}}]
+\tikz \graph [branch right, grow down]
+ { subgraph K_nm [V={6,...,9}, W={b,...,e}] };
+\end{codeexample}
+ %
+\begin{codeexample}[preamble={\usetikzlibrary{graphs.standard}}]
+\tikz \graph [simple, branch right, grow down]
+{
+ subgraph K_nm [V={1,2,3}, W={a,b,c,d}, ->];
+ subgraph K_nm [V={2,3}, W={b,c}, <-];
+};
+\end{codeexample}
+ %
+\end{graph}
+
+\begin{graph}{subgraph P\_n}
+ This graph is the path on the vertices in |V|.
+ %
+\begin{codeexample}[preamble={\usetikzlibrary{graphs.standard}}]
+\tikz \graph [branch right] { subgraph P_n [n=3] };
+\end{codeexample}
+ %
+\end{graph}
+
+\begin{graph}{subgraph C\_n}
+ This graph is the cycle on the vertices in |V|.
+ %
+\begin{codeexample}[preamble={\usetikzlibrary{graphs.standard}}]
+\tikz \graph [clockwise] { subgraph C_n [n=7, ->] };
+\end{codeexample}
+ %
+\end{graph}
+
+\begin{graph}{subgraph Grid\_n}
+ This graph is a grid of the vertices in |V|.
+ %
+ \begin{key}{/tikz/graphs/wrap after=\meta{number}}
+ Defines the number of nodes placed in a single row of the grid. This
+ value implicitly defines the number of grid columns as well. In the
+ following example a |grid placement| is used to visualize the edges
+ created between the nodes of a |Grid_n| |subgraph| using different
+ values for |wrap after|.
+ %
+\begin{codeexample}[preamble={\usetikzlibrary{graphs.standard}}]
+\tikz \graph [grid placement] { subgraph Grid_n [n=3,wrap after=1] };
+\tikz \graph [grid placement] { subgraph Grid_n [n=3,wrap after=3] };
+\end{codeexample}
+ %
+\begin{codeexample}[preamble={\usetikzlibrary{graphs.standard}}]
+\tikz \graph [grid placement] { subgraph Grid_n [n=4,wrap after=2] };
+\tikz \graph [grid placement] { subgraph Grid_n [n=4] };
+\end{codeexample}
+ \end{key}
+\end{graph}
+
+% TODO: Implement the Grid_nm subgraph described here:
+%
+%\begin{graph}{subgraph Grid\_nm}
+% This graph is a grid built from the cartesian product of the two node
+% sets |V| and |W| which are either defined using the keys
+% |/tikz/graphs/V| and |/tikz/graphs/W| or |/tikz/graphs/n| and
+% |/tikz/graphs/m| or a mixture of both.
+%
+% The resulting |Grid_nm| subgraph has $n$ ``rows'' and $m$ ``columns'' and
+% the nodes are named |V i W j| with $1\le i\le n$ and $1\le j\le n$.
+% The names of the two shores |V| and |W| can be changed as described in
+% the documentation of the keys |/tikz/graphs/name shore V| and
+% |/tikz/graphs/name shore W|.
+% \begin{codeexample}[preamble={\usetikzlibrary{graphs}}]
+%\tikz \graph [grid placement] { subgraph Grid_nm [V={1,2,3}, W={4, 5, 6}] };
+% \end{codeexample}
+%\end{graph}
+
+
+\subsubsection{Group Operators}
+
+The following keys use the |operator| key to setup operators that connect the
+vertices of the current group having a certain color in a specific way.
+
+\begin{key}{/tikz/graphs/clique=\meta{color} (default all)}
+ Adds an edge between all vertices of the current group having the (logical)
+ color \meta{color}. Since, by default, this color is set to |all|, which is
+ a color that all nodes get by default, when you do not specify anything,
+ all nodes will be connected.
+ %
+\begin{codeexample}[preamble={\usetikzlibrary{graphs}}]
+\tikz \graph [clockwise, n=5] {
+ a,
+ b,
+ {
+ [clique]
+ c, d, e
+ }
+};
+\end{codeexample}
+ %
+\begin{codeexample}[preamble={\usetikzlibrary{graphs}}]
+\tikz \graph [color class=red, clockwise, n=5] {
+ [clique=red, ->]
+ a, b[red], c[red], d, e[red]
+};
+\end{codeexample}
+ %
+\end{key}
+
+\begin{key}{/tikz/graphs/induced independent set=\meta{color} (default all)}
+ This key is the ``opposite'' of a |clique|: It removes all edges in the
+ current group having belonging to color class \meta{color}. More precisely,
+ an edge of kind |-!-| is added for each pair of vertices. This means that
+ edge only get removed if you specify the |simple| option.
+ %
+\begin{codeexample}[preamble={\usetikzlibrary{graphs.standard}}]
+\tikz \graph [simple] {
+ subgraph K_n [<->, n=7, clockwise]; % create lots of edges
+
+ { [induced independent set] 1, 3, 4, 5, 6 }
+};
+\end{codeexample}
+ %
+\end{key}
+
+\begin{key}{/tikz/graphs/cycle=\meta{color} (default all)}
+ Connects the nodes colored \meta{color} is a cyclic fashion. The ordering
+ is the ordering in which they appear in the whole graph specification.
+ %
+\begin{codeexample}[preamble={\usetikzlibrary{graphs}}]
+\tikz \graph [clockwise, n=6, phase=60] {
+ { [cycle, ->] a, b, c },
+ { [cycle, <-] d, e, f }
+};
+\end{codeexample}
+ %
+\end{key}
+
+\begin{key}{/tikz/graphs/induced cycle=\meta{color} (default all)}
+ While the |cycle| command will only add edges, this key will also remove
+ all other edges between the nodes of the cycle, provided we are
+ constructing a |simple| graph.
+ %
+\begin{codeexample}[preamble={\usetikzlibrary{graphs.standard}}]
+\tikz \graph [simple] {
+ subgraph K_n [n=7, clockwise]; % create lots of edges
+
+ { [induced cycle, ->, edge=red] 2, 3, 4, 6, 7 },
+};
+\end{codeexample}
+ %
+\end{key}
+
+\begin{key}{/tikz/graphs/path=\meta{color} (default all)}
+ Works like |cycle|, only there is no edge from the last to the first
+ vertex.
+ %
+\begin{codeexample}[preamble={\usetikzlibrary{graphs}}]
+\tikz \graph [clockwise, n=6] {
+ { [path, ->] a, b, c },
+ { [path, <-] d, e, f }
+};
+\end{codeexample}
+ %
+\end{key}
+
+\begin{key}{/tikz/graphs/induced path=\meta{color} (default all)}
+ Works like |induced cycle|, only there is no edge from the last to the
+ first vertex.
+ %
+\begin{codeexample}[preamble={\usetikzlibrary{graphs.standard}}]
+\tikz \graph [simple] {
+ subgraph K_n [n=7, clockwise]; % create lots of edges
+
+ { [induced path, ->, edges=red] 2, 3, 4, 6, 7 },
+};
+\end{codeexample}
+ %
+\end{key}
+
+
+\subsubsection{Joining Operators}
+
+The following keys are typically used as options of an \meta{edge
+specification}, but can also be called in a group specification (however, then,
+the colors need to be set explicitly).
+
+\begin{key}{/tikz/graphs/complete bipartite=\meta{from color}\meta{to color} (default \char`\{source'\char`\}\char`\{target'\char`\})}
+ Adds all possible edges from every node having color \meta{from color} to
+ every node having color \meta{to color}:
+ %
+\begin{codeexample}[preamble={\usetikzlibrary{graphs}}]
+\tikz \graph { {a, b} ->[complete bipartite]
+ {c, d, e} --[complete bipartite]
+ {g, h, i, j} --[complete bipartite]
+ k };
+\end{codeexample}
+ %
+\begin{codeexample}[preamble={\usetikzlibrary{graphs}}]
+\tikz \graph [color class=red, color class=green, clockwise, n=6] {
+ [complete bipartite={red}{green}, ->]
+ a [red], b[red], c[red], d[green], e[green], f[green]
+};
+\end{codeexample}
+ %
+\end{key}
+
+\begin{key}{/tikz/graphs/induced complete bipartite}
+ Works like the |complete bipartite| operator, but in a |simple| graph any
+ edges between the vertices in either shore are removed (more precisely,
+ they get replaced by |-!-| edges).
+ %
+\begin{codeexample}[preamble={\usetikzlibrary{graphs.standard}}]
+\tikz \graph [simple] {
+ subgraph K_n [n=5, clockwise]; % Lots of edges
+
+ {2, 3} ->[induced complete bipartite] {4, 5}
+};
+\end{codeexample}
+ %
+\end{key}
+
+\begin{key}{/tikz/graphs/matching=\meta{from color}\meta{to color} (default \char`\{source'\char`\}\char`\{target'\char`\})}
+ This joining operator forms a maximum \emph{matching} between the nodes of
+ the two sets of nodes having colors \meta{from color} and \meta{to color},
+ respectively. The first node of the from set is connected to the first node
+ of to set, the second node of the from set is connected to the second node
+ of the to set, and so on. If the sets have the same size, what results is
+ what graph theoreticians call a \emph{perfect matching}, otherwise only a
+ maximum, but not perfect matching results.
+ %
+\begin{codeexample}[preamble={\usetikzlibrary{graphs}}]
+\tikz \graph {
+ {a, b, c} ->[matching]
+ {d, e, f} --[matching]
+ {g, h} --[matching]
+ {i, j, k}
+};
+\end{codeexample}
+ %
+\end{key}
+
+\begin{key}{/tikz/graphs/matching and star=\meta{from color}\meta{to color} (default \char`\{source'\char`\}\char`\{target'\char`\})}
+ The |matching and star| connector works like the |matching| connector, only
+ it behaves differently when the two to-be-connected sets have different
+ size. In this case, all the surplus nodes get connected to the last node of
+ the other set, resulting in what is known as a \emph{star} in graph theory.
+ This simple rule allows for some powerful effects (since this connector is
+ the one initially set, there is no need to add it here):
+ %
+\begin{codeexample}[preamble={\usetikzlibrary{graphs}}]
+\tikz \graph { a -> {b, c} -> {d, e} -- f};
+\end{codeexample}
+ %
+ The |matching and star| connector also makes it easy to create trees and
+ series-parallel graphs.
+\end{key}
+
+\begin{key}{/tikz/graphs/butterfly=\opt{\meta{options}}}
+ The |butterfly| connector is used to create the kind of connections present
+ between layers of a so-called \emph{butterfly network}. As for other
+ connectors, two sets of nodes are connected, which are the nodes having
+ color |target'| and |source'| by default. In a \emph{level $l$} connection,
+ the first $l$ nodes of the first set are connected to the second $l$ nodes
+ of the second set, while the second $l$ nodes of the first set get
+ connected to the first $l$ nodes of the second set. Then, for next $2l$
+ nodes of both sets a similar kind of connection is installed. Additionally,
+ each node gets connected to the corresponding node in the other set with
+ the same index (as in a |matching|):
+ %
+\begin{codeexample}[preamble={\usetikzlibrary{graphs.standard}}]
+\tikz \graph [left anchor=east, right anchor=west,
+ branch down=4mm, grow right=15mm] {
+ subgraph I_n [n=12, name=A] --[butterfly={level=3}]
+ subgraph I_n [n=12, name=B] --[butterfly={level=2}]
+ subgraph I_n [n=12, name=C]
+};
+\end{codeexample}
+ %
+ Unlike most joining operators, the colors of the nodes in the first and the
+ second set are not passed as parameters to the |butterfly| key. Rather,
+ they can be set using the \meta{options}, which are executed with the path
+ prefix |/tikz/graphs/butterfly|.
+ %
+ \begin{key}{/tikz/graphs/butterfly/level=\meta{level} (initially 1)}
+ Sets the level $l$ for the connections.
+ \end{key}
+ %
+ \begin{key}{/tikz/graphs/butterfly/from=\meta{color} (initially target')}
+ Sets the color class of the from nodes.
+ \end{key}
+ %
+ \begin{key}{/tikz/graphs/butterfly/to=\meta{color} (initially source')}
+ Sets the color class of the to nodes.
+ \end{key}
+\end{key}
+
+
+%%% Local Variables:
+%%% mode: latex
+%%% TeX-master: "pgfmanual-pdftex-version"
+%%% End: