def test_resitance_network_3(self):
        ''' Test unconnected network of two nodes
        '''

        # network topology: two unconnected nodes
        r_arr = np.array([0, np.inf, 0])
        RN = tl.ResistanceNetwork(2, r_arr)

        # test resistance is infinite
        self.assertTrue(np.isinf(RN.get_two_point_resistance(0, 1)))
    def test_resitance_network_4(self):
        ''' Test two-point resistance of series node network with unconnected node
        '''

        # network topology: series of 6 nodes with random resistors between
        r01, r12, r23, r34, r45 = 3.26096629, 0.90862276, 2.73187024, 3.74048988, np.inf
        r_arr = np.array([
            0.0, r01, 0.0, np.inf, r12, 0.0, np.inf, np.inf, r23, 0.0, np.inf,
            np.inf, np.inf, r34, 0.0, np.inf, np.inf, np.inf, np.inf, r45, 0.0
        ])
        RN = tl.ResistanceNetwork(6, r_arr)

        # test two point resistance
        er01 = r01
        er02 = r01 + r12
        er03 = er02 + r23
        er04 = er03 + r34
        er05 = er04 + r45
        er12 = r12
        er13 = er12 + r23
        er14 = er13 + r34
        er15 = er14 + r45
        er23 = r23
        er24 = er23 + r34
        er25 = er24 + r45
        er34 = r34
        er35 = er34 + r45
        er45 = r45
        self.assertAlmostEqual(RN.get_two_point_resistance(0, 1), er01)
        self.assertAlmostEqual(RN.get_two_point_resistance(0, 2), er02)
        self.assertAlmostEqual(RN.get_two_point_resistance(0, 3), er03)
        self.assertAlmostEqual(RN.get_two_point_resistance(0, 4), er04)
        self.assertAlmostEqual(RN.get_two_point_resistance(1, 2), er12)
        self.assertAlmostEqual(RN.get_two_point_resistance(1, 3), er13)
        self.assertAlmostEqual(RN.get_two_point_resistance(1, 4), er14)
        self.assertAlmostEqual(RN.get_two_point_resistance(2, 3), er23)
        self.assertAlmostEqual(RN.get_two_point_resistance(2, 4), er24)
        self.assertAlmostEqual(RN.get_two_point_resistance(3, 4), er34)

        # singular nodes
        self.assertAlmostEqual(RN.get_two_point_resistance(0, 0), 0.0)
        self.assertAlmostEqual(RN.get_two_point_resistance(1, 1), 0.0)
        self.assertAlmostEqual(RN.get_two_point_resistance(2, 2), 0.0)
        self.assertAlmostEqual(RN.get_two_point_resistance(3, 3), 0.0)
        self.assertAlmostEqual(RN.get_two_point_resistance(4, 4), 0.0)
        self.assertAlmostEqual(RN.get_two_point_resistance(5, 5), 0.0)

        # unconnected nodes
        self.assertTrue(np.isinf(RN.get_two_point_resistance(0, 5)))
        self.assertTrue(np.isinf(RN.get_two_point_resistance(1, 5)))
        self.assertTrue(np.isinf(RN.get_two_point_resistance(2, 5)))
        self.assertTrue(np.isinf(RN.get_two_point_resistance(3, 5)))
        self.assertTrue(np.isinf(RN.get_two_point_resistance(4, 5)))
    def test_resitance_network_5(self):
        ''' Test two-point resistance of 6 node, disconnected network
        '''

        # network topology: square where opposite nodes 2-4 are directly connect but 1-3 aren't
        # See Wu (2004) Section I; Example 1
        # two additional nodes are connected to each other but nothing else
        r1, r2, r3 = 8.14799202, 7.90884073, 6.726105639263754
        r_arr = np.array([
            0, r1, 0, np.inf, r1, 0, r1, r2, r1, 0, np.inf, np.inf, np.inf,
            np.inf, 0, np.inf, np.inf, np.inf, np.inf, r3, 0
        ])
        RN = tl.ResistanceNetwork(6, r_arr)

        c1 = 1.0 / r1
        c2 = 1.0 / r2

        # test resistance
        r02 = (1.0 / (4.0 * c1)) * (0.5 - 0.5)**2 + (1 / (2.0 * c1)) * (
            -1.0 / np.sqrt(2.0) -
            1.0 / np.sqrt(2))**2 + (1.0 /
                                    (2.0 * c1 + 2.0 * c2)) * (0.0 - 0.0)**2
        r01 = (1.0 / (4.0 * c1)) * (0.5 - -0.5)**2 + (1 / (2.0 * c1)) * (
            -1.0 / np.sqrt(2.0) -
            0.0)**2 + (1.0 /
                       (2.0 * c1 + 2.0 * c2)) * (0.0 - -1.0 / np.sqrt(2.0))**2
        r45 = r3
        self.assertAlmostEqual(RN.get_two_point_resistance(0, 2), r02)
        self.assertAlmostEqual(RN.get_two_point_resistance(0, 1), r01)
        self.assertAlmostEqual(RN.get_two_point_resistance(4, 5), r45)
        self.assertTrue(np.isinf(RN.get_two_point_resistance(0, 4)))
        self.assertTrue(np.isinf(RN.get_two_point_resistance(1, 4)))
        self.assertTrue(np.isinf(RN.get_two_point_resistance(2, 4)))
        self.assertTrue(np.isinf(RN.get_two_point_resistance(3, 4)))
        self.assertTrue(np.isinf(RN.get_two_point_resistance(0, 5)))
        self.assertTrue(np.isinf(RN.get_two_point_resistance(1, 5)))
        self.assertTrue(np.isinf(RN.get_two_point_resistance(2, 5)))
        self.assertTrue(np.isinf(RN.get_two_point_resistance(3, 5)))
    def test_resitance_network_1(self):
        ''' Test laplacian matrix and two-point resistance of 4 node network
        '''

        # network topology: square where opposit nodes 2-4 are directly connect but 1-3 aren't
        # See Wu (2004) Section I; Example 1
        r1, r2 = 8.14799202, 7.90884073
        r_arr = np.array([0, r1, 0, np.inf, r1, 0, r1, r2, r1, 0])
        RN = tl.ResistanceNetwork(4, r_arr)

        c1 = 1.0 / r1
        c2 = 1.0 / r2

        # test laplacian
        L = RN.laplacian_matrix
        self.assertAlmostEqual(L[0][0], 2 * c1)
        self.assertAlmostEqual(L[0][1], -c1)
        self.assertAlmostEqual(L[0][2], 0.0)
        self.assertAlmostEqual(L[0][3], -c1)
        self.assertAlmostEqual(L[1][0], -c1)
        self.assertAlmostEqual(L[1][1], 2 * c1 + c2)
        self.assertAlmostEqual(L[1][2], -c1)
        self.assertAlmostEqual(L[1][3], -c2)
        self.assertAlmostEqual(L[2][0], 0.0)
        self.assertAlmostEqual(L[2][1], -c1)
        self.assertAlmostEqual(L[2][2], 2 * c1)
        self.assertAlmostEqual(L[2][3], -c1)
        self.assertAlmostEqual(L[3][0], -c1)
        self.assertAlmostEqual(L[3][1], -c2)
        self.assertAlmostEqual(L[3][2], -c1)
        self.assertAlmostEqual(L[3][3], 2 * c1 + c2)

        # test eigen pairs
        expected_eigenpairs = []
        expected_eigenpairs.append([4 * c1, [0.5, -0.5, 0.5, -0.5]])
        expected_eigenpairs.append(
            [2 * c1, [-1.0 / np.sqrt(2), 0.0, 1.0 / np.sqrt(2), 0.0]])
        expected_eigenpairs.append(
            [2 * c1 + 2 * c2, [0.0, -1.0 / np.sqrt(2), 0.0, 1.0 / np.sqrt(2)]])

        eigenpairs = RN.get_nonzero_eigenpairs()
        for i, p in enumerate(eigenpairs):
            self.assertTrue(
                any(np.isclose(p[0], [ep[0] for ep in expected_eigenpairs])))
            # j = np.where(np.isclose(p[0], [ep[0] for ep in expected_eigenpairs]))[0][0]
            # self.assertAlmostEqual(p[1][0], list(reversed(expected_eigenpairs[j][1]))[0])
            # self.assertAlmostEqual(p[1][1], list(reversed(expected_eigenpairs[j][1]))[1])
            # self.assertAlmostEqual(p[1][2], list(reversed(expected_eigenpairs[j][1]))[2])
            # self.assertAlmostEqual(p[1][3], list(reversed(expected_eigenpairs[j][1]))[3])

        # test resistance
        r02 = (1.0 / (4.0 * c1)) * (0.5 - 0.5)**2 + (1 / (2.0 * c1)) * (
            -1.0 / np.sqrt(2.0) -
            1.0 / np.sqrt(2))**2 + (1.0 /
                                    (2.0 * c1 + 2.0 * c2)) * (0.0 - 0.0)**2
        r01 = (1.0 / (4.0 * c1)) * (0.5 - -0.5)**2 + (1 / (2.0 * c1)) * (
            -1.0 / np.sqrt(2.0) -
            0.0)**2 + (1.0 /
                       (2.0 * c1 + 2.0 * c2)) * (0.0 - -1.0 / np.sqrt(2.0))**2
        self.assertAlmostEqual(RN.get_two_point_resistance(0, 2), r02)
        self.assertAlmostEqual(RN.get_two_point_resistance(0, 1), r01)