\batchmode
\documentclass[11pt]{article}
\makeatletter
\usepackage{alltt}
\usepackage{graphicx}
\title{Link 1.3}
\author{Jonathan W. Berry \\	Elon College, N.C. \\	berryj@numen.elon.edu \\	(note: this html version of the manual is buggy in the
	sense that many figures and examples have been garbled
	in the latex to html conversion process.  The situation
	will improve as the manual and latex2html improve.  }
\makeindex

\newcommand{\Link}{{\em LINK~}}

\newcommand{\Linkn}{{\em LINK}}

\newcommand{\rar}[2]{{{\em #1}\(\rightarrow\){\em #2}}}

\newcommand{\Container}{{\em Container}}

\newcommand{\ContainerNode}{{\em ContainerNode}}

\newcommand{\ElementOps}{{\em ElementOps}}

\newcommand{\FlowInfo}{{\em FlowInfo}}

\newcommand{\Array}{{\em Array}}

\newcommand{\SortedArray}{{\em SortedArray}}

\newcommand{\SortedList}{{\em SortedList}}

\newcommand{\List}{{\em List}}

\newcommand{\Item}{{\em Item}}

\newcommand{\ListNode}{{\em ListNode}}

\newcommand{\Queue}{{\em Queue}}

\newcommand{\Deque}{{\em Deque}}

\newcommand{\Stack}{{\em Stack}}

\newcommand{\DList}{{\em DList}}

\newcommand{\Permutation}{{\em Permutation}}

\newcommand{\Matrix}{{\em Matrix}}

\newcommand{\BinaryHeap}{{\em BinaryHeap}}

\newcommand{\BinaryHeapNode}{{\em BinaryHeapNode}}

\newcommand{\BinarySearchTree}{{\em BinarySearchTree}}

\newcommand{\RedBlackTree}{{\em RedBlackTree}}

\newcommand{\BinomialHeap}{{\em BinomialHeap}}

\newcommand{\SimpleContainer}{{\em SimpleContainer}}

\newcommand{\Dictionary}{{\em Dictionary}}

\newcommand{\Collection}{{\em Collection}}

\newcommand{\SetBase}{{\em SetBase}}

\newcommand{\MSetBase}{{\em MSetBase}}

\newcommand{\SymSet}{{\em SymSet}}

\newcommand{\Set}{{\em Set}}

\newcommand{\MSet}{{\em MSet}}

\newcommand{\SubSet}{{\em SubSet}}

\newcommand{\SequenceBase}{{\em SequenceBase}}

\newcommand{\Sequence}{{\em Sequence}}

\newcommand{\Iterator}{{\em Iterator}}

\newcommand{\GraphObject}{{\em GraphObject}}

\newcommand{\Graph}{{\em Graph}}

\newcommand{\Subgraph}{{\em Subgraph}}

\newcommand{\MUHyperGraph}{{\em MUHyperGraph}}

\newcommand{\MDHyperGraph}{{\em MDHyperGraph}}

\newcommand{\MBinGraph}{{\em MBinGraph}}

\newcommand{\MUBinGraph}{{\em MUBinGraph}}

\newcommand{\MDBinGraph}{{\em MDBinGraph}}

\newcommand{\HyperGraph}{{\em HyperGraph}}

\newcommand{\UHyperGraph}{{\em UHyperGraph}}

\newcommand{\DHyperGraph}{{\em DHyperGraph}}

\newcommand{\BinGraph}{{\em BinGraph}}

\newcommand{\UBinGraph}{{\em UBinGraph}}

\newcommand{\DBinGraph}{{\em DBinGraph}}

\newcommand{\Vertex}{{\em Vertex}}

\newcommand{\Edge}{{\em Edge}}

\newcommand{\Attribute}{{\em Attribute}}

\newcommand{\GraphView}{{\em GraphView}}

\newcommand{\Graphic}{{\em Graphic}}

\newcommand{\VertexGraphic}{{\em VertexGraphic}}

\newcommand{\EdgeGraphic}{{\em EdgeGraphic}}

\newcommand{\Graphics}{{\em Graphics}}

\newcommand{\GraphWindow}{{\em GraphWindow}}

\newcommand{\GraphCanvas}{{\em GraphCanvas}}

\newcommand{\Canvas}{{\em Canvas}}

\newcommand{\GraphShell}{{\em GraphShell}}

\newcommand{\Selection}{{\em Selection}}

\newcommand{\Containers}{{\em Containers}}

\newcommand{\ContainerNodes}{{\em ContainerNodes}}

\newcommand{\Arrays}{{\em Arrays}}

\newcommand{\SortedArrays}{{\em SortedArrays}}

\newcommand{\SortedLists}{{\em SortedLists}}

\newcommand{\Lists}{{\em Lists}}

\newcommand{\Items}{{\em Items}}

\newcommand{\ListNodes}{{\em ListNodes}}

\newcommand{\Queues}{{\em Queues}}

\newcommand{\Deques}{{\em Deques}}

\newcommand{\Stacks}{{\em Stacks}}

\newcommand{\DLists}{{\em DLists}}

\newcommand{\Matrices}{{\em Matrices}}

\newcommand{\Permutations}{{\em Permutations}}

\newcommand{\BinaryHeaps}{{\em BinaryHeaps}}

\newcommand{\BinaryHeapNodes}{{\em BinaryHeapNodes}}

\newcommand{\BinarySearchTrees}{{\em BinarySearchTrees}}

\newcommand{\RedBlackTrees}{{\em RedBlackTrees}}

\newcommand{\BinomialHeaps}{{\em BinomialHeaps}}

\newcommand{\SimpleContainers}{{\em SimpleContainers}}

\newcommand{\Collections}{{\em Collections}}

\newcommand{\SetBases}{{\em SetBases}}

\newcommand{\MSetBases}{{\em MSetBases}}

\newcommand{\SymSets}{{\em SymSets}}

\newcommand{\Sets}{{\em Sets}}

\newcommand{\MSets}{{\em MSets}}

\newcommand{\SubSets}{{\em SubSets}}

\newcommand{\SequenceBases}{{\em SequenceBases}}

\newcommand{\Sequences}{{\em Sequences}}

\newcommand{\Iterators}{{\em Iterators}}

\newcommand{\VertexGraphics}{{\em VertexGraphics}}

\newcommand{\EdgeGraphics}{{\em EdgeGraphics}}

\newcommand{\GraphObjects}{{\em GraphObjects}}

\newcommand{\Graphs}{{\em Graphs}}

\newcommand{\Subgraphs}{{\em Subgraphs}}

\newcommand{\MUHyperGraphs}{{\em MUHyperGraphs}}

\newcommand{\MDHyperGraphs}{{\em MDHyperGraphs}}

\newcommand{\MBinGraphs}{{\em MBinGraphs}}

\newcommand{\MUBinGraphs}{{\em MUBinGraphs}}

\newcommand{\MDBinGraphs}{{\em MDBinGraphs}}

\newcommand{\HyperGraphs}{{\em HyperGraphs}}

\newcommand{\UHyperGraphs}{{\em UHyperGraphs}}

\newcommand{\DHyperGraphs}{{\em DHyperGraphs}}

\newcommand{\BinGraphs}{{\em BinGraphs}}

\newcommand{\UBinGraphs}{{\em UBinGraphs}}

\newcommand{\DBinGraphs}{{\em DBinGraphs}}

\newcommand{\Vertices}{{\em Vertices}}

\newcommand{\Edges}{{\em Edges}}

\newcommand{\Attributes}{{\em Attributes}}

\newcommand{\GraphViews}{{\em GraphViews}}

\newcommand{\GraphWindows}{{\em GraphWindows}}

\newcommand{\Selections}{{\em Selections}}

\newcommand{\MHyperGraph}{{\em MHyperGraph}\ }

\newcommand{\MHyperGraphs}{{\em MHyperGraphs}\ }

\newcommand{\MHyperGraphn}{{\em MHyperGraph}}

\newcommand{\MHyperGraphsn}{{\em MHyperGraphs}}

\newcommand{\SetFuncs}{{\em{SetFuncs}}\ }

\newcommand{\SetFuncsn}{{\em{SetFuncs}}}

\newcommand{\ronei}{{\mbox{$r_1(i)$}}}

\newcommand{\rji}{{\mbox{$r_j(i)$}}}

\newcommand{\lowerb}{{\em lower\_bound}\ }

\newcommand{\lowerbn}{{\em lower\_bound}}

\newcommand{\upperb}{{\em upper\_bound}\ }

\newcommand{\upperbn}{{\em upper\_bound}}

\newcommand{\type}{{\em type}\ }

\newcommand{\typen}{{\em type}}

\newcommand{\vlist}{{\em vlist}\ }

\newcommand{\vlistn}{{\em vlist}}

\newcommand{\elist}{{\em elist}\ }

\newcommand{\elistn}{{\em elist}}

\newcommand{\integer}{{\em integer}\ }

\newcommand{\integern}{{\em integer}}

\newcommand{\kn} {{$k_n$}}

\newcommand{\emsymbol}{{\em symbol}\ }

\newcommand{\emsymboln}{{\em symbol}}

\newcommand{\emlist}{{\em list}\ }

\newcommand{\emlistn}{{\em list}}

\newcommand{\emlistone}{\mbox{$l_1$}\ }

\newcommand{\emlistonen}{\mbox{$l_1$}}

\newcommand{\emlisttwo}{\mbox{$l_2$}\ }

\newcommand{\emlisttwon}{\mbox{$l_2$}}

\newcommand{\emlistk}{\mbox{$l_k$}\ }

\newcommand{\emlistkn}{\mbox{$l_k$}}

\newcommand{\emlisti}{\mbox{$l_i$}\ }

\newcommand{\emlistin}{\mbox{$l_i$}}

\newcommand{\emlistj}{\mbox{$l_j$}\ }

\newcommand{\emlistjn}{\mbox{$l_j$}}

\newcommand{\vect}{\mbox{$vec$}\ }

\newcommand{\vectn}{\mbox{$vec$}}

\newcommand{\vectone}{\mbox{$vec_1$}\ }

\newcommand{\vectonen}{\mbox{$vec_1$}}

\newcommand{\vecttwo}{\mbox{$vec_2$}\ }

\newcommand{\vecttwon}{\mbox{$vec_2$}}

\newcommand{\vectk}{\mbox{$vec_k$}\ }

\newcommand{\vectkn}{\mbox{$vec_k$}}

\newcommand{\vecti}{\mbox{$vec_i$}\ }

\newcommand{\vectin}{\mbox{$vec_i$}}

\newcommand{\vectj}{\mbox{$vec_j$}\ }

\newcommand{\vectjn}{\mbox{$vec_j$}}

\newcommand{\collection}{\mbox{$collection$}\ }

\newcommand{\collectionn}{\mbox{$collection$}}

\newcommand{\col}{\mbox{$col$}\ }

\newcommand{\coln}{\mbox{$col$}}

\newcommand{\colone}{\mbox{$col$}\ }

\newcommand{\colonen}{\mbox{$col$}}

\newcommand{\coltwo}{\mbox{$col_2$}\ }

\newcommand{\coltwon}{\mbox{$col_2$}}

\newcommand{\colk}{\mbox{$col_k$}\ }

\newcommand{\colkn}{\mbox{$col_k$}}

\newcommand{\coli}{\mbox{$col_i$}\ }

\newcommand{\colin}{\mbox{$col_i$}}

\newcommand{\colj}{\mbox{$col_j$}\ }

\newcommand{\coljn}{\mbox{$col_j$}}

\newcommand{\set}{\mbox{$set$}\ }

\newcommand{\setn}{\mbox{$set$}}

\newcommand{\setone}{\mbox{$set$}\ }

\newcommand{\setonen}{\mbox{$set$}}

\newcommand{\settwo}{\mbox{$set_2$}\ }

\newcommand{\settwon}{\mbox{$set_2$}}

\newcommand{\setk}{\mbox{$set_k$}\ }

\newcommand{\setkn}{\mbox{$set_k$}}

\newcommand{\seti}{\mbox{$set_i$}\ }

\newcommand{\setin}{\mbox{$set_i$}}

\newcommand{\setj}{\mbox{$set_j$}\ }

\newcommand{\setjn}{\mbox{$set_j$}}

\newcommand{\sequence}{\mbox{$sequence$}\ }

\newcommand{\sequencen}{\mbox{$sequence$}}

\newcommand{\sequenceone}{\mbox{$sequence$}\ }

\newcommand{\sequenceonen}{\mbox{$sequence$}}

\newcommand{\sequencetwo}{\mbox{$sequence_2$}\ }

\newcommand{\sequencetwon}{\mbox{$sequence_2$}}

\newcommand{\sequencek}{\mbox{$sequence_k$}\ }

\newcommand{\sequencekn}{\mbox{$sequence_k$}}

\newcommand{\sequencei}{\mbox{$sequence_i$}\ }

\newcommand{\sequencein}{\mbox{$sequence_i$}}

\newcommand{\sequencej}{\mbox{$sequence_j$}\ }

\newcommand{\sequencejn}{\mbox{$sequence_j$}}

\newcommand{\ms}{{\em ms}\ }

\newcommand{\msn}{{\em ms}}

\newcommand{\setvertex}{\mbox{$set-vertex$}\ }

\newcommand{\setvertexn}{\mbox{$set-vertex$}}

\newcommand{\msetvertex}{\mbox{$mset-vertex$}\ }

\newcommand{\msetvertexn}{\mbox{$mset-vertex$}}

\newcommand{\setedge}{\mbox{$set-edge$}\ }

\newcommand{\setedgen}{\mbox{$set-edge$}}

\newcommand{\msetedge}{\mbox{$mset-edge$}\ }

\newcommand{\msetedgen}{\mbox{$mset-edge$}}

\newcommand{\mset}{\mbox{$mset$}\ }

\newcommand{\msetn}{\mbox{$mset$}}

\newcommand{\msetone}{\mbox{$mset$}\ }

\newcommand{\msetonen}{\mbox{$mset$}}

\newcommand{\msettwo}{\mbox{$mset_2$}\ }

\newcommand{\msettwon}{\mbox{$mset_2$}}

\newcommand{\msetk}{\mbox{$mset_k$}\ }

\newcommand{\msetkn}{\mbox{$mset_k$}}

\newcommand{\mseti}{\mbox{$mset_i$}\ }

\newcommand{\msetin}{\mbox{$mset_i$}}

\newcommand{\msetj}{\mbox{$mset_j$}\ }

\newcommand{\msetjn}{\mbox{$mset_j$}}

\newcommand{\g} {\mbox{$g$}\  }

\newcommand{\gn}{\mbox{$g$}}

\newcommand{\gv} {\mbox{$gv$}\  }

\newcommand{\gvn}{\mbox{$gv$}}

\newcommand{\vg} {\mbox{$vg$}\  }

\newcommand{\vgn}{\mbox{$vg$}}

\newcommand{\eg} {\mbox{$eg$}\  }

\newcommand{\egn}{\mbox{$eg$}}

\newcommand{\graph} {\mbox{$graph$}\ }

\newcommand{\graphn}{\mbox{$graph$}  }

\newcommand{\graphone} {\mbox{$graph$}\ }

\newcommand{\graphonen}{\mbox{$graph$}  }

\newcommand{\graphtwo}{\mbox{$graph_2$}\ }

\newcommand{\graphtwon}{\mbox{$graph_2$}  }

\newcommand{\graphk}{\mbox{$graph_k$}\ }

\newcommand{\graphkn}{\mbox{$graph_k$}  }

\newcommand{\graphi}{\mbox{$graph_i$}\ }

\newcommand{\graphin}{\mbox{$graph_i$}  }

\newcommand{\graphj}{\mbox{$graph_j$}\ }

\newcommand{\graphjn}{\mbox{$graph_j$}  }

\newcommand{\vi} {\mbox{$vi$}\ }

\newcommand{\vin}{\mbox{$vi$}  }

\newcommand{\vertex}{\mbox{$vertex$}\ }

\newcommand{\vertexn}{\mbox{$vertex$}}

\newcommand{\vertexone}{\mbox{$vertex$}\ }

\newcommand{\vertexonen}{\mbox{$vertex$}  }

\newcommand{\vertextwo}{\mbox{$vertex_2$}\ }

\newcommand{\vertextwon}{\mbox{$vertex_2$}  }

\newcommand{\vertexk}{\mbox{$vertex_k$}\ }

\newcommand{\vertexkn}{\mbox{$vertex_k$}  }

\newcommand{\vertexi}{\mbox{$vertex_i$}\ }

\newcommand{\vertexin}{\mbox{$vertex_i$}  }

\newcommand{\vertexj}{\mbox{$vertex_j$}\ }

\newcommand{\vertexjn}{\mbox{$vertex_j$}  }

\newcommand{\ei}{\mbox{$ei$}\ }

\newcommand{\ein}{\mbox{$ei$}}

\newcommand{\edge}{\mbox{$edge$}\ }

\newcommand{\edgen}{\mbox{$edge$}}

\newcommand{\edgeone}{\mbox{$edge$}\ }

\newcommand{\edgeonen}{\mbox{$edge$}}

\newcommand{\edgetwo}{\mbox{$edge_2$}\ }

\newcommand{\edgetwon}{\mbox{$edge_2$}}

\newcommand{\edgek}{\mbox{$edge_k$}\ }

\newcommand{\edgekn}{\mbox{$edge_k$}}

\newcommand{\edgei}{\mbox{$edge_i$}\ }

\newcommand{\edgein}{\mbox{$edge_i$}}

\newcommand{\edgej}{\mbox{$edge_j$}\ }

\newcommand{\edgejn}{\mbox{$edge_j$}}

\newcommand{\val}{{\em value}\ }

\newcommand{\valn}{{\em value}}

\newcommand{\ind}{{\em index}\ }

\newcommand{\indn}{{\em index}}

\newcommand{\newsize}{{\em newsize}\ }

\newcommand{\newsizen}{{\em newsize}}

\newcommand{\size}{{\em size}\ }

\newcommand{\sizen}{{\em size}}

\newcommand{\ione}{\mbox{$i_1$}\ }

\newcommand{\ionen}{\mbox{$i_1$}}

\newcommand{\itwo}{\mbox{$i_2$}\ }

\newcommand{\itwon}{\mbox{$i_2$}}

\newcommand{\ithree}{\mbox{$i_3$}\ }

\newcommand{\ithreen}{\mbox{$i_3$}}

\newcommand{\ik}{\mbox{$i_k$}\ }

\newcommand{\ikn}{\mbox{$i_k$}}

\newcommand{\lth}{\mbox{$<$}\ }

\newcommand{\lthn}{\mbox{$<$}}

\newcommand{\ltheq}{\mbox{$<=$}\ }

\newcommand{\ltheqn}{\mbox{$<=$}}

\newcommand{\gth}{\mbox{$>$}\ }

\newcommand{\gthn}{\mbox{$>$}}

\newcommand{\gtheq}{\mbox{$>=$}\ }

\newcommand{\gtheqn}{\mbox{$>=$}}

\newcommand{\equal}{\mbox{$==$}\ }

\newcommand{\equaln}{\mbox{$==$}}

\newcommand{\notequal}{\mbox{$!=$}\ }

\newcommand{\notequaln}{\mbox{$!=$}}

\newcommand{\xpixels}{{\em xpixels}\ }

\newcommand{\xpixelsn}{{\em xpixels}}

\newcommand{\ypixels}{{\em ypixels}\ }

\newcommand{\ypixelsn}{{\em ypixels}}

\newcommand{\name}{{\em name}\ }

\newcommand{\namen}{{\em name}}

\newcommand{\layout}{{\em layout}\ }

\newcommand{\layoutn}{{\em layout}}

\newcommand{\creation}{
\noindent{\bf 1. Creation}

\vspace{0.3in}
}

\newcommand{\operations}{
\noindent{\bf 2. Operations}

\vspace{0.3in}
}

\newcommand{\implementations}{
\noindent{\bf 3. Implementations}

\vspace{0.3in}
}

\newcommand{\utilities}{
\noindent{\bf 3. Utilities}

\vspace{0.3in}
}

\renewcommand{\thefigure}{\thesection.\arabic{figure}}

\renewcommand{\topfraction} {0.9}

\renewcommand{\bottomfraction} {0.9}

\makeatother
\ifx\AtBeginDocument\undefined \newcommand{\AtBeginDocument}[1]{}\fi
\newenvironment{tex2html_wrap}{}{}
\newbox\sizebox
\setlength{\hoffset}{0pt}\setlength{\voffset}{0pt}
\addtolength{\textheight}{\footskip}\setlength{\footskip}{0pt}
\addtolength{\textheight}{\topmargin}\setlength{\topmargin}{0pt}
\addtolength{\textheight}{\headheight}\setlength{\headheight}{0pt}
\addtolength{\textheight}{\headsep}\setlength{\headsep}{0pt}
\setlength{\textwidth}{349pt}
\newwrite\lthtmlwrite
\makeatletter
\let\realnormalsize=\normalsize
\topskip=0pt
\def\preveqno{}\let\real@float=\@float \let\realend@float=\end@float
\def\@float{\let\@savefreelist\@freelist\real@float}
\def\end@float{\realend@float\global\let\@freelist\@savefreelist}
\let\real@dbflt=\@dbflt \let\end@dblfloat=\end@float
\let\@largefloatcheck=\relax
\def\@dbflt{\let\@savefreelist\@freelist\real@dbflt}
\def\adjustnormalsize{\def\normalsize{\mathsurround=0pt \realnormalsize\parindent=0pt\abovedisplayskip=0pt\belowdisplayskip=0pt}\normalsize}
\def\lthtmltypeout#1{{\let\protect\string\immediate\write\lthtmlwrite{#1}}}%
\newcommand\lthtmlhboxmathA{\adjustnormalsize\setbox\sizebox=\hbox\bgroup}%
\newcommand\lthtmlvboxmathA{\adjustnormalsize\setbox\sizebox=\vbox\bgroup%
 \let\ifinner=\iffalse }%
\newcommand\lthtmlboxmathZ{\@next\next\@currlist{}{\def\next{\voidb@x}}%
 \expandafter\box\next\egroup}%
\newcommand\lthtmlmathtype[1]{\def\lthtmlmathenv{#1}}%
\newcommand\lthtmllogmath{\lthtmltypeout{l2hSize %
:\lthtmlmathenv:\the\ht\sizebox::\the\dp\sizebox::\the\wd\sizebox.\preveqno}}%
\newcommand\lthtmlfigureA[1]{\let\@savefreelist\@freelist
       \lthtmlmathtype{#1}\lthtmlvboxmathA}%
\newcommand\lthtmlfigureZ{\lthtmlboxmathZ\lthtmllogmath\copy\sizebox
       \global\let\@freelist\@savefreelist}%
\newcommand\lthtmldisplayA[1]{\lthtmlmathtype{#1}\lthtmlvboxmathA}%
\newcommand\lthtmldisplayB[1]{\edef\preveqno{(\theequation)}%
  \lthtmldisplayA{#1}\let\@eqnnum\relax}%
\newcommand\lthtmldisplayZ{\lthtmlboxmathZ\lthtmllogmath\lthtmlsetmath}%
\newcommand\lthtmlinlinemathA[1]{\lthtmlmathtype{#1}\lthtmlhboxmathA  \vrule height1.5ex width0pt }%
\newcommand\lthtmlinlinemathZ{\egroup\expandafter\ifdim\dp\sizebox>0pt %
  \expandafter\centerinlinemath\fi\lthtmllogmath\lthtmlsetmath}
\def\lthtmlsetmath{\hbox{\vrule width.5pt\vtop{\vbox{%
  \kern.5pt\kern0.8 pt\hbox{\hglue.5pt\copy\sizebox\hglue0.8 pt}\kern.5pt%
  \ifdim\dp\sizebox>0pt\kern0.8 pt\fi}%
  \ifdim\hsize>\wd\sizebox \hrule depth1pt\fi}}}
\def\centerinlinemath{\dimen1=\ht\sizebox
  \ifdim\dimen1<\dp\sizebox \ht\sizebox=\dp\sizebox
  \else \dp\sizebox=\ht\sizebox \fi}

\def\lthtmlcheckvsize{\ifdim\ht\sizebox<\vsize\expandafter\vfill
  \else\expandafter\vss\fi}%
\makeatletter


\begin{document}
\pagestyle{empty}\thispagestyle{empty}%
\lthtmltypeout{latex2htmlLength hsize=\the\hsize}%
\lthtmltypeout{latex2htmlLength vsize=\the\vsize}%
\lthtmltypeout{latex2htmlLength hoffset=\the\hoffset}%
\lthtmltypeout{latex2htmlLength voffset=\the\voffset}%
\lthtmltypeout{latex2htmlLength topmargin=\the\topmargin}%
\lthtmltypeout{latex2htmlLength topskip=\the\topskip}%
\lthtmltypeout{latex2htmlLength headheight=\the\headheight}%
\lthtmltypeout{latex2htmlLength headsep=\the\headsep}%
\lthtmltypeout{latex2htmlLength parskip=\the\parskip}%
\lthtmltypeout{latex2htmlLength oddsidemargin=\the\oddsidemargin}%
\makeatletter
\if@twoside\lthtmltypeout{latex2htmlLength evensidemargin=\the\evensidemargin}%
\else\lthtmltypeout{latex2htmlLength evensidemargin=\the\oddsidemargin}\fi%
\makeatother
{\newpage\clearpage
\lthtmlfigureA{figure638}%
\begin{figure}\centerline{
\includegraphics 
*[width=5.5in]{dfs.ps}}
\vspace*{3mm}
\centerline{
\includegraphics 
*[width=5.5in]{titlepage_stk.ps}}
\end{figure}%
\lthtmlfigureZ
\hfill\lthtmlcheckvsize\clearpage}

\stepcounter{part}
\stepcounter{section}
\stepcounter{section}
\stepcounter{section}
\setcounter{figure}{0}
\setcounter{section}{0}
\stepcounter{subsection}
\stepcounter{subsection}
\stepcounter{subsection}
\stepcounter{section}
\setcounter{figure}{0}
\setcounter{section}{0}
\stepcounter{part}
\stepcounter{section}
\setcounter{figure}{0}
{\newpage\clearpage
\lthtmlinlinemathA{tex2html_wrap_inline1040}%
$\ldots$%
\lthtmlinlinemathZ
\hfill\lthtmlcheckvsize\clearpage}

\stepcounter{section}
\setcounter{figure}{0}
\stepcounter{subsection}
\stepcounter{subsubsection}
\stepcounter{subsection}
{\newpage\clearpage
\lthtmldisplayA{displaymath1082}%
\begin{displaymath}\lbrace [1 2 3] \lbrace \lbrace1 2\rbrace \lbrace1 3\rbrace \lbrace2 3\rbrace\rbrace\rbrace \end{displaymath}%
\lthtmldisplayZ
\hfill\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmldisplayA{displaymath1083}%
\begin{displaymath}\lbrace [1 2 3] \lbrace<1 2> <1 3> <2 3>\rbrace\rbrace \end{displaymath}%
\lthtmldisplayZ
\hfill\lthtmlcheckvsize\clearpage}

\stepcounter{section}
\setcounter{figure}{0}
\stepcounter{subsection}
\stepcounter{subsection}
\stepcounter{subsection}
\stepcounter{subsection}
\stepcounter{subsection}
\stepcounter{section}
\setcounter{figure}{0}
\stepcounter{subsection}
\stepcounter{section}
\setcounter{figure}{0}
\stepcounter{subsection}
\stepcounter{subsubsection}
\stepcounter{subsubsection}
\stepcounter{subsubsection}
\stepcounter{subsubsection}
\stepcounter{subsubsection}
\stepcounter{section}
\setcounter{figure}{0}
\stepcounter{subsection}
\stepcounter{subsection}
\stepcounter{subsubsection}
\stepcounter{part}
\stepcounter{section}
\setcounter{figure}{0}
{\newpage\clearpage
\lthtmlfigureA{figure1354}%
\begin{figure}
\begin{flushleft}
\hrulefill

\begin{alltt}\relax
STk>  {\bf (define g (graph)) }{\em{
\(\#\)[undefined]} }
\relax\end{alltt}
\begin{alltt}\relax
STk>  {\bf (describe g) }{\em{
\(\#\)[\(<\)ubingraph*\(>\) 40243e34] is an instance of class \(<\)ubingraph*\(>\)
Slots are: 
     val = \(\{\)[]  \(\{\)\(\}\)\(\}\)
\(\#\)f} }
\relax\end{alltt}

\hrulefill
\end{flushleft}\end{figure}%
\lthtmlfigureZ
\hfill\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlfigureA{figure1368}%
\begin{figure}
\begin{flushleft}
\hrulefill

\begin{alltt}\relax
STk>  {\bf (define h (graph '(1 2 3) '((1) (2 3) (1 2 3)))) }{\em{
\(\#\)[undefined]} }
\relax\end{alltt}
\begin{alltt}\relax
STk>  {\bf (describe h) }{\em{
\(\#\)[\(<\)uhypergraph*\(>\) 4023f874] is an instance of class \(<\)uhypergraph*\(>\)
Slots are: 
     val = \(\{\)[1 2 3]  \(\{\)\(\{\)1\(\}\) \(\{\)1 2 3\(\}\) \(\{\)2 3\(\}\)\(\}\)\(\}\)
\(\#\)f} }
\relax\end{alltt}

\hrulefill
\end{flushleft}\end{figure}%
\lthtmlfigureZ
\hfill\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlfigureA{figure1406}%
\begin{figure}
\begin{flushleft}
\hrulefill

\begin{alltt}\relax
STk>  {\bf (define g (graph '(1 2 3) '((1 2) (2 3) (3 1)))) }{\em{
\(\#\)[undefined]} }
\relax\end{alltt}
\begin{alltt}\relax
STk>  {\bf (define h (graph '(1 2 3) '((1) (2 3) (1 2 3)))) }{\em{
\(\#\)[undefined]} }
\relax\end{alltt}
\begin{alltt}\relax
STk>  {\bf (define h2 (graph (+ (vertices g) (vertices h))
                   (+ (edges g) (edges h)))) }{\em{
\(\#\)[undefined]} }
\relax\end{alltt}
\begin{alltt}\relax
STk>  {\bf (describe h2) }{\em{
\(\#\)[\(<\)muhypergraph*\(>\) 4023bd88] is an instance of class \(<\)muhypergraph*\(>\)
Slots are: 
     val = \(\{\)[1 2 3]  \(\{\)\(\{\)1\(\}\) \(\{\)1 2\(\}\) \(\{\)1 2 3\(\}\) \(\{\)1 3\(\}\) \(\{\)2 3\(\}\) \(\{\)2 3\(\}\)\(\}\)\(\}\)
\(\#\)f} }
\relax\end{alltt}

\hrulefill
\end{flushleft}\end{figure}%
\lthtmlfigureZ
\hfill\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlfigureA{figure1470}%
\begin{figure}
\begin{flushleft}
\hrulefill

\begin{alltt}\relax
STk>  {\bf (add-vertex! 1 g) }{\em{
\(\#\)[\(<\)vertex*\(>\) 4023f778]} }
\relax\end{alltt}
\begin{alltt}\relax
STk>  {\bf (add-vertex! 'apple g) }{\em{
\(\#\)[\(<\)vertex*\(>\) 4023f43c]} }
\relax\end{alltt}
\begin{alltt}\relax
STk>  {\bf (add-vertex! "orange" g) }{\em{
\(\#\)[\(<\)vertex*\(>\) 4023f190]} }
\relax\end{alltt}
\begin{alltt}\relax
STk>  {\bf (describe g) }{\em{
\(\#\)[\(<\)ubingraph*\(>\) 40243e34] is an instance of class \(<\)ubingraph*\(>\)
Slots are: 
     val = \(\{\)[1 apple orange]  \(\{\)\(\}\)\(\}\)
\(\#\)f} }
\relax\end{alltt}

\hrulefill
\end{flushleft}\end{figure}%
\lthtmlfigureZ
\hfill\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlinlinemathA{tex2html_wrap_inline1699}%
$V \choose 2$%
\lthtmlinlinemathZ
\hfill\lthtmlcheckvsize\clearpage}

\stepcounter{section}
\setcounter{figure}{0}
\stepcounter{subsection}
{\newpage\clearpage
\lthtmlinlinemathA{tex2html_wrap_inline2392}%
$i \mbox{$<$}\ j$%
\lthtmlinlinemathZ
\hfill\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlinlinemathA{tex2html_wrap_inline2414}%
$i \mbox{$<=$}\ j$%
\lthtmlinlinemathZ
\hfill\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlinlinemathA{tex2html_wrap_inline2436}%
$i \mbox{$>$}\ j$%
\lthtmlinlinemathZ
\hfill\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlinlinemathA{tex2html_wrap_inline2458}%
$i \mbox{$>=$}\ j$%
\lthtmlinlinemathZ
\hfill\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlinlinemathA{tex2html_wrap_inline2546}%
$\mbox{$col$}\ \subseteq \mbox{$col_2$}\ \subseteq \mbox{$col_k$}\ $%
\lthtmlinlinemathZ
\hfill\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlinlinemathA{tex2html_wrap_inline2564}%
$\mbox{$col$}\ \subset \mbox{$col_2$}\ \subset \mbox{$col_k$}\ ,$%
\lthtmlinlinemathZ
\hfill\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlinlinemathA{tex2html_wrap_inline2570}%
$\mbox{$col_i$}\ \subset \mbox{$col_j$}\ $%
\lthtmlinlinemathZ
\hfill\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlinlinemathA{tex2html_wrap_inline2578}%
$\mbox{$col_i$}\ \cup \mbox{$col_j$}\ $%
\lthtmlinlinemathZ
\hfill\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlinlinemathA{tex2html_wrap_inline2580}%
$r\_i(e) $%
\lthtmlinlinemathZ
\hfill\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlinlinemathA{tex2html_wrap_inline2582}%
$ r\_j(e)$%
\lthtmlinlinemathZ
\hfill\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlinlinemathA{tex2html_wrap_inline2602}%
$\mbox{$set$},$%
\lthtmlinlinemathZ
\hfill\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlinlinemathA{tex2html_wrap_inline2606}%
$\mbox{$set$}\ $%
\lthtmlinlinemathZ
\hfill\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlfigureA{figure2180}%
\begin{figure}
\begin{flushleft}
\hrulefill

\begin{alltt}\relax
STk>  {\bf (define ms (mset-int 3 2 2 1)) }{\em{
\(\#\)[undefined]} }
\relax\end{alltt}
\begin{alltt}\relax
STk>  {\bf (describe ms) }{\em{
\(\#\)[\(<\)mset\(<\)int*\(>\)\(>\) 4023e1d0] is an instance of class \(<\)mset\(<\)int*\(>\)\(>\)
Slots are: 
     val = \(\{\)1 2 2 3\(\}\)
\(\#\)f} }
\relax\end{alltt}
\begin{alltt}\relax
STk>  {\bf (define s (set-int ms)) }{\em{
\(\#\)[undefined]} }
\relax\end{alltt}
\begin{alltt}\relax
STk>  {\bf (describe s) }{\em{
\(\#\)[\(<\)set\(<\)int*\(>\)\(>\) 402123a4] is an instance of class \(<\)set\(<\)int*\(>\)\(>\)
Slots are: 
     val = \(\{\)1 2 3\(\}\)
\(\#\)f} }
\relax\end{alltt}

\hrulefill
\end{flushleft}\end{figure}%
\lthtmlfigureZ
\hfill\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlfigureA{figure2777}%
\begin{figure}
\begin{flushleft}
\hrulefill

\begin{alltt}\relax
STk>  {\bf (define m (list->mset-int '(1 2 2 3))) }{\em{
\(\#\)[undefined]} }
\relax\end{alltt}
\begin{alltt}\relax
STk>  {\bf (describe m) }{\em{
\(\#\)[\(<\)mset\(<\)int*\(>\)\(>\) 4023e8fc] is an instance of class \(<\)mset\(<\)int*\(>\)\(>\)
Slots are: 
     val = \(\{\)1 2 2 3\(\}\)
\(\#\)f} }
\relax\end{alltt}
\begin{alltt}\relax
STk>  {\bf (define s (list->set-int (mset-int->list m))) }{\em{
\(\#\)[undefined]} }
\relax\end{alltt}
\begin{alltt}\relax
STk>  {\bf (describe s) }{\em{
\(\#\)[\(<\)set\(<\)int*\(>\)\(>\) 40211354] is an instance of class \(<\)set\(<\)int*\(>\)\(>\)
Slots are: 
     val = \(\{\)1 2 3\(\}\)
\(\#\)f} }
\relax\end{alltt}
\begin{alltt}\relax
STk>  {\bf (define sq (list->sequence-int '(3 1))) }{\em{
\(\#\)[undefined]} }
\relax\end{alltt}
\begin{alltt}\relax
STk>  {\bf (describe sq) }{\em{
\(\#\)[\(<\)sequence\(<\)int*\(>\)\(>\) 4020d0e8] is an instance of class \(<\)sequence\(<\)int*\(>\)\(>\)
Slots are: 
     val = \(<\)3 1\(>\)
\(\#\)f} }
\relax\end{alltt}

\hrulefill
\end{flushleft}\end{figure}%
\lthtmlfigureZ
\hfill\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlfigureA{figure2866}%
\begin{figure}
\begin{flushleft}
\hrulefill

\begin{alltt}\relax
STk>  {\bf (define ms (mset-int 1 2 2 3)) }{\em{
\(\#\)[undefined]} }
\relax\end{alltt}
\begin{alltt}\relax
STk>  {\bf (if (member 2 ms)
          (remove! 2 ms)) }{\em{
\(\#\)[undefined]} }
\relax\end{alltt}
\begin{alltt}\relax
STk>  {\bf (describe ms) }{\em{
\(\#\)[\(<\)mset\(<\)int*\(>\)\(>\) 4023e1d0] is an instance of class \(<\)mset\(<\)int*\(>\)\(>\)
Slots are: 
     val = \(\{\)1 2 3\(\}\)
\(\#\)f} }
\relax\end{alltt}

\hrulefill
\end{flushleft}\end{figure}%
\lthtmlfigureZ
\hfill\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlfigureA{figure2968}%
\begin{figure}
\begin{flushleft}
\hrulefill

\begin{alltt}\relax
STk>  {\bf (define ms (mset-int 1 2 2 3)) }{\em{
\(\#\)[undefined]} }
\relax\end{alltt}
\begin{alltt}\relax
STk>  {\bf (define sq (sequence-int 1 2 2 3)) }{\em{
\(\#\)[undefined]} }
\relax\end{alltt}
\begin{alltt}\relax
STk>  {\bf (null? ms) }{\em{
\(\#\)f} }
\relax\end{alltt}
\begin{alltt}\relax
STk>  {\bf (null? sq) }{\em{
\(\#\)f} }
\relax\end{alltt}
\begin{alltt}\relax
STk>  {\bf (eq? sq ms) }{\em{
\(\#\)f} }
\relax\end{alltt}
\begin{alltt}\relax
STk>  {\bf (eqv? sq ms) }{\em{
\(\#\)t} }
\relax\end{alltt}

\hrulefill
\end{flushleft}\end{figure}%
\lthtmlfigureZ
\hfill\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlfigureA{figure3029}%
\begin{figure}
\begin{flushleft}
\hrulefill

\begin{alltt}\relax
STk>  {\bf (define-generic f) }{\em{
\(\#\)[undefined]} }
\relax\end{alltt}
\begin{alltt}\relax
STk>  {\bf (define-method f ((a <collection<int*>>)) 'f) }{\em{
f} }
\relax\end{alltt}
\begin{alltt}\relax
STk>  {\bf (f (mset-int 1 2)) }{\em{
f} }
\relax\end{alltt}
\begin{alltt}\relax
STk>  {\bf (f (set-int 1 2)) }{\em{
f} }
\relax\end{alltt}
\begin{alltt}\relax
STk>  {\bf (f (sequence-int 1 2)) }{\em{
f} }
\relax\end{alltt}
\begin{alltt}\relax
STk>  {\bf (f (list-int 1 2)) }{\em{

*** Error:
No applicable method for \(\#\)[\(<\)generic\(>\) f]
in call (f \(\#\)[\(<\)list\(<\)int*\(>\)\(>\) 4022e340])} }
\relax\end{alltt}

\hrulefill
\end{flushleft}\end{figure}%
\lthtmlfigureZ
\hfill\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlfigureA{figure3077}%
\begin{figure}
\begin{flushleft}
\hrulefill

\begin{alltt}\relax
STk>  {\bf (define ms (mset-int 3 2 2 1)) }{\em{
\(\#\)[undefined]} }
\relax\end{alltt}
\begin{alltt}\relax
STk>  {\bf (define sq (sequence-int 3 2 2 1)) }{\em{
\(\#\)[undefined]} }
\relax\end{alltt}
\begin{alltt}\relax
STk>  {\bf (cond ((< ms sq) 'seq-greater)
       (#t        'mset-lesseq)) }{\em{
seq-greater} }
\relax\end{alltt}

\hrulefill
\end{flushleft}\end{figure}%
\lthtmlfigureZ
\hfill\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlfigureA{figure3168}%
\begin{figure}
\begin{flushleft}
\hrulefill

\begin{alltt}\relax
STk>  {\bf (define s (set-int 1 2 3)) }{\em{
\(\#\)[undefined]} }
\relax\end{alltt}
\begin{alltt}\relax
STk>  {\bf (define bin-edges (choose s 2)) }{\em{
\(\#\)[undefined]} }
\relax\end{alltt}
\begin{alltt}\relax
STk>  {\bf (define hyper-edges (power-set s)) }{\em{
\(\#\)[undefined]} }
\relax\end{alltt}
\begin{alltt}\relax
STk>  {\bf (describe bin-edges) }{\em{
\(\#\)[\(<\)set\(<\)set\(<\)int*\(>\)\(>\)\(>\) 4023d5d0] is an instance of class \(<\)set\(<\)set\(<\)int*\(>\)\(>\)\(>\)
Slots are: 
     val = \(\{\)\(\{\)1 2\(\}\) \(\{\)1 3\(\}\) \(\{\)2 3\(\}\)\(\}\)
\(\#\)f} }
\relax\end{alltt}
\begin{alltt}\relax
STk>  {\bf (describe hyper-edges) }{\em{
\(\#\)[\(<\)set\(<\)set\(<\)int*\(>\)\(>\)\(>\) 4023c5d4] is an instance of class \(<\)set\(<\)set\(<\)int*\(>\)\(>\)\(>\)
Slots are: 
     val = \(\{\)\(\{\)\(\}\) \(\{\)1\(\}\) \(\{\)1 2\(\}\) \(\{\)1 2 3\(\}\) \(\{\)1 3\(\}\) \(\{\)2\(\}\) \(\{\)2 3\(\}\) \(\{\)3\(\}\)\(\}\)
\(\#\)f} }
\relax\end{alltt}

\hrulefill
\end{flushleft}\end{figure}%
\lthtmlfigureZ
\hfill\lthtmlcheckvsize\clearpage}

\stepcounter{subsection}
{\newpage\clearpage
\lthtmlfigureA{figure3612}%
\begin{figure}
\begin{flushleft}
\hrulefill

\begin{alltt}\relax
STk>  {\bf (define v (vector-int 10)) }{\em{
\(\#\)[undefined]} }
\relax\end{alltt}
\begin{alltt}\relax
STk>  {\bf (describe v) }{\em{
\(\#\)[\(<\)array\(<\)int*\(>\)\(>\) 402442d8] is an instance of class \(<\)array\(<\)int*\(>\)\(>\)
Slots are: 
     val = []
\(\#\)f} }
\relax\end{alltt}
\begin{alltt}\relax
STk>  {\bf (vector-fill! v 0) }{\em{

*** Error:
vector-fill!: not a vector: \(\#\)[\(<\)array\(<\)int*\(>\)\(>\) 402442d8]} }
\relax\end{alltt}
\begin{alltt}\relax
STk>  {\bf (vector-set! v 1 10) }{\em{

*** Error:
vector-set!: not a vector: \(\#\)[\(<\)array\(<\)int*\(>\)\(>\) 402442d8]} }
\relax\end{alltt}
\begin{alltt}\relax
STk>  {\bf (describe v) }{\em{
\(\#\)[\(<\)array\(<\)int*\(>\)\(>\) 402442d8] is an instance of class \(<\)array\(<\)int*\(>\)\(>\)
Slots are: 
     val = []
\(\#\)f} }
\relax\end{alltt}

\hrulefill
\end{flushleft}\end{figure}%
\lthtmlfigureZ
\hfill\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlfigureA{figure3873}%
\begin{figure}
\begin{flushleft}
\hrulefill

\begin{alltt}\relax
STk>  {\bf (vector-int? v) }{\em{
\(\#\)t} }
\relax\end{alltt}
\begin{alltt}\relax
STk>  {\bf (define v2 (vector 10)) }{\em{
\(\#\)[undefined]} }
\relax\end{alltt}
\begin{alltt}\relax
STk>  {\bf (vector? v2) }{\em{
\(\#\)t} }
\relax\end{alltt}
\begin{alltt}\relax
STk>  {\bf (vector-int? v2) }{\em{
\(\#\)f} }
\relax\end{alltt}

\hrulefill
\end{flushleft}\end{figure}%
\lthtmlfigureZ
\hfill\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlfigureA{figure3962}%
\begin{figure}
\begin{flushleft}
\hrulefill

\begin{alltt}\relax
STk>  {\bf (describe v) }{\em{
\(\#\)[\(<\)array\(<\)int*\(>\)\(>\) 402442d8] is an instance of class \(<\)array\(<\)int*\(>\)\(>\)
Slots are: 
     val = []
\(\#\)f} }
\relax\end{alltt}
\begin{alltt}\relax
STk>  {\bf (define l (vector-int->list v)) }{\em{
\(\#\)[undefined]} }
\relax\end{alltt}
\begin{alltt}\relax
STk>  {\bf l }{\em{
()} }
\relax\end{alltt}

\hrulefill
\end{flushleft}\end{figure}%
\lthtmlfigureZ
\hfill\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlfigureA{figure3992}%
\begin{figure}
\begin{flushleft}
\hrulefill

\begin{alltt}\relax
STk>  {\bf (define v3 (vector-copy v)) }{\em{

*** Error:
vector-copy: bad vector: \(\#\)[\(<\)array\(<\)int*\(>\)\(>\) 402442d8]} }
\relax\end{alltt}
\begin{alltt}\relax
STk>  {\bf (describe v3) }{\em{

*** Error:
unbound variable: v3} }
\relax\end{alltt}
\begin{alltt}\relax
STk>  {\bf (define v3 (vector-int v)) }{\em{
\(\#\)[undefined]} }
\relax\end{alltt}
\begin{alltt}\relax
STk>  {\bf (describe v3) }{\em{
\(\#\)[\(<\)array\(<\)int*\(>\)\(>\) 4029ac50] is an instance of class \(<\)array\(<\)int*\(>\)\(>\)
Slots are: 
     val = []
\(\#\)f} }
\relax\end{alltt}

\hrulefill
\end{flushleft}\end{figure}%
\lthtmlfigureZ
\hfill\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlfigureA{figure4039}%
\begin{figure}
\begin{flushleft}
\hrulefill

\begin{alltt}\relax
STk>  {\bf (describe v) }{\em{
\(\#\)[\(<\)array\(<\)int*\(>\)\(>\) 402442d8] is an instance of class \(<\)array\(<\)int*\(>\)\(>\)
Slots are: 
     val = []
\(\#\)f} }
\relax\end{alltt}
\begin{alltt}\relax
STk>  {\bf (define v3 (vector-int v)) }{\em{
\(\#\)[undefined]} }
\relax\end{alltt}
\begin{alltt}\relax
STk>  {\bf (<= v v3) }{\em{

*** Error:
Bad number in a comparison: (a b)} }
\relax\end{alltt}
\begin{alltt}\relax
STk>  {\bf (vector-set! v 0 1) }{\em{

*** Error:
vector-set!: not a vector: \(\#\)[\(<\)array\(<\)int*\(>\)\(>\) 402442d8]} }
\relax\end{alltt}
\begin{alltt}\relax
STk>  {\bf (describe v) }{\em{
\(\#\)[\(<\)array\(<\)int*\(>\)\(>\) 402442d8] is an instance of class \(<\)array\(<\)int*\(>\)\(>\)
Slots are: 
     val = []
\(\#\)f} }
\relax\end{alltt}
\begin{alltt}\relax
STk>  {\bf (<= v v3) }{\em{

*** Error:
Bad number in a comparison: (a b)} }
\relax\end{alltt}

\hrulefill
\end{flushleft}\end{figure}%
\lthtmlfigureZ
\hfill\lthtmlcheckvsize\clearpage}

\stepcounter{subsection}
\stepcounter{section}
\setcounter{figure}{0}
\stepcounter{subsection}
\stepcounter{subsubsection}
\stepcounter{subsubsection}
\stepcounter{subsubsection}
\stepcounter{subsubsection}
\stepcounter{subsubsection}
{\newpage\clearpage
\lthtmlfigureA{figure5113}%
\begin{figure}
\begin{flushleft}
\hrulefill

\begin{alltt}\relax
STk>  {\bf (define g (graph '(1 2 3) '((1 2) (1 3) (3 1)))) }{\em{
\(\#\)[undefined]} }
\relax\end{alltt}
\begin{alltt}\relax
STk>  {\bf (define v (vertices g)) }{\em{
\(\#\)[undefined]} }
\relax\end{alltt}
\begin{alltt}\relax
STk>  {\bf (describe v) }{\em{
\(\#\)[\(<\)set\(<\)vertex*\(>\)\(>\) 4023f07c] is an instance of class \(<\)set\(<\)vertex*\(>\)\(>\)
Slots are: 
     val = \(\{\)1 2 3\(\}\)
\(\#\)f} }
\relax\end{alltt}
\begin{alltt}\relax
STk>  {\bf (define n (neighbors (ref v 0))) }{\em{
\(\#\)[undefined]} }
\relax\end{alltt}
\begin{alltt}\relax
STk>  {\bf (describe n) }{\em{
\(\#\)[\(<\)set\(<\)vertex*\(>\)\(>\) 4021db10] is an instance of class \(<\)set\(<\)vertex*\(>\)\(>\)
Slots are: 
     val = \(\{\)2 3\(\}\)
\(\#\)f} }
\relax\end{alltt}

\hrulefill
\end{flushleft}\end{figure}%
\lthtmlfigureZ
\hfill\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlfigureA{figure5244}%
\begin{figure}
\begin{flushleft}
\hrulefill

\begin{alltt}\relax
STk>  {\bf (define dg (digraph '(1 2 3 4) '((1 2 3) (2 3 4)))) }{\em{
\(\#\)[undefined]} }
\relax\end{alltt}
\begin{alltt}\relax
STk>  {\bf (define n (neighbors (vertex-ref dg 1))) }{\em{
\(\#\)[undefined]} }
\relax\end{alltt}
\begin{alltt}\relax
STk>  {\bf (describe (vertex-ref dg 1)) }{\em{
\(\#\)[\(<\)vertex*\(>\) 40220d68] is an instance of class \(<\)vertex*\(>\)
Slots are: 
     val = 2
\(\#\)f} }
\relax\end{alltt}
\begin{alltt}\relax
STk>  {\bf (describe n) }{\em{
\(\#\)[\(<\)set\(<\)vertex*\(>\)\(>\) 4023ee84] is an instance of class \(<\)set\(<\)vertex*\(>\)\(>\)
Slots are: 
     val = \(\{\)3 4\(\}\)
\(\#\)f} }
\relax\end{alltt}
\begin{alltt}\relax
STk>  {\bf (define in (in-neighbors (vertex-ref dg 1))) }{\em{
\(\#\)[undefined]} }
\relax\end{alltt}
\begin{alltt}\relax
STk>  {\bf (describe in) }{\em{
\(\#\)[\(<\)set\(<\)vertex*\(>\)\(>\) 402155fc] is an instance of class \(<\)set\(<\)vertex*\(>\)\(>\)
Slots are: 
     val = \(\{\)1\(\}\)
\(\#\)f} }
\relax\end{alltt}
\begin{alltt}\relax
STk>  {\bf (define out (out-neighbors (vertex-ref dg 1))) }{\em{
\(\#\)[undefined]} }
\relax\end{alltt}
\begin{alltt}\relax
STk>  {\bf (describe out) }{\em{
\(\#\)[\(<\)set\(<\)vertex*\(>\)\(>\) 402116a8] is an instance of class \(<\)set\(<\)vertex*\(>\)\(>\)
Slots are: 
     val = \(\{\)3 4\(\}\)
\(\#\)f} }
\relax\end{alltt}

\hrulefill
\end{flushleft}\end{figure}%
\lthtmlfigureZ
\hfill\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlfigureA{figure5341}%
\begin{figure}
\begin{flushleft}
\hrulefill

\begin{alltt}\relax
STk>  {\bf (define g (graph '(1 2 3) '((1 2) (1 3) (3 1)))) }{\em{
\(\#\)[undefined]} }
\relax\end{alltt}
\begin{alltt}\relax
STk>  {\bf (map (lambda (x) 
            (find-string-attribute 'color x)) 
          (set-vertex->list (vertices g))) }{\em{
("black" "black" "black")} }
\relax\end{alltt}

\hrulefill
\end{flushleft}\end{figure}%
\lthtmlfigureZ
\hfill\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlfigureA{figure5455}%
\begin{figure}
\begin{flushleft}
\hrulefill

\begin{alltt}\relax
STk>  {\bf (define g (graph '(1 2 3) '((1 2) (1 3) (3 1)))) }{\em{
\(\#\)[undefined]} }
\relax\end{alltt}
\begin{alltt}\relax
STk>  {\bf (set-string-attribute! 'color "red" (vertex-ref g 1)) }{\em{
\(\#\)[undefined]} }
\relax\end{alltt}
\begin{alltt}\relax
STk>  {\bf (map (lambda (x) (find-string-attribute 'color x)) 
(set-vertex->list (vertices g))) }{\em{
("black" "red" "black")} }
\relax\end{alltt}

\hrulefill
\end{flushleft}\end{figure}%
\lthtmlfigureZ
\hfill\lthtmlcheckvsize\clearpage}

\stepcounter{subsection}
{\newpage\clearpage
\lthtmlinlinemathA{tex2html_wrap_inline6536}%
$\Delta(g)$%
\lthtmlinlinemathZ
\hfill\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlfigureA{figure5954}%
\begin{figure}
\begin{flushleft}
\hrulefill

\begin{alltt}\relax
STk>  {\bf (define g (graph '(1 2 3 4) '((1 2) (1 3) (1 4)))) }{\em{
\(\#\)[undefined]} }
\relax\end{alltt}
\begin{alltt}\relax
STk>  {\bf (define (max-vert l)
        (cond ((null? l) 0)
              (#t (max (degree (car l)) (max-vert (cdr l)))))) }{\em{
\(\#\)[undefined]} }
\relax\end{alltt}
\begin{alltt}\relax
STk>  {\bf (define-generic delta) }{\em{
\(\#\)[undefined]} }
\relax\end{alltt}
\begin{alltt}\relax
STk>  {\bf (define-method delta ((g <graph*>))
        (let ((v (set-vertex->list (vertices g))))
                (max-vert v))) }{\em{
delta} }
\relax\end{alltt}
\begin{alltt}\relax
STk>  {\bf (delta g) }{\em{
3} }
\relax\end{alltt}

\hrulefill
\end{flushleft}\end{figure}%
\lthtmlfigureZ
\hfill\lthtmlcheckvsize\clearpage}

\stepcounter{subsection}
\stepcounter{subsection}
\stepcounter{part}
\stepcounter{section}
\setcounter{figure}{1}
\setcounter{section}{1}
\stepcounter{section}
\stepcounter{subsection}
{\newpage\clearpage
\lthtmlfigureA{figure7112}%
\begin{figure}\begin{verbatim}#####################################################################
#USER_SOURCE = \
#               demo.cpp \
#               linkUserInit.cpp # must edit this file and include it
#                               # in this list to augment the GUI
#
USER_SOURCE = \
                demoNoGUI.cpp  # demoNoGUI.cpp is a sample program
                                # using LINK objects, but not the GUI.
#####################################################################
#####################################################################
## Name your executable file below.
#####################################################################
#EXECUTABLE = demo
EXECUTABLE = demoNoGUI
#####################################################################\end{verbatim}\end{figure}%
\lthtmlfigureZ
\hfill\lthtmlcheckvsize\clearpage}

\stepcounter{subsection}
{\newpage\clearpage
\lthtmlfigureA{figure7144}%
\begin{figure}
\begin{verbatim}//**************************************************************************
PRIMITIVE evenOddRanksWrapper(SCM g)
{
        Graph *gr;
        if (!(gr = getGraph(g)))   // see src/stkWrapper/stkUtils.cpp
                Err("even-odd-ranks: expected <graph*> ", g);
        Set<Set<Vertex*> > result = evenOddRanks(gr);
        Set<Set<Vertex*> >* new_copy = new Set<Set<Vertex*> >(result);
        return STk_make_CXXwrapper(
                Wrapper<Set<Set<Vertex*> > >::type,     // stkWrapper/Wrapper.h
                Wrapper<Set<Set<Vertex*> > >::name,
                (void *) new_copy,
                LINK_DYNAMIC);          // tells STk's garbage collector
                                        // to delete new_copy when the user
                                        // is finished with it
}
//
// This is what must go into userinit.cpp
//
void STk_evenOddRanks_Init()
{
        STk_add_new_cpp_primitive("even-odd-ranks",     // cmd name
                                  tc_subr_1,            // # parms
                                  (PRIMITIVE (*)(...))evenOddRanksWrapper);
}
//***********************************************************************\end{verbatim}\end{figure}%
\lthtmlfigureZ
\hfill\lthtmlcheckvsize\clearpage}

\stepcounter{subsection}
\stepcounter{subsection}
{\newpage\clearpage
\lthtmlfigureA{figure7161}%
\begin{figure}
\begin{alltt}\relax
UBinGraph*
GenRandom(int n, int p)
{
    UBinGraph*  graph = new UBinGraph(); 
    graph->addVertices(n);
    const SortedArray<Vertex*>& vertices = graph->vertices();
    int num_vertices = graph->order();
    if (p < 0.0 || p > 1.0) {
        warning("GenRandom(): bad edge probability, using 0.0");
        p = 0.0;
    }
    Set<Vertex*> s;  
    for (int i=1; i < num_vertices; i++) {
        for (int j=i; j < num_vertices; j++) 
                if (LINK_randomDouble0_1() < p) {
                        s.insert(vertices[i]);
                        s.insert(vertices[j]);
                        Edge* edge = graph->addEdge(s);
                        s.clear();
                }
    }
    return graph;
}
\relax\end{alltt}\end{figure}%
\lthtmlfigureZ
\hfill\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlfigureA{figure7170}%
\begin{figure}
\begin{alltt}\relax
static PRIMITIVE GenRandomCmd(SCM n, SCM p)
{
        Graph *gr;
        if (!INTEGERP(n))
                Err("gen-random-graph: bad arg 1, <integer> expected", n);
        if (!IFLONUMP(p))
                Err("gen-random-graph: bad arg 2, <number> expected", n);
        int sz = INTEGER(n);
        double prob = FLONUM(n);
        Graph *g = GenRandom(sz, prob);
        Register<Graph>::createEntry(Wrapper<UBinGraph>::type,
                                     Wrapper<UBinGraph>::name, g);
        Graph **gp = new Graph*(g);
        return STk_make_CXXwrapper(Wrapper<UBinGraph*>::type,
                Wrapper<UBinGraph*>::name, (void *) gp, LINK_DYNAMIC);
}
void gen_Random_Wrapper()
{
        STk_add_new_cpp_primitive("gen-random-graph", tc_subr_2,
                               (PRIMITIVE (*)(...))GenRandomGraphCmd);
}
\relax\end{alltt}\end{figure}%
\lthtmlfigureZ
\hfill\lthtmlcheckvsize\clearpage}

\stepcounter{subsection}
\stepcounter{subsubsection}
\stepcounter{subsubsection}
\stepcounter{subsubsection}
{\newpage\clearpage
\lthtmlfigureA{figure7193}%
\begin{figure}
\begin{alltt}\relax
#include<LINK/wrappers/algorithmSTkInit.h>
 
void gen_Animation_Wrapper();
void gen_BiconnectedComponents_Wrapper();
void gen_BreadthFirstSearch_Wrapper();
void gen_DepthFirstSearch_Wrapper();
void gen_GoldbergTarjan_Wrapper();
void gen_HamiltonianCycles_Wrapper();
void gen_KLFM_Wrapper();
void gen_Kruskal_Wrapper();
void gen_MaximalClique_Wrapper();
void gen_Prim_Wrapper();
void gen_StronglyConnectedComponents_Wrapper();
void gen_TopologicalSort_Wrapper();
void gen_Triangles_Wrapper();
 
void STk_algorithm_init(void)
{
        gen_Animation_Wrapper();
        gen_BiconnectedComponents_Wrapper();
        gen_BreadthFirstSearch_Wrapper();
        gen_DepthFirstSearch_Wrapper();
        gen_GoldbergTarjan_Wrapper();
        gen_HamiltonianCycles_Wrapper();
        gen_Kruskal_Wrapper();
        gen_KLFM_Wrapper();
        gen_MaximalClique_Wrapper();
        gen_Prim_Wrapper();
        gen_StronglyConnectedComponents_Wrapper();
        gen_TopologicalSort_Wrapper();
        gen_Triangles_Wrapper();
}
 
void STk_algorithm_cleanup(void)
{
}
\relax\end{alltt}\end{figure}%
\lthtmlfigureZ
\hfill\lthtmlcheckvsize\clearpage}

\stepcounter{section}
{\newpage\clearpage
\lthtmlfigureA{figure7229}%
\begin{figure}
\begin{flushleft}
\begin{minipage}[t]{\textwidth}
\hrulefill

\vspace*{-5mm}

\begin{verbatim}#include<LINK/basic/Sequence.h>
#include<LINK/graph/DBinGraph.h>
#include<LINK/graph/Attribute.h>
#include<LINK/algorithm/Algorithms.h>

main()
{
        DBinGraph g;
        Sequence<Vertex*>  s, postorder;
        Vertex *parent, *child1, *child2;

        child1 = g.addVertex("child1"); 
        parent = g.addVertex("parent");
        child2 = g.addVertex("child2");
        s.insert(parent); s.append(child1);  
        g.addEdge(s);
        s.clear();
        s.insert(parent); s.append(child2);  
        g.addEdge(s);
        
        postorder = DepthFirstSearch(&g);
        cout << postorder << endl;
}\end{verbatim}

\vspace*{-7mm}

\hrulefill

\vspace*{-5mm}

\begin{verbatim} 
<child1 child2 parent>\end{verbatim}

\vspace*{-6mm}

\hrulefill
\end{minipage}
\end{flushleft}\end{figure}%
\lthtmlfigureZ
\hfill\lthtmlcheckvsize\clearpage}

\stepcounter{subsection}
\stepcounter{section}
\setcounter{figure}{1}
\setcounter{section}{1}
\stepcounter{section}
\stepcounter{subsection}
{\newpage\clearpage
\lthtmlfigureA{figure7321}%
\begin{figure}
\centerline{
\includegraphics 
*[height=2in,width=3in]{figures/elementOps.ps}}\end{figure}%
\lthtmlfigureZ
\hfill\lthtmlcheckvsize\clearpage}

\stepcounter{subsection}
{\newpage\clearpage
\lthtmlfigureA{figure7560}%
\begin{figure}
\begin{flushleft}
\begin{minipage}[t]{\textwidth}
\hrulefill

\vspace*{-5mm}

\begin{verbatim}#include<iostream.h>
#include<LINK/basic/List.h>

main()
{
        List<int> l;

        l.insert(1);
        l.insert(2);
        l.insert(3);
        l.insert(4);

        Iterator<int> get_next(&l);
        int i;
        while (get_next(i))
                cout << "next element: " << i << endl;
}\end{verbatim}

\vspace*{-7mm}

\hrulefill

\vspace*{-5mm}

\begin{verbatim} 
next element: 4
next element: 3
next element: 2
next element: 1\end{verbatim}

\vspace*{-6mm}

\hrulefill
\end{minipage}
\end{flushleft}\end{figure}%
\lthtmlfigureZ
\hfill\lthtmlcheckvsize\clearpage}

\stepcounter{subsubsection}
\stepcounter{subsection}
{\newpage\clearpage
\lthtmlfigureA{figure7762}%
\begin{figure}
\begin{flushleft}
\begin{minipage}[t]{\textwidth}
\hrulefill

\vspace*{-5mm}

\begin{verbatim}#include<iostream.h>
#include<LINK/basic/List.h>

main()
{
        List<int> l;

        ContainerNode *cn = l.insert(3);
        l.insertAfter(4, cn);
        cout << l << endl;

        cn = l.search(3);
        ContainerNode *cn2 = l.successor(cn);
        cout << "value: " << l.info(cn2) << endl; 
}\end{verbatim}

\vspace*{-7mm}

\hrulefill

\vspace*{-5mm}

\begin{verbatim} 
(3 4)
value: 4\end{verbatim}

\vspace*{-6mm}

\hrulefill
\end{minipage}
\end{flushleft}\end{figure}%
\lthtmlfigureZ
\hfill\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlfigureA{figure7799}%
\begin{figure}
\begin{flushleft}
\begin{minipage}[t]{\textwidth}
\hrulefill

\vspace*{-5mm}

\begin{verbatim}#include<iostream.h>
#include<LINK/basic/List.h>

main()
{
        List<int> list1;

        for (int i=0; i<3; i++)
                list1.append(i);

        List<int> list2(list1);
        list2.append(9);

        List<int> list3;
        list3 = list2;
        list3.insert(12);

        cout << list1 << endl;
        cout << list2 << endl;
        cout << list3 << endl;
}\end{verbatim}

\vspace*{-7mm}

\hrulefill

\vspace*{-5mm}

\begin{verbatim} 
(0 1 2)
(0 1 2 9)
(12 0 1 2 9)\end{verbatim}

\vspace*{-6mm}

\hrulefill
\end{minipage}
\end{flushleft}\end{figure}%
\lthtmlfigureZ
\hfill\lthtmlcheckvsize\clearpage}

\stepcounter{subsection}
{\newpage\clearpage
\lthtmlfigureA{figure8127}%
\begin{figure}
\begin{flushleft}
\begin{minipage}[t]{\textwidth}
\hrulefill

\vspace*{-5mm}

\begin{verbatim}#include<iostream.h>
#include<LINK/basic/List.h>

main()
{
        List<int> list;

        for (int i=0; i<3; i++)
                list.insert(2 * i);

        SortedList<int> slist(list);
        slist.insert(3);

        List<int> list2(slist);

        cout << list << endl;
        cout << slist << endl;
        cout << list2 << endl;
}\end{verbatim}

\vspace*{-7mm}

\hrulefill

\vspace*{-5mm}

\begin{verbatim} 
(4 2 0)
(0 2 3 4)
(0 2 3 4)\end{verbatim}

\vspace*{-6mm}

\hrulefill
\end{minipage}
\end{flushleft}\end{figure}%
\lthtmlfigureZ
\hfill\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlfigureA{figure8245}%
\begin{figure}
\begin{flushleft}
\begin{minipage}[t]{\textwidth}
\hrulefill

\vspace*{-5mm}

\begin{verbatim}#include<iostream.h>
#include<LINK/basic/List.h>
main()
{
        List<int> list1;
        SortedList<int> list2;
        list1.append(2); list2.append(2);
        list1.append(1); list2.append(1);

        List<int> list3(list1);
        list3.append(3);

        List<List<int> > llist;
        llist.append(list1); llist.append(list2); llist.append(list3);
        Iterator<List<int> > it1(&llist);
        Iterator<List<int> > it2(&llist);
        List<int> temp1, temp2;
        while (it1(temp1)) {
            while (it2(temp2)) {
                if (temp1 == temp2)
                        cout <<"("<< temp1 << " == " << temp2 << ")\t" ;
                if (temp1 != temp2)
                        cout <<"(" << temp1 << " != " << temp2 <<  ")\t" ;
                if (temp1 <= temp2)
                        cout <<"(" << temp1 << " <= " << temp2 <<  ")\t" ;
                if (temp1 < temp2)
                        cout <<"(" << temp1 << " < " << temp2 <<  ")\t" ;
                if (temp1 >= temp2)
                        cout <<"(" << temp1 << " >= " << temp2 <<  ")\t" ;
                if (temp1 > temp2)
                        cout <<"(" << temp1 << " > " << temp2 <<  ")\t" ;
                cout << endl;
            }
            it2.reset();
        }
}\end{verbatim}

\vspace*{-7mm}

\hrulefill

\vspace*{-5mm}

\begin{verbatim} 
((2 1) == (2 1))        ((2 1) <= (2 1))        ((2 1) >= (2 1))        
((2 1) != (1 2))        ((2 1) >= (1 2))        ((2 1) > (1 2)) 
((2 1) != (2 1 3))      ((2 1) <= (2 1 3))      ((2 1) < (2 1 3))       
((1 2) != (2 1))        ((1 2) <= (2 1))        ((1 2) < (2 1)) 
((1 2) == (1 2))        ((1 2) <= (1 2))        ((1 2) >= (1 2))        
((1 2) != (2 1 3))      ((1 2) <= (2 1 3))      ((1 2) < (2 1 3))       
((2 1 3) != (2 1))      ((2 1 3) >= (2 1))      ((2 1 3) > (2 1))       
((2 1 3) != (1 2))      ((2 1 3) >= (1 2))      ((2 1 3) > (1 2))       
((2 1 3) == (2 1 3))    ((2 1 3) <= (2 1 3))    ((2 1 3) >= (2 1 3))\end{verbatim}

\vspace*{-6mm}

\hrulefill
\end{minipage}
\end{flushleft}\end{figure}%
\lthtmlfigureZ
\hfill\lthtmlcheckvsize\clearpage}

\stepcounter{subsection}
{\newpage\clearpage
\lthtmlfigureA{figure8460}%
\begin{figure}
\begin{flushleft}
\begin{minipage}[t]{\textwidth}
\hrulefill

\vspace*{-5mm}

\begin{verbatim}#include<iostream.h>
#include<LINK/basic/DList.h>

main()
{
        DList<int> l;

        ContainerNode *cn = l.insert(3);
        l.insertBefore(4, cn);
        cout << l << endl;

        cout << "value: " << l.info(l.predecessor(cn)) << endl; 
}\end{verbatim}

\vspace*{-7mm}

\hrulefill

\vspace*{-5mm}

\begin{verbatim} 
(4 3)
value: 4\end{verbatim}

\vspace*{-6mm}

\hrulefill
\end{minipage}
\end{flushleft}\end{figure}%
\lthtmlfigureZ
\hfill\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlfigureA{figure8541}%
\begin{figure}
\begin{flushleft}
\begin{minipage}[t]{\textwidth}
\hrulefill

\vspace*{-5mm}

\begin{verbatim}#include<iostream.h>

#include<LINK/basic/DList.h>
#include<LINK/basic/List.h>

main()
{
        DList<int> dl;

        dl.insert(1);
        ContainerNode *cn = dl.insert(2);

        DList<int> dl2(dl);

        dl.unlink(cn);
        dl2.insert(cn); 

        cout << dl << endl; 
        cout << dl2 << endl; 
}\end{verbatim}

\vspace*{-7mm}

\hrulefill

\vspace*{-5mm}

\begin{verbatim} 
(1)
(2 1 2)\end{verbatim}

\vspace*{-6mm}

\hrulefill
\end{minipage}
\end{flushleft}\end{figure}%
\lthtmlfigureZ
\hfill\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlfigureA{figure8559}%
\begin{figure}
\begin{flushleft}
\begin{minipage}[t]{\textwidth}
\hrulefill

\vspace*{-5mm}

\begin{verbatim}#include<iostream.h>
#include<LINK/basic/List.h>

#include<LINK/basic/DList.h>

main()
{
        List<int> l;

        l.insert(5);
        l.insert(4);
        l.insert(3);

        DList<int> dl(l);

        if (dl == l)
           cout << "they have the same elements in the same order" << endl;
        dl.append(7);

        cout << dl << endl; 
        cout << l << endl; 
}\end{verbatim}

\vspace*{-7mm}

\hrulefill

\vspace*{-5mm}

\begin{verbatim} 
they have the same elements in the same order
(3 4 5 7)
(3 4 5)\end{verbatim}

\vspace*{-6mm}

\hrulefill
\end{minipage}
\end{flushleft}\end{figure}%
\lthtmlfigureZ
\hfill\lthtmlcheckvsize\clearpage}

\stepcounter{subsection}
\stepcounter{subsubsection}
\stepcounter{subsubsection}
\stepcounter{subsection}
{\newpage\clearpage
\lthtmlfigureA{figure9058}%
\begin{figure}
\begin{flushleft}
\begin{minipage}[t]{\textwidth}
\hrulefill

\vspace*{-5mm}

\begin{verbatim}#include<iostream.h>
#include<LINK/basic/Array.h>

main()
{
        Array<int> l;

        l.insert(3);
        l[2] = 4;
        cout << l << endl;
        int i, count = l.size();
        for (i=0; i<count; i++)
                cout << l[i] << " ";
        cout << endl;

        Iterator<int> it(&l);
        int element;
        while (it(element)) 
                cout << element << " ";
        cout << endl;
}\end{verbatim}

\vspace*{-7mm}

\hrulefill

\vspace*{-5mm}

\begin{verbatim} 
[3 0 4]
3 0 4 
3 0 4\end{verbatim}

\vspace*{-6mm}

\hrulefill
\end{minipage}
\end{flushleft}\end{figure}%
\lthtmlfigureZ
\hfill\lthtmlcheckvsize\clearpage}

\stepcounter{subsection}
{\newpage\clearpage
\lthtmlinlinemathA{tex2html_wrap_inline9457}%
$O(\log n)$%
\lthtmlinlinemathZ
\hfill\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlfigureA{figure9401}%
\begin{figure}
\begin{flushleft}
\begin{minipage}[t]{\textwidth}
\hrulefill

\vspace*{-5mm}

\begin{verbatim}#include<iostream.h>
#include<LINK/basic/List.h>
#include<LINK/basic/Array.h>

main()
{
        Array<int> array;
        List<int> list;

        for (int i=0; i<3; i++) {
                array.insert(2 * i);
                list.insert(2 * i);
        }

        SortedList<int> slist(array);
        SortedArray<int> sarray(list);
        slist.insert(3);
        sarray.insert(-4);

        cout << array << endl;
        cout << list  << endl;
        cout << slist << endl;
        cout << sarray<< endl;
}\end{verbatim}

\vspace*{-7mm}

\hrulefill

\vspace*{-5mm}

\begin{verbatim} 
[4 2 0]
(4 2 0)
(0 2 3 4)
[-4 0 2 4]\end{verbatim}

\vspace*{-6mm}

\hrulefill
\end{minipage}
\end{flushleft}\end{figure}%
\lthtmlfigureZ
\hfill\lthtmlcheckvsize\clearpage}

\stepcounter{subsection}
\stepcounter{subsubsection}
{\newpage\clearpage
\lthtmlfigureA{figure9694}%
\begin{figure}
\begin{flushleft}
\begin{minipage}[t]{\textwidth}
\hrulefill

\vspace*{-5mm}

\begin{verbatim}#include<iostream.h>
#include<LINK/basic/BinaryHeap.h>

main()
{
        BinaryHeap<int, char> heap; // default size = BINHEAPSIZE (general.h)
        ContainerNode *cn;

        heap.insert(1, 'a');
        heap.insert(2, 'b');
        cn = heap.insert(3, 'c');

        cout << heap << endl;

        heap.decreaseKey(cn, -4);
        BinaryHeapNode<int,char> *next;

        for (int i=0; i<3; i++) {
                next = heap.extractMin();
                cout << next->item << " ";
        }
        cout << endl;
}\end{verbatim}

\vspace*{-7mm}

\hrulefill

\vspace*{-5mm}

\begin{verbatim} 
[a b c]
c a b\end{verbatim}

\vspace*{-6mm}

\hrulefill
\end{minipage}
\end{flushleft}\end{figure}%
\lthtmlfigureZ
\hfill\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlfigureA{figure9748}%
\begin{figure}
\begin{flushleft}
\begin{minipage}[t]{\textwidth}
\hrulefill

\vspace*{-5mm}

\begin{verbatim}#include<iostream.h>
#include<LINK/basic/BinaryHeap.h>
#include<LINK/basic/List.h>

main()
{
        BinaryHeap<int, char> heap(10);
        ContainerNode *cn;

        heap.insert(1, 'a');
        heap.insert(2, 'b');

        List<char> list(heap);  // uses Iterator to copy
        list.insert('d');

        cout << heap << endl;
        cout << list << endl;

        //BinaryHeap<int, char> heap2(list);  
        //error: dictionaries cannot be constructed using 
        //       other container types.
}\end{verbatim}

\vspace*{-7mm}

\hrulefill

\vspace*{-5mm}

\begin{verbatim} 
[a b]
(d a b)\end{verbatim}

\vspace*{-6mm}

\hrulefill
\end{minipage}
\end{flushleft}\end{figure}%
\lthtmlfigureZ
\hfill\lthtmlcheckvsize\clearpage}

\stepcounter{subsubsection}
\stepcounter{subsection}
{\newpage\clearpage
\lthtmlfigureA{figure10419}%
\begin{figure}
\begin{flushleft}
\begin{minipage}[t]{\textwidth}
\hrulefill

\vspace*{-5mm}

\begin{verbatim}#include<iostream.h>
#include<LINK/basic/BinarySearchTree.h>

main()
{
        BinarySearchTree<int, char> bntree;
        ContainerNode *cn;

        bntree.insert(1, 'b');
        bntree.insert(-1, 'a');
        bntree.insert(2, 'c');

        cout << bntree << endl;

        bntree.preorderWalk(cout);
        bntree.inorderWalk(cout);
        bntree.postorderWalk(cout);
}\end{verbatim}

\vspace*{-7mm}

\hrulefill

\vspace*{-5mm}

\begin{verbatim} 
<(-1,a)(1,b)(2,c)>

<(1,b)(-1,a)(2,c)>
<(-1,a)(1,b)(2,c)>
<(-1,a)(2,c)(1,b)>\end{verbatim}

\vspace*{-6mm}

\hrulefill
\end{minipage}
\end{flushleft}\end{figure}%
\lthtmlfigureZ
\hfill\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlfigureA{figure10567}%
\begin{figure}
\begin{flushleft}
\begin{minipage}[t]{\textwidth}
\hrulefill

\vspace*{-5mm}

\begin{verbatim}#include<iostream.h>
#include<LINK/basic/RedBlackTree.h>

main()
{
        RedBlackTree<int, char> rbtree;
        ContainerNode *cn;

        rbtree.insert(1, 'b');
        rbtree.insert(-1, 'a');
        rbtree.insert(2, 'c');

        cout << rbtree << endl;

        rbtree.preorderWalk(cout);
        rbtree.inorderWalk(cout);
        rbtree.postorderWalk(cout);
}\end{verbatim}

\vspace*{-7mm}

\hrulefill

\vspace*{-5mm}

\begin{verbatim} 
<(-1,a)(1,b)(2,c)>

<(1,b)(-1,a)(2,c)>
<(-1,a)(1,b)(2,c)>
<(-1,a)(2,c)(1,b)>\end{verbatim}

\vspace*{-6mm}

\hrulefill
\end{minipage}
\end{flushleft}\end{figure}%
\lthtmlfigureZ
\hfill\lthtmlcheckvsize\clearpage}

\stepcounter{section}
{\newpage\clearpage
\lthtmlfigureA{figure10584}%
\begin{figure}\centerline{
\includegraphics 
*[height=3in,width=4in]{figures/collection_hier.ps}}\end{figure}%
\lthtmlfigureZ
\hfill\lthtmlcheckvsize\clearpage}

\stepcounter{subsection}
\stepcounter{subsubsection}
\stepcounter{subsubsection}
{\newpage\clearpage
\lthtmlfigureA{figure10604}%
\begin{figure}
\begin{flushleft}
\begin{minipage}[t]{\textwidth}
\hrulefill

\vspace*{-5mm}

\begin{verbatim}#include<iostream.h>
#include<LINK/basic/Array.h>
#include<LINK/basic/List.h>
#include<LINK/basic/MSet.h>

main()
{
        MSet<int> list_set1;

        for (int i=0; i<3; i++)
                list_set1.append(i);

        //*************reference count is incremented*********
        MSet<int> list_set2(list_set1);

        //*************complete copy is made******************
        MSetBase<int, SortedArray<int> > array_set(list_set1);

        cout << list_set1 << endl;
        cout << list_set2 << endl;
        cout << array_set << endl;
}\end{verbatim}

\vspace*{-7mm}

\hrulefill

\vspace*{-5mm}

\begin{verbatim} 
{0 1 2}
{0 1 2}
{0 1 2}\end{verbatim}

\vspace*{-6mm}

\hrulefill
\end{minipage}
\end{flushleft}\end{figure}%
\lthtmlfigureZ
\hfill\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlfigureA{figure10650}%
\begin{figure}
\begin{flushleft}
\begin{minipage}[t]{\textwidth}
\hrulefill

\vspace*{-5mm}

\begin{verbatim}#include<iostream.h>
#include<LINK/basic/MSet.h>

main()
{
        MSet<int> mset1, mset2;

        for (int i=0; i<3; i++)
                mset1.append(i);

        mset1.insert(0);
        mset2 = mset1;          // reference count increment
        mset2.append(0);        // copy

        cout << mset1 << endl;
        cout << mset2 << endl;
}\end{verbatim}

\vspace*{-7mm}

\hrulefill

\vspace*{-5mm}

\begin{verbatim} 
{0 0 1 2}
{0 0 0 1 2}\end{verbatim}

\vspace*{-6mm}

\hrulefill
\end{minipage}
\end{flushleft}\end{figure}%
\lthtmlfigureZ
\hfill\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlfigureA{figure10673}%
\begin{figure}
\begin{flushleft}
\begin{minipage}[t]{\textwidth}
\hrulefill

\vspace*{-5mm}

\begin{verbatim}#include<iostream.h>
#include<LINK/basic/MSet.h>

MSet<int> f()
{
        MSet<int> mset;
        mset.insert(9);
        mset.insert(10);
        mset.append(11);
        return mset;
}

main()
{
        MSet<int> mset0;
        MSet<int> mset1; 
        mset0.insert(1);
        mset0.insert(2);
        mset0.append(3);

        mset1 = mset0;
        MSet<int> mset2(mset1); 

        mset0 = f();            // function return takes O(1) (reference
                                // counting means that {9 10 11} needn't
                                // be recopied)
        mset1.insert(9);
        cout << mset0<< endl;
        cout << mset1 << endl;
        cout << mset2 << endl;
}\end{verbatim}

\vspace*{-7mm}

\hrulefill

\vspace*{-5mm}

\begin{verbatim} 
{9 10 11}
{1 2 3 9}
{1 2 3}\end{verbatim}

\vspace*{-6mm}

\hrulefill
\end{minipage}
\end{flushleft}\end{figure}%
\lthtmlfigureZ
\hfill\lthtmlcheckvsize\clearpage}

\stepcounter{subsubsection}
{\newpage\clearpage
\lthtmlfigureA{figure10693}%
\begin{figure}
\begin{flushleft}
\begin{minipage}[t]{\textwidth}
\hrulefill

\vspace*{-5mm}

\begin{verbatim}#include<iostream.h>
#include<LINK/basic/MSet.h>

main()
{
        MSet<int> mset1;
        SortedList<int> slist; 

        for (int i=0; i<3; i++) {
                mset1.insert(i);
                slist.insert(i);
        }

        //List<int> list1(mset1);     // illegal - Containers must be 
                                      // constructed with other Containers

        if (mset1 == slist)
                cout << "(" << mset1 <<" == " << slist << ")" << endl;
}\end{verbatim}

\vspace*{-7mm}

\hrulefill

\vspace*{-5mm}

\begin{verbatim} 
({0 1 2} == (0 1 2))\end{verbatim}

\vspace*{-6mm}

\hrulefill
\end{minipage}
\end{flushleft}\end{figure}%
\lthtmlfigureZ
\hfill\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlfigureA{figure10713}%
\begin{figure}
\begin{flushleft}
\begin{minipage}[t]{\textwidth}
\hrulefill

\vspace*{-5mm}

\begin{verbatim}#include<iostream.h>
#include<LINK/basic/MSet.h>
#include<LINK/basic/Set.h>

main()
{
        MSet<int> mset1;

        for (int i=0; i<3; i++) 
                mset1.insert(i);
        mset1.insert(0);

        Set<int> set1(mset1);

        if (mset1 != set1)
                cout << "(" << mset1 <<" != " << set1 << ")" << endl;

        if (mset1 <= set1)
                cout << "(" << mset1 <<" <= " << set1 << ")" << endl;

        if (mset1 < set1)
                cout << "(" << mset1 <<" < " << set1 << ")" << endl;
}\end{verbatim}

\vspace*{-7mm}

\hrulefill

\vspace*{-5mm}

\begin{verbatim} 
({0 0 1 2} != {0 1 2})
({0 0 1 2} <= {0 1 2})
({0 0 1 2} < {0 1 2})\end{verbatim}

\vspace*{-6mm}

\hrulefill
\end{minipage}
\end{flushleft}\end{figure}%
\lthtmlfigureZ
\hfill\lthtmlcheckvsize\clearpage}

\stepcounter{subsubsection}
{\newpage\clearpage
\lthtmlfigureA{figure10730}%
\begin{figure}
\begin{flushleft}
\begin{minipage}[t]{\textwidth}
\hrulefill

\vspace*{-5mm}

\begin{verbatim}#include<iostream.h>
#include<LINK/basic/MSet.h>
#include<LINK/basic/Set.h>

main()
{
        MSet<int> mset1, mset2;

        for (int i=0; i<3; i++) {
                mset1.insert(i);
                mset1.insert(i);
                mset2.insert(2*i);
                mset2.insert(2*i);
        }

        (mset1 + mset2);
        cout << mset1 << " + " << mset2 <<" = " << (mset1 + mset2) << endl;
        (mset1 ^ mset2);
        cout << mset1 << " ^ " << mset2 <<" = " << (mset1 ^ mset2) << endl;
        (mset1 - mset2);
        cout << mset1 << " - " << mset2 <<" = " << mset1-mset2 << endl;
}\end{verbatim}

\vspace*{-7mm}

\hrulefill

\vspace*{-5mm}

\begin{verbatim} 
{0 0 1 1 2 2} + {0 0 2 2 4 4} = {0 0 0 0 1 1 2 2 2 2 4 4}
{0 0 1 1 2 2} ^ {0 0 2 2 4 4} = {0 0 2 2}
{0 0 1 1 2 2} - {0 0 2 2 4 4} = {1 1}\end{verbatim}

\vspace*{-6mm}

\hrulefill
\end{minipage}
\end{flushleft}\end{figure}%
\lthtmlfigureZ
\hfill\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlfigureA{figure10745}%
\begin{figure}
\begin{flushleft}
\begin{minipage}[t]{\textwidth}
\hrulefill

\vspace*{-5mm}

\begin{verbatim}#include<iostream.h>
#include<LINK/basic/MSet.h>     
#include<LINK/basic/Set.h>
#include<LINK/basic/Sequence.h>

main()
{
        MSet<int> mset1;
        Set<int> set;
        Sequence<int> seq1;

        for (int i=0; i<3; i++) {
                mset1.insert(i);
                mset1.insert(i);
                seq1.insert(2*i);
                seq1.insert(2*i);
        }
        cout << mset1 << " + " <<seq1 <<" = " << mset1+seq1 << endl;
        cout <<seq1  << " + " << mset1<<" = " <<seq1+mset1 << endl;
        cout << mset1 << " ^ " <<seq1 <<" = " << (mset1^seq1) << endl;
        cout << seq1 << " ^ " << mset1<<" = " << (seq1^mset1) << endl;
        cout << mset1 << " - " <<seq1 <<" = " << mset1-seq1 << endl;
        cout << seq1 << " - " << mset1<<" = " <<seq1-mset1 << endl;
        cout << "Set receives return value" << endl;
        cout << "-------------------------" << endl;
        cout << mset1 << " + " <<seq1 <<" = " << (set=mset1+seq1) << endl;
        cout << mset1 << " ^ " <<seq1 <<" = " << (set=(mset1^seq1)) << endl;
        cout << mset1 << " - " <<seq1 <<" = " << (set=mset1-seq1) << endl;
}\end{verbatim}

\vspace*{-7mm}

\hrulefill

\vspace*{-5mm}

\begin{verbatim} 
{0 0 1 1 2 2} + <4 4 2 2 0 0> = {0 0 0 0 1 1 2 2 2 2 4 4}
<4 4 2 2 0 0> + {0 0 1 1 2 2} = {0 0 0 0 1 1 2 2 2 2 4 4}
{0 0 1 1 2 2} ^ <4 4 2 2 0 0> = {0 0 2 2}
<4 4 2 2 0 0> ^ {0 0 1 1 2 2} = {0 0 2 2}
{0 0 1 1 2 2} - <4 4 2 2 0 0> = {1 1}
<4 4 2 2 0 0> - {0 0 1 1 2 2} = {4 4}
Set receives return value
-------------------------
{0 0 1 1 2 2} + <4 4 2 2 0 0> = {0 1 2 4}
{0 0 1 1 2 2} ^ <4 4 2 2 0 0> = {0 2}
{0 0 1 1 2 2} - <4 4 2 2 0 0> = {1}\end{verbatim}

\vspace*{-6mm}

\hrulefill
\end{minipage}
\end{flushleft}\end{figure}%
\lthtmlfigureZ
\hfill\lthtmlcheckvsize\clearpage}

\stepcounter{subsubsection}
\stepcounter{subsection}
{\newpage\clearpage
\lthtmlfigureA{figure11055}%
\begin{figure}
\begin{flushleft}
\begin{minipage}[t]{\textwidth}
\hrulefill

\vspace*{-5mm}

\begin{verbatim}#include<iostream.h>
#include<LINK/basic/Array.h>
#include<LINK/basic/MSet.h>
#include<LINK/basic/Set.h>

main()
{
        MSetBase<int, SortedArray<int> > mset1;
        MSet<int> mset2;                        // default impl:SortedList

        for (int i=0; i<3; i++) {
                mset1.insert(i);
                mset2.insert(i);
        }

        mset2.insert(0);
        cout<<"there are "<<mset2.occurrences(0)<<" zeros in "<< mset2<<endl;

        if (mset1.properSubsetQ(mset2))
                cout << mset1 << " is a proper subset of " << mset2 << endl;
        if (mset1.subsetQ(mset2))
                cout << mset1 << " is a subset of " << mset2 << endl;

        mset2.remove(0);

        if (mset1.properSubsetQ(mset2))
                cout << mset1 << " is a proper subset of " << mset2 << endl;
        if (mset1.subsetQ(mset2))
                cout << mset1 << " is a subset of " << mset2 << endl;

}\end{verbatim}

\vspace*{-7mm}

\hrulefill

\vspace*{-5mm}

\begin{verbatim} 
there are 2 zeros in {0 0 1 2}
{0 1 2} is a proper subset of {0 0 1 2}
{0 1 2} is a subset of {0 0 1 2}
{0 1 2} is a subset of {0 1 2}\end{verbatim}

\vspace*{-6mm}

\hrulefill
\end{minipage}
\end{flushleft}\end{figure}%
\lthtmlfigureZ
\hfill\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlinlinemathA{tex2html_wrap_inline11918}%
\(\rightarrow\)%
\lthtmlinlinemathZ
\hfill\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlinlinemathA{tex2html_wrap_inline12152}%
$n\_r(e))$%
\lthtmlinlinemathZ
\hfill\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlinlinemathA{tex2html_wrap_inline12154}%
$n\_\mbox{this}(e) - n\_c(e)))$%
\lthtmlinlinemathZ
\hfill\lthtmlcheckvsize\clearpage}

\stepcounter{subsection}
\stepcounter{subsection}
{\newpage\clearpage
\lthtmlfigureA{figure12472}%
\begin{figure}
\begin{flushleft}
\begin{minipage}[t]{\textwidth}
\hrulefill

\vspace*{-5mm}

\begin{verbatim}#include<iostream.h>
#include<LINK/basic/MSet.h>
#include<LINK/basic/Sequence.h>

main()
{
        MSet<int> mset1;
        Sequence<int> seq; 
        seq.insert(1);
        seq.insert(2);
        seq.append(3);
        cout << seq << endl;

        for (int i=0; i<3; i++) {
                mset1.insert(i);
        }
        Sequence<int> seq1(mset1); 

        cout << mset1 << endl;
        cout << seq1 << endl;
        if (mset1 == seq1)
                cout << "(" << mset1 <<" == " << seq1 << ")" << endl;
        seq1.append(-2);
        if (mset1 <= seq1)
                cout << "(" << mset1 <<" <= " << seq1 << ")" << endl;
}\end{verbatim}

\vspace*{-7mm}

\hrulefill

\vspace*{-5mm}

\begin{verbatim} 
<2 1 3>
{0 1 2}
<0 1 2>
({0 1 2} == <0 1 2>)
({0 1 2} <= <0 1 2 -2>)\end{verbatim}

\vspace*{-6mm}

\hrulefill
\end{minipage}
\end{flushleft}\end{figure}%
\lthtmlfigureZ
\hfill\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlfigureA{figure12535}%
\begin{figure}
\begin{flushleft}
\begin{minipage}[t]{\textwidth}
\hrulefill

\vspace*{-5mm}

\begin{verbatim}#include<iostream.h>
#include<LINK/basic/MSet.h>
#include<LINK/basic/Sequence.h>

MSet<int> ms()
{
        MSet<int> mset;
        mset.insert(12); mset.insert(13);
        return mset;
}

Sequence<int> sq()
{
        Sequence<int> seq;
        seq.insert(9); seq.append(10);
        return seq;
}

main()
{
        Sequence<int> seq0(ms());       // copy is made
        Sequence<int> seq1(sq());       // reference counting eliminates 
                                        // need for copy
        cout << seq0 << endl;
        cout << seq1 << endl;
}\end{verbatim}

\vspace*{-7mm}

\hrulefill

\vspace*{-5mm}

\begin{verbatim} 
<12 13>
<9 10>\end{verbatim}

\vspace*{-6mm}

\hrulefill
\end{minipage}
\end{flushleft}\end{figure}%
\lthtmlfigureZ
\hfill\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlinlinemathA{tex2html_wrap_inline12786}%
$ \mbox{this-$>$size()}$%
\lthtmlinlinemathZ
\hfill\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlinlinemathA{tex2html_wrap_inline12794}%
$s[i] \ldots s[j]$%
\lthtmlinlinemathZ
\hfill\lthtmlcheckvsize\clearpage}

\stepcounter{section}
\stepcounter{subsection}
\stepcounter{subsection}
{\newpage\clearpage
\lthtmlinlinemathA{tex2html_wrap_inline12802}%
$1,\ldots,n$%
\lthtmlinlinemathZ
\hfill\lthtmlcheckvsize\clearpage}

\stepcounter{section}
\setcounter{figure}{1}
\setcounter{section}{1}
\stepcounter{section}
\stepcounter{subsection}
{\newpage\clearpage
\lthtmlinlinemathA{tex2html_wrap_inline13435}%
$V = \{v_0, v_1,\ldots, v_{n-1}\}$%
\lthtmlinlinemathZ
\hfill\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlinlinemathA{tex2html_wrap_inline13437}%
$E = \{e_0, e_2, \ldots, e_{m-1}\}$%
\lthtmlinlinemathZ
\hfill\lthtmlcheckvsize\clearpage}

\stepcounter{subsection}
{\newpage\clearpage
\lthtmlfigureA{figure13365}%
\begin{figure}
\begin{flushleft}
\begin{minipage}[t]{\textwidth}
\hrulefill

\vspace*{-5mm}

\begin{verbatim}#include<iostream.h>
#include<LINK/graph/DBinGraph.h>
#include<LINK/graph/Vertex.h>
#include<LINK/graph/Attribute.h>

void main()
{
        int i;
        DBinGraph g1;
        if (newAttribute((Graph*)&g1, "test_attr", 1) != LINK_OK)
                error("Attr.cpp: error creating test_attr");

        g1.addVertices(4);
        Vertex** vertices = g1.vertexStart();
        int num_vertices = g1.order();

        for (i=2; i<num_vertices; i++) {
                setAttribute((GraphObject*)vertices[i], "test_attr", i);
        }
        int value;
        for (i=0; i<num_vertices; i++) {
                getAttribute((GraphObject*)vertices[i], "test_attr", value);
                cout << "v: "<<*vertices[i]<<" test_attr: "<<value<<endl;
        }
}\end{verbatim}

\vspace*{-7mm}

\hrulefill

\vspace*{-5mm}

\begin{verbatim} 
v: 0 test_attr: 1
v: 1 test_attr: 1
v: 2 test_attr: 2
v: 3 test_attr: 3\end{verbatim}

\vspace*{-6mm}

\hrulefill
\end{minipage}
\end{flushleft}\end{figure}%
\lthtmlfigureZ
\hfill\lthtmlcheckvsize\clearpage}

\stepcounter{subsection}
\stepcounter{subsection}
\stepcounter{subsection}
\stepcounter{subsection}
{\newpage\clearpage
\lthtmlinlinemathA{tex2html_wrap_inline14013}%
$\{w : (w \in e) \wedge (w \neq v)\}$%
\lthtmlinlinemathZ
\hfill\lthtmlcheckvsize\clearpage}

\stepcounter{subsection}
{\newpage\clearpage
\lthtmlfigureA{figure14185}%
\begin{figure}
\begin{flushleft}
\begin{minipage}[t]{\textwidth}
\hrulefill

\vspace*{-5mm}

\begin{verbatim}#include<iostream.h>
#include<LINK/basic/Array.h>
#include<LINK/basic/Set.h>
#include<LINK/graph/BinGraph.h>

main()
{
        BinGraph g;
        MSet<Vertex*> s;
        Set<Vertex*>  s2;
        Vertex *v1, *v2;

        v1 = g.addVertex("v1");
        v2 = g.addVertex("v2");
        s.insert(v2); s.insert(v1); s.insert(v1);
        s2 = s;
        g.addEdge(s);
        g.addEdge(s2); 
        cout << g << endl;
}\end{verbatim}

\vspace*{-7mm}

\hrulefill

\vspace*{-5mm}

\begin{verbatim} 
{[v1 v2]  {{v1 v2}}}\end{verbatim}

\vspace*{-6mm}

\hrulefill
\end{minipage}
\end{flushleft}\end{figure}%
\lthtmlfigureZ
\hfill\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlfigureA{figure14284}%
\begin{figure}
\begin{flushleft}
\begin{minipage}[t]{\textwidth}
\hrulefill

\vspace*{-5mm}

\begin{verbatim}#include<iostream.h>
#include<LINK/graph/DBinGraph.h>
#include<LINK/basic/Set.h>
#include<LINK/basic/Sequence.h>

main()
{
        DBinGraph g1;

        g1.addVertices(4);
        Vertex** vertices = g1.vertexStart();
        int num_vertices = g1.order();

        for (int i=1; i<num_vertices; i++) {
                Sequence<Vertex*> s;
                s.append(vertices[i]);
                s.append(vertices[i-1]);
                g1.addEdge(s);
        }
        cout << g1 << endl;
}\end{verbatim}

\vspace*{-7mm}

\hrulefill

\vspace*{-5mm}

\begin{verbatim} 
{[0 1 2 3]  {<1 0> <2 1> <3 2>}}\end{verbatim}

\vspace*{-6mm}

\hrulefill
\end{minipage}
\end{flushleft}\end{figure}%
\lthtmlfigureZ
\hfill\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlfigureA{figure14297}%
\begin{figure}
\begin{flushleft}
\begin{minipage}[t]{\textwidth}
\hrulefill

\vspace*{-5mm}

\begin{verbatim}#include<iostream.h>
#include<LINK/graph/DBinGraph.h>
#include<LINK/basic/Sequence.h>

main()
{
        MDBinGraph mg;
        DBinGraph g;
        Sequence<Vertex*> s;
        Vertex *v1, *v2;

        v1 = mg.addVertex("v1");
        v2 = mg.addVertex("v2");
        s.append(v1); s.append(v2);
        mg.addEdge(s); mg.addEdge(s);
        cout << mg << endl;
        
        s.clear();

        v1 = g.addVertex("v1");
        v2 = g.addVertex("v2");
        s.append(v1); s.append(v2);
        g.addEdge(s); g.addEdge(s);
        cout << g << endl;
}\end{verbatim}

\vspace*{-7mm}

\hrulefill

\vspace*{-5mm}

\begin{verbatim} 
{[v1 v2]  {<v1 v2> <v1 v2>}}
{[v1 v2]  {<v1 v2>}}\end{verbatim}

\vspace*{-6mm}

\hrulefill
\end{minipage}
\end{flushleft}\end{figure}%
\lthtmlfigureZ
\hfill\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlfigureA{figure14310}%
\begin{figure}
\begin{flushleft}
\begin{minipage}[t]{\textwidth}
\hrulefill

\vspace*{-5mm}

\begin{verbatim}#include<iostream.h>
#include<LINK/graph/UBinGraph.h>
#include<LINK/graph/DBinGraph.h>
#include<LINK/basic/Sequence.h>

main()
{
        UBinGraph ug;
        DBinGraph dg;
        Sequence<Vertex*> sq;
        Set<Vertex*>       s;
        Vertex *v1, *v2;

        v1 = ug.addVertex("v1");
        v2 = ug.addVertex("v2");
        s.append(v2); s.append(v1);   // must obey sorted order
        ug.addEdge(s);
        cout << ug << endl;
        
        v1 = dg.addVertex("v1");
        v2 = dg.addVertex("v2");
        sq.append(v2); sq.append(v1);
        dg.addEdge(sq); 
        cout << dg << endl;
}\end{verbatim}

\vspace*{-7mm}

\hrulefill

\vspace*{-5mm}

\begin{verbatim} 
UBinGraph::addEdge
{[v1 v2]  {{v1 v2}}}
{[v1 v2]  {<v2 v1>}}\end{verbatim}

\vspace*{-6mm}

\hrulefill
\end{minipage}
\end{flushleft}\end{figure}%
\lthtmlfigureZ
\hfill\lthtmlcheckvsize\clearpage}

\stepcounter{subsubsection}
{\newpage\clearpage
\lthtmlinlinemathA{tex2html_wrap_inline14392}%
$V' \subseteq V$%
\lthtmlinlinemathZ
\hfill\lthtmlcheckvsize\clearpage}

\stepcounter{subsubsection}
{\newpage\clearpage
\lthtmlfigureA{figure14369}%
\begin{figure}
\begin{flushleft}
\begin{minipage}[t]{\textwidth}
\hrulefill

\vspace*{-5mm}

\begin{verbatim}#include<fstream.h>
#include<LINK/graph/UBinGraph.h>
#include<LINK/graph/Attribute.h>

void main()
{
        UBinGraph g1;
        if (newAttribute((Graph*)&g1, "test_attr", 1.0) != LINK_OK)
                error("Attr.cpp: error creating test_attr");
        g1.addVertices(2);
        Vertex** vertices = g1.vertexStart();
        setAttribute((GraphObject*)vertices[1], "test_attr", 8.0);
        ofstream fout;
        fout.open("g1.g", ios::out);
        g1.saveToFile(&fout);
        ifstream fin;
        fin.open("g1.g", ios::in);
        char ch;
        while (fin.get(ch))   cout.put(ch);
}\end{verbatim}

\vspace*{-7mm}

\hrulefill

\vspace*{-5mm}

\begin{verbatim} 
 { Graph UBinGraph 
 (
  graph_name("Graph0")
  name("")
  width(1)
  size(10)
  weight(1.00000)
  x(0.500000)
  y(0.500000)
  color("black")
  label("")
  mark(0)
  type(0)
  starttime(0)
  finishtime(0)
  back(0)
  low(0)
  partition(0)
  distance(0.00000)
  pred(0)
  forefather(0)
  open(1)
  test_attr(1.00000)
 )
 Vertices [
   0 ( name("0") )
   1 ( name("1") test_attr(8.00000) )
 ]
 Edges {
 }
 }\end{verbatim}

\vspace*{-6mm}

\hrulefill
\end{minipage}
\end{flushleft}\end{figure}%
\lthtmlfigureZ
\hfill\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlfigureA{figure14484}%
\begin{figure}
\begin{flushleft}
\begin{minipage}[t]{\textwidth}
\hrulefill

\vspace*{-5mm}

\begin{verbatim}#include<iostream.h>
#include<fstream.h>
#include<LINK/graph/UBinGraph.h>

Graph  *LoadGraph(String);      // use parser of input graph lang.

void main()
{
        ifstream fin;
        fin.open("Progg0.g", ios::in);
        char ch;
        while (fin.get(ch))   cout.put(ch);
        fin.close();
        cout << "----------------------------" << endl;
        Graph *gp= LoadGraph("Progg0.g");
        cout << *gp << endl;
}\end{verbatim}

\vspace*{-7mm}

\hrulefill

\vspace*{-5mm}

\begin{verbatim} 
 { Graph UBinGraph 
 (
  graph_name("Graph1")
  name("")
  direction(0)
  weight(1)
  color(1)
  color(4)
  open(1)
  test_attr(1)
 )
 Vertices [
   v1 ( name("v1") test_attr(8) )
   v2 ( name("v2") )
   v3 ( name("v3") )
 ]
 Edges {
{ v1 v2 } ( name("e0") )
 }
 }
----------------------------
Parse failed: the returned graph is empty\end{verbatim}

\vspace*{-6mm}

\hrulefill
\end{minipage}
\end{flushleft}\end{figure}%
\lthtmlfigureZ
\hfill\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlfigureA{figure14497}%
\begin{figure}
\begin{flushleft}
\begin{minipage}[t]{\textwidth}
\hrulefill

\vspace*{-5mm}

\begin{verbatim}#include<iostream.h>
#include<LINK/graph/UBinGraph.h>

main()
{
        UBinGraph g;
        Set<Vertex*>       s;
        Vertex *v1, *v2;

        v1 = g.addVertex("v1");
        v2 = g.addVertex("v2");
        s.append( v2); s.append( v1);   // must obey sorted order
        g.addEdge(s);
        cout << g << endl;

        UBinGraph g2(g);        // graph attributes other than "name" are 
                                // not copied.
        g2.addVertex("v3");
        cout << g2 << endl;
}\end{verbatim}

\vspace*{-7mm}

\hrulefill

\vspace*{-5mm}

\begin{verbatim} 
UBinGraph::addEdge
{[v1 v2]  {{v1 v2}}}
{[v1 v2 v3]  {}}\end{verbatim}

\vspace*{-6mm}

\hrulefill
\end{minipage}
\end{flushleft}\end{figure}%
\lthtmlfigureZ
\hfill\lthtmlcheckvsize\clearpage}

\stepcounter{subsubsection}
{\newpage\clearpage
\lthtmlinlinemathA{tex2html_wrap_inline15201}%
$(0\ldots n-1)$%
\lthtmlinlinemathZ
\hfill\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlinlinemathA{tex2html_wrap_inline15205}%
$(0\ldots m-1)$%
\lthtmlinlinemathZ
\hfill\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlinlinemathA{tex2html_wrap_inline15231}%
$O(l\log n)$%
\lthtmlinlinemathZ
\hfill\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlinlinemathA{tex2html_wrap_inline15353}%
$w \in V(g)$%
\lthtmlinlinemathZ
\hfill\lthtmlcheckvsize\clearpage}

\stepcounter{subsubsection}
\stepcounter{section}
{\newpage\clearpage
\lthtmlfigureA{figure15539}%
\begin{figure}\centerline{
\includegraphics 
*[height=3in,width=4.5in]{figures/graph_hier.ps}}\end{figure}%
\lthtmlfigureZ
\hfill\lthtmlcheckvsize\clearpage}

\stepcounter{section}
\stepcounter{section}
\setcounter{figure}{1}
\setcounter{section}{1}
\stepcounter{section}
{\newpage\clearpage
\lthtmlfigureA{figure15725}%
\begin{figure}
\begin{flushleft}
\begin{minipage}[t]{\textwidth}
\hrulefill

\vspace*{-5mm}

\begin{verbatim}#include<LINK/basic/Sequence.h>
#include<LINK/graph/DBinGraph.h>
#include<LINK/graph/Attribute.h>
#include<LINK/algorithm/Algorithms.h>

main()
{
        DBinGraph g;
        Sequence<Vertex*>  s, postorder;
        Vertex *parent, *child1, *child2;

        child1 = g.addVertex("child1"); 
        parent = g.addVertex("parent");
        child2 = g.addVertex("child2");
        s.insert(parent); s.append(child1);  
        g.addEdge(s);
        s.clear();
        s.insert(parent); s.append(child2);  
        g.addEdge(s);
        
        postorder = DepthFirstSearch(&g);
        cout << postorder << endl;
}\end{verbatim}

\vspace*{-7mm}

\hrulefill

\vspace*{-5mm}

\begin{verbatim} 
<child1 child2 parent>\end{verbatim}

\vspace*{-6mm}

\hrulefill
\end{minipage}
\end{flushleft}\end{figure}%
\lthtmlfigureZ
\hfill\lthtmlcheckvsize\clearpage}

\stepcounter{subsection}
\stepcounter{part}
\setcounter{figure}{0}
\setcounter{section}{0}
\stepcounter{section}
{\newpage\clearpage
\lthtmlfigureA{figure15803}%
\begin{figure}
\centerline{
\includegraphics 
*[height=3in,width=4.5in]{figures/directory_hier.ps}}\end{figure}%
\lthtmlfigureZ
\hfill\lthtmlcheckvsize\clearpage}

\stepcounter{part}
\setcounter{figure}{0}
\setcounter{section}{0}
\appendix
\stepcounter{section}
\stepcounter{subsection}
\stepcounter{subsection}
{\newpage\clearpage
\lthtmlinlinemathA{tex2html_wrap_inline16299}%
$\rightarrow$%
\lthtmlinlinemathZ
\hfill\lthtmlcheckvsize\clearpage}

\stepcounter{subsection}

\end{document}
