← Back to branch summary

~ubuntu-branches/ubuntu/vivid/python-igraph/vivid

« back to all changes in this revision

Viewing changes to igraph/test/cliques.py

  • Committer: Package Import Robot
  • Author(s): TANIGUCHI Takaki
  • Date: 2012-03-17 17:23:55 UTC
  • Revision ID: package-import@ubuntu.com-20120317172355-e9iki37igmxnlq38
Tags: upstream-0.5.4
Import upstream version 0.5.4

Show diffs side-by-side

added added

removed removed

Lines of Context:
igraph/test/cliques.py
 
1
import unittest
 
2
from igraph import *
 
3
 
 
4
class CliqueTests(unittest.TestCase):
 
5
    def setUp(self):
 
6
        self.g=Graph.Full(6)
 
7
        self.g.delete_edges([(0, 1), (0, 2), (3, 5)])
 
8
 
 
9
    def testCliques(self):
 
10
        tests = {(4, -1): [[1, 2, 3, 4], [1, 2, 4, 5]],
 
11
                 (2, 2): [[0, 3], [0, 4], [0, 5],
 
12
                          [1, 2], [1, 3], [1, 4], [1, 5],
 
13
                          [2, 3], [2, 4], [2, 5], [3, 4], [4, 5]],
 
14
                 (-1, -1): [[0], [1], [2], [3], [4], [5],
 
15
                            [0, 3], [0, 4], [0, 5],
 
16
                            [1, 2], [1, 3], [1, 4], [1, 5],
 
17
                            [2, 3], [2, 4], [2, 5], [3, 4], [4, 5],
 
18
                            [0, 3, 4], [0, 4, 5],
 
19
                            [1, 2, 3], [1, 2, 4], [1, 2, 5],
 
20
                            [1, 3, 4], [1, 4, 5], [2, 3, 4], [2, 4, 5],
 
21
                            [1, 2, 3, 4], [1, 2, 4, 5]]}
 
22
        for (lo, hi), exp in tests.iteritems():
 
23
            self.assertEqual(map(tuple, exp), self.g.cliques(lo, hi))
 
24
 
 
25
    def testLargestCliques(self):
 
26
        self.assertEqual(self.g.largest_cliques(),
 
27
                         [(1, 2, 3, 4), (1, 2, 4, 5)])
 
28
 
 
29
    def testMaximalCliques(self):
 
30
        self.assertEqual(self.g.maximal_cliques(),
 
31
                         [(0, 3, 4), (0, 4, 5),
 
32
                          (1, 2, 3, 4), (1, 2, 4, 5)])
 
33
 
 
34
    def testCliqueNumber(self):
 
35
        self.assertEqual(self.g.clique_number(), 4)
 
36
        self.assertEqual(self.g.omega(), 4)
 
37
 
 
38
class IndependentVertexSetTests(unittest.TestCase):
 
39
    def setUp(self):
 
40
        self.g1=Graph.Tree(5, 2, TREE_UNDIRECTED)
 
41
        self.g2=Graph.Tree(10, 2, TREE_UNDIRECTED)
 
42
 
 
43
    def testIndependentVertexSets(self):
 
44
        tests = {(4, -1): [],
 
45
                 (2, 2): [(0, 3), (0, 4), (1, 2), (2, 3), (2, 4), (3, 4)],
 
46
                 (-1, -1): [(0,), (1,), (2,), (3,), (4,),
 
47
                            (0, 3), (0, 4), (1, 2), (2, 3), (2, 4),
 
48
                            (3, 4), (0, 3, 4), (2, 3, 4)]}
 
49
        for (lo, hi), exp in tests.iteritems():
 
50
            self.assertEqual(exp, self.g1.independent_vertex_sets(lo, hi))
 
51
 
 
52
    def testLargestIndependentVertexSets(self):
 
53
        self.assertEqual(self.g1.largest_independent_vertex_sets(),
 
54
                         [(0, 3, 4), (2, 3, 4)])
 
55
 
 
56
    def testMaximalIndependentVertexSets(self):
 
57
        self.assertEqual(self.g2.maximal_independent_vertex_sets(),
 
58
                         [(0, 3, 4, 5, 6), (0, 3, 5, 6, 9),
 
59
                          (0, 4, 5, 6, 7, 8), (0, 5, 6, 7, 8, 9),
 
60
                          (1, 2, 7, 8, 9), (1, 5, 6, 7, 8, 9),
 
61
                          (2, 3, 4), (2, 3, 9), (2, 4, 7, 8)])
 
62
 
 
63
    def testIndependenceNumber(self):
 
64
        self.assertEqual(self.g2.independence_number(), 6)
 
65
        self.assertEqual(self.g2.alpha(), 6)
 
66
 
 
67
 
 
68
class MotifTests(unittest.TestCase):
 
69
    def setUp(self):
 
70
        self.g = Graph.Erdos_Renyi(100, 0.2, directed=True)
 
71
 
 
72
    def testDyads(self):
 
73
        """
 
74
        @note: this test is not exhaustive, it only checks whether the
 
75
          L{DyadCensus} objects "understand" attribute and item accessors
 
76
        """
 
77
        dc = self.g.dyad_census()
 
78
        accessors = ["mut", "mutual", "asym", "asymm", "asymmetric", "null"]
 
79
        for a in accessors:
 
80
            self.failUnless(isinstance(getattr(dc, a), int))
 
81
            self.failUnless(isinstance(dc[a], int))
 
82
        self.failUnless(isinstance(list(dc), list))
 
83
        self.failUnless(isinstance(tuple(dc), tuple))
 
84
        self.failUnless(len(list(dc)) == 3)
 
85
        self.failUnless(len(tuple(dc)) == 3)
 
86
 
 
87
    def testTriads(self):
 
88
        """
 
89
        @note: this test is not exhaustive, it only checks whether the
 
90
          L{TriadCensus} objects "understand" attribute and item accessors
 
91
        """
 
92
        tc = self.g.triad_census()
 
93
        accessors = ["003", "012", "021d", "030C"]
 
94
        for a in accessors:
 
95
            self.failUnless(isinstance(getattr(tc, "t"+a), int))
 
96
            self.failUnless(isinstance(tc[a], int))
 
97
        self.failUnless(isinstance(list(tc), list))
 
98
        self.failUnless(isinstance(tuple(tc), tuple))
 
99
        self.failUnless(len(list(tc)) == 16)
 
100
        self.failUnless(len(tuple(tc)) == 16)
 
101
 
 
102
def suite():
 
103
    clique_suite = unittest.makeSuite(CliqueTests)
 
104
    indvset_suite = unittest.makeSuite(IndependentVertexSetTests)
 
105
    motif_suite = unittest.makeSuite(MotifTests)
 
106
    return unittest.TestSuite([clique_suite, indvset_suite, motif_suite])
 
107
 
 
108
def test():
 
109
    runner = unittest.TextTestRunner()
 
110
    runner.run(suite())
 
111
    
 
112
if __name__ == "__main__":
 
113
    test()
 
114