okstra 0.114.0 → 0.115.0

package/runtime/python/okstra_vendor/networkx/algorithms/approximation/tests/test_treewidth.py

@@ -1,274 +0,0 @@
-import itertools
-
-import networkx as nx
-from networkx.algorithms.approximation import (
-    treewidth_min_degree,
-    treewidth_min_fill_in,
-)
-from networkx.algorithms.approximation.treewidth import (
-    MinDegreeHeuristic,
-    min_fill_in_heuristic,
-)
-
-
-def is_tree_decomp(graph, decomp):
-    """Check if the given tree decomposition is valid."""
-    for x in graph.nodes():
-        appear_once = False
-        for bag in decomp.nodes():
-            if x in bag:
-                appear_once = True
-                break
-        assert appear_once
-
-    # Check if each connected pair of nodes are at least once together in a bag
-    for x, y in graph.edges():
-        appear_together = False
-        for bag in decomp.nodes():
-            if x in bag and y in bag:
-                appear_together = True
-                break
-        assert appear_together
-
-    # Check if the nodes associated with vertex v form a connected subset of T
-    for v in graph.nodes():
-        subset = []
-        for bag in decomp.nodes():
-            if v in bag:
-                subset.append(bag)
-        sub_graph = decomp.subgraph(subset)
-        assert nx.is_connected(sub_graph)
-
-
-class TestTreewidthMinDegree:
-    """Unit tests for the min_degree function"""
-
-    @classmethod
-    def setup_class(cls):
-        """Setup for different kinds of trees"""
-        cls.complete = nx.Graph()
-        cls.complete.add_edge(1, 2)
-        cls.complete.add_edge(2, 3)
-        cls.complete.add_edge(1, 3)
-
-        cls.small_tree = nx.Graph()
-        cls.small_tree.add_edge(1, 3)
-        cls.small_tree.add_edge(4, 3)
-        cls.small_tree.add_edge(2, 3)
-        cls.small_tree.add_edge(3, 5)
-        cls.small_tree.add_edge(5, 6)
-        cls.small_tree.add_edge(5, 7)
-        cls.small_tree.add_edge(6, 7)
-
-        cls.deterministic_graph = nx.Graph()
-        cls.deterministic_graph.add_edge(0, 1)  # deg(0) = 1
-
-        cls.deterministic_graph.add_edge(1, 2)  # deg(1) = 2
-
-        cls.deterministic_graph.add_edge(2, 3)
-        cls.deterministic_graph.add_edge(2, 4)  # deg(2) = 3
-
-        cls.deterministic_graph.add_edge(3, 4)
-        cls.deterministic_graph.add_edge(3, 5)
-        cls.deterministic_graph.add_edge(3, 6)  # deg(3) = 4
-
-        cls.deterministic_graph.add_edge(4, 5)
-        cls.deterministic_graph.add_edge(4, 6)
-        cls.deterministic_graph.add_edge(4, 7)  # deg(4) = 5
-
-        cls.deterministic_graph.add_edge(5, 6)
-        cls.deterministic_graph.add_edge(5, 7)
-        cls.deterministic_graph.add_edge(5, 8)
-        cls.deterministic_graph.add_edge(5, 9)  # deg(5) = 6
-
-        cls.deterministic_graph.add_edge(6, 7)
-        cls.deterministic_graph.add_edge(6, 8)
-        cls.deterministic_graph.add_edge(6, 9)  # deg(6) = 6
-
-        cls.deterministic_graph.add_edge(7, 8)
-        cls.deterministic_graph.add_edge(7, 9)  # deg(7) = 5
-
-        cls.deterministic_graph.add_edge(8, 9)  # deg(8) = 4
-
-    def test_petersen_graph(self):
-        """Test Petersen graph tree decomposition result"""
-        G = nx.petersen_graph()
-        _, decomp = treewidth_min_degree(G)
-        is_tree_decomp(G, decomp)
-
-    def test_small_tree_treewidth(self):
-        """Test small tree
-
-        Test if the computed treewidth of the known self.small_tree is 2.
-        As we know which value we can expect from our heuristic, values other
-        than two are regressions
-        """
-        G = self.small_tree
-        # the order of removal should be [1,2,4]3[5,6,7]
-        # (with [] denoting any order of the containing nodes)
-        # resulting in treewidth 2 for the heuristic
-        treewidth, _ = treewidth_min_fill_in(G)
-        assert treewidth == 2
-
-    def test_heuristic_abort(self):
-        """Test heuristic abort condition for fully connected graph"""
-        graph = {}
-        for u in self.complete:
-            graph[u] = set()
-            for v in self.complete[u]:
-                if u != v:  # ignore self-loop
-                    graph[u].add(v)
-
-        deg_heuristic = MinDegreeHeuristic(graph)
-        node = deg_heuristic.best_node(graph)
-        if node is None:
-            pass
-        else:
-            assert False
-
-    def test_empty_graph(self):
-        """Test empty graph"""
-        G = nx.Graph()
-        _, _ = treewidth_min_degree(G)
-
-    def test_two_component_graph(self):
-        G = nx.Graph()
-        G.add_node(1)
-        G.add_node(2)
-        treewidth, _ = treewidth_min_degree(G)
-        assert treewidth == 0
-
-    def test_not_sortable_nodes(self):
-        G = nx.Graph([(0, "a")])
-        treewidth_min_degree(G)
-
-    def test_heuristic_first_steps(self):
-        """Test first steps of min_degree heuristic"""
-        graph = {
-            n: set(self.deterministic_graph[n]) - {n} for n in self.deterministic_graph
-        }
-        deg_heuristic = MinDegreeHeuristic(graph)
-        elim_node = deg_heuristic.best_node(graph)
-        steps = []
-
-        while elim_node is not None:
-            steps.append(elim_node)
-            nbrs = graph[elim_node]
-
-            for u, v in itertools.permutations(nbrs, 2):
-                if v not in graph[u]:
-                    graph[u].add(v)
-
-            for u in graph:
-                if elim_node in graph[u]:
-                    graph[u].remove(elim_node)
-
-            del graph[elim_node]
-            elim_node = deg_heuristic.best_node(graph)
-
-        # check only the first 5 elements for equality
-        assert steps[:5] == [0, 1, 2, 3, 4]
-
-
-class TestTreewidthMinFillIn:
-    """Unit tests for the treewidth_min_fill_in function."""
-
-    @classmethod
-    def setup_class(cls):
-        """Setup for different kinds of trees"""
-        cls.complete = nx.Graph()
-        cls.complete.add_edge(1, 2)
-        cls.complete.add_edge(2, 3)
-        cls.complete.add_edge(1, 3)
-
-        cls.small_tree = nx.Graph()
-        cls.small_tree.add_edge(1, 2)
-        cls.small_tree.add_edge(2, 3)
-        cls.small_tree.add_edge(3, 4)
-        cls.small_tree.add_edge(1, 4)
-        cls.small_tree.add_edge(2, 4)
-        cls.small_tree.add_edge(4, 5)
-        cls.small_tree.add_edge(5, 6)
-        cls.small_tree.add_edge(5, 7)
-        cls.small_tree.add_edge(6, 7)
-
-        cls.deterministic_graph = nx.Graph()
-        cls.deterministic_graph.add_edge(1, 2)
-        cls.deterministic_graph.add_edge(1, 3)
-        cls.deterministic_graph.add_edge(3, 4)
-        cls.deterministic_graph.add_edge(2, 4)
-        cls.deterministic_graph.add_edge(3, 5)
-        cls.deterministic_graph.add_edge(4, 5)
-        cls.deterministic_graph.add_edge(3, 6)
-        cls.deterministic_graph.add_edge(5, 6)
-
-    def test_petersen_graph(self):
-        """Test Petersen graph tree decomposition result"""
-        G = nx.petersen_graph()
-        _, decomp = treewidth_min_fill_in(G)
-        is_tree_decomp(G, decomp)
-
-    def test_small_tree_treewidth(self):
-        """Test if the computed treewidth of the known self.small_tree is 2"""
-        G = self.small_tree
-        # the order of removal should be [1,2,4]3[5,6,7]
-        # (with [] denoting any order of the containing nodes)
-        # resulting in treewidth 2 for the heuristic
-        treewidth, _ = treewidth_min_fill_in(G)
-        assert treewidth == 2
-
-    def test_heuristic_abort(self):
-        """Test if min_fill_in returns None for fully connected graph"""
-        graph = {}
-        for u in self.complete:
-            graph[u] = set()
-            for v in self.complete[u]:
-                if u != v:  # ignore self-loop
-                    graph[u].add(v)
-        next_node = min_fill_in_heuristic(graph)
-        if next_node is None:
-            pass
-        else:
-            assert False
-
-    def test_empty_graph(self):
-        """Test empty graph"""
-        G = nx.Graph()
-        _, _ = treewidth_min_fill_in(G)
-
-    def test_two_component_graph(self):
-        G = nx.Graph()
-        G.add_node(1)
-        G.add_node(2)
-        treewidth, _ = treewidth_min_fill_in(G)
-        assert treewidth == 0
-
-    def test_not_sortable_nodes(self):
-        G = nx.Graph([(0, "a")])
-        treewidth_min_fill_in(G)
-
-    def test_heuristic_first_steps(self):
-        """Test first steps of min_fill_in heuristic"""
-        graph = {
-            n: set(self.deterministic_graph[n]) - {n} for n in self.deterministic_graph
-        }
-        elim_node = min_fill_in_heuristic(graph)
-        steps = []
-
-        while elim_node is not None:
-            steps.append(elim_node)
-            nbrs = graph[elim_node]
-
-            for u, v in itertools.permutations(nbrs, 2):
-                if v not in graph[u]:
-                    graph[u].add(v)
-
-            for u in graph:
-                if elim_node in graph[u]:
-                    graph[u].remove(elim_node)
-
-            del graph[elim_node]
-            elim_node = min_fill_in_heuristic(graph)
-
-        # check only the first 2 elements for equality
-        assert steps[:2] == [6, 5]

