I solved this once by making a NoDupesGraph where you could add edges with just the names of vertices .

class NoDupesGraph(Graph):
    '''Add nodes without worrying if it is a duplicate.
       Add edges without worrying if nodes exist   '''

    def __init__(self,*args,**kwargs):
        self._nodes = {}

    def add_nodupe_vertex(self,label,*args,**kwargs):
      '''Return a node with label. Create node if label is new'''
          n = self._nodes[label]
      except KeyError:
          n = self.add_vertex()
      return n

    def add_nodupe_edge(self, n1_label, n2_label,directed=False):
      Get or create edges using get_or_create_node
      #there may be two if graph is directed but edge isn't
      edges = []

      n1 = self.add_nodupe_vertex(n1_label)
      n2 = self.add_nodupe_vertex(n2_label)
      if self.is_directed() and not directed:
      return edges

    def flush_empty_nodes(self):
        '''not implemented'''

    def condense_edges(self):
        '''if a node connects to only two edges, combine those
        edges and delete the node.
        not implemented

This could be easily modified to suit your need.

On Mon, Apr 27, 2015 at 3:23 PM, Krister <thekswenson@gmail.com> wrote:
Thanks for the quick response Thiago!

In this code all the edges and vertices are created by graph-tool and the result is something much faster...
   is this the best I can do?

It's somewhat annoying to have to keep track of the vertices that will be created like this:

def graph_tool_create_all_at_once():
  """ Create a graph_tool graph given a list of pairs. """
  G = Graph(directed=False)
  objectTOi = {}
  vertexpairs = []
  counter = 0
  for o1,o2 in get_pairs_of_ints():
    if(o1 in objectTOi):
      u = objectTOi[o1]
      u = counter
      counter += 1
      objectTOi[o1] = u
    if(o2 in objectTOi):
      v = objectTOi[o2]
      v = counter
      counter += 1
      objectTOi[o2] = v



On 27 April 2015 at 16:39, Tiago de Paula Peixoto <tiago@skewed.de> wrote:
On 27.04.2015 14:29, thekswenson wrote:
> I've been using networkx to simply create a graph and check the connected
> components.  The bottleneck of the operation is the creation of the edges.
> I've heard that graph-tool is very efficient so I've replaces the code with
> a graph-tool graph.
> To my surprise, the creation of a graph-tool graph is MUCH slower than that
> of a networkx graph.
> Am I doing something wrong?

How does the performance change if you create the necessary edges

In graph-tool things are faster than in networkx when they are delegated
to C++, otherwise this should be comparable in speed. In the case of
adding many edges, this is done by using the Graph.add_edge_list()
function, which runs in C++ internally. In your example, this should
provide a massive speed-up.


Tiago de Paula Peixoto <tiago@skewed.de>

graph-tool mailing list

graph-tool mailing list