Ticket #14000: trac_14000.patch

File trac_14000.patch, 7.1 KB (added by ncohen, 7 years ago)
  • sage/graphs/generic_graph.py

    # HG changeset patch
    # User Nathann Cohen <nathann.cohen@gmail.com>
    # Date 1358962778 -3600
    # Node ID ffa112def1286bbce6d47eb6fb0b8a8d7f20c3e7
    # Parent  46c148d364a31d689e8f2ada71b44cdf611d2651
    Speedup in GenericGraph.relabel() and two new options
    
    diff --git a/sage/graphs/generic_graph.py b/sage/graphs/generic_graph.py
    a b  
    1555015550        # could pass format='all' to get QQbar eigenvalues and eigenspaces
    1555115551        # which would be a change in default behavior
    1555215552        return M.right_eigenspaces(format='galois', algebraic_multiplicity=False)
    15553    
     15553
    1555415554    ### Automorphism and isomorphism
    1555515555
    15556     def relabel(self, perm=None, inplace=True, return_map=False):
     15556    def relabel(self, perm=None, inplace=True, return_map=False, check_input = True, complete_partial_function = True):
    1555715557        r"""
    1555815558        Relabels the vertices of ``self``
    1555915559
     
    1556615566
    1556715567         - ``return_map`` -- a boolean (default: ``False``)
    1556815568
     15569         - ``check_input`` (boolean) -- whether to test input for
     15570           correctness. *This can potentially be very time-consuming !*.
     15571
     15572         - ``complete_partial_function`` (boolean) -- whether to automatically
     15573           complete the permutation if some elements of the graph are not
     15574           associated with any new name. In this case, those elements are not
     15575           relabeled *This can potentially be very time-consuming !*.
     15576
    1556915577        If ``perm`` is a function ``f``, then each vertex ``v`` is
    1557015578        relabeled to ``f(v)``.
    1557115579
     
    1559315601        If ``return_map`` is ``True`` a dictionary representing the
    1559415602        relabelling map is returned (incompatible with ``inplace==False``).
    1559515603
    15596 
    15597         EXAMPLES::
    15598        
     15604        EXAMPLES::
     15605
    1559915606            sage: G = graphs.PathGraph(3)
    1560015607            sage: G.am()
    1560115608            [0 1 0]
    1560215609            [1 0 1]
    1560315610            [0 1 0]
    15604        
     15611
    1560515612        Relabeling using a dictionary::
    15606        
     15613
    1560715614            sage: G.relabel({1:2,2:1}, inplace=False).am()
    1560815615            [0 0 1]
    1560915616            [0 0 1]
    1561015617            [1 1 0]
    15611        
     15618
    1561215619        Relabeling using a list::
    15613        
     15620
    1561415621            sage: G.relabel([0,2,1], inplace=False).am()
    1561515622            [0 0 1]
    1561615623            [0 0 1]
    1561715624            [1 1 0]
    1561815625
    1561915626        Relabeling using a tuple::
    15620        
     15627
    1562115628            sage: G.relabel((0,2,1), inplace=False).am()
    1562215629            [0 0 1]
    1562315630            [0 0 1]
    1562415631            [1 1 0]
    15625        
     15632
    1562615633        Relabeling using a Sage permutation::
    15627        
     15634
    1562815635            sage: from sage.groups.perm_gps.permgroup_named import SymmetricGroup
    1562915636            sage: S = SymmetricGroup(3)
    1563015637            sage: gamma = S('(1,2)')
     
    1565315660            NotImplementedError: Non injective relabeling
    1565415661
    1565515662        Relabeling to simpler labels::
    15656        
     15663
    1565715664            sage: G = graphs.CubeGraph(3)
    1565815665            sage: G.vertices()
    1565915666            ['000', '001', '010', '011', '100', '101', '110', '111']
    1566015667            sage: G.relabel()
    1566115668            sage: G.vertices()
    1566215669            [0, 1, 2, 3, 4, 5, 6, 7]
    15663        
     15670
    1566415671        Recovering the relabeling with ``return_map``::
    1566515672
    1566615673            sage: G = graphs.CubeGraph(3)
     
    1567515682            {0: 10, 1: 11, 2: 12}
    1567615683
    1567715684        TESTS::
    15678        
     15685
    1567915686            sage: P = Graph(graphs.PetersenGraph())
    1568015687            sage: P.delete_edge([0,1])
    1568115688            sage: P.add_edge((4,5))
    1568215689            sage: P.add_edge((2,6))
    1568315690            sage: P.delete_vertices([0,1])
    1568415691            sage: P.relabel()
    15685        
     15692
    1568615693        The attributes are properly updated too
    15687        
    15688         ::
    15689        
     15694
     15695        ::
     15696
    1569015697            sage: G = graphs.PathGraph(5)
    1569115698            sage: G.set_vertices({0: 'before', 1: 'delete', 2: 'after'})
    1569215699            sage: G.set_boundary([1,2,3])
     
    1571115718        """
    1571215719        from sage.groups.perm_gps.permgroup_element import PermutationGroupElement
    1571315720
     15721        if not inplace:
     15722            from copy import copy
     15723            G = copy(self)
     15724            perm2 = G.relabel(perm,
     15725                              return_map= return_map,
     15726                              check_input = check_input,
     15727                              complete_partial_function = complete_partial_function)
     15728
     15729            if return_map:
     15730                return G, perm2
     15731            else:
     15732                return G
     15733
    1571415734        # If perm is not a dictionary, we build one !
    1571515735
    1571615736        if perm is None:
     
    1572015740                perm[v] = i
    1572115741                i += 1
    1572215742
     15743            complete_partial_function = False
     15744            check_input = False
     15745
    1572315746        elif isinstance(perm, dict):
    1572415747
    1572515748            # If all vertices do not have a new label, the code will touch the
     
    1574215765
    1574315766        elif callable(perm):
    1574415767            perm = dict( [ i, perm(i) ] for i in self.vertices() )
     15768            complete_partial_function = False
    1574515769
    1574615770        else:
    1574715771            raise TypeError("Type of perm is not supported for relabeling.")
    1574815772
    15749         if not inplace:
    15750             from copy import copy
    15751             G = copy(self)
    15752             G.relabel(perm)
    15753             if return_map:
    15754                 return G, perm
    15755             return G
    15756 
    15757         keys = perm.keys()
    15758         verts = self.vertices()
    15759         if len(set(perm.values())) < len(keys):
    15760             raise NotImplementedError, "Non injective relabeling"
    15761         for v in verts:
    15762             if v not in keys:
    15763                 perm[v] = v
    15764         for v in perm.iterkeys():
    15765             if v in verts:
    15766                 try:
    15767                     hash(perm[v])
    15768                 except TypeError:
    15769                     raise ValueError("perm dictionary must be of the format {a:a1, b:b1, ...} where a,b,... are vertices and a1,b1,... are hashable")
     15773        # Whether to complete the relabeling function if some vertices do not
     15774        # appear in the permutation.
     15775        if complete_partial_function:
     15776            for v in self:
     15777                if v not in perm:
     15778                    perm[v] = v
     15779
     15780        # Whether to check input
     15781        if check_input:
     15782            if len(set(perm.values())) < len(perm):
     15783                raise NotImplementedError, "Non injective relabeling"
     15784
     15785            for v in perm.iterkeys():
     15786                if v in self:
     15787                    try:
     15788                        hash(perm[v])
     15789                    except TypeError:
     15790                        raise ValueError("perm dictionary must be of the format {a:a1, b:b1, ...} where a,b,... are vertices and a1,b1,... are hashable")
     15791
    1577015792        self._backend.relabel(perm, self._directed)
    1577115793
    1577215794        attributes_to_update = ('_pos', '_assoc', '_embedding')
     
    1578715809        """
    1578815810        Returns the number of edges from vertex to an edge in cell. In the
    1578915811        case of a digraph, returns a tuple (in_degree, out_degree).
    15790        
    15791         EXAMPLES::
    15792        
     15812
     15813        EXAMPLES::
     15814
    1579315815            sage: G = graphs.CubeGraph(3)
    1579415816            sage: cell = G.vertices()[:3]
    1579515817            sage: G.degree_to_cell('011', cell)
    1579615818            2
    1579715819            sage: G.degree_to_cell('111', cell)
    1579815820            0
    15799        
    15800         ::
    15801        
     15821
     15822        ::
     15823
    1580215824            sage: D = DiGraph({ 0:[1,2,3], 1:[3,4], 3:[4,5]})
    1580315825            sage: cell = [0,1,2]
    1580415826            sage: D.degree_to_cell(5, cell)