package/runtime/python/okstra_vendor/networkx/algorithms/approximation/tests/test_vertex_cover.py

@@ -1,68 +0,0 @@
-import networkx as nx
-from networkx.algorithms.approximation import min_weighted_vertex_cover
-
-
-def is_cover(G, node_cover):
-    return all({u, v} & node_cover for u, v in G.edges())
-
-
-class TestMWVC:
-    """Unit tests for the approximate minimum weighted vertex cover
-    function,
-    :func:`~networkx.algorithms.approximation.vertex_cover.min_weighted_vertex_cover`.
-
-    """
-
-    def test_unweighted_directed(self):
-        # Create a star graph in which half the nodes are directed in
-        # and half are directed out.
-        G = nx.DiGraph()
-        G.add_edges_from((0, v) for v in range(1, 26))
-        G.add_edges_from((v, 0) for v in range(26, 51))
-        cover = min_weighted_vertex_cover(G)
-        assert 1 == len(cover)
-        assert is_cover(G, cover)
-
-    def test_unweighted_undirected(self):
-        # create a simple star graph
-        size = 50
-        sg = nx.star_graph(size)
-        cover = min_weighted_vertex_cover(sg)
-        assert 1 == len(cover)
-        assert is_cover(sg, cover)
-
-    def test_weighted(self):
-        wg = nx.Graph()
-        wg.add_node(0, weight=10)
-        wg.add_node(1, weight=1)
-        wg.add_node(2, weight=1)
-        wg.add_node(3, weight=1)
-        wg.add_node(4, weight=1)
-
-        wg.add_edge(0, 1)
-        wg.add_edge(0, 2)
-        wg.add_edge(0, 3)
-        wg.add_edge(0, 4)
-
-        wg.add_edge(1, 2)
-        wg.add_edge(2, 3)
-        wg.add_edge(3, 4)
-        wg.add_edge(4, 1)
-
-        cover = min_weighted_vertex_cover(wg, weight="weight")
-        csum = sum(wg.nodes[node]["weight"] for node in cover)
-        assert 4 == csum
-        assert is_cover(wg, cover)
-
-    def test_unweighted_self_loop(self):
-        slg = nx.Graph()
-        slg.add_node(0)
-        slg.add_node(1)
-        slg.add_node(2)
-
-        slg.add_edge(0, 1)
-        slg.add_edge(2, 2)
-
-        cover = min_weighted_vertex_cover(slg)
-        assert 2 == len(cover)
-        assert is_cover(slg, cover)

