Esempio n. 1
0
    def test_lyap(self):
        A = matrix([[-1, 1], [-1, 0]])
        Q = matrix([[1, 0], [0, 1]])
        X = lyap(A, Q)
        # print("The solution obtained is ", X)
        assert_array_almost_equal(A * X + X * A.T + Q, zeros((2, 2)))

        A = matrix([[1, 2], [-3, -4]])
        Q = matrix([[3, 1], [1, 1]])
        X = lyap(A, Q)
        # print("The solution obtained is ", X)
        assert_array_almost_equal(A * X + X * A.T + Q, zeros((2, 2)))
Esempio n. 2
0
    def test_lyap(self):
        A = matrix([[-1, 1],[-1, 0]])
        Q = matrix([[1,0],[0,1]])
        X = lyap(A,Q)
        # print("The solution obtained is ", X)
        assert_array_almost_equal(A * X + X * A.T + Q, zeros((2,2)))

        A = matrix([[1, 2],[-3, -4]])
        Q = matrix([[3, 1],[1, 1]])
        X = lyap(A,Q)
        # print("The solution obtained is ", X)
        assert_array_almost_equal(A * X + X * A.T + Q, zeros((2,2)))
    def test_lyap_g(self):
        A = array([[-1, 2], [-3, -4]])
        Q = array([[3, 1], [1, 1]])
        E = array([[1, 2], [2, 1]])
        X = lyap(A, Q, None, E)
        # print("The solution obtained is ", X)
        assert_array_almost_equal(A @ X @ E.T + E @ X @ A.T + Q,
                                  zeros((2,2)))

        # Make sure that trying to solve with SciPy generates an error
        with pytest.raises(ControlArgument, match="'scipy' not valid"):
            X = lyap(A, Q, None, E, method='scipy')
Esempio n. 4
0
    def test_lyap(self):
        A = array([[-1, 1], [-1, 0]])
        Q = array([[1, 0], [0, 1]])
        X = lyap(A, Q)
        # print("The solution obtained is ", X)
        assert_array_almost_equal(A.dot(X) + X.dot(A.T) + Q, zeros((2, 2)))

        A = array([[1, 2], [-3, -4]])
        Q = array([[3, 1], [1, 1]])
        X = lyap(A, Q)
        # print("The solution obtained is ", X)
        assert_array_almost_equal(A.dot(X) + X.dot(A.T) + Q, zeros((2, 2)))
    def test_lyap(self):
        A = array([[-1, 1],[-1, 0]])
        Q = array([[1,0],[0,1]])
        X = lyap(A,Q)
        # print "The solution obtained is ", X
        assert_array_almost_equal(dot(A,X)+dot(X,A.T)+Q,zeros((2,2)))

        A = array([[1, 2],[-3, -4]])  
        Q = array([[3, 1],[1, 1]])
        X = lyap(A,Q)
        # print "The solution obtained is ", X
        assert_array_almost_equal(dot(A,X)+dot(X,A.T)+Q,zeros((2,2)))
Esempio n. 6
0
    def test_lyap_sylvester(self):
        A = 5
        B = matrix([[4, 3], [4, 3]])
        C = matrix([2, 1])
        X = lyap(A, B, C)
        # print("The solution obtained is ", X)
        assert_array_almost_equal(A * X + X * B + C, zeros((1, 2)))

        A = matrix([[2, 1], [1, 2]])
        B = matrix([[1, 2], [0.5, 0.1]])
        C = matrix([[1, 0], [0, 1]])
        X = lyap(A, B, C)
        # print("The solution obtained is ", X)
        assert_array_almost_equal(A * X + X * B + C, zeros((2, 2)))
Esempio n. 7
0
    def test_lyap_sylvester(self):
        A = 5
        B = matrix([[4, 3], [4, 3]])
        C = matrix([2, 1])
        X = lyap(A,B,C)
        # print("The solution obtained is ", X)
        assert_array_almost_equal(A * X + X * B + C, zeros((1,2)))

        A = matrix([[2,1],[1,2]])
        B = matrix([[1,2],[0.5,0.1]])
        C = matrix([[1,0],[0,1]])
        X = lyap(A,B,C)
        # print("The solution obtained is ", X)
        assert_array_almost_equal(A * X + X * B + C, zeros((2,2)))
    def test_lyap_sylvester(self):
        A = 5
        B = array([[4, 3], [4, 3]])
        C = array([2, 1])
        X = lyap(A, B, C)
        # print "The solution obtained is ", X
        assert_array_almost_equal(dot(A, X) + dot(X, B) + C, zeros((1, 2)))

        A = array([[2, 1], [1, 2]])
        B = array([[1, 2], [0.5, 0.1]])
        C = array([[1, 0], [0, 1]])
        X = lyap(A, B, C)
        # print "The solution obtained is ", X
        assert_array_almost_equal(dot(A, X) + dot(X, B) + C, zeros((2, 2)))
    def test_lyap_sylvester(self):
        A = 5
        B = array([[4, 3], [4, 3]])
        C = array([2, 1])
        X = lyap(A,B,C)
        # print "The solution obtained is ", X
        assert_array_almost_equal(dot(A,X)+dot(X,B)+C,zeros((1,2)))

        A = array([[2,1],[1,2]])
        B = array([[1,2],[0.5,0.1]])
        C = array([[1,0],[0,1]])
        X = lyap(A,B,C)
        # print "The solution obtained is ", X
        assert_array_almost_equal(dot(A,X)+dot(X,B)+C,zeros((2,2)))
