def model_to_fg(model, solve_systems=False, compiler='numpy', order=None):
sgm = simple_global_representation(model, solve_systems=solve_systems)
controls = sgm['controls']
states = sgm['states']
parameters = sgm['parameters']
shocks = sgm['shocks']
f_eqs = sgm['f_eqs']
g_eqs = sgm['g_eqs']
controls_f = [c(1) for c in controls]
states_f = [c(1) for c in states]
controls_p = [c(-1) for c in controls]
states_p = [c(-1) for c in states]
shocks_f = [c(1) for c in shocks]
args_g = [states_p, controls_p, shocks]
args_f = [states, controls, states_f, controls_f, shocks_f]
if order is not None:
from dolo.compiler.function_compiler import compile_function
g_fun = compile_function(g_eqs, sum(args_g, []), parameters, order)
f_fun = compile_function(
f_eqs, sum([states, controls, states_f, controls_f], []),
parameters, order)
return [g_fun, f_fun]
keep_auxiliary = 'a_eqs' in sgm
if keep_auxiliary:
# auxiliaries = sgm['auxiliaries']
a_eqs = sgm['a_eqs']
args_a = [states, controls]
if compiler == 'numpy':
from dolo.compiler.function_compiler import compile_multiargument_function
elif compiler == 'theano':
from dolo.compiler.function_compiler_theano import compile_multiargument_function
elif compiler == 'numexpr':
from dolo.compiler.function_compiler_numexpr import compile_multiargument_function
elif compiler == 'numba':
from dolo.compiler.function_compiler_numba import compile_multiargument_function
elif compiler == 'numba_gpu':
from dolo.compiler.function_compiler_numba_gpu import compile_multiargument_function
else:
raise Exception('Unknown compiler type : {}'.format(compiler))
g = compile_multiargument_function(g_eqs, args_g, ['s', 'x', 'e'],
parameters, 'g')
f = compile_multiargument_function(f_eqs, args_f,
['s', 'x', 'snext', 'xnext', 'e'],
parameters, 'f')
if keep_auxiliary:
a = compile_multiargument_function(a_eqs, args_a, ['s', 'x'],
parameters, 'a')
return [f, g, a]
else:
return [f, g]
def model_to_fg(model, solve_systems=False, compiler='numpy', order=None):
sgm = simple_global_representation(model, solve_systems=solve_systems)
controls = sgm['controls']
states = sgm['states']
parameters = sgm['parameters']
shocks = sgm['shocks']
f_eqs = sgm['f_eqs']
g_eqs = sgm['g_eqs']
controls_f = [c(1) for c in controls]
states_f = [c(1) for c in states]
controls_p = [c(-1) for c in controls]
states_p = [c(-1) for c in states]
shocks_f = [c(1) for c in shocks]
args_g = [states_p, controls_p, shocks]
args_f = [states, controls, states_f, controls_f, shocks_f]
if order is not None:
from dolo.compiler.function_compiler import compile_function
g_fun = compile_function( g_eqs, sum(args_g, []), parameters, order )
f_fun = compile_function( f_eqs, sum([states, controls, states_f, controls_f], []), parameters, order )
return [g_fun, f_fun]
keep_auxiliary = 'a_eqs' in sgm
if keep_auxiliary:
# auxiliaries = sgm['auxiliaries']
a_eqs = sgm['a_eqs']
args_a = [states, controls]
if compiler=='numpy':
from dolo.compiler.function_compiler import compile_multiargument_function
elif compiler == 'theano':
from dolo.compiler.function_compiler_theano import compile_multiargument_function
elif compiler == 'numexpr':
from dolo.compiler.function_compiler_numexpr import compile_multiargument_function
elif compiler == 'numba':
from dolo.compiler.function_compiler_numba import compile_multiargument_function
elif compiler == 'numba_gpu':
from dolo.compiler.function_compiler_numba_gpu import compile_multiargument_function
else:
raise Exception('Unknown compiler type : {}'.format(compiler))
g = compile_multiargument_function(g_eqs, args_g, ['s','x','e'], parameters, 'g' )
f = compile_multiargument_function(f_eqs, args_f, ['s','x','snext','xnext','e'], parameters, 'f' )
if keep_auxiliary:
a = compile_multiargument_function(a_eqs, args_a, ['s','x'], parameters, 'a' )
return [f,g,a]
else:
return [f,g]
def model_to_fg(model, solve_systems=False, compiler='numpy', order=None):
sgm = simple_global_representation(model, solve_systems=solve_systems)
controls = sgm['controls']
states = sgm['states']
parameters = sgm['parameters']
shocks = sgm['shocks']
f_eqs = sgm['f_eqs']
g_eqs = sgm['g_eqs']
controls_f = [c(1) for c in controls]
states_f = [c(1) for c in states]
controls_p = [c(-1) for c in controls]
states_p = [c(-1) for c in states]
shocks_f = [c(1) for c in shocks]
args_g = [states_p, controls_p, shocks]
args_f = [states, controls, states_f, controls_f, shocks_f]
if order is not None:
from dolo.compiler.function_compiler import compile_function
g_fun = compile_function( g_eqs, sum(args_g, []), parameters, order )
f_fun = compile_function( f_eqs, sum([states, controls, states_f, controls_f], []), parameters, order )
return [g_fun, f_fun]
keep_auxiliary = 'a_eqs' in sgm
if keep_auxiliary:
# auxiliaries = sgm['auxiliaries']
a_eqs = sgm['a_eqs']
args_a = [states, controls]
if compiler=='numpy':
from dolo.compiler.function_compiler import compile_multiargument_function
elif compiler == 'theano':
from dolo.compiler.function_compiler_theano import compile_multiargument_function
elif compiler == 'numexpr':
from dolo.compiler.function_compiler_numexpr import compile_multiargument_function
else:
raise Exception('Unknown compiler type : {}'.format(compiler))
g = compile_multiargument_function(g_eqs, args_g, ['s','x','e'], parameters, 'g' )
f = compile_multiargument_function(f_eqs, args_f, ['s','x','snext','xnext','e'], parameters, 'f' )
if keep_auxiliary:
a = compile_multiargument_function(a_eqs, args_a, ['s','x'], parameters, 'a' )
return [f,g,a]
else:
return [f,g]
#
#def model_to_fga(model, compiler='numpy'):
#
# from dolo.misc.triangular_solver import solve_triangular_system
#
# from dolo.misc.misc import timeshift
#
# eq_g = model['equations_groups']
# v_g = model['variables_groups']
#
# f_eqs = [eq.gap for eq in eq_g['arbitrage']]
# g_eqs = [eq for eq in eq_g['transition']]
# a_eqs = [eq for eq in eq_g['auxiliary']]
#
# # auxiliaries_2 are simply replaced in all other types of equations
# a2_dict = {}
# a2_dict_g = {}
#
# if 'auxiliary_2' in eq_g:
# aux2_eqs = eq_g['auxiliary_2']
# dd = {eq.lhs: eq.rhs for eq in aux2_eqs}
# dd.update( { eq.lhs(1): timeshift(eq.rhs,1) for eq in aux2_eqs } )
# dd.update( { eq.lhs(-1): timeshift(eq.rhs,-1) for eq in aux2_eqs } )
# ds = solve_triangular_system(dd)
#
# f_eqs = [eq.subs(ds) for eq in f_eqs]
# a_eqs = [eq.subs(ds) for eq in a_eqs]
# g_eqs = [eq.subs(ds) for eq in g_eqs]
#
# controls = v_g['controls']
# auxiliaries = v_g['auxiliary']
# states = v_g['states']
#
# parameters = model.parameters
# shocks = model.shocks
#
# dd = {eq.lhs: eq.rhs for eq in g_eqs}
# ds = solve_triangular_system(dd)
# g_eqs = [ds[eq.lhs] for eq in g_eqs]
#
# dd = {eq.lhs: eq.rhs for eq in a_eqs}
# ds = solve_triangular_system(dd)
# a_eqs = [ds[eq.lhs] for eq in a_eqs]
#
#
# auxiliaries_f = [c(1) for c in auxiliaries]
# auxiliaries_p = [c(-1) for c in auxiliaries]
#
# controls_f = [c(1) for c in controls]
# states_f = [c(1) for c in states]
# controls_p = [c(-1) for c in controls]
# states_p = [c(-1) for c in states]
# shocks_f = [c(1) for c in shocks]
#
# args_g = [states_p, controls_p, auxiliaries_p, shocks]
# args_f = [states, controls, states_f, controls_f, auxiliaries, auxiliaries_f, shocks_f]
# args_a = [states, controls]
#
#
# if compiler=='numpy':
# from dolo.compiler.compiling import compile_multiargument_function
# compile_multiargument_function
# elif compiler == 'theano':
# from dolo.compiler.compiling_theano import compile_multiargument_function
# elif compiler == 'numexpr':
# from dolo.compiler.compiling_numexpr import compile_multiargument_function
#
# g = compile_multiargument_function(g_eqs, args_g, ['s','x','y','e'], parameters, 'g' )
# f = compile_multiargument_function(f_eqs, args_f, ['s','x','snext','xnext','y','ynext','e'], parameters, 'f' )
# a = compile_multiargument_function(a_eqs, args_a, ['s','x'], parameters, 'a' )
#
# return [f,a,g]
def solve_risky_ss(model, X_bar, X_s, verbose=False):
import numpy
from dolo.compiler.function_compiler import compile_function
import time
from dolo.compiler.compiler_functions import simple_global_representation
parms = model.calibration['parameters']
sigma = model.calibration['covariances']
sgm = simple_global_representation(model)
states = sgm['states']
controls = sgm['controls']
shocks = sgm['shocks']
parameters = sgm['parameters']
f_eqs = sgm['f_eqs']
g_eqs = sgm['g_eqs']
g_args = [s(-1) for s in states] + [c(-1) for c in controls] + shocks
f_args = states + controls + [v(1)
for v in states] + [v(1) for v in controls]
p_args = parameters
g_fun = compile_function(g_eqs, g_args, p_args, 2)
f_fun = compile_function(f_eqs, f_args, p_args, 3)
epsilons_0 = np.zeros((sigma.shape[0]))
from numpy import dot
from dolo.numeric.tensor import sdot, mdot
def residuals(X, sigma, parms, g_fun, f_fun):
import numpy
dummy_x = X[0:1, 0]
X_bar = X[1:, 0]
S_bar = X[0, 1:]
X_s = X[1:, 1:]
[n_x, n_s] = X_s.shape
n_e = sigma.shape[0]
xx = np.concatenate([S_bar, X_bar, epsilons_0])
[g_0, g_1, g_2] = g_fun(xx, parms)
[f_0, f_1, f_2,
f_3] = f_fun(np.concatenate([S_bar, X_bar, S_bar, X_bar]), parms)
res_g = g_0 - S_bar
# g is a first order function
g_s = g_1[:, :n_s]
g_x = g_1[:, n_s:n_s + n_x]
g_e = g_1[:, n_s + n_x:]
g_se = g_2[:, :n_s, n_s + n_x:]
g_xe = g_2[:, n_s:n_s + n_x, n_s + n_x:]
# S(s,e) = g(s,x,e)
S_s = g_s + dot(g_x, X_s)
S_e = g_e
S_se = g_se + mdot(g_xe, [X_s, numpy.eye(n_e)])
# V(s,e) = [ g(s,x,e) ; x( g(s,x,e) ) ]
V_s = np.row_stack([S_s, dot(X_s, S_s)]) # ***
V_e = np.row_stack([S_e, dot(X_s, S_e)])
V_se = np.row_stack([S_se, dot(X_s, S_se)])
# v(s) = [s, x(s)]
v_s = np.row_stack([numpy.eye(n_s), X_s])
# W(s,e) = [xx(s,e); yy(s,e)]
W_s = np.row_stack([v_s, V_s])
#return
nn = n_s + n_x
f_v = f_1[:, :nn]
f_V = f_1[:, nn:]
f_1V = f_2[:, :, nn:]
f_VV = f_2[:, nn:, nn:]
f_1VV = f_3[:, :, nn:, nn:]
# E = lambda v: np.tensordot(v, sigma, axes=((2,3),(0,1)) ) # expectation operator
F = f_0 + 0.5 * np.tensordot(
mdot(f_VV, [V_e, V_e]), sigma, axes=((1, 2), (0, 1)))
F_s = sdot(f_1, W_s)
f_see = mdot(f_1VV, [W_s, V_e, V_e]) + 2 * mdot(f_VV, [V_se, V_e])
F_s += 0.5 * np.tensordot(f_see, sigma, axes=(
(2, 3), (0, 1))) # second order correction
resp = np.row_stack(
[np.concatenate([dummy_x, res_g]),
np.column_stack([F, F_s])])
return resp
# S_bar = s_fun_init( numpy.atleast_2d(X_bar).T ,parms).flatten()
# S_bar = S_bar.flatten()
S_bar = model.calibration['states']
S_bar = np.array(S_bar)
X0 = np.row_stack(
[np.concatenate([np.zeros(1), S_bar]),
np.column_stack([X_bar, X_s])])
fobj = lambda X: residuals(X, sigma, parms, g_fun, f_fun)
if verbose:
val = fobj(X0)
print('val')
print(val)
# exit()
t = time.time()
sol = solver(fobj,
X0,
method='lmmcp',
verbose=verbose,
options={
'preprocess': False,
'eps1': 1e-15,
'eps2': 1e-15
})
if verbose:
print('initial guess')
print(X0)
print('solution')
print sol
print('initial residuals')
print(fobj(X0))
print('residuals')
print fobj(sol)
s = time.time()
if verbose:
print('Elapsed : {0}'.format(s - t))
#sol = solver(fobj,X0, method='fsolve', verbose=True, options={'preprocessor':False})
norm = lambda x: numpy.linalg.norm(x, numpy.inf)
if verbose:
print("Initial error: {0}".format(norm(fobj(X0))))
print("Final error: {0}".format(norm(fobj(sol))))
print("Solution")
print(sol)
X_bar = sol[1:, 0]
S_bar = sol[0, 1:]
X_s = sol[1:, 1:]
# compute transitions
n_s = len(states)
n_x = len(controls)
[g, dg, junk] = g_fun(np.concatenate([S_bar, X_bar, epsilons_0]), parms)
g_s = dg[:, :n_s]
g_x = dg[:, n_s:n_s + n_x]
P = g_s + dot(g_x, X_s)
if verbose:
eigenvalues = numpy.linalg.eigvals(P)
print eigenvalues
eigenvalues = [abs(e) for e in eigenvalues]
eigenvalues.sort()
print(eigenvalues)
return [S_bar, X_bar, X_s, P]
def solve_risky_ss(model, X_bar, X_s, verbose=False):
import numpy
from dolo.compiler.function_compiler import compile_function
import time
from dolo.compiler.compiler_functions import simple_global_representation
parms = model.calibration['parameters']
sigma = model.calibration['covariances']
sgm = simple_global_representation(model)
states = sgm['states']
controls = sgm['controls']
shocks = sgm['shocks']
parameters = sgm['parameters']
f_eqs = sgm['f_eqs']
g_eqs = sgm['g_eqs']
g_args = [s(-1) for s in states] + [c(-1) for c in controls] + shocks
f_args = states + controls + [v(1) for v in states] + [v(1) for v in controls]
p_args = parameters
g_fun = compile_function(g_eqs, g_args, p_args, 2)
f_fun = compile_function(f_eqs, f_args, p_args, 3)
epsilons_0 = np.zeros((sigma.shape[0]))
from numpy import dot
from dolo.numeric.tensor import sdot,mdot
def residuals(X, sigma, parms, g_fun, f_fun):
import numpy
dummy_x = X[0:1,0]
X_bar = X[1:,0]
S_bar = X[0,1:]
X_s = X[1:,1:]
[n_x,n_s] = X_s.shape
n_e = sigma.shape[0]
xx = np.concatenate([S_bar, X_bar, epsilons_0])
[g_0, g_1, g_2] = g_fun(xx, parms)
[f_0,f_1,f_2,f_3] = f_fun( np.concatenate([S_bar, X_bar, S_bar, X_bar]), parms)
res_g = g_0 - S_bar
# g is a first order function
g_s = g_1[:,:n_s]
g_x = g_1[:,n_s:n_s+n_x]
g_e = g_1[:,n_s+n_x:]
g_se = g_2[:,:n_s,n_s+n_x:]
g_xe = g_2[:, n_s:n_s+n_x, n_s+n_x:]
# S(s,e) = g(s,x,e)
S_s = g_s + dot(g_x, X_s)
S_e = g_e
S_se = g_se + mdot(g_xe,[X_s, numpy.eye(n_e)])
# V(s,e) = [ g(s,x,e) ; x( g(s,x,e) ) ]
V_s = np.row_stack([
S_s,
dot( X_s, S_s )
]) # ***
V_e = np.row_stack([
S_e,
dot( X_s, S_e )
])
V_se = np.row_stack([
S_se,
dot( X_s, S_se )
])
# v(s) = [s, x(s)]
v_s = np.row_stack([
numpy.eye(n_s),
X_s
])
# W(s,e) = [xx(s,e); yy(s,e)]
W_s = np.row_stack([
v_s,
V_s
])
#return
nn = n_s + n_x
f_v = f_1[:,:nn]
f_V = f_1[:,nn:]
f_1V = f_2[:,:,nn:]
f_VV = f_2[:,nn:,nn:]
f_1VV = f_3[:,:,nn:,nn:]
# E = lambda v: np.tensordot(v, sigma, axes=((2,3),(0,1)) ) # expectation operator
F = f_0 + 0.5*np.tensordot( mdot(f_VV,[V_e,V_e]), sigma, axes=((1,2),(0,1)) )
F_s = sdot(f_1, W_s)
f_see = mdot(f_1VV, [W_s, V_e, V_e]) + 2*mdot(f_VV, [V_se, V_e])
F_s += 0.5 * np.tensordot(f_see, sigma, axes=((2,3),(0,1)) ) # second order correction
resp = np.row_stack([
np.concatenate([dummy_x,res_g]),
np.column_stack([F,F_s])
])
return resp
# S_bar = s_fun_init( numpy.atleast_2d(X_bar).T ,parms).flatten()
# S_bar = S_bar.flatten()
S_bar = model.calibration['states']
S_bar = np.array(S_bar)
X0 = np.row_stack([
np.concatenate([np.zeros(1),S_bar]),
np.column_stack([X_bar,X_s])
])
fobj = lambda X: residuals(X, sigma, parms, g_fun, f_fun)
if verbose:
val = fobj(X0)
print('val')
print(val)
# exit()
t = time.time()
sol = solver(fobj,X0, method='lmmcp', verbose=verbose, options={'preprocess':False, 'eps1':1e-15, 'eps2': 1e-15})
if verbose:
print('initial guess')
print(X0)
print('solution')
print sol
print('initial residuals')
print(fobj(X0))
print('residuals')
print fobj(sol)
s = time.time()
if verbose:
print('Elapsed : {0}'.format(s-t))
#sol = solver(fobj,X0, method='fsolve', verbose=True, options={'preprocessor':False})
norm = lambda x: numpy.linalg.norm(x,numpy.inf)
if verbose:
print( "Initial error: {0}".format( norm( fobj(X0)) ) )
print( "Final error: {0}".format( norm( fobj(sol) ) ) )
print("Solution")
print(sol)
X_bar = sol[1:,0]
S_bar = sol[0,1:]
X_s = sol[1:,1:]
# compute transitions
n_s = len(states)
n_x = len(controls)
[g, dg, junk] = g_fun( np.concatenate( [S_bar, X_bar, epsilons_0] ), parms)
g_s = dg[:,:n_s]
g_x = dg[:,n_s:n_s+n_x]
P = g_s + dot(g_x, X_s)
if verbose:
eigenvalues = numpy.linalg.eigvals(P)
print eigenvalues
eigenvalues = [abs(e) for e in eigenvalues]
eigenvalues.sort()
print(eigenvalues)
return [S_bar, X_bar, X_s, P]