package/runtime/python/okstra_vendor/networkx/algorithms/assortativity/tests/base_test.py

@@ -1,81 +0,0 @@
-import networkx as nx
-
-
-class BaseTestAttributeMixing:
-    @classmethod
-    def setup_class(cls):
-        G = nx.Graph()
-        G.add_nodes_from([0, 1], fish="one")
-        G.add_nodes_from([2, 3], fish="two")
-        G.add_nodes_from([4], fish="red")
-        G.add_nodes_from([5], fish="blue")
-        G.add_edges_from([(0, 1), (2, 3), (0, 4), (2, 5)])
-        cls.G = G
-
-        D = nx.DiGraph()
-        D.add_nodes_from([0, 1], fish="one")
-        D.add_nodes_from([2, 3], fish="two")
-        D.add_nodes_from([4], fish="red")
-        D.add_nodes_from([5], fish="blue")
-        D.add_edges_from([(0, 1), (2, 3), (0, 4), (2, 5)])
-        cls.D = D
-
-        M = nx.MultiGraph()
-        M.add_nodes_from([0, 1], fish="one")
-        M.add_nodes_from([2, 3], fish="two")
-        M.add_nodes_from([4], fish="red")
-        M.add_nodes_from([5], fish="blue")
-        M.add_edges_from([(0, 1), (0, 1), (2, 3)])
-        cls.M = M
-
-        S = nx.Graph()
-        S.add_nodes_from([0, 1], fish="one")
-        S.add_nodes_from([2, 3], fish="two")
-        S.add_nodes_from([4], fish="red")
-        S.add_nodes_from([5], fish="blue")
-        S.add_edge(0, 0)
-        S.add_edge(2, 2)
-        cls.S = S
-
-        N = nx.Graph()
-        N.add_nodes_from([0, 1], margin=-2)
-        N.add_nodes_from([2, 3], margin=-2)
-        N.add_nodes_from([4], margin=-3)
-        N.add_nodes_from([5], margin=-4)
-        N.add_edges_from([(0, 1), (2, 3), (0, 4), (2, 5)])
-        cls.N = N
-
-        F = nx.Graph()
-        F.add_edges_from([(0, 3), (1, 3), (2, 3)], weight=0.5)
-        F.add_edge(0, 2, weight=1)
-        nx.set_node_attributes(F, dict(F.degree(weight="weight")), "margin")
-        cls.F = F
-
-        K = nx.Graph()
-        K.add_nodes_from([1, 2], margin=-1)
-        K.add_nodes_from([3], margin=1)
-        K.add_nodes_from([4], margin=2)
-        K.add_edges_from([(3, 4), (1, 2), (1, 3)])
-        cls.K = K
-
-
-class BaseTestDegreeMixing:
-    @classmethod
-    def setup_class(cls):
-        cls.P4 = nx.path_graph(4)
-        cls.D = nx.DiGraph()
-        cls.D.add_edges_from([(0, 2), (0, 3), (1, 3), (2, 3)])
-        cls.D2 = nx.DiGraph()
-        cls.D2.add_edges_from([(0, 3), (1, 0), (1, 2), (2, 4), (4, 1), (4, 3), (4, 2)])
-        cls.M = nx.MultiGraph()
-        nx.add_path(cls.M, range(4))
-        cls.M.add_edge(0, 1)
-        cls.S = nx.Graph()
-        cls.S.add_edges_from([(0, 0), (1, 1)])
-        cls.W = nx.Graph()
-        cls.W.add_edges_from([(0, 3), (1, 3), (2, 3)], weight=0.5)
-        cls.W.add_edge(0, 2, weight=1)
-        S1 = nx.star_graph(4)
-        S2 = nx.star_graph(4)
-        cls.DS = nx.disjoint_union(S1, S2)
-        cls.DS.add_edge(4, 5)

