Esempio n. 1
0
def test_bootstrap() :
    corpus = utils.get_data('SELECT id FROM refdesc WHERE abstract_keywords IS NOT NULL LIMIT 2000;','../../Data/dumps/20160126_cybergeo.sqlite3')
    for kwLimit in [50,100,200] :
        for subCorpusSize in [100,500,1000,2000] :
            bootstrapSize=25
            [relevantkw,relevant_dico,allkw] = bootstrap_subcorpuses(corpus,kwLimit,subCorpusSize,bootstrapSize)
            utils.export_dico_csv(relevant_dico,'res/conv_dico/bootstrap_relevantDico_kwLimit'+str(kwLimit)+'_subCorpusSize'+str(subCorpusSize)+'_bootstrapSize'+str(bootstrapSize),True)
            utils.export_list(relevantkw,'res/conv_kw/kw_'+str(kwLimit)+'_subCorpusSize'+str(subCorpusSize),False)
	    utils.export_dico_num_csv(relevantkw,'res/conv_tm/kw_'+str(kwLimit)+'_subCorpusSize'+str(subCorpusSize),False)
	    for i in range(len(allkw)) :
		    local_kw = allkw[i]
		    utils.export_list(local_kw.keys(),'res/conv_kw/kw_'+str(kwLimit)+'_subCorpusSize'+str(subCorpusSize)+'_run'+str(i),False)
		    utils.export_dico_num_csv(local_kw,'res/conv_tm/kw_'+str(kwLimit)+'_subCorpusSize'+str(subCorpusSize)+'_run'+str(i),False)
 def KruskalMST(self, g, j):
     result = []
     i, e = 0, 0
     graph = export_list(g)
     graph = sorted(graph, key=lambda item: item[2])
     parent = []
     rank = []
     for node in g.get_vertices():
         parent.append(int(node.get_id()))
         rank.append(0)
     while e < len(g.get_vertices()) - 1:
         u, v, w = graph[i]
         i = i + 1
         x = self.find(parent, u)
         y = self.find(parent, v)
         if x != y:
             e = e + 1
             result.append([u, v, w])
             j.inserir_aresta(u, v, w)
             self.union(parent, rank, x, y)
     # print("Constructed MST :")
     # print("Vertex A    Vertex B  Weight")
     # for u, v, weight in result:
     #    print("    %d          %d        %d" % (u, v, weight))
     return j
 def KruskalMSTCampus(self, g):
     total = 0
     vertices_atingidos = set()
     result = []
     i, e = 0, 0
     graph = export_list(g)
     graph = sorted(graph, key=lambda item: item[2])
     parent = []
     rank = []
     for node in g.get_vertices():
         parent.append(int(node.get_id()))
         rank.append(0)
     while e < len(g.get_vertices()) - 1:
         if len(graph) - 1 != i:
             u, v, w = graph[i]
             i = i + 1
             x = self.find(parent, u)
             y = self.find(parent, v)
             if x != y:
                 e = e + 1
                 result.append([u, v, w])
                 total += w
                 vertices_atingidos.add(u)
                 vertices_atingidos.add(v)
                 self.union(parent, rank, x, y)
         else:
             break
     return vertices_atingidos, total
Esempio n. 4
0
def test():
    print(
        'Testando grafo de exemplo do livro Algoritmos 3rd (Cormen), página 480.'
    )

    g = grafo(True)

    g.inserir_vertice('a')
    g.inserir_vertice('b')
    g.inserir_vertice('c')
    g.inserir_vertice('d')
    g.inserir_vertice('e')

    g.inserir_aresta('a', 'b', 6)
    g.inserir_aresta('a', 'c', 7)
    g.inserir_aresta('a', 'e', 2)
    g.inserir_aresta('b', 'd', 5)
    g.inserir_aresta('b', 'c', 8)
    g.inserir_aresta('b', 'e', -4)
    g.inserir_aresta('c', 'd', -3)
    g.inserir_aresta('c', 'e', 9)
    g.inserir_aresta('d', 'b', -2)
    g.inserir_aresta('e', 'd', 7)

    m = minimo()
    m.bellman_ford(g, 'd')
    # bellman_ford(g, 'd')
    print(export_list(g))

    for v in g.get_vertices():
        caminho = [v.get_id()]
        caminho_minino(v, caminho)
        print('O menor caminho é: %s com custo %d.' %
              (caminho[::-1], v.get_distancia()))
Esempio n. 5
0
    def get_list_members(self, owner, slug, attr='screen_name', export=True):

        output_list = []

        for member in tweepy.Cursor(self.API.list_members, owner,
                                    slug).items():
            if attr == 'id':
                output_list.append(member.id)
            else:
                output_list.append(member.screen_name)

        if export:
            utils.export_list(slug, output_list)

        print(
            self.msg.success_get_list_members.format(
                len(output_list), attr, owner,
                slug))  # To do: hide if used w/i function

        return output_list
    def KruskalMSTDistancia(self, g, j):
        result = []
        total = 0
        i, e = 0, 0
        graph = export_list(g)
        graph = sorted(graph, key=lambda item: item[2])
        parent = []
        rank = []
        for node in g.get_vertices():
            parent.append(int(node.get_id()))
            rank.append(0)
        while e < len(g.get_vertices()) - 1:
            u, v, w = graph[i]
            i = i + 1
            x = self.find(parent, u)
            y = self.find(parent, v)
            if x != y:
                e = e + 1
                result.append([u, v, w])
                j.inserir_aresta(u, v, w)
                t = j.get_vertice(u)
                total += w
                if t.is_capital():
                    for zzz in t.get_vertices_adjacentes():
                        if zzz.get_id() != v:
                            t.set_peso(zzz, sys.maxsize)

                t = j.get_vertice(v)
                if t.is_capital():
                    for zzz in t.get_vertices_adjacentes():
                        if zzz.get_id() != u:
                            zzz.set_peso(i, sys.maxsize)

                self.union(parent, rank, x, y)
        # print("Constructed MST :")
        # print("Vertex A    Vertex B  Weight")
        # for u, v, weight in result:
        #    print("    %d          %d        %d" % (u, v, weight))
        return t
 def KruskalMST(self, g):
     total = 0
     result = []
     i, e = 0, 0
     graph = export_list(g)
     graph = sorted(graph, key=lambda item: item[2])
     parent = []
     rank = []
     for node in g.get_vertices():
         parent.append(int(node.get_id()))
         rank.append(0)
     while e < len(g.get_vertices()) - 1:
         u, v, w = graph[i]
         i = i + 1
         x = self.find(parent, u)
         y = self.find(parent, v)
         if x != y:
             e = e + 1
             result.append([u, v, w])
             total += w
             self.union(parent, rank, x, y)
     return total