def setUp(self):
        self.numVertices = 10
        self.numFeatures = 3
        self.maxEdgeTypes = 3
        self.vList = VertexList(self.numVertices, self.numFeatures)

        self.sMultiGraph = SparseMultiGraph(self.vList, self.maxEdgeTypes)
    def testGetAllEdges(self):
        sMultiGraph = SparseMultiGraph(self.vList, self.maxEdgeTypes, False)

        self.assertEquals(sMultiGraph.getAllEdges().shape[0], 0)
        self.assertEquals(sMultiGraph.getAllEdges().shape[1], 3)

        sMultiGraph.addEdge(0, 1, 0)
        sMultiGraph.addEdge(0, 1, 1)
        sMultiGraph.addEdge(0, 2, 0)

        allEdges = numpy.array([[0, 1, 0], [0, 2, 0], [0, 1, 1]])

        self.assertTrue((sMultiGraph.getAllEdges() == allEdges).all())
    def testGetNeighboursByEdgeType(self):
        sMultiGraph = SparseMultiGraph(self.vList, self.maxEdgeTypes, True)

        sMultiGraph.addEdge(0, 1, 2)
        sMultiGraph.addEdge(0, 3, 1)
        sMultiGraph.addEdge(2, 1, 0)
        sMultiGraph.addEdge(1, 4, 0)
        sMultiGraph.addEdge(9, 4, 0)
        sMultiGraph.addEdge(9, 4, 1)

        self.assertEquals(sMultiGraph.getNeighboursByEdgeType(0, 1), [3])
        self.assertEquals(sMultiGraph.getNeighboursByEdgeType(0, 2), [1])
        self.assertEquals(sMultiGraph.getNeighboursByEdgeType(0, 0), [])
        self.assertEquals(set(sMultiGraph.getNeighboursByEdgeType(4, 0)),
                          set([1, 9]))
    def testGetNeighbours(self):
        sMultiGraph = SparseMultiGraph(self.vList, self.maxEdgeTypes, True)

        sMultiGraph.addEdge(0, 1, 2)
        sMultiGraph.addEdge(0, 3, 1)
        sMultiGraph.addEdge(2, 1, 0)
        sMultiGraph.addEdge(1, 4, 0)
        sMultiGraph.addEdge(9, 4, 0)
        sMultiGraph.addEdge(9, 4, 1)

        self.assertEquals(set(sMultiGraph.neighbours(0)), set([1, 3]))
        self.assertEquals(set(sMultiGraph.neighbours(1)), set([0, 2, 4]))
        self.assertEquals(sMultiGraph.neighbours(3), [0])
        self.assertEquals(set(sMultiGraph.neighbours(4)), set([9, 1]))
        self.assertEquals(sMultiGraph.neighbours(9), [4])
    def readGraph(self,
                  vertexFileName,
                  edgeFileNames,
                  undirected=True,
                  delimiter=None):
        """
        Read a MultiGraph from at least 2 files: one is the information about
        vertices and the other(s) are lists of edges. For the list of vertices
        the first column must be the ID of the vertex. 
        """

        X = numpy.loadtxt(vertexFileName,
                          skiprows=1,
                          converters=self.converters,
                          usecols=self.vertexIndices,
                          delimiter=delimiter)

        numVertices = X.shape[0]
        numFeatures = X.shape[1] - 1

        vertexIds = X[:, 0]
        vertexIdsDict = {}

        for i in range(0, numVertices):
            vertexIdsDict[vertexIds[i]] = i

        if self.nanProcessor != None:
            X[:, 1:numFeatures + 1] = self.nanProcessor(X[:,
                                                          1:numFeatures + 1])

        vertexList = VertexList(numVertices, numFeatures)
        vertexList.setVertices(X[:, 1:numFeatures + 1])

        maxEdgeTypes = len(edgeFileNames)
        sparseMultiGraph = SparseMultiGraph(vertexList, maxEdgeTypes,
                                            undirected)

        for i in range(0, maxEdgeTypes):
            self.__readEdgeFile(vertexIdsDict, edgeFileNames[i],
                                sparseMultiGraph, i)

        logging.info("MultiGraph read with " +
                     str(sparseMultiGraph.getNumVertices()) +
                     " vertices and " + str(sparseMultiGraph.getNumEdges()) +
                     " edges")

        return sparseMultiGraph
    def testGetNumEdges(self):
        sMultiGraph = SparseMultiGraph(self.vList, self.maxEdgeTypes)

        self.assertEquals(sMultiGraph.getNumEdges(), 0)

        for i in range(self.maxEdgeTypes):
            self.assertEquals(sMultiGraph.getNumEdges(i), 0)

        sMultiGraph.addEdge(0, 1, 2)
        sMultiGraph.addEdge(0, 1, 1)

        self.assertEquals(sMultiGraph.getNumEdges(), 2)
        self.assertEquals(sMultiGraph.getNumEdges(1), 1)
        self.assertEquals(sMultiGraph.getNumEdges(2), 1)

        sMultiGraph.addEdge(0, 1, 0)
        sMultiGraph.addEdge(0, 2, 0)
        self.assertEquals(sMultiGraph.getNumEdges(), 4)
        self.assertEquals(sMultiGraph.getNumEdges(0), 2)
    def testInit(self):
        sMultiGraph = SparseMultiGraph(self.vList, self.maxEdgeTypes)
        sMultiGraph = SparseMultiGraph(self.vList, self.maxEdgeTypes, False)

        self.assertRaises(ValueError, SparseMultiGraph, self.vList, 0)
        self.assertRaises(ValueError, SparseMultiGraph, self.vList, -1)
    def testIsUndirected(self):
        self.assertEquals(self.sMultiGraph.isUndirected(), True)

        sMultiGraph = SparseMultiGraph(self.vList, self.maxEdgeTypes, False)

        self.assertEquals(sMultiGraph.isUndirected(), False)