package/runtime/python/okstra_vendor/networkx/algorithms/assortativity/tests/test_connectivity.py

@@ -1,143 +0,0 @@
-from itertools import permutations
-
-import pytest
-
-import networkx as nx
-
-
-class TestNeighborConnectivity:
-    def test_degree_p4(self):
-        G = nx.path_graph(4)
-        answer = {1: 2.0, 2: 1.5}
-        nd = nx.average_degree_connectivity(G)
-        assert nd == answer
-
-        D = G.to_directed()
-        answer = {2: 2.0, 4: 1.5}
-        nd = nx.average_degree_connectivity(D)
-        assert nd == answer
-
-        answer = {1: 2.0, 2: 1.5}
-        D = G.to_directed()
-        nd = nx.average_degree_connectivity(D, source="in", target="in")
-        assert nd == answer
-
-        D = G.to_directed()
-        nd = nx.average_degree_connectivity(D, source="in", target="in")
-        assert nd == answer
-
-    def test_degree_p4_weighted(self):
-        G = nx.path_graph(4)
-        G[1][2]["weight"] = 4
-        answer = {1: 2.0, 2: 1.8}
-        nd = nx.average_degree_connectivity(G, weight="weight")
-        assert nd == answer
-        answer = {1: 2.0, 2: 1.5}
-        nd = nx.average_degree_connectivity(G)
-        assert nd == answer
-
-        D = G.to_directed()
-        answer = {2: 2.0, 4: 1.8}
-        nd = nx.average_degree_connectivity(D, weight="weight")
-        assert nd == answer
-
-        answer = {1: 2.0, 2: 1.8}
-        D = G.to_directed()
-        nd = nx.average_degree_connectivity(
-            D, weight="weight", source="in", target="in"
-        )
-        assert nd == answer
-
-        D = G.to_directed()
-        nd = nx.average_degree_connectivity(
-            D, source="in", target="out", weight="weight"
-        )
-        assert nd == answer
-
-    def test_weight_keyword(self):
-        G = nx.path_graph(4)
-        G[1][2]["other"] = 4
-        answer = {1: 2.0, 2: 1.8}
-        nd = nx.average_degree_connectivity(G, weight="other")
-        assert nd == answer
-        answer = {1: 2.0, 2: 1.5}
-        nd = nx.average_degree_connectivity(G, weight=None)
-        assert nd == answer
-
-        D = G.to_directed()
-        answer = {2: 2.0, 4: 1.8}
-        nd = nx.average_degree_connectivity(D, weight="other")
-        assert nd == answer
-
-        answer = {1: 2.0, 2: 1.8}
-        D = G.to_directed()
-        nd = nx.average_degree_connectivity(D, weight="other", source="in", target="in")
-        assert nd == answer
-
-        D = G.to_directed()
-        nd = nx.average_degree_connectivity(D, weight="other", source="in", target="in")
-        assert nd == answer
-
-    def test_degree_barrat(self):
-        G = nx.star_graph(5)
-        G.add_edges_from([(5, 6), (5, 7), (5, 8), (5, 9)])
-        G[0][5]["weight"] = 5
-        nd = nx.average_degree_connectivity(G)[5]
-        assert nd == 1.8
-        nd = nx.average_degree_connectivity(G, weight="weight")[5]
-        assert nd == pytest.approx(3.222222, abs=1e-5)
-
-    def test_zero_deg(self):
-        G = nx.DiGraph()
-        G.add_edge(1, 2)
-        G.add_edge(1, 3)
-        G.add_edge(1, 4)
-        c = nx.average_degree_connectivity(G)
-        assert c == {1: 0, 3: 1}
-        c = nx.average_degree_connectivity(G, source="in", target="in")
-        assert c == {0: 0, 1: 0}
-        c = nx.average_degree_connectivity(G, source="in", target="out")
-        assert c == {0: 0, 1: 3}
-        c = nx.average_degree_connectivity(G, source="in", target="in+out")
-        assert c == {0: 0, 1: 3}
-        c = nx.average_degree_connectivity(G, source="out", target="out")
-        assert c == {0: 0, 3: 0}
-        c = nx.average_degree_connectivity(G, source="out", target="in")
-        assert c == {0: 0, 3: 1}
-        c = nx.average_degree_connectivity(G, source="out", target="in+out")
-        assert c == {0: 0, 3: 1}
-
-    def test_in_out_weight(self):
-        G = nx.DiGraph()
-        G.add_edge(1, 2, weight=1)
-        G.add_edge(1, 3, weight=1)
-        G.add_edge(3, 1, weight=1)
-        for s, t in permutations(["in", "out", "in+out"], 2):
-            c = nx.average_degree_connectivity(G, source=s, target=t)
-            cw = nx.average_degree_connectivity(G, source=s, target=t, weight="weight")
-            assert c == cw
-
-    def test_invalid_source(self):
-        with pytest.raises(nx.NetworkXError):
-            G = nx.DiGraph()
-            nx.average_degree_connectivity(G, source="bogus")
-
-    def test_invalid_target(self):
-        with pytest.raises(nx.NetworkXError):
-            G = nx.DiGraph()
-            nx.average_degree_connectivity(G, target="bogus")
-
-    def test_invalid_undirected_graph(self):
-        G = nx.Graph()
-        with pytest.raises(nx.NetworkXError):
-            nx.average_degree_connectivity(G, target="bogus")
-        with pytest.raises(nx.NetworkXError):
-            nx.average_degree_connectivity(G, source="bogus")
-
-    def test_single_node(self):
-        # TODO Is this really the intended behavior for providing a
-        # single node as the argument `nodes`? Shouldn't the function
-        # just return the connectivity value itself?
-        G = nx.trivial_graph()
-        conn = nx.average_degree_connectivity(G, nodes=0)
-        assert conn == {0: 0}

