Example #1
0
    def __init__(
        self,
        molecule1,
        molecule2,
        prematched=[],
        vertex_equality=None,
        edge_equality=None,
        maxsol=0,
    ):

        if vertex_equality is None:
            import operator
            vertex_equality = operator.eq

        if edge_equality is None:
            import operator
            edge_equality = operator.eq

        self.molecule1 = molecule1.atom_for
        self.molecule2 = molecule2.atom_for
        self.best = [[]]
        self.largest = 0

        from graph import maximum_clique

        self.compat_graph = maximum_clique.compatibility_graph(
            first=molecule1.graph,
            second=molecule2.graph,
            vertex_equality=vertex_equality,
            edge_equality=edge_equality)

        self.prematched = prematched

        if self.prematched:
            desc_for_1 = molecule1.descriptor_for
            desc_for_2 = molecule2.descriptor_for
            pairs = set([(desc_for_1[l], desc_for_2[r])
                         for (l, r) in self.prematched])
            vertices = [
                v for v in self.compat_graph.vertices()
                if self.compat_graph.vertex_label(vertex=v) in pairs
            ]

            assert len(vertices) == len(self.prematched)
            neighbours = set(
                self.compat_graph.adjacent_vertices(vertex=vertices[0]))

            for v in vertices[1:]:
                neighbours.intersection_update(
                    self.compat_graph.adjacent_vertices(vertex=v))

            self.compat_graph = maximum_clique.selected_subgraph(
                graph=self.compat_graph,
                vertices=neighbours,
            )

        self.result = maximum_clique.greedy(graph=self.compat_graph,
                                            maxsol=maxsol)
Example #2
0
  def __init__(
    self,
    molecule1,
    molecule2,
    prematched = [],
    vertex_equality = None,
    edge_equality = None,
    maxsol = 0,
    ):

    if vertex_equality is None:
      import operator
      vertex_equality = operator.eq

    if edge_equality is None:
      import operator
      edge_equality = operator.eq

    self.molecule1 = molecule1.atom_for
    self.molecule2 = molecule2.atom_for
    self.best = [ [] ]
    self.largest = 0

    from graph import maximum_clique

    self.compat_graph = maximum_clique.compatibility_graph(
      first = molecule1.graph,
      second = molecule2.graph,
      vertex_equality = vertex_equality,
      edge_equality = edge_equality
      )

    self.prematched = prematched

    if self.prematched:
      desc_for_1 = molecule1.descriptor_for
      desc_for_2 = molecule2.descriptor_for
      pairs = set(
        [ ( desc_for_1[ l ], desc_for_2[ r ] ) for ( l, r ) in self.prematched ]
        )
      vertices = [ v for v in self.compat_graph.vertices()
        if self.compat_graph.vertex_label( vertex = v ) in pairs ]

      assert len( vertices ) == len( self.prematched )
      neighbours = set( self.compat_graph.adjacent_vertices( vertex = vertices[0] ) )

      for v in vertices[1:]:
        neighbours.intersection_update( self.compat_graph.adjacent_vertices( vertex = v ) )

      self.compat_graph = maximum_clique.selected_subgraph(
        graph = self.compat_graph,
        vertices = neighbours,
        )

    self.result = maximum_clique.greedy( graph = self.compat_graph, maxsol = maxsol )
  def manipulation(self, left, right):

    u1 = left.add_vertex( label = "O" )
    u2 = left.add_vertex( label = "C" )
    u3 = left.add_vertex( label = "C" )
    u4 = left.add_vertex( label = "N" )
    u5 = left.add_vertex( label = "O" )

    left.add_edge( vertex1 = u1, vertex2 = u2, weight = 1 )
    left.add_edge( vertex1 = u2, vertex2 = u3, weight = 1 )
    left.add_edge( vertex1 = u3, vertex2 = u4, weight = 1 )
    left.add_edge( vertex1 = u3, vertex2 = u5, weight = 2 )

    v1 = right.add_vertex( label = "O" )
    v2 = right.add_vertex( label = "C" )
    v3 = right.add_vertex( label = "C" )
    v4 = right.add_vertex( label = "N" )
    v5 = right.add_vertex( label = "O" )

    right.add_edge( vertex1 = v1, vertex2 = v2, weight = 2 )
    right.add_edge( vertex1 = v2, vertex2 = v3, weight = 1 )
    right.add_edge( vertex1 = v3, vertex2 = v4, weight = 1 )
    right.add_edge( vertex1 = v3, vertex2 = v5, weight = 2 )

    result = maximum_clique.compatibility_graph(
      first = left,
      second = right,
      )

    vertices = list( result.vertices() )
    edges = list( result.edges() )

    self.assertEqual( len( vertices ), 9 )
    self.assertEqual( len( edges ), 16 )

    self.assertEqual(
      set( result.vertex_label( vertex = v ) for v in result.vertices() ),
      set(
        [
          ( u1, v1 ), ( u1, v5 ), ( u5, v1 ), ( u5, v5 ),
          ( u2, v2 ), ( u2, v3 ), ( u3, v2 ), ( u3, v3 ),
          ( u4, v4 ),
          ]
        )
      )
    edges_between = set(
      [
        frozenset(
          [
            result.vertex_label( vertex = result.source( edge = e ) ),
            result.vertex_label( vertex = result.target( edge = e ) ),
            ]
          )
        for e in result.edges()
        ]
      )
    self.assertEqual(
      edges_between,
      set(
        [
          frozenset( [ ( u1, v1 ), ( u3, v3 ) ] ),
          frozenset( [ ( u1, v1 ), ( u4, v4 ) ] ),
          frozenset( [ ( u1, v1 ), ( u5, v5 ) ] ),

          frozenset( [ ( u1, v5 ), ( u3, v2 ) ] ),
          frozenset( [ ( u1, v5 ), ( u4, v4 ) ] ),
          frozenset( [ ( u1, v5 ), ( u5, v1 ) ] ),

          frozenset( [ ( u2, v2 ), ( u3, v3 ) ] ),
          frozenset( [ ( u2, v2 ), ( u4, v4 ) ] ),
          frozenset( [ ( u2, v2 ), ( u5, v5 ) ] ),

          frozenset( [ ( u2, v3 ), ( u3, v2 ) ] ),
          frozenset( [ ( u2, v3 ), ( u5, v1 ) ] ),

          frozenset( [ ( u3, v2 ), ( u5, v1 ) ] ),

          frozenset( [ ( u3, v3 ), ( u4, v4 ) ] ),
          frozenset( [ ( u3, v3 ), ( u5, v5 ) ] ),

          frozenset( [ ( u4, v4 ), ( u5, v1 ) ] ),
          frozenset( [ ( u4, v4 ), ( u5, v5 ) ] ),
          ]
        )
      )
