def testSimulateCascades(self): 
        #Test submodularity 
        n = 20 
        p = 0.1
        graph = igraph.Graph.Erdos_Renyi(n, p)
        
        numRuns = 1
        influences = numpy.zeros(n)
        
        activeVertexInds = set([0])  
        lastInfluence = MaxInfluence.simulateCascades(graph, activeVertexInds, numRuns)
        
        for i in range(n): 
            activeVertexInds = set([0, i])  
            influences[i] = MaxInfluence.simulateCascades(graph, activeVertexInds, numRuns)

        marginalGains = (influences - lastInfluence)
        
        activeVertexInds = set([0, 1]) 
        lastInfluence = MaxInfluence.simulateCascades(graph, activeVertexInds, numRuns)
        
        for i in range(n): 
            activeVertexInds = set([0, 1, i])  
            influences[i] = MaxInfluence.simulateCascades(graph, activeVertexInds, numRuns)
            

        marginalGains2 = (influences - lastInfluence)
    def testSimulateAllCascades(self): 
        n = 100 
        p = 0.01
        graph = igraph.Graph.Erdos_Renyi(n, p)
        
        numRuns = 10000 
                
        influences = numpy.zeros(n)
        for i in range(numRuns): 
            influences += MaxInfluence.simulateAllCascades(graph, [], p=0.2)
        influences /= numRuns         
        
        #Now compute influence via the other way 
        influences2 = numpy.zeros(n)
        for i in range(n): 
            influences2[i] = MaxInfluence.simulateCascades(graph, set([i]), numRuns, p=0.2)
        nptst.assert_array_almost_equal(influences, influences2, 1)
        
        #Now test with p=1
        influences = MaxInfluence.simulateAllCascades(graph, [], p=1.0)
        
        influences2 = numpy.zeros(n)
        for i in range(n): 
            influences2[i] = MaxInfluence.simulateCascades(graph, set([i]), 1, p=1.0)
            
        nptst.assert_array_almost_equal(influences, influences2)
        
        #Test where we have an active vertex
        influences = MaxInfluence.simulateAllCascades(graph, [0, 10, 20], p=1.0)
        
        influences2 = numpy.zeros(n)
        for i in range(n): 
            influences2[i] = MaxInfluence.simulateCascades(graph, set([0, 10, 20, i]), 1, p=1.0)
            
        nptst.assert_array_almost_equal(influences, influences2)
        
        #Now test with p=0
        influences = MaxInfluence.simulateAllCascades(graph, [], p=0.0)
        
        influences2 = numpy.zeros(n)
        for i in range(n): 
            influences2[i] = MaxInfluence.simulateCascades(graph, set([i]), 1, p=0.0)
            
        nptst.assert_array_almost_equal(influences, influences2)
        
        #See if we get more accurate results on a small graph 
        numRuns = 100000 
        graph = igraph.Graph()        
        graph.add_vertices(8)
        graph.add_edges([(0,1), (0,2), (1, 3), (2,3), (2,4), (5,6), (6,7), (5, 4)])
        
        influences = numpy.zeros(graph.vcount())
        for i in range(numRuns): 
            influences += MaxInfluence.simulateAllCascades(graph, [], p=0.2)
        influences /= numRuns  
        
        influences2 = numpy.zeros(graph.vcount())
        for i in range(graph.vcount()): 
            influences2[i] = MaxInfluence.simulateCascades(graph, set([i]), numRuns, p=0.2)

             
        nptst.assert_array_almost_equal(influences, influences2, 2)
        
        #Test with some initial vertices 
        influences = numpy.zeros(graph.vcount())
        for i in range(numRuns): 
            influences += MaxInfluence.simulateAllCascades(graph, [0], p=0.2)
        influences /= numRuns  
        
        influences2 = numpy.zeros(graph.vcount())
        for i in range(graph.vcount()): 
            influences2[i] = MaxInfluence.simulateCascades(graph, set([0, i]), numRuns, p=0.2)
        
        print(influences, influences2)
        nptst.assert_array_almost_equal(influences, influences2, 2)
        
        influences = numpy.zeros(graph.vcount())
        for i in range(numRuns): 
            influences += MaxInfluence.simulateAllCascades(graph, [0, 5], p=0.2)
        influences /= numRuns  
        
        influences2 = numpy.zeros(graph.vcount())
        for i in range(graph.vcount()): 
            influences2[i] = MaxInfluence.simulateCascades(graph, set([0, 5, i]), numRuns, p=0.2)
        
        print(influences, influences2)
        nptst.assert_array_almost_equal(influences, influences2, 2)