Beispiel #1
0
def run_tc(property_graph: PropertyGraph, _input_args):
    analytics.sort_all_edges_by_dest(property_graph)
    tc_plan = analytics.TriangleCountPlan.ordered_count(edges_sorted=True)

    with time_block("triangle counting"):
        n = analytics.triangle_count(property_graph, tc_plan)

    print(f"STATS:\nNumber of Triangles: {n}")
Beispiel #2
0
def test_triangle_count_presorted():
    property_graph = PropertyGraph(
        get_input("propertygraphs/rmat15_cleaned_symmetric"))
    sort_nodes_by_degree(property_graph)
    sort_all_edges_by_dest(property_graph)
    n = triangle_count(
        property_graph,
        TriangleCountPlan.node_iteration(relabeling=False, edges_sorted=True))
    assert n == 282617
Beispiel #3
0
def test_jaccard_sorted(property_graph: PropertyGraph):
    sort_all_edges_by_dest(property_graph)

    property_name = "NewProp"
    compare_node = 0

    jaccard(property_graph, compare_node, property_name, JaccardPlan.sorted())

    jaccard_assert_valid(property_graph, compare_node, property_name)

    similarities: np.ndarray = property_graph.get_node_property(
        property_name).to_numpy()
    assert similarities[compare_node] == 1
    assert similarities[1917] == approx(0.28571428)
    assert similarities[2812] == approx(0.01428571)
Beispiel #4
0
def test_subgraph_extraction():
    property_graph = PropertyGraph(
        get_input("propertygraphs/rmat15_cleaned_symmetric"))
    sort_all_edges_by_dest(property_graph)
    nodes = [1, 3, 11, 120]

    expected_edges = [[
        nodes.index(property_graph.get_edge_dest(e))
        for e in property_graph.edges(i)
        if property_graph.get_edge_dest(e) in nodes
    ] for i in nodes]

    pg = subgraph_extraction(property_graph, nodes)

    assert isinstance(pg, PropertyGraph)
    assert len(pg) == len(nodes)
    assert pg.num_edges() == 6

    for i, _ in enumerate(expected_edges):
        assert len(pg.edges(i)) == len(expected_edges[i])
        assert [pg.get_edge_dest(e) for e in pg.edges(i)] == expected_edges[i]
Beispiel #5
0
def test_triangle_count():
    property_graph = PropertyGraph(
        get_input("propertygraphs/rmat15_cleaned_symmetric"))
    original_first_edge_list = [
        property_graph.get_edge_dest(e) for e in property_graph.edges(0)
    ]
    n = triangle_count(property_graph)
    assert n == 282617

    n = triangle_count(property_graph, TriangleCountPlan.node_iteration())
    assert n == 282617

    n = triangle_count(property_graph, TriangleCountPlan.edge_iteration())
    assert n == 282617

    assert [property_graph.get_edge_dest(e)
            for e in property_graph.edges(0)] == original_first_edge_list

    sort_all_edges_by_dest(property_graph)
    n = triangle_count(property_graph,
                       TriangleCountPlan.ordered_count(edges_sorted=True))
    assert n == 282617
Beispiel #6
0
def test_sort_all_edges_by_dest(property_graph: PropertyGraph):
    original_dests = [[
        property_graph.get_edge_dest(e) for e in property_graph.edges(n)
    ] for n in range(NODES_TO_SAMPLE)]
    mapping = sort_all_edges_by_dest(property_graph)
    new_dests = [[
        property_graph.get_edge_dest(e) for e in property_graph.edges(n)
    ] for n in range(NODES_TO_SAMPLE)]
    for n in range(NODES_TO_SAMPLE):
        assert len(original_dests[n]) == len(new_dests[n])
        my_mapping = [mapping[e].as_py() for e in property_graph.edges(n)]
        for i, _ in enumerate(my_mapping):
            assert original_dests[n][i] == new_dests[n][
                my_mapping[i] - property_graph.edges(n)[0]]
        original_dests[n].sort()

        assert original_dests[n] == new_dests[n]
Beispiel #7
0
def test_find_edge_sorted_by_dest(property_graph: PropertyGraph):
    sort_all_edges_by_dest(property_graph)
    assert find_edge_sorted_by_dest(property_graph, 0, 1000) is None
    assert find_edge_sorted_by_dest(property_graph, 0, 1967) == 2