Example #4
0
    def manipulation(self, left, right):

        u1 = left.add_vertex(label="O")
        u2 = left.add_vertex(label="C")
        u3 = left.add_vertex(label="C")
        u4 = left.add_vertex(label="N")
        u5 = left.add_vertex(label="O")

        left.add_edge(vertex1=u1, vertex2=u2, weight=1)
        left.add_edge(vertex1=u2, vertex2=u3, weight=1)
        left.add_edge(vertex1=u3, vertex2=u4, weight=1)
        left.add_edge(vertex1=u3, vertex2=u5, weight=2)

        v1 = right.add_vertex(label="O")
        v2 = right.add_vertex(label="C")
        v3 = right.add_vertex(label="C")
        v4 = right.add_vertex(label="N")
        v5 = right.add_vertex(label="O")

        right.add_edge(vertex1=v1, vertex2=v2, weight=2)
        right.add_edge(vertex1=v2, vertex2=v3, weight=1)
        right.add_edge(vertex1=v3, vertex2=v4, weight=1)
        right.add_edge(vertex1=v3, vertex2=v5, weight=2)

        result = maximum_clique.compatibility_graph(
            first=left,
            second=right,
        )

        vertices = list(result.vertices())
        edges = list(result.edges())

        self.assertEqual(len(vertices), 9)
        self.assertEqual(len(edges), 16)

        self.assertEqual(
            set(result.vertex_label(vertex=v) for v in result.vertices()),
            set([
                (u1, v1),
                (u1, v5),
                (u5, v1),
                (u5, v5),
                (u2, v2),
                (u2, v3),
                (u3, v2),
                (u3, v3),
                (u4, v4),
            ]))
        edges_between = set([
            frozenset([
                result.vertex_label(vertex=result.source(edge=e)),
                result.vertex_label(vertex=result.target(edge=e)),
            ]) for e in result.edges()
        ])
        self.assertEqual(
            edges_between,
            set([
                frozenset([(u1, v1), (u3, v3)]),
                frozenset([(u1, v1), (u4, v4)]),
                frozenset([(u1, v1), (u5, v5)]),
                frozenset([(u1, v5), (u3, v2)]),
                frozenset([(u1, v5), (u4, v4)]),
                frozenset([(u1, v5), (u5, v1)]),
                frozenset([(u2, v2), (u3, v3)]),
                frozenset([(u2, v2), (u4, v4)]),
                frozenset([(u2, v2), (u5, v5)]),
                frozenset([(u2, v3), (u3, v2)]),
                frozenset([(u2, v3), (u5, v1)]),
                frozenset([(u3, v2), (u5, v1)]),
                frozenset([(u3, v3), (u4, v4)]),
                frozenset([(u3, v3), (u5, v5)]),
                frozenset([(u4, v4), (u5, v1)]),
                frozenset([(u4, v4), (u5, v5)]),
            ]))