Esempio n. 10
0
 def test_lyap_g(self):
     A = matrix([[-1, 2], [-3, -4]])
     Q = matrix([[3, 1], [1, 1]])
     E = matrix([[1, 2], [2, 1]])
     X = lyap(A, Q, None, E)
     # print("The solution obtained is ", X)
     assert_array_almost_equal(A * X * E.T + E * X * A.T + Q, zeros((2, 2)))
Esempio n. 11
0
 def test_lyap_g(self):
     A = matrix([[-1, 2],[-3, -4]])
     Q = matrix([[3, 1],[1, 1]])
     E = matrix([[1,2],[2,1]])
     X = lyap(A,Q,None,E)
     # print("The solution obtained is ", X)
     assert_array_almost_equal(A * X * E.T + E * X * A.T + Q, zeros((2,2)))
Esempio n. 12
0
 def test_lyap_g(self):
     A = array([[-1, 2], [-3, -4]])
     Q = array([[3, 1], [1, 1]])
     E = array([[1, 2], [2, 1]])
     X = lyap(A, Q, None, E)
     # print("The solution obtained is ", X)
     assert_array_almost_equal(
         A.dot(X).dot(E.T) + E.dot(X).dot(A.T) + Q, zeros((2, 2)))
 def test_lyap_g(self):
     A = array([[-1, 2], [-3, -4]])
     Q = array([[3, 1], [1, 1]])
     E = array([[1, 2], [2, 1]])
     X = lyap(A, Q, None, E)
     # print "The solution obtained is ", X
     assert_array_almost_equal(dot(A,dot(X,E.T)) + dot(E,dot(X,A.T)) + Q, \
                                   zeros((2,2)))
Esempio n. 14
0
 def test_lyap_g(self):
     A = array([[-1, 2],[-3, -4]])
     Q = array([[3, 1],[1, 1]])
     E = array([[1,2],[2,1]])
     X = lyap(A,Q,None,E)
     # print "The solution obtained is ", X
     assert_array_almost_equal(dot(A,dot(X,E.T)) + dot(E,dot(X,A.T)) + Q, \
                                   zeros((2,2)))
Esempio n. 15
0
    def test_lyap(self):
        A = array([[-1, 1], [-1, 0]])
        Q = array([[1, 0], [0, 1]])
        X = lyap(A, Q)
        # print("The solution obtained is ", X)
        assert_array_almost_equal(A @ X + X @ A.T + Q, zeros((2,2)))

        A = array([[1, 2], [-3, -4]])
        Q = array([[3, 1], [1, 1]])
        X = lyap(A,Q)
        # print("The solution obtained is ", X)
        assert_array_almost_equal(A @ X + X @ A.T + Q, zeros((2,2)))

        # Compare methods
        if slycot_check():
            X_scipy = lyap(A, Q, method='scipy')
            X_slycot = lyap(A, Q, method='slycot')
            assert_array_almost_equal(X_scipy, X_slycot)
Esempio n. 16
0
    def test_lyap_sylvester(self):
        A = 5
        B = array([[4, 3], [4, 3]])
        C = array([2, 1])
        X = lyap(A, B, C)
        # print("The solution obtained is ", X)
        assert_array_almost_equal(A * X + X @ B + C, zeros((1,2)))

        A = array([[2, 1], [1, 2]])
        B = array([[1, 2], [0.5, 0.1]])
        C = array([[1, 0], [0, 1]])
        X = lyap(A, B, C)
        # print("The solution obtained is ", X)
        assert_array_almost_equal(A @ X + X @ B + C, zeros((2,2)))

        # Compare methods
        if slycot_check():
            X_scipy = lyap(A, B, C, method='scipy')
            X_slycot = lyap(A, B, C, method='slycot')
            assert_array_almost_equal(X_scipy, X_slycot)