package/runtime/python/okstra_vendor/networkx/algorithms/assortativity/tests/test_correlation.py

@@ -1,122 +0,0 @@
-import pytest
-
-import networkx as nx
-from networkx.algorithms.assortativity.correlation import attribute_ac
-
-from .base_test import BaseTestAttributeMixing, BaseTestDegreeMixing
-
-np = pytest.importorskip("numpy")
-pytest.importorskip("scipy")
-
-
-class TestDegreeMixingCorrelation(BaseTestDegreeMixing):
-    def test_degree_assortativity_undirected(self):
-        r = nx.degree_assortativity_coefficient(self.P4)
-        np.testing.assert_almost_equal(r, -1.0 / 2, decimal=4)
-
-    def test_degree_assortativity_node_kwargs(self):
-        G = nx.Graph()
-        edges = [(0, 1), (0, 3), (1, 2), (1, 3), (1, 4), (5, 9), (9, 0)]
-        G.add_edges_from(edges)
-        r = nx.degree_assortativity_coefficient(G, nodes=[1, 2, 4])
-        np.testing.assert_almost_equal(r, -1.0, decimal=4)
-
-    def test_degree_assortativity_directed(self):
-        r = nx.degree_assortativity_coefficient(self.D)
-        np.testing.assert_almost_equal(r, -0.57735, decimal=4)
-
-    def test_degree_assortativity_directed2(self):
-        """Test degree assortativity for a directed graph where the set of
-        in/out degree does not equal the total degree."""
-        r = nx.degree_assortativity_coefficient(self.D2)
-        np.testing.assert_almost_equal(r, 0.14852, decimal=4)
-
-    def test_degree_assortativity_multigraph(self):
-        r = nx.degree_assortativity_coefficient(self.M)
-        np.testing.assert_almost_equal(r, -1.0 / 7.0, decimal=4)
-
-    def test_degree_pearson_assortativity_undirected(self):
-        r = nx.degree_pearson_correlation_coefficient(self.P4)
-        np.testing.assert_almost_equal(r, -1.0 / 2, decimal=4)
-
-    def test_degree_pearson_assortativity_directed(self):
-        r = nx.degree_pearson_correlation_coefficient(self.D)
-        np.testing.assert_almost_equal(r, -0.57735, decimal=4)
-
-    def test_degree_pearson_assortativity_directed2(self):
-        """Test degree assortativity with Pearson for a directed graph where
-        the set of in/out degree does not equal the total degree."""
-        r = nx.degree_pearson_correlation_coefficient(self.D2)
-        np.testing.assert_almost_equal(r, 0.14852, decimal=4)
-
-    def test_degree_pearson_assortativity_multigraph(self):
-        r = nx.degree_pearson_correlation_coefficient(self.M)
-        np.testing.assert_almost_equal(r, -1.0 / 7.0, decimal=4)
-
-    def test_degree_assortativity_weighted(self):
-        r = nx.degree_assortativity_coefficient(self.W, weight="weight")
-        np.testing.assert_almost_equal(r, -0.1429, decimal=4)
-
-    def test_degree_assortativity_double_star(self):
-        r = nx.degree_assortativity_coefficient(self.DS)
-        np.testing.assert_almost_equal(r, -0.9339, decimal=4)
-
-
-class TestAttributeMixingCorrelation(BaseTestAttributeMixing):
-    def test_attribute_assortativity_undirected(self):
-        r = nx.attribute_assortativity_coefficient(self.G, "fish")
-        assert r == 6.0 / 22.0
-
-    def test_attribute_assortativity_directed(self):
-        r = nx.attribute_assortativity_coefficient(self.D, "fish")
-        assert r == 1.0 / 3.0
-
-    def test_attribute_assortativity_multigraph(self):
-        r = nx.attribute_assortativity_coefficient(self.M, "fish")
-        assert r == 1.0
-
-    def test_attribute_assortativity_coefficient(self):
-        # from "Mixing patterns in networks"
-        # fmt: off
-        a = np.array([[0.258, 0.016, 0.035, 0.013],
-                      [0.012, 0.157, 0.058, 0.019],
-                      [0.013, 0.023, 0.306, 0.035],
-                      [0.005, 0.007, 0.024, 0.016]])
-        # fmt: on
-        r = attribute_ac(a)
-        np.testing.assert_almost_equal(r, 0.623, decimal=3)
-
-    def test_attribute_assortativity_coefficient2(self):
-        # fmt: off
-        a = np.array([[0.18, 0.02, 0.01, 0.03],
-                      [0.02, 0.20, 0.03, 0.02],
-                      [0.01, 0.03, 0.16, 0.01],
-                      [0.03, 0.02, 0.01, 0.22]])
-        # fmt: on
-        r = attribute_ac(a)
-        np.testing.assert_almost_equal(r, 0.68, decimal=2)
-
-    def test_attribute_assortativity(self):
-        a = np.array([[50, 50, 0], [50, 50, 0], [0, 0, 2]])
-        r = attribute_ac(a)
-        np.testing.assert_almost_equal(r, 0.029, decimal=3)
-
-    def test_attribute_assortativity_negative(self):
-        r = nx.numeric_assortativity_coefficient(self.N, "margin")
-        np.testing.assert_almost_equal(r, -0.2903, decimal=4)
-
-    def test_assortativity_node_kwargs(self):
-        G = nx.Graph()
-        G.add_nodes_from([0, 1], size=2)
-        G.add_nodes_from([2, 3], size=3)
-        G.add_edges_from([(0, 1), (2, 3)])
-        r = nx.numeric_assortativity_coefficient(G, "size", nodes=[0, 3])
-        np.testing.assert_almost_equal(r, 1.0, decimal=4)
-
-    def test_attribute_assortativity_float(self):
-        r = nx.numeric_assortativity_coefficient(self.F, "margin")
-        np.testing.assert_almost_equal(r, -0.1429, decimal=4)
-
-    def test_attribute_assortativity_mixed(self):
-        r = nx.numeric_assortativity_coefficient(self.K, "margin")
-        np.testing.assert_almost_equal(r, 0.4340, decimal=4)