def test_dlyap_scalar():
a = 0.5
b = 0.75
sol = solve_discrete_lyapunov(a, b)
assert_allclose(sol, np.ones((1, 1)))
def test_dlyap_scalar():
a = .5
b = .75
sol = solve_discrete_lyapunov(a, b)
assert_allclose(sol, np.ones((1, 1)))
def test_dlyap_simple_ones():
A = np.zeros((4, 4))
B = np.ones((4, 4))
sol = solve_discrete_lyapunov(A, B)
assert_allclose(sol, np.ones((4, 4)))
def test_dlyap_simple_ones():
A = np.zeros((4, 4))
B = np.ones((4, 4))
sol = solve_discrete_lyapunov(A, B)
assert_allclose(sol, np.ones((4, 4)))
def test_solve_discrete_lyapunov_B():
'Simple test where X is same as B'
A = np.ones((2, 2)) * .5
B = np.array([[.5, -.5], [-.5, .5]])
X = qme.solve_discrete_lyapunov(A, B)
assert_allclose(B, X)
def test_solve_discrete_lyapunov_zero():
'Simple test where X is all zeros'
A = np.eye(4) * .95
B = np.zeros((4, 4))
X = qme.solve_discrete_lyapunov(A, B)
assert_allclose(X, np.zeros((4, 4)))
def test_solve_discrete_lyapunov_complex():
'Complex test, A is companion matrix'
A = np.array([[0.5 + 0.3j, 0.1 + 0.1j],
[ 1, 0]])
B = np.eye(2)
X = qme.solve_discrete_lyapunov(A, B)
assert_allclose(np.dot(np.dot(A, X), A.conj().transpose()) - X, -B,
atol=1e-15)
def test_solve_discrete_lyapunov_complex():
'Complex test, A is companion matrix'
A = np.array([[0.5 + 0.3j, 0.1 + 0.1j],
[ 1, 0]])
B = np.eye(2)
X = qme.solve_discrete_lyapunov(A, B)
assert_allclose(np.dot(np.dot(A, X), A.conj().transpose()) - X, -B,
atol=1e-15)
def computeG(A0, A1, d, Q0, tau0, beta, mu):
"""
Compute government income given mu and return tax revenues and
policy matrixes for the planner.
Parameters
----------
A0 : float
A constant parameter for the inverse demand function
A1 : float
A constant parameter for the inverse demand function
d : float
A constant parameter for quadratic adjustment cost of production
Q0 : float
An initial condition for production
tau0 : float
An initial condition for taxes
beta : float
A constant parameter for discounting
mu : float
Lagrange multiplier
Returns
-------
T0 : array(float)
Present discounted value of government spending
A : array(float)
One of the transition matrices for the states
B : array(float)
Another transition matrix for the states
F : array(float)
Policy rule matrix
P : array(float)
Value function matrix
"""
# Create Matrices for solving Ramsey problem
R = np.array([[0, -A0 / 2, 0, 0], [-A0 / 2, A1 / 2, -mu / 2, 0],
[0, -mu / 2, 0, 0], [0, 0, 0, d / 2]])
A = np.array([[1, 0, 0, 0], [0, 1, 0, 1], [0, 0, 0, 0],
[-A0 / d, A1 / d, 0, A1 / d + 1 / beta]])
B = np.array([0, 0, 1, 1 / d]).reshape(-1, 1)
Q = 0
# Use LQ to solve the Ramsey Problem.
lq = LQ(Q, -R, A, B, beta=beta)
P, F, d = lq.stationary_values()
# Need y_0 to compute government tax revenue.
P21 = P[3, :3]
P22 = P[3, 3]
z0 = np.array([1, Q0, tau0]).reshape(-1, 1)
u0 = -P22**(-1) * P21.dot(z0)
y0 = np.vstack([z0, u0])
# Define A_F and S matricies
AF = A - B.dot(F)
S = np.array([0, 1, 0, 0]).reshape(-1, 1).dot(np.array([[0, 0, 1, 0]]))
# Solves equation (25)
temp = beta * AF.T.dot(S).dot(AF)
Omega = solve_discrete_lyapunov(np.sqrt(beta) * AF.T, temp)
T0 = y0.T.dot(Omega).dot(y0)
return T0, A, B, F, P
def computeG(A0, A1, d, Q0, tau0, beta, mu):
"""
Compute government income given mu and return tax revenues and
policy matrixes for the planner.
Parameters
----------
A0 : float
A constant parameter for the inverse demand function
A1 : float
A constant parameter for the inverse demand function
d : float
A constant parameter for quadratic adjustment cost of production
Q0 : float
An initial condition for production
tau0 : float
An initial condition for taxes
beta : float
A constant parameter for discounting
mu : float
Lagrange multiplier
Returns
-------
T0 : array(float)
Present discounted value of government spending
A : array(float)
One of the transition matrices for the states
B : array(float)
Another transition matrix for the states
F : array(float)
Policy rule matrix
P : array(float)
Value function matrix
"""
# Create Matrices for solving Ramsey problem
R = np.array([[0, -A0/2, 0, 0],
[-A0/2, A1/2, -mu/2, 0],
[0, -mu/2, 0, 0],
[0, 0, 0, d/2]])
A = np.array([[1, 0, 0, 0],
[0, 1, 0, 1],
[0, 0, 0, 0],
[-A0/d, A1/d, 0, A1/d+1/beta]])
B = np.array([0, 0, 1, 1/d]).reshape(-1, 1)
Q = 0
# Use LQ to solve the Ramsey Problem.
lq = LQ(Q, -R, A, B, beta=beta)
P, F, d = lq.stationary_values()
# Need y_0 to compute government tax revenue.
P21 = P[3, :3]
P22 = P[3, 3]
z0 = np.array([1, Q0, tau0]).reshape(-1, 1)
u0 = -P22**(-1) * P21.dot(z0)
y0 = np.vstack([z0, u0])
# Define A_F and S matricies
AF = A - B.dot(F)
S = np.array([0, 1, 0, 0]).reshape(-1, 1).dot(np.array([[0, 0, 1, 0]]))
# Solves equation (25)
temp = beta * AF.T.dot(S).dot(AF)
Omega = solve_discrete_lyapunov(np.sqrt(beta) * AF.T, temp)
T0 = y0.T.dot(Omega).dot(y0)
return T0, A, B, F, P
