Ticket #14805: trac_14805.patch

File trac_14805.patch, 29.6 KB (added by ncohen, 6 years ago)
  • doc/en/reference/graphs/index.rst

    # HG changeset patch
    # User Nathann Cohen <nathann.cohen@gmail.com>
    # Date 1371902834 -7200
    #      Sat Jun 22 14:07:14 2013 +0200
    # Node ID 0eee5ed9955fd55b5fb02b524b1c9a59067234eb
    # Parent  5d8c13e7b81a1e152855073f97a4d48ee97255d1
    Adds sage.graphs.base.graph_backend to the documentation
    
    diff --git a/doc/en/reference/graphs/index.rst b/doc/en/reference/graphs/index.rst
    a b  
    3838   sage/graphs/base/sparse_graph
    3939   sage/graphs/base/dense_graph
    4040   sage/graphs/base/static_sparse_graph
     41   sage/graphs/base/graph_backends
    4142
    4243Hypergraphs
    4344-----------
  • sage/graphs/base/graph_backends.py

    diff --git a/sage/graphs/base/graph_backends.py b/sage/graphs/base/graph_backends.py
    a b  
    2020    extensions of this class.  Note, this graph has a number of placeholder
    2121    functions, so the doctests are rather silly.
    2222
    23     DOCTEST:
     23    TESTS::
     24
    2425        sage: import sage.graphs.base.graph_backends
    2526
    2627    """
     
    3132        """
    3233        Add an edge (u,v) to self, with label l.  If directed is True, this is
    3334        interpreted as an arc from u to v.
    34        
    35         INPUT:
    36             u,v:      vertices
    37             l:        edge label
    38             directed: boolean
    39        
    40         DOCTEST:
     35
     36        INPUT::
     37
     38        - ``u,v`` -- vertices
     39        - ``l`` -- edge label
     40        - ``directed`` -- boolean
     41
     42        TESTS::
     43
    4144            sage: G = sage.graphs.base.graph_backends.GenericGraphBackend()
    4245            sage: G.add_edge(1,2,'a',True)
    4346            Traceback (most recent call last):
     
    4952        """
    5053        Add a sequence of edges to self.  If directed is True, these are
    5154        interpreted as arcs.
    52        
     55
    5356        INPUT:
    54             edges:    iterator
    55             directed: boolean
    56        
    57         DOCTEST:
     57
     58        - ``edges`` -- list/iterator of edges to be added.
     59
     60        - ``directed`` -- boolean
     61
     62        TESTS::
     63
    5864            sage: G = sage.graphs.base.graph_backends.GenericGraphBackend()
    5965            sage: G.add_edges([],True)
    6066            Traceback (most recent call last):
    6167            ...
    6268            NotImplementedError
    63         """ 
     69        """
    6470        raise NotImplementedError()
     71
    6572    def add_vertex(self, name):
    6673        """
    6774        Add a labelled vertex to self.
    68        
     75
    6976        INPUT:
    7077
    7178        - ``name`` -- vertex label
    72        
     79
    7380        OUTPUT:
    7481
    75         If ``name``=``None``, the new vertex name is returned, ``None`` otherwise.
     82        If ``name=None``, the new vertex name is returned, ``None`` otherwise.
    7683
    77         DOCTEST:
     84        TESTS::
     85
    7886            sage: G = sage.graphs.base.graph_backends.GenericGraphBackend()
    7987            sage: G.add_vertex(0)
    8088            Traceback (most recent call last):
    8189            ...
    8290            NotImplementedError
    83         """ 
     91        """
    8492        raise NotImplementedError()
    8593    def add_vertices(self, vertices):
    8694        """
    8795        Add labelled vertices to self.
    88        
     96
    8997        INPUT:
    9098
    91         - ``vertices``: iterator of vertex labels. A new label is created, used and returned in
    92           the output list for all ``None`` values in ``vertices``.
     99        - ``vertices`` -- iterator of vertex labels. A new label is created,
     100          used and returned in the output list for all ``None`` values in
     101          ``vertices``.
    93102
    94103        OUTPUT:
    95104
     
    103112            Traceback (most recent call last):
    104113            ...
    105114            NotImplementedError
    106         """ 
     115        """
    107116        raise NotImplementedError()
    108117    def degree(self, v, directed):
    109118        """
    110119        Returns the total number of vertices incident to v.
    111        
     120
    112121        INPUT:
    113             v:       a vertex label
    114             directed: boolean
     122
     123        - ``v`` -- a vertex label
     124        - ``directed`` -- boolean
     125
    115126        OUTPUT:
     127
    116128            degree of v
    117            
    118         DOCTEST:
     129
     130        TESTS::
     131
    119132            sage: G = sage.graphs.base.graph_backends.GenericGraphBackend()
    120133            sage: G.degree(1, False)
    121134            Traceback (most recent call last):
    122135            ...
    123136            NotImplementedError
    124         """ 
     137        """
    125138        raise NotImplementedError()
    126139    def del_edge(self, u, v, l, directed):
    127140        """
    128141        Deletes the edge (u,v) with label l.
    129142
    130143        INPUT:
    131             u,v:      vertices
    132             l:        edge label
    133             directed: boolean
    134        
    135         DOCTEST:
     144
     145        - ``u,v`` -- vertices
     146        - ``l`` -- edge label
     147        - ``directed`` -- boolean
     148
     149        TESTS::
     150
    136151            sage: G = sage.graphs.base.graph_backends.GenericGraphBackend()
    137152            sage: G.del_edge(1,2,'a',True)
    138153            Traceback (most recent call last):
    139154            ...
    140155            NotImplementedError
    141         """ 
     156        """
    142157        raise NotImplementedError()
    143158    def del_vertex(self, v):
    144159        """
    145160        Delete a labelled vertex in self.
    146        
     161
    147162        INPUT:
    148             v: vertex label
    149        
    150         DOCTEST:
     163
     164        - ``v`` -- vertex label
     165
     166        TESTS::
     167
    151168            sage: G = sage.graphs.base.graph_backends.GenericGraphBackend()
    152169            sage: G.del_vertex(0)
    153170            Traceback (most recent call last):
    154171            ...
    155172            NotImplementedError
    156         """ 
     173        """
    157174        raise NotImplementedError()
    158175    def del_vertices(self, vertices):
    159176        """
    160177        Delete labelled vertices in self.
    161        
     178
    162179        INPUT:
    163             vertices: iterator of vertex labels
    164        
    165         DOCTEST:
     180
     181        - ``vertices`` -- iterator of vertex labels
     182
     183        TESTS::
     184
    166185            sage: G = sage.graphs.base.graph_backends.GenericGraphBackend()
    167186            sage: G.del_vertices([1,2,3])
    168187            Traceback (most recent call last):
    169188            ...
    170189            NotImplementedError
    171         """ 
     190        """
    172191        raise NotImplementedError()
    173192    def get_edge_label(self, u, v):
    174193        """
    175194        Returns the edge label of (u,v).
    176195
    177196        INPUT:
    178             u,v: vertex labels
    179        
     197
     198        - ``u,v`` -- vertex labels
     199
    180200        OUTPUT:
     201
    181202            label of (u,v)
    182        
    183         DOCTEST:
     203
     204        TESTS::
     205
    184206            sage: G = sage.graphs.base.graph_backends.GenericGraphBackend()
    185207            sage: G.get_edge_label(1,2)
    186208            Traceback (most recent call last):
    187209            ...
    188210            NotImplementedError
    189         """ 
     211        """
    190212        raise NotImplementedError()
    191213    def has_edge(self, u, v, l):
    192214        """
    193215        True if self has an edge (u,v) with label l.
    194216
    195217        INPUT:
    196             u,v: vertex labels
    197             l: label
    198        
     218
     219        - ``u,v`` -- vertex labels
     220        - ``l`` -- label
     221
    199222        OUTPUT:
     223
    200224            boolean
    201        
    202         DOCTEST:
     225
     226        TESTS::
     227
    203228            sage: G = sage.graphs.base.graph_backends.GenericGraphBackend()
    204229            sage: G.has_edge(1,2,'a')
    205230            Traceback (most recent call last):
    206231            ...
    207232            NotImplementedError
    208         """ 
     233        """
    209234        raise NotImplementedError()
    210235    def has_vertex(self, v):
    211236        """
    212237        True if self has a vertex with label v.
    213238
    214239        INPUT:
    215             v: vertex label
    216        
     240
     241        - ``v`` -- vertex label
     242
    217243        OUTPUT:
    218244            boolean
    219        
    220         DOCTEST:
     245
     246        TESTS::
     247
    221248            sage: G = sage.graphs.base.graph_backends.GenericGraphBackend()
    222249            sage: G.has_vertex(0)
    223250            Traceback (most recent call last):
    224251            ...
    225252            NotImplementedError
    226         """ 
     253        """
    227254        raise NotImplementedError()
    228255    def iterator_edges(self, vertices, labels):
    229256        """
    230257        Iterate over the edges incident to a sequence of vertices. Edges are
    231258        assumed to be undirected.
    232        
     259
    233260        INPUT:
    234             vertices:     a list of vertex labels
    235             labels:       boolean
    236            
     261
     262        - ``vertices`` -- a list of vertex labels
     263        - ``labels`` -- boolean
     264
    237265        OUTPUT:
    238             a generator which yields edges, with or without labels
     266
     267            a generator which yields edges, with or without labels
    239268            depending on the labels parameter.
    240            
    241         DOCTEST:
     269
     270        TESTS::
     271
    242272            sage: G = sage.graphs.base.graph_backends.GenericGraphBackend()
    243273            sage: G.iterator_edges([],True)
    244274            Traceback (most recent call last):
     
    249279    def iterator_in_edges(self, vertices, labels):
    250280        """
    251281        Iterate over the incoming edges incident to a sequence of vertices.
    252        
     282
    253283        INPUT:
    254             vertices:     a list of vertex labels
    255             labels:       boolean
    256            
     284
     285        - ``vertices`` -- a list of vertex labels
     286        - ``labels`` -- boolean
     287
    257288        OUTPUT:
    258             a generator which yields edges, with or without labels 
     289            a generator which yields edges, with or without labels
    259290            depending on the labels parameter.
    260            
    261         DOCTEST:
     291
     292        TESTS::
     293
    262294            sage: G = sage.graphs.base.graph_backends.GenericGraphBackend()
    263295            sage: G.iterator_in_edges([],True)
    264296            Traceback (most recent call last):
     
    269301    def iterator_out_edges(self, vertices, labels):
    270302        """
    271303        Iterate over the outbound edges incident to a sequence of vertices.
    272        
     304
    273305        INPUT:
    274             vertices:     a list of vertex labels
    275             labels:       boolean
    276            
     306
     307        - ``vertices`` -- a list of vertex labels
     308        - ``labels`` -- boolean
     309
    277310        OUTPUT:
    278             a generator which yields edges, with or without labels
     311
     312            a generator which yields edges, with or without labels
    279313            depending on the labels parameter.
    280            
    281         DOCTEST:
     314
     315        TESTS::
     316
    282317            sage: G = sage.graphs.base.graph_backends.GenericGraphBackend()
    283318            sage: G.iterator_out_edges([],True)
    284319            Traceback (most recent call last):
     
    289324    def iterator_nbrs(self, v):
    290325        """
    291326        Iterate over the vertices adjacent to v.
    292        
     327
    293328        INPUT:
    294             v: vertex label
    295            
     329
     330        - ``v`` -- vertex label
     331
    296332        OUTPUT:
     333
    297334            a generator which yields vertex labels
    298            
    299         DOCTEST:
     335
     336        TESTS::
     337
    300338            sage: G = sage.graphs.base.graph_backends.GenericGraphBackend()
    301339            sage: G.iterator_nbrs(0)
    302340            Traceback (most recent call last):
     
    308346        """
    309347        Iterate over the vertices u such that the edge (u,v) is in self
    310348        (that is, predecessors of v).
    311        
     349
    312350        INPUT:
    313             v: vertex label
    314            
     351
     352        - ``v`` -- vertex label
     353
    315354        OUTPUT:
     355
    316356            a generator which yields vertex labels
    317            
    318         DOCTEST:
     357
     358        TESTS::
     359
    319360            sage: G = sage.graphs.base.graph_backends.GenericGraphBackend()
    320361            sage: G.iterator_in_nbrs(0)
    321362            Traceback (most recent call last):
     
    327368        """
    328369        Iterate over the vertices u such that the edge (v,u) is in self
    329370        (that is, successors of v).
    330        
     371
    331372        INPUT:
    332             v: vertex label
    333            
     373
     374        - ``v`` -- vertex label
     375
    334376        OUTPUT:
     377
    335378            a generator which yields vertex labels
    336            
    337         DOCTEST:
     379
     380        TESTS::
     381
    338382            sage: G = sage.graphs.base.graph_backends.GenericGraphBackend()
    339383            sage: G.iterator_out_nbrs(0)
    340384            Traceback (most recent call last):
     
    345389    def iterator_verts(self, verts):
    346390        """
    347391        Iterate over the vertices v with labels in verts.
    348        
     392
    349393        INPUT:
    350             vertex: vertex labels
    351            
     394
     395        - ``vertex`` -- vertex labels
     396
    352397        OUTPUT:
     398
    353399            a generator which yields vertices
    354            
    355         DOCTEST:
     400
     401        TESTS::
     402
    356403            sage: G = sage.graphs.base.graph_backends.GenericGraphBackend()
    357404            sage: G.iterator_verts(0)
    358405            Traceback (most recent call last):
     
    360407            NotImplementedError
    361408        """
    362409        raise NotImplementedError()
    363     def loops(self, new):
     410
     411    def loops(self, new=None):
    364412        """
    365         Get/set whether or not self allows loops.       
    366        
     413        Get/set whether or not self allows loops.
     414
    367415        INPUT:
    368             new: boolean or None
    369        
    370         DOCTEST:
     416
     417        - ``new`` -- can be a boolean (in which case it sets the value) or
     418          ``None``, in which case the current value is returned. It is set to
     419          ``None`` by default.
     420
     421        TESTS::
     422
    371423            sage: G = sage.graphs.base.graph_backends.GenericGraphBackend()
    372424            sage: G.loops(True)
    373425            Traceback (most recent call last):
     
    379431            NotImplementedError
    380432        """
    381433        raise NotImplementedError()
    382     def multiple_edges(self, new):
     434    def multiple_edges(self, new=None):
    383435        """
    384436        Get/set whether or not self allows multiple edges.
    385        
     437
    386438        INPUT:
    387             new: boolean or None
    388        
    389         DOCTEST:
     439
     440        - ``new`` -- can be a boolean (in which case it sets the value) or
     441          ``None``, in which case the current value is returned. It is set to
     442          ``None`` by default.
     443
     444        TESTS::
     445
    390446            sage: G = sage.graphs.base.graph_backends.GenericGraphBackend()
    391447            sage: G.multiple_edges(True)
    392448            Traceback (most recent call last):
     
    398454            NotImplementedError
    399455        """
    400456        raise NotImplementedError()
    401     def name(self, new):
     457    def name(self, new=None):
    402458        """
    403459        Get/set name of self.
    404        
     460
    405461        INPUT:
    406             new: string or None
    407        
    408         DOCTEST:
     462
     463        - ``new`` -- can be a string (in which case it sets the value) or
     464          ``None``, in which case the current value is returned. It is set to
     465          ``None`` by default.
     466
     467        TESTS::
     468
    409469            sage: G = sage.graphs.base.graph_backends.GenericGraphBackend()
    410470            sage: G.name("A Generic Graph")
    411471            Traceback (most recent call last):
     
    420480    def num_edges(self, directed):
    421481        """
    422482        The number of edges in self
    423        
     483
    424484        INPUT:
    425             directed: boolean
    426        
    427         DOCTEST:
     485
     486        - ``directed`` -- boolean
     487
     488        TESTS::
     489
    428490            sage: G = sage.graphs.base.graph_backends.GenericGraphBackend()
    429491            sage: G.num_edges(True)
    430492            Traceback (most recent call last):
     
    439501    def num_verts(self):
    440502        """
    441503        The number of vertices in self
    442        
    443         DOCTEST:
     504
     505        TESTS::
     506
    444507            sage: G = sage.graphs.base.graph_backends.GenericGraphBackend()
    445508            sage: G.num_verts()
    446509            Traceback (most recent call last):
     
    451514    def relabel(self, perm, directed):
    452515        """
    453516        Relabel the vertices of self by a permutation.
     517
    454518        INPUT:
    455             perm:     permutation
    456             directed: boolean
    457        
    458         DOCTEST:
     519
     520        - ``perm`` -- permutation
     521        - ``directed`` -- boolean
     522
     523        TESTS::
     524
    459525            sage: G = sage.graphs.base.graph_backends.GenericGraphBackend()
    460526            sage: G.relabel([],False)
    461527            Traceback (most recent call last):
     
    466532    def set_edge_label(self, u, v, l, directed):
    467533        """
    468534        Label the edge (u,v) by l.
    469        
     535
    470536        INPUT:
    471             u,v:      vertices
    472             l:        edge label
    473             directed: boolean
    474        
    475         DOCTEST:
     537
     538        - ``u,v`` -- vertices
     539        - ``l`` -- edge label
     540        - ``directed`` -- boolean
     541
     542        TESTS::
     543
    476544            sage: G = sage.graphs.base.graph_backends.GenericGraphBackend()
    477545            sage: G.set_edge_label(1,2,'a',True)
    478546            Traceback (most recent call last):
    479547            ...
    480548            NotImplementedError
    481         """       
     549        """
    482550        raise NotImplementedError()
    483551
    484552class NetworkXGraphDeprecated(SageObject):
    485553    """
    486554    Class for unpickling old networkx.XGraph formats
    487555
    488     DOCTEST::
     556    TESTS::
    489557
    490558        sage: from sage.graphs.base.graph_backends import NetworkXGraphDeprecated as NXGD
    491559        sage: X = NXGD()
    492560        doctest:...
    493        
     561
    494562    """
    495563
    496564    def __init__(self):
     
    557625    """
    558626    Class for unpickling old networkx.XDiGraph formats
    559627
    560     DOCTEST:
     628    TESTS::
     629
    561630        sage: import sage.graphs.base.graph_backends
    562631    """
    563632
     
    629698    """
    630699    A wrapper for NetworkX as the backend of a graph.
    631700
    632     DOCTEST:
     701    TESTS::
     702
    633703        sage: import sage.graphs.base.graph_backends
    634704
    635705    """
     
    639709    def __init__(self, N=None):
    640710        """
    641711        Initialize the backend with NetworkX graph N.
    642        
    643         DOCTEST:
     712
     713        TESTS::
     714
    644715            sage: G = sage.graphs.base.graph_backends.NetworkXGraphBackend()
    645716            sage: G.iterator_edges([],True)
    646717            <generator object iterator_edges at ...>
     
    659730        """
    660731        Add an edge (u,v) to self, with label l.  If directed is True, this is
    661732        interpreted as an arc from u to v.
    662        
     733
    663734        INPUT:
    664             u,v:      vertices
    665             l:        edge label
    666             directed: boolean
    667        
    668         DOCTEST:
     735
     736        - ``u,v`` -- vertices
     737        - ``l`` -- edge label
     738        - ``directed`` -- boolean
     739
     740        TESTS::
     741
    669742            sage: G = sage.graphs.base.graph_backends.NetworkXGraphBackend()
    670743            sage: G.add_edge(1,2,'a',True)
    671744        """
     
    687760        """
    688761        Add a sequence of edges to self.  If directed is True, these are
    689762        interpreted as arcs.
    690        
     763
    691764        INPUT:
    692             edges:    iterator
    693             directed: boolean
    694        
    695         DOCTEST:
     765
     766        - ``edges`` -- list/iterator of edges to be added.
     767        - ``directed`` -- boolean
     768
     769        TESTS::
     770
    696771            sage: G = sage.graphs.base.graph_backends.NetworkXGraphBackend()
    697772            sage: G.add_edges([],True)
    698773        """
     
    707782    def add_vertex(self, name):
    708783        """
    709784        Add a labelled vertex to self.
    710        
     785
    711786        INPUT:
    712787
    713788        - ``name``: vertex label
    714        
     789
    715790        OUTPUT:
    716791
    717         If ``name``=``None``, the new vertex name is returned. ``None`` otherwise.
     792        If ``name=None``, the new vertex name is returned. ``None`` otherwise.
    718793
    719         DOCTEST:
     794        TESTS::
    720795
    721796            sage: G = sage.graphs.base.graph_backends.NetworkXGraphBackend()
    722797            sage: G.add_vertex(0)
     
    785860    def degree(self, v, directed):
    786861        """
    787862        Returns the total number of vertices incident to v.
    788        
     863
    789864        INPUT:
    790             v:       a vertex label
    791             directed: boolean
     865
     866        - ``v`` -- a vertex label
     867        - ``directed`` -- boolean
     868
    792869        OUTPUT:
     870
    793871            degree of v
    794            
    795         DOCTEST:
     872
     873        TESTS::
     874
    796875            sage: G = sage.graphs.base.graph_backends.NetworkXGraphBackend()
    797876            sage: G.add_vertices(range(3))
    798877            sage: G.degree(1, False)
     
    810889        Deletes the edge (u,v) with label l.
    811890
    812891        INPUT:
    813             u,v:      vertices
    814             l:        edge label
    815             directed: boolean
    816        
    817         DOCTEST:
     892
     893        - ``u,v`` -- vertices
     894        - ``l`` -- edge label
     895        - ``directed`` -- boolean
     896
     897        TESTS::
     898
    818899            sage: G = sage.graphs.base.graph_backends.NetworkXGraphBackend()
    819900            sage: G.del_edge(1,2,'a',True)
    820901        """
     
    840921    def del_vertex(self, v):
    841922        """
    842923        Delete a labelled vertex in self.
    843        
     924
    844925        INPUT:
    845             v: vertex label
    846        
    847         DOCTEST:
     926
     927        - ``v`` -- vertex label
     928
     929        TESTS::
     930
    848931            sage: G = sage.graphs.base.graph_backends.NetworkXGraphBackend()
    849932            sage: G.del_vertex(0)
    850933            Traceback (most recent call last):
     
    861944    def del_vertices(self, vertices):
    862945        """
    863946        Delete labelled vertices in self.
    864        
     947
    865948        INPUT:
    866             vertices: iterator of vertex labels
    867        
    868         DOCTEST:
     949
     950        - ``vertices`` -- iterator of vertex labels
     951
     952        TESTS::
     953
    869954            sage: G = sage.graphs.base.graph_backends.NetworkXGraphBackend()
    870955            sage: G.del_vertices([1,2,3])
    871956            Traceback (most recent call last):
     
    885970        Returns the edge label of (u,v).
    886971
    887972        INPUT:
    888             u,v: vertex labels
    889        
     973
     974        - ``u,v`` -- vertex labels
     975
    890976        OUTPUT:
    891977            label of (u,v)
    892        
    893         DOCTEST:
     978
     979        TESTS::
     980
    894981            sage: G = sage.graphs.base.graph_backends.NetworkXGraphBackend()
    895982            sage: G.get_edge_label(1,2)
    896983            Traceback (most recent call last):
     
    9181005        True if self has an edge (u,v) with label l.
    9191006
    9201007        INPUT:
    921             u,v: vertex labels
    922             l: label
    923        
     1008
     1009        - ``u,v`` -- vertex labels
     1010        - ``l`` -- label
     1011
    9241012        OUTPUT:
    9251013            boolean
    926        
    927         DOCTEST:
     1014
     1015        TESTS::
     1016
    9281017            sage: G = sage.graphs.base.graph_backends.NetworkXGraphBackend()
    9291018            sage: G.has_edge(1,2,'a')
    9301019            False
     
    9481037        True if self has a vertex with label v.
    9491038
    9501039        INPUT:
    951             v: vertex label
    952        
     1040
     1041        - ``v`` -- vertex label
     1042
    9531043        OUTPUT:
    9541044            boolean
    955        
    956         DOCTEST:
     1045
     1046        TESTS::
     1047
    9571048            sage: G = sage.graphs.base.graph_backends.NetworkXGraphBackend()
    9581049            sage: G.has_vertex(0)
    9591050            False
     
    9691060        """
    9701061        Iterate over the edges incident to a sequence of vertices. Edges are
    9711062        assumed to be undirected.
    972        
     1063
    9731064        INPUT:
    974             vertices:     a list of vertex labels
    975             labels:       boolean
    976            
     1065
     1066        - ``vertices`` -- a list of vertex labels
     1067        - ``labels`` -- boolean
     1068
    9771069        OUTPUT:
    978             a generator which yields edges, with or without labels 
     1070            a generator which yields edges, with or without labels
    9791071            depending on the labels parameter.
    980            
    981         DOCTEST:
     1072
     1073        TESTS::
     1074
    9821075            sage: G = sage.graphs.base.graph_backends.NetworkXGraphBackend()
    9831076            sage: G.iterator_edges([],True)
    9841077            <generator object iterator_edges at ...>
     
    10191112    def iterator_in_edges(self, vertices, labels):
    10201113        """
    10211114        Iterate over the incoming edges incident to a sequence of vertices.
    1022        
     1115
    10231116        INPUT:
    1024             vertices:     a list of vertex labels
    1025             labels:       boolean
    1026            
     1117
     1118        - ``vertices`` -- a list of vertex labels
     1119        - ``labels`` -- boolean
     1120
    10271121        OUTPUT:
    1028             a generator which yields edges, with or without labels 
     1122            a generator which yields edges, with or without labels
    10291123            depending on the labels parameter.
    1030            
    1031         DOCTEST:
     1124
     1125        TESTS::
     1126
    10321127            sage: G = sage.graphs.base.graph_backends.NetworkXGraphBackend()
    10331128            sage: i = G.iterator_in_edges([],True)
    10341129        """
     
    10671162    def iterator_out_edges(self, vertices, labels):
    10681163        """
    10691164        Iterate over the outbound edges incident to a sequence of vertices.
    1070        
     1165
    10711166        INPUT:
    1072             vertices:     a list of vertex labels
    1073             labels:       boolean
    1074            
     1167
     1168        - ``vertices`` -- a list of vertex labels
     1169        - ``labels`` -- boolean
     1170
    10751171        OUTPUT:
    1076             a generator which yields edges, with or without labels 
     1172            a generator which yields edges, with or without labels
    10771173            depending on the labels parameter.
    1078            
    1079         DOCTEST:
     1174
     1175        TESTS::
     1176
    10801177            sage: G = sage.graphs.base.graph_backends.NetworkXGraphBackend()
    10811178            sage: i = G.iterator_out_edges([],True)
    10821179        """
     
    10961193    def iterator_nbrs(self, v):
    10971194        """
    10981195        Iterate over the vertices adjacent to v.
    1099        
     1196
    11001197        INPUT:
    1101             v: vertex label
    1102            
     1198
     1199        - ``v`` -- vertex label
     1200
    11031201        OUTPUT:
    11041202            a generator which yields vertex labels
    1105            
    1106         DOCTEST:
     1203
     1204        TESTS::
     1205
    11071206            sage: G = sage.graphs.base.graph_backends.NetworkXGraphBackend()
    11081207            sage: G.add_vertex(0)
    11091208            sage: G.iterator_nbrs(0)
     
    11201219        """
    11211220        Iterate over the vertices u such that the edge (u,v) is in self
    11221221        (that is, predecessors of v).
    1123        
     1222
    11241223        INPUT:
    1125             v: vertex label
    1126            
     1224
     1225        - ``v`` -- vertex label
     1226
    11271227        OUTPUT:
    11281228            a generator which yields vertex labels
    1129            
    1130         DOCTEST:
     1229
     1230        TESTS::
     1231
    11311232            sage: G = sage.graphs.base.graph_backends.NetworkXGraphBackend()
    11321233            sage: G.iterator_in_nbrs(0)
    11331234            Traceback (most recent call last):
     
    11451246        """
    11461247        Iterate over the vertices u such that the edge (v,u) is in self
    11471248        (that is, successors of v).
    1148        
     1249
    11491250        INPUT:
    1150             v: vertex label
    1151            
     1251
     1252        - ``v`` -- vertex label
     1253
    11521254        OUTPUT:
    11531255            a generator which yields vertex labels
    1154            
    1155         DOCTEST:
     1256
     1257        TESTS::
     1258
    11561259            sage: G = sage.graphs.base.graph_backends.NetworkXGraphBackend()
    11571260            sage: G.iterator_out_nbrs(0)
    11581261            Traceback (most recent call last):
     
    11691272    def iterator_verts(self, verts):
    11701273        """
    11711274        Iterate over the vertices v with labels in verts.
    1172        
     1275
    11731276        INPUT:
    1174             vertex: vertex labels
    1175            
     1277
     1278        - ``vertex`` -- vertex labels
     1279
    11761280        OUTPUT:
    11771281            a generator which yields vertices
    1178            
    1179         DOCTEST:
     1282
     1283        TESTS::
     1284
    11801285            sage: G = sage.graphs.base.graph_backends.NetworkXGraphBackend()
    11811286            sage: G.iterator_verts(0)
    11821287            <generator object bunch_iter at ...>
     
    11881293
    11891294        return self._nxg.nbunch_iter(verts)
    11901295
    1191     def loops(self, new):
     1296    def loops(self, new=None):
    11921297        """
    1193         Get/set whether or not self allows loops.       
    1194        
     1298        Get/set whether or not self allows loops.
     1299
    11951300        INPUT:
    1196             new: boolean or None
    1197        
    1198         DOCTEST:
     1301
     1302        - ``new`` -- can be a boolean (in which case it sets the value) or
     1303          ``None``, in which case the current value is returned. It is set to
     1304          ``None`` by default.
     1305
     1306        TESTS::
     1307
    11991308            sage: G = sage.graphs.base.graph_backends.NetworkXGraphBackend()
    12001309            sage: G.loops(True)
    12011310            sage: G.loops(None)
     
    12081317        else:
    12091318            self._loops = False
    12101319
    1211     def multiple_edges(self, new):
     1320    def multiple_edges(self, new=None):
    12121321        """
    12131322        Get/set whether or not self allows multiple edges.
    1214        
     1323
    12151324        INPUT:
    1216             new: boolean or None
    1217        
    1218         DOCTEST:
     1325
     1326        - ``new`` -- can be a boolean (in which case it sets the value) or
     1327          ``None``, in which case the current value is returned. It is set to
     1328          ``None`` by default.
     1329
     1330        TESTS::
     1331
    12191332            sage: G = sage.graphs.base.graph_backends.NetworkXGraphBackend()
    12201333            sage: G.multiple_edges(True)
    12211334            sage: G.multiple_edges(None)
     
    12421355            else:
    12431356                self._nxg = Graph(self._nxg)
    12441357
    1245     def name(self, new):
     1358    def name(self, new=None):
    12461359        """
    12471360        Get/set name of self.
    1248        
     1361
    12491362        INPUT:
    1250             new: string or None
    1251        
    1252         DOCTEST:
     1363
     1364        - ``new`` -- can be a string (in which case it sets the value) or
     1365          ``None``, in which case the current value is returned. It is set to
     1366          ``None`` by default.
     1367
     1368        TESTS::
     1369
    12531370            sage: G = sage.graphs.base.graph_backends.NetworkXGraphBackend()
    12541371            sage: G.name("A NetworkX Graph")
    12551372            sage: G.name(None)
     
    12671384    def num_edges(self, directed):
    12681385        """
    12691386        The number of edges in self
    1270        
     1387
    12711388        INPUT:
    1272             directed: boolean
    1273        
    1274         DOCTEST:
     1389
     1390        - ``directed`` -- boolean
     1391
     1392        TESTS::
     1393
    12751394            sage: G = sage.graphs.base.graph_backends.NetworkXGraphBackend()
    12761395            sage: G.num_edges(True)
    12771396            0
     
    12881407    def num_verts(self):
    12891408        """
    12901409        The number of vertices in self
    1291        
    1292         DOCTEST:
     1410
     1411        TESTS::
     1412
    12931413            sage: G = sage.graphs.base.graph_backends.NetworkXGraphBackend()
    12941414            sage: G.num_verts()
    12951415            0
     
    13041424    def relabel(self, perm, directed):
    13051425        """
    13061426        Relabel the vertices of self by a permutation.
     1427
    13071428        INPUT:
    1308             perm:     permutation
    1309             directed: boolean
    1310        
    1311         DOCTEST:
     1429
     1430        - ``perm`` -- permutation
     1431        - ``directed`` -- boolean
     1432
     1433        TESTS::
     1434
    13121435            sage: G = sage.graphs.base.graph_backends.NetworkXGraphBackend()
    13131436            sage: G.relabel([],False)
    13141437        """
     
    13561479    def set_edge_label(self, u, v, l, directed):
    13571480        """
    13581481        Label the edge (u,v) by l.
    1359        
     1482
    13601483        INPUT:
    1361             u,v:      vertices
    1362             l:        edge label
    1363             directed: boolean
    1364        
    1365         DOCTEST:
     1484
     1485        - ``u,v`` -- vertices
     1486        - ``l`` -- edge label
     1487        - ``directed`` -- boolean
     1488
     1489        TESTS::
     1490
    13661491            sage: G = sage.graphs.base.graph_backends.NetworkXGraphBackend()
    13671492            sage: G.set_edge_label(1,2,'a',True)
    13681493        """