\begin{minipage}[t]{8in}
\begin{tabular}{ll}
Graph*  & bipartiteRepresentation\index{GraphBuild!bipartiteRepresentation}(Graph *{\em g}); 
\end{tabular}\\

	
 \parbox[b]{2in} \ \ 
\begin{minipage}[t]{4in} Primarily useful for obtaining alternate representations for
	  hypergraphs, this function creates a new binary graph whose
	  vertex set is the union of the vertex and edge sets of {\em g}.
	  A Vertex $v$ representing edge $e$ of {\em g} is adjacent to the 
	  vertices representing vertices of {\em g} which are members of $e$.\end{minipage}
\end{minipage}
\vspace{0.2in}


\begin{minipage}[t]{8in}
\begin{tabular}{ll}
int  & compareVertexNames\index{GraphBuild!compareVertexNames}(char *, char *);
\end{tabular}\\

	
 \parbox[b]{2in} \ \ 
\begin{minipage}[t]{4in} This is the default method for comparing vertices.  Vertex names
	  are character strings, but those strings most often contain digits.
	  Standard lexicographic ordering of strings is therefore not 
	  very convenient most of the time.  This routines determines if
	  the strings represent integers, and if so, compares their 
	  integer values.\end{minipage}
\end{minipage}
\vspace{0.2in}


\begin{minipage}[t]{8in}
\begin{tabular}{ll}
Graph* makeGraph(Set$<$Vertex*$>$, MSet$<$Edge*$>$);  
\\
Graph* makeGraph(MSet$<$Vertex*$>$ vset, MSet$<$Set$<$Vertex*$>$ $>$ eset);
\\
Graph* makeGraph(MSet$<$Vertex*$>$ vset, MSet$<$Sequence$<$Vertex*$>$ $>$ eset);
\\
Graph* makeGraph(MSet$<$char*$>$ vset, MSet$<$Set$<$char*$>$ $>$ eset);
\\
Graph* makeGraph(Set$<$char*$>$ vseq, MSet$<$Sequence$<$char*$>$ $>$ eseq);
\\
Graph* makeGraph(Set$<$int*$>$ vset, MSet$<$Set$<$int*$>$ $>$ eset);
\end{tabular}\\

	
 \parbox[b]{2in} \ \ 
\begin{minipage}[t]{4in}These routines dynamically allocate and construct a new graph of the 
	 appropriate type given the passed vertex and edge sets.\end{minipage}
\end{minipage}
\vspace{0.2in}


\begin{minipage}[t]{8in}
\begin{tabular}{ll}
Graph*  & directedGraph\index{GraphBuild!directedGraph}(const Graph* g);
\end{tabular}\\

		
 \parbox[b]{2in} \ \ 
\begin{minipage}[t]{4in}Dynamically allocate a new empty graph of the same type as
		 {\em g}, except if {\em g} is not directed.  In that case,
		 dynamically allocate a directed graph of the corresponding 
		 type.\end{minipage}
\end{minipage}
\vspace{0.2in}


\begin{minipage}[t]{8in}
\begin{tabular}{ll}
Graph*  & multiGraph\index{GraphBuild!multiGraph}(const Graph* g);
\end{tabular}\\

		
 \parbox[b]{2in} \ \ 
\begin{minipage}[t]{4in}Dynamically allocate a new empty graph of the same type as
		 {\em g}, except if {\em g} is a simple graph.  In that case,
		 dynamically allocate a multigraph of the corresponding type.\end{minipage}
\end{minipage}
\vspace{0.2in}


\begin{minipage}[t]{8in}
\begin{tabular}{ll}
graph*  & nautyGraph\index{GraphBuild!nautyGraph}(const Graph* g);
\end{tabular}\\

		
 \parbox[b]{2in} \ \ 
\begin{minipage}[t]{4in}Given a LINK graph object, return a graph in the format
		 of {\em nauty}, the system due to Brendan McKay for 
		 identifying automorphism groups and testing isomorphism.\end{minipage}
\end{minipage}
\vspace{0.2in}


\begin{minipage}[t]{8in}
\begin{tabular}{ll}
Graph*  & newEmpty()\index{GraphBuild!newEmpty()}onst Graph* g);
\end{tabular}\\

		
 \parbox[b]{2in} \ \ 
\begin{minipage}[t]{4in}Dynamically allocate a new empty graph of the same type as
		 {\em g}.\end{minipage}
\end{minipage}
\vspace{0.2in}


\begin{minipage}[t]{8in}
\begin{tabular}{ll}
Graph*  & simpleGraph\index{GraphBuild!simpleGraph}(const Graph* g);
\end{tabular}\\

		
 \parbox[b]{2in} \ \ 
\begin{minipage}[t]{4in}Dynamically allocate a new empty graph of the same type as
		 {\em g}, except if {\em g} is a simple graph.  In that case,
		 dynamically allocate a multigraph of the corresponding type.\end{minipage}
\end{minipage}
\vspace{0.2in}


\begin{minipage}[t]{8in}
\begin{tabular}{ll}
Graph*  & undirectedGraph\index{GraphBuild!undirectedGraph}(const Graph* g);
\end{tabular}\\

		
 \parbox[b]{2in} \ \ 
\begin{minipage}[t]{4in}Dynamically allocate a new empty graph of the same type as
		 {\em g}, except if {\em g} is not undirected.  In that case,
		 dynamically allocate an undirected graph of the corresponding 
		 type.\end{minipage}
\end{minipage}
\vspace{0.2in}

