COIN-OR::LEMON - Graph Library

Changeset 70:851ca9a60e90 in lemon-0.x for doc


Ignore:
Timestamp:
02/10/04 14:29:15 (16 years ago)
Author:
Alpar Juttner
Branch:
default
Phase:
public
Convert:
svn:c9d7d8f5-90d6-0310-b91f-818b3a526b0e/lemon/trunk@86
Message:

.

Location:
doc
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • doc/etikol.texi

    r29 r70  
    11\input texinfo   @c -*-texinfo-*-
    2 @comment $Id: etikol.texi,v 1.4 2004/01/21 08:39:33 alpar Exp $
     2@comment $Id: etikol.texi,v 1.5 2004/02/10 13:29:15 alpar Exp $
    33@comment %**start of header
    44@setfilename etikol.info
     
    3636@comment %**end of header
    3737
    38 @c @copying
    39 @c This manual is for GNU ETIL-OL Optimization Library
    40 @c (version @value{VERSION}, @value{UPDATED}).
     38@copying
     39This manual is for GNU ETIL-OL Optimization Library
     40(version @value{VERSION}, @value{UPDATED}).
    4141
    42 @c Copyright @copyright{} 2003 ETIK.
     42Copyright @copyright{} 2003 ETIK.
    4343
    44 @c @quotation
    45 @c Permission is granted to copy, distribute and/or modify this document
    46 @c under the terms of the GNU Free Documentation License, Version 1.1 or
    47 @c any later version published by the Free Software Foundation; with no
    48 @c Invariant Sections, with the Front-Cover Texts being ``A GNU Manual,''
    49 @c and with the Back-Cover Texts as in (a) below.  A copy of the
    50 @c license is included in the section entitled ``GNU Free Documentation
    51 @c License.''
     44@quotation
     45Permission is granted to copy, distribute and/or modify this document
     46under the terms of the GNU Free Documentation License, Version 1.1 or
     47any later version published by the Free Software Foundation; with no
     48Invariant Sections, with the Front-Cover Texts being ``A GNU Manual,''
     49and with the Back-Cover Texts as in (a) below.  A copy of the
     50license is included in the section entitled ``GNU Free Documentation
     51License.''
    5252
    53 @c (a) The FSF's Back-Cover Text is: ``You have freedom to copy and modify
    54 @c this GNU Manual, like GNU software.  Copies published by the Free
    55 @c Software Foundation raise funds for GNU development.''
    56 @c @end quotation
    57 @c @end copying
     53(a) The FSF's Back-Cover Text is: ``You have freedom to copy and modify
     54this GNU Manual, like GNU software.  Copies published by the Free
     55Software Foundation raise funds for GNU development.''
     56@end quotation
     57@end copying
    5858
    5959@dircategory Texinfo documentation system
  • doc/flf-graph.texi

    r26 r70  
    2828
    2929@anchor{Graph-NodeIterator}
    30 @deftp {Type} Graph::NodePoint
     30@deftp {Type} Graph::NodeIt
    3131@deftpx {Type} Graph::NodeIterator
    3232These types points a node uniquely. The difference between the
    33 @code{NodePoint} and the @code{NodeIterator} is that @code{NodePoint}
     33@code{NodeIt} and the @code{NodeIterator} is that @code{NodeIt}
    3434requires the graph structure itself for most of the operations.
    3535For examples using iterators you can go through all nodes as follows.
     
    3838Graph G;
    3939int nodenum=0;
    40 for(Graph::NodeIterator n(G);n.Valid();++n) ++nodenum;
     40for(Graph::NodeIterator n(G);n.valid();++n) ++nodenum;
    4141@end verbatim
    4242@end quotation
    43 Using @code{NodePoint} the last line looks like this.
     43Using @code{NodeIt} the last line looks like this.
    4444@quotation
    4545@verbatim
    46 for(MyGraph::NodePoint n(G);n.Valid();n=G.Next(n)) ++nodenum;
     46for(Graph::NodeIt n(G);n.valid();n=G.next(n)) ++nodenum;
    4747@end verbatim
    4848@end quotation
     
    5050@quotation
    5151@verbatim
    52 MyGraph::NodePoint n;
    53 for(G.GetFirst(n);G.Valid(n);G.GoNext(n)) ++nodenum;
     52MyGraph::NodeIt n;
     53for(G.getFirst(n);G.valid(n);G.goNext(n)) ++nodenum;
    5454@end verbatim
    5555@end quotation
    5656@end deftp
    5757
    58 @deftp {Type} Graph::EdgePoint
    59 @deftpx {Type} Graph::InEdgePoint
    60 @deftpx {Type} Graph::OutEdgePoint
    61 @deftpx {Type} Graph::BiEdgePoint
    62 @deftpx {Type} Graph::SymEdgePoint
     58@deftp {Type} Graph::EdgeIt
     59@deftpx {Type} Graph::InEdgeIt
     60@deftpx {Type} Graph::OutEdgeIt
     61@deftpx {Type} Graph::BiEdgeIt
     62@deftpx {Type} Graph::SymEdgeIt
    6363Each of these types points an edge uniquely. The difference between the
    64 @code{EdgePoint} and the
     64@code{EdgeIt} and the
    6565@c @mref{Graph-NodeIterator,@code{EdgeIterator}}
    6666@mref{Graph-NodeIterator , EdgeIterator}
    6767series is that
    68 @code{EdgePoint} requires the graph structure itself for most of the
     68@code{EdgeIt} requires the graph structure itself for most of the
    6969operations.
    7070@end deftp
     
    7676@deftpx {Type} Graph::BiEdgeIterator
    7777@deftpx {Type} Graph::SymEdgeIterator
    78 @deftpx {Type} Graph::AllEdgeIterator
     78@deftpx {Type} Graph::EachEdgeIterator
    7979Each of these types points an edge uniquely. The difference between the
    80 @code{EdgePoint} and the @code{EdgeIterator} series is that
    81 @code{EdgePoint} requires the graph structure itself for most of the
     80@code{EdgeIt} and the @code{EdgeIterator} series is that
     81@code{EdgeIt} requires the graph structure itself for most of the
    8282operations.
    8383
     
    108108@subsubsection Graph Maintenence Operations
    109109
    110 @deftypefun NodeIterator Graph::AddNode ()
     110@deftypefun NodeIterator Graph::addNode ()
    111111Adds a new node to the graph and returns a @code{NodeIterator} pointing to it.
    112112@end deftypefun
    113113
    114 @deftypefun EdgeIterator Graph::AddEdge (@w{const @mref{Graph-NodeIterator,NodeIterator} @var{from}}, @w{const @mref{Graph-NodeIterator,NodeIterator} @var{to}})
     114@deftypefun EdgeIterator Graph::addEdge (@w{const @mref{Graph-NodeIterator,NodeIterator} @var{from}}, @w{const @mref{Graph-NodeIterator,NodeIterator} @var{to}})
    115115Adds a new edge with tail @var{from} and head @var{to} to the graph
    116116and returns an @code{EdgeIterator} pointing to it.
    117117@end deftypefun
    118118
    119 @deftypefun void Graph::Delete (@w{const @mref{Graph-NodeIterator,NodeIterator} @var{n}})
     119@deftypefun void Graph::delete (@w{const @mref{Graph-NodeIterator,NodeIterator} @var{n}})
    120120Deletes the node @var{n}. It also deletes the adjacent edges.
    121121@end deftypefun
    122122
    123 @deftypefun void Graph::Delete (@w{const @mref{Graph-EdgeIterator,EdgeIterator} @var{e}})
     123@deftypefun void Graph::delete (@w{const @mref{Graph-EdgeIterator,EdgeIterator} @var{e}})
    124124Deletes the edge @var{n}.
    125125@end deftypefun
    126126
    127 @deftypefun void Graph::Clean ()
     127@deftypefun void Graph::clean ()
    128128Deletes all edges and nodes from the graph.
    129129@end deftypefun
    130130
    131 @deftypefun int Graph::NodeNum ()
     131@deftypefun int Graph::nodeNum ()
    132132Returns the number of the nodes in the graph.
    133133@end deftypefun
    134134
    135 @subsubsection NodePoint Operations
    136 
    137 @deftypefun NodePoint Graph::GetFirst (NodePoint &@var{n})
    138 @deftypefunx NodePoint Graph::Next (const NodePoint @var{n})
    139 @deftypefunx {NodePoint &} Graph::GoNext (NodePoint &@var{n})
     135@subsubsection NodeIt Operations
     136
     137@deftypefun NodeIt Graph::getFirst (NodeIt &@var{n})
     138@deftypefunx NodeIt Graph::next (const NodeIt @var{n})
     139@deftypefunx {NodeIt &} Graph::goNext (NodeIt &@var{n})
    140140The nodes in the graph forms a list. @code{GetFirst(n)} sets @var{n} to
    141 be the first node. @code{Next(n)} gives back the subsequent
     141be the first node. @code{next(n)} gives back the subsequent
    142142node. @code{Next(n)} is equivalent to @code{n=Next(n)}, though it
    143143might be faster.  ??? What should be the return value ???
    144144@end deftypefun
    145145
    146 @deftypefun bool Graph::Valid (NodePoint &@var{e})
    147 @deftypefunx bool NodePoint::Valid ()
    148 These functions check if and NodePoint is valid or not.
     146@deftypefun bool Graph::valid (NodeIt &@var{e})
     147@deftypefunx bool NodeIt::valid ()
     148These functions check if and NodeIt is valid or not.
    149149??? Which one should be implemented ???
    150150@end deftypefun
    151151
    152 @subsubsection EdgePoint Operations
    153 
    154 @deftypefun AllEdgePoint Graph::GetFirst (const AllEdgePoint & @var{e})
    155 @deftypefunx AllEdgePoint Graph::Next (const AllEdgePoint @var{n})
    156 @deftypefunx {AllEdgePoint &} Graph::GoNext (AllEdgePoint &@var{n})
     152@subsubsection EdgeIt Operations
     153
     154@deftypefun EachEdgeIt Graph::getFirst (const EachEdgeIt & @var{e})
     155@deftypefunx EachEdgeIt Graph::next (const EachEdgeIt @var{n})
     156@deftypefunx {EachEdgeIt &} Graph::goNext (EachEdgeIt &@var{n})
    157157With these functions you can go though all the edges of the graph.
    158158??? What should be the return value ???
    159159@end deftypefun
    160160
    161 @deftypefun InEdgePoint Graph::GetFirst (const InEdgePoint & @var{e}, const NodePoint @var{n})
    162 @deftypefunx OutEdgePoint Graph::GetFirst (const OutEdgePoint & @var{e}, const NodePoint @var{n})
    163 @deftypefunx SymEdgePoint Graph::GetFirst (const SymEdgePoint & @var{e}, const NodePoint @var{n})
     161@deftypefun InEdgeIt Graph::getFirst (const InEdgeIt & @var{e}, const NodeIt @var{n})
     162@deftypefunx OutEdgeIt Graph::getFirst (const OutEdgeIt & @var{e}, const NodeIt @var{n})
     163@deftypefunx SymEdgeIt Graph::getFirst (const SymEdgeIt & @var{e}, const NodeIt @var{n})
    164164The edges leaving from, arriving at or adjacent with a node forms a
    165165list.  These functions give back the first elements of these
    166166lists. The exact behavior depends on the type of @var{e}.
    167167
    168 If @var{e} is an @code{InEdgePoint} or an @code{OutEdgePoint} then
    169 @code{GetFirst} sets @var{e} to be the first incoming or outgoing edge
     168If @var{e} is an @code{InEdgeIt} or an @code{OutEdgeIt} then
     169@code{getFirst} sets @var{e} to be the first incoming or outgoing edge
    170170of the node @var{n}, respectively.
    171171
    172 If @var{e} is a @code{SymEdgePoint} then
    173 @code{GetFirst} sets @var{e} to be the first incoming if there exists one
     172If @var{e} is a @code{SymEdgeIt} then
     173@code{getFirst} sets @var{e} to be the first incoming if there exists one
    174174otherwise the first outgoing edge.
    175175
     
    178178@end deftypefun
    179179
    180 @deftypefun InEdgePoint Graph::Next (const InEdgePoint @var{e})
    181 @deftypefunx OutEdgePoint Graph::Next (const OutEdgePoint @var{e})
    182 @deftypefunx SymEdgePoint Graph::Next (const SymEdgePoint @var{e})
     180@deftypefun InEdgeIt Graph::next (const InEdgeIt @var{e})
     181@deftypefunx OutEdgeIt Graph::next (const OutEdgeIt @var{e})
     182@deftypefunx SymEdgeIt Graph::next (const SymEdgeIt @var{e})
    183183These functions give back the edge that follows @var{e}
    184184@end deftypefun
    185185
    186 @deftypefun {InEdgePoint &} Graph::GoNext (InEdgePoint &@var{e})
    187 @deftypefunx {OutEdgePoint &} Graph::GoNext (OutEdgePoint &@var{e})
    188 @deftypefunx {SymEdgePoint &} Graph::GoNext (SymEdgePoint &@var{e})
    189 @code{G.GoNext(e)} is equivalent to @code{e=G.Next(e)}, though it
     186@deftypefun {InEdgeIt &} Graph::goNext (InEdgeIt &@var{e})
     187@deftypefunx {OutEdgeIt &} Graph::goNext (OutEdgeIt &@var{e})
     188@deftypefunx {SymEdgeIt &} Graph::goNext (SymEdgeIt &@var{e})
     189@code{G.goNext(e)} is equivalent to @code{e=G.next(e)}, though it
    190190might be faster.
    191191??? What should be the return value ???
    192192@end deftypefun
    193193
    194 @deftypefun bool Graph::Valid (EdgePoint &@var{e})
    195 @deftypefunx bool EdgePoint::Valid ()
    196 These functions check if and EdgePoint is valid or not.
     194@deftypefun bool Graph::valid (EdgeIt &@var{e})
     195@deftypefunx bool EdgeIt::valid ()
     196These functions check if and EdgeIt is valid or not.
    197197??? Which one should be implemented ???
    198198@end deftypefun
    199199
    200 @deftypefun NodePoint Graph::From (const EdgePoint @var{e})
    201 @deftypefunx NodePoint Graph::To (const EdgePoint @var{e})
    202 @deftypefunx NodePoint Graph::ANode (const InEdgePoint @var{e})
    203 @deftypefunx NodePoint Graph::ANode (const OutEdgePoint @var{e})
    204 @deftypefunx NodePoint Graph::ANode (const SymEdgePoint @var{e})
    205 @deftypefunx NodePoint Graph::BNode (const InEdgePoint @var{e})
    206 @deftypefunx NodePoint Graph::BNode (const OutEdgePoint @var{e})
    207 @deftypefunx NodePoint Graph::BNode (const SymEdgePoint @var{e})
     200@deftypefun NodeIt Graph::tail (const EdgeIt @var{e})
     201@deftypefunx NodeIt Graph::head (const EdgeIt @var{e})
     202@deftypefunx NodeIt Graph::aNode (const InEdgeIt @var{e})
     203@deftypefunx NodeIt Graph::aNode (const OutEdgeIt @var{e})
     204@deftypefunx NodeIt Graph::aNode (const SymEdgeIt @var{e})
     205@deftypefunx NodeIt Graph::bNode (const InEdgeIt @var{e})
     206@deftypefunx NodeIt Graph::bNode (const OutEdgeIt @var{e})
     207@deftypefunx NodeIt Graph::bNode (const SymEdgeIt @var{e})
    208208There queries give back the two endpoints of the edge @var{e}.  For a
    209 directed edge @var{e}, @code{From(e)} and @code{To(e)} is its tail and
     209directed edge @var{e}, @code{tail(e)} and @code{head(e)} is its tail and
    210210its head, respectively. For an undirected @var{e}, they are two
    211211endpoints, but you should not rely on which end is which.
    212212
    213 @code{ANode(e)} is the node which @var{e} is bounded to, i.e. it is
    214 equal to @code{From(e)} if @var{e} is an @code{OutEdgePoint} and
    215 @code{To(e)} if @var{e} is an @code{InEdgePoint}. If @var{e} is a
    216 @code{SymEdgePoint} and it or its first preceding edge was created by
    217 @code{GetFirst(e,n)}, then @code{ANode(e)} is equal to @var{n}.
    218 
    219 @code{BNode(e)} is the other end of the edge.
    220 
    221 ???It it implemented in an other way now. (Member function <-> Graph global)???
     213@code{aNode(e)} is the node which @var{e} is bounded to, i.e. it is
     214equal to @code{tail(e)} if @var{e} is an @code{OutEdgeIt} and
     215@code{head(e)} if @var{e} is an @code{InEdgeIt}. If @var{e} is a
     216@code{SymEdgeIt} and it or its first preceding edge was created by
     217@code{getFirst(e,n)}, then @code{aNode(e)} is equal to @var{n}.
     218
     219@code{bNode(e)} is the other end of the edge.
     220
     221???It is implemented in an other way now. (Member function <-> Graph global)???
    222222@end deftypefun
    223223
Note: See TracChangeset for help on using the changeset viewer.