def portfolios_to_deterministic(model, pf_names):
#######
#######
import re
regex = re.compile('.*<=(.*)<=.*')
for i, eq in enumerate(model.equations_groups['arbitrage']):
from dolo.symbolic.symbolic import Variable, Equation
m = regex.match(eq.tags['complementarity'])
vs = m.group(1).strip()
if vs in pf_names:
v = Variable(vs)
neq = Equation(v, 0)
neq.tag(**eq.tags)
model.equations_groups['arbitrage'][i] = neq
print('Warning : initial model changed')
model.update()
return model
def portfolios_to_deterministic(model,pf_names):
#######
#######
import re
regex = re.compile('.*<=(.*)<=.*')
for i,eq in enumerate(model.equations_groups['arbitrage']):
from dolo.symbolic.symbolic import Variable, Equation
m = regex.match(eq.tags['complementarity'])
vs = m.group(1).strip()
if vs in pf_names:
v = Variable(vs)
neq = Equation(v,0)
neq.tag(**eq.tags)
model.equations_groups['arbitrage'][i] = neq
print('Warning : initial model changed')
model.update()
return model
def parse_yaml_text(txt, verbose=False):
'''
Imports the content of a modfile into the current interpreter scope
'''
txt = txt.replace('..', '-')
txt = txt.replace('--', '-')
txt = txt.replace('^', '**')
raw_dict = yaml.load(txt)
if verbose == True:
print('YAML file successfully parsed')
declarations = raw_dict['declarations']
# check
if 'controls' in declarations:
variables_groups = OrderedDict()
known_types = [
'states', 'controls', 'expectations', 'auxiliary', 'auxiliary_2'
]
for vtype in known_types:
if vtype in declarations:
variables_groups[vtype] = [
Variable(vn, 0) for vn in declarations[vtype]
]
variables_ordering = sum(variables_groups.values(), [])
else:
vnames = declarations['variables']
variables_ordering = [Variable(vn, 0) for vn in vnames]
variables_groups = None
parameters_ordering = [Parameter(vn) for vn in declarations['parameters']]
shocks_ordering = [Shock(vn, 0) for vn in declarations['shocks']]
context = [
(s.name, s)
for s in variables_ordering + parameters_ordering + shocks_ordering
]
context = dict(context)
# add some common functions
for f in [
sympy.log, sympy.exp, sympy.sin, sympy.cos, sympy.tan, sympy.asin,
sympy.acos, sympy.atan, sympy.sinh, sympy.cosh, sympy.tanh,
sympy.pi
]:
context[str(f)] = f
context['sqrt'] = sympy.sqrt
import re
# we recognize two kinds of equations:
# lhs = rhs
# lhs | comp where comp is a complementarity condition
equations = []
equations_groups = OrderedDict()
raw_equations = raw_dict['equations']
if isinstance(raw_equations,
dict): # tests whether there are groups of equations
for groupname in raw_equations.keys():
equations_groups[groupname] = []
for raw_eq in raw_equations[
groupname]: # Modfile is supposed to represent a global model. TODO: change it
teqg = raw_eq.split('|')
teq = teqg[0]
if '=' in teq:
lhs, rhs = str.split(teq, '=')
else:
lhs = teq
rhs = '0'
try:
lhs = eval(lhs, context)
rhs = eval(rhs, context)
except Exception as e:
print('Error parsing equation : ' + teq)
print str(e)
raise e
eq = Equation(lhs, rhs)
eq.tag(eq_type=groupname)
if len(teqg) > 1:
comp = teqg[1]
eq.tag(complementarity=comp)
equations.append(eq)
#equations_groups[groupname].append( eq )
else:
for teq in raw_equations:
if '=' in teq:
lhs, rhs = str.split(teq, '=')
else:
lhs = teq
rhs = '0'
try:
lhs = eval(lhs, context)
rhs = eval(rhs, context)
except Exception as e:
print('Error parsing equations : ' + teq)
print str(e)
eq = Equation(lhs, rhs)
equations.append(eq)
equations_groups = None
parameters_values = {}
init_values = {}
covariances = None
if 'calibration' in raw_dict:
calibration = raw_dict['calibration']
if 'parameters' in calibration:
parameters_values = [
(Parameter(k), eval(str(v), context))
for k, v in calibration['parameters'].iteritems()
]
parameters_values = dict(parameters_values)
#steady_state = raw_dict['steady_state']
if 'steady_state' in calibration:
init_values = [
(Variable(vn, 0), eval(str(value), context))
for vn, value in calibration['steady_state'].iteritems()
]
init_values = dict(init_values)
if 'covariances' in calibration:
context['sympy'] = sympy
covariances = eval(
'sympy.Matrix({0})'.format(calibration['covariances']),
context)
else:
covariances = None # to avoid importing numpy
model_dict = {
'variables_ordering': variables_ordering,
'parameters_ordering': parameters_ordering,
'shocks_ordering': shocks_ordering,
'variables_groups': variables_groups,
'equations_groups': equations_groups,
'equations': equations,
'parameters_values': parameters_values,
'init_values': init_values,
'covariances': covariances
}
if 'model_type' in raw_dict:
model_dict['model_type'] = raw_dict['model_type']
model_dict['original_data'] = raw_dict
model = Model(**model_dict)
model.check_consistency(auto_remove_variables=False)
return model
def parse_yaml_text(txt,verbose=False):
'''
Imports the content of a modfile into the current interpreter scope
'''
txt = txt.replace('..','-')
txt = txt.replace('--','-')
txt = txt.replace('^','**')
raw_dict = yaml.load(txt)
if verbose == True:
print('YAML file successfully parsed')
declarations = raw_dict['declarations']
# check
if 'controls' in declarations:
variables_groups = OrderedDict()
known_types = ['states','controls','expectations','auxiliary','auxiliary_2']
for vtype in known_types:
if vtype in declarations:
variables_groups[vtype] = [Variable(vn,0) for vn in declarations[vtype]]
variables_ordering = sum(variables_groups.values(),[])
else:
vnames = declarations['variables']
variables_ordering = [Variable(vn,0) for vn in vnames]
variables_groups = None
parameters_ordering = [Parameter(vn) for vn in declarations['parameters']]
shocks_ordering = [Shock(vn,0) for vn in declarations['shocks']]
context = [(s.name,s) for s in variables_ordering + parameters_ordering + shocks_ordering]
context = dict(context)
# add some common functions
for f in [sympy.log, sympy.exp,
sympy.sin, sympy.cos, sympy.tan,
sympy.asin, sympy.acos, sympy.atan,
sympy.sinh, sympy.cosh, sympy.tanh,
sympy.pi]:
context[str(f)] = f
context['sqrt'] = sympy.sqrt
import re
# we recognize two kinds of equations:
# lhs = rhs
# lhs | comp where comp is a complementarity condition
equations = []
equations_groups = OrderedDict()
raw_equations = raw_dict['equations']
if isinstance(raw_equations,dict): # tests whether there are groups of equations
for groupname in raw_equations.keys():
equations_groups[groupname] = []
for raw_eq in raw_equations[groupname]: # Modfile is supposed to represent a global model. TODO: change it
teqg = raw_eq.split('|')
teq = teqg[0]
if '=' in teq:
lhs,rhs = str.split(teq,'=')
else:
lhs = teq
rhs = '0'
try:
lhs = eval(lhs,context)
rhs = eval(rhs,context)
except Exception as e:
print('Error parsing equation : ' + teq)
print str(e)
raise e
eq = Equation(lhs,rhs)
eq.tag(eq_type=groupname)
if len(teqg)>1:
comp = teqg[1]
eq.tag(complementarity=comp)
equations.append(eq)
#equations_groups[groupname].append( eq )
else:
for teq in raw_equations:
if '=' in teq:
lhs,rhs = str.split(teq,'=')
else:
lhs = teq
rhs = '0'
try:
lhs = eval(lhs,context)
rhs = eval(rhs,context)
except Exception as e:
print('Error parsing equations : ' + teq)
print str(e)
eq = Equation(lhs,rhs)
equations.append(eq)
equations_groups = None
parameters_values = {}
init_values = {}
covariances = None
if 'calibration' in raw_dict:
calibration = raw_dict['calibration']
if 'parameters' in calibration:
parameters_values = [ (Parameter(k), eval(str(v),context)) for k,v in calibration['parameters'].iteritems() ]
parameters_values = dict(parameters_values)
#steady_state = raw_dict['steady_state']
if 'steady_state' in calibration:
init_values = [ (Variable(vn,0), eval(str(value),context)) for vn,value in calibration['steady_state'].iteritems() ]
init_values = dict(init_values)
if 'covariances' in calibration:
context['sympy'] = sympy
covariances = eval('sympy.Matrix({0})'.format( calibration['covariances'] ), context)
else:
covariances = None # to avoid importing numpy
model_dict = {
'variables_ordering': variables_ordering,
'parameters_ordering': parameters_ordering,
'shocks_ordering': shocks_ordering,
'variables_groups': variables_groups,
'equations_groups': equations_groups,
'equations': equations,
'parameters_values': parameters_values,
'init_values': init_values,
'covariances': covariances
}
if 'model_type' in raw_dict:
model_dict['model_type'] = raw_dict['model_type']
model_dict['original_data'] = raw_dict
model = Model(**model_dict)
model.check_consistency(auto_remove_variables=False)
return model
def solve_portfolio_model(model, pf_names, order=1):
pf_model = model
from dolo import Variable, Parameter, Equation
import re
n_states = len(pf_model['variables_groups']['states'])
states = pf_model['variables_groups']['states']
steady_states = [Parameter(v.name+'_bar') for v in pf_model['variables_groups']['states']]
n_pfs = len(pf_names)
pf_vars = [Variable(v) for v in pf_names]
res_vars = [Variable('res_'+str(i)) for i in range(n_pfs)]
pf_parms = [Parameter('K_'+str(i)) for i in range(n_pfs)]
pf_dparms = [[Parameter('K_'+str(i)+'_'+str(j)) for j in range(n_states)] for i in range(n_pfs)]
from sympy import Matrix
# creation of the new model
import copy
print('Warning: initial model has been changed.')
new_model = copy.copy(pf_model)
new_model['variables_groups']['controls']+=res_vars
new_model['parameters_ordering'].extend(steady_states)
for p in pf_parms + Matrix(pf_dparms)[:]:
new_model['parameters_ordering'].append(p)
new_model.parameters_values[p] = 0
compregex = re.compile('(.*)<=(.*)<=(.*)')
to_be_added = []
expressions = Matrix(pf_parms) + Matrix(pf_dparms)*( Matrix(states) - Matrix(steady_states))
for eq in new_model['equations_groups']['arbitrage']:
if 'complementarity' in eq.tags:
tg = eq.tags['complementarity']
[lhs,mhs,rhs] = compregex.match(tg).groups()
mhs = new_model.eval_string(mhs)
else:
mhs = None
if mhs in pf_vars:
i = pf_vars.index(mhs)
eq_n = eq.tags['eq_number']
neq = Equation(mhs, expressions[i])
neq.tag(**eq.tags)
new_model['equations'][eq_n] = neq
eq_res = Equation(eq.gap, res_vars[i])
eq_res.tag(eq_type='arbitrage')
to_be_added.append(eq_res)
new_model['equations'].extend(to_be_added)
new_model.check()
new_model.check_consistency(verbose=True)
print(new_model.parameters)
print(len(new_model['equations']))
print(len(new_model.equations))
print(len(new_model['equations_groups']['arbitrage']))
print('parameters_ordering')
print(new_model['parameters_ordering'])
print(new_model.parameters)
# now, we need to solve for the optimal portfolio coefficients
from dolo.numeric.perturbations_to_states import approximate_controls
dr = approximate_controls(new_model)
print('ok')
import numpy
n_controls = len(model['variables_groups']['controls'])
def constant_residuals(x):
for i in range(n_pfs):
p = pf_parms[i]
v = pf_vars[i]
new_model.parameters_values[p] = x[i]
new_model.init_values[v] = x[i]
[X_bar, X_s, X_ss] = approximate_controls(new_model, order=2, return_dr=False)
return X_bar[n_controls-n_pfs:n_controls]
x0 = numpy.zeros(n_pfs)
from dolo.numeric.solver import solver
portfolios_0 = solver(constant_residuals, x0)
print('Zero order portfolios : ')
print(portfolios_0)
print('Zero order: Final error:')
print(constant_residuals(portfolios_0))
def dynamic_residuals(X, return_dr=False):
x = X[:,0]
dx = X[:,1:]
for i in range(n_pfs):
p = pf_parms[i]
v = pf_vars[i]
model.parameters_values[p] = x[i]
model.init_values[v] = x[i]
for j in range(n_states):
model.parameters_values[pf_dparms[i][j]] = dx[i,j]
if return_dr:
dr = approximate_controls(new_model, order=2)
return dr
else:
[X_bar, X_s, X_ss, X_sss] = approximate_controls(new_model, order=3, return_dr=False)
crit = numpy.column_stack([
X_bar[n_controls-n_pfs:n_controls],
X_s[n_controls-n_pfs:n_controls,:],
])
return crit
y0 = numpy.column_stack([x0, numpy.zeros((n_pfs, n_states))])
print('Initial error:')
print(dynamic_residuals(y0))
portfolios_1 = solver(dynamic_residuals, y0)
print('First order portfolios : ')
print(portfolios_1)
print('Final error:')
print(dynamic_residuals(portfolios_1))
dr = dynamic_residuals(portfolios_1, return_dr=True)
return dr
def parse_yaml_text(txt,verbose=False, compiler=None):
'''
Imports the content of a modfile into the current interpreter scope
'''
txt = txt.replace('..','-')
txt = txt.replace('--','-')
txt = txt.replace('^','**')
txt = txt.replace('equilibrium:','arbitrage:')
txt = txt.replace('_|_','|')
raw_dict = yaml.load(txt)
if verbose == True:
print('YAML file successfully parsed')
declarations = raw_dict['declarations']
# check
variables_groups = OrderedDict()
for vtype in declarations.keys():
if vtype not in ('shocks','parameters'):
variables_groups[vtype] = [Variable(vn) for vn in declarations[vtype]]
variables_ordering = sum(variables_groups.values(),[])
# else:
# vnames = declarations['variables']
# variables_ordering = [Variable(vn) for vn in vnames]
# variables_groups = None
parameters_ordering = [Parameter(vn) for vn in declarations['parameters']]
shocks_ordering = [Shock(vn) for vn in declarations['shocks']]
context = [(s.name,s) for s in variables_ordering + parameters_ordering + shocks_ordering]
context = dict(context)
from dolo.symbolic.symbolic import timeshift as TS
# add some common functions
for f in [sympy.log, sympy.exp,
sympy.sin, sympy.cos, sympy.tan,
sympy.asin, sympy.acos, sympy.atan,
sympy.sinh, sympy.cosh, sympy.tanh,
sympy.pi, sympy.sign]:
context[str(f)] = f
context['sqrt'] = sympy.sqrt
context['TS'] = TS
if 'horrible_hack' in raw_dict:
tt = raw_dict['horrible_hack']
exec(tt, context)
import re
# we recognize two kinds of equations:
# lhs = rhs
# lhs | comp where comp is a complementarity condition
equations = []
equations_groups = OrderedDict()
raw_equations = raw_dict['equations']
if not isinstance(raw_equations,dict):
raw_dict['model_type'] = 'dynare'
raw_equations = {'dynare_block': raw_equations}
if True: # tests whether there are groups of equations
for groupname in raw_equations.keys():
equations_groups[groupname] = []
for raw_eq in raw_equations[groupname]: # Modfile is supposed to represent a global model. TODO: change it
teqg = raw_eq.split('|')
teq = teqg[0]
if '=' in teq:
lhs,rhs = str.split(teq,'=')
else:
lhs = teq
rhs = '0'
try:
lhs = eval(lhs,context)
rhs = eval(rhs,context)
except Exception as e:
print('Error parsing equation : ' + teq)
print( str(e) )
raise e
eq = Equation(lhs,rhs)
eq.tag(eq_type=groupname)
if len(teqg)>1:
comp = teqg[1]
eq.tag(complementarity=comp)
equations.append(eq)
equations_groups[groupname].append( eq )
else:
for teq in raw_equations:
if '=' in teq:
lhs,rhs = str.split(teq,'=')
else:
lhs = teq
rhs = '0'
try:
lhs = eval(lhs,context)
rhs = eval(rhs,context)
except Exception as e:
print('Error parsing equations : ' + teq)
print(str(e))
eq = Equation(lhs,rhs)
equations.append(eq)
equations_groups = None
parameters_values = {}
init_values = {}
covariances = None
if 'calibration' in raw_dict:
calibration = raw_dict['calibration']
if 'parameters' in calibration:
parameters_values = [ (Parameter(k), eval(str(v),context)) for k,v in iteritems(calibration['parameters']) ]
parameters_values = dict(parameters_values)
#steady_state = raw_dict['steady_state']
if 'steady_state' in calibration:
init_values = [ (Variable(vn), eval(str(value),context)) for vn,value in iteritems(calibration['steady_state']) ]
init_values = dict(init_values)
if 'covariances' in calibration:
context['sympy'] = sympy
covariances = eval('sympy.Matrix({0})'.format( calibration['covariances'] ), context)
else:
covariances = None # to avoid importing numpy
symbols = variables_groups
symbols['shocks'] = shocks_ordering
symbols['parameters'] = parameters_ordering
calibration_s = {}
calibration_s.update(parameters_values)
calibration_s.update(init_values)
from dolo.symbolic.model import SModel
model = SModel( equations_groups, symbols, calibration_s, covariances )
model.__data__ = raw_dict
return model
def parse_yaml_text(txt, verbose=False, compiler=None):
'''
Imports the content of a modfile into the current interpreter scope
'''
txt = txt.replace('..', '-')
txt = txt.replace('--', '-')
txt = txt.replace('^', '**')
txt = txt.replace('equilibrium:', 'arbitrage:')
txt = txt.replace('_|_', '|')
raw_dict = yaml.load(txt)
if verbose == True:
print('YAML file successfully parsed')
declarations = raw_dict['declarations']
# check
variables_groups = OrderedDict()
for vtype in declarations.keys():
if vtype not in ('shocks', 'parameters'):
variables_groups[vtype] = [
Variable(vn) for vn in declarations[vtype]
]
variables_ordering = sum(variables_groups.values(), [])
# else:
# vnames = declarations['variables']
# variables_ordering = [Variable(vn) for vn in vnames]
# variables_groups = None
parameters_ordering = [Parameter(vn) for vn in declarations['parameters']]
shocks_ordering = [Shock(vn) for vn in declarations['shocks']]
context = [
(s.name, s)
for s in variables_ordering + parameters_ordering + shocks_ordering
]
context = dict(context)
from dolo.symbolic.symbolic import timeshift as TS
# add some common functions
for f in [
sympy.log, sympy.exp, sympy.sin, sympy.cos, sympy.tan, sympy.asin,
sympy.acos, sympy.atan, sympy.sinh, sympy.cosh, sympy.tanh,
sympy.pi, sympy.sign
]:
context[str(f)] = f
context['sqrt'] = sympy.sqrt
context['TS'] = TS
if 'horrible_hack' in raw_dict:
tt = raw_dict['horrible_hack']
exec(tt, context)
import re
# we recognize two kinds of equations:
# lhs = rhs
# lhs | comp where comp is a complementarity condition
equations = []
equations_groups = OrderedDict()
raw_equations = raw_dict['equations']
if not isinstance(raw_equations, dict):
raw_dict['model_type'] = 'dynare'
raw_equations = {'dynare_block': raw_equations}
if True: # tests whether there are groups of equations
for groupname in raw_equations.keys():
equations_groups[groupname] = []
for raw_eq in raw_equations[
groupname]: # Modfile is supposed to represent a global model. TODO: change it
teqg = raw_eq.split('|')
teq = teqg[0]
if '=' in teq:
lhs, rhs = str.split(teq, '=')
else:
lhs = teq
rhs = '0'
try:
lhs = eval(lhs, context)
rhs = eval(rhs, context)
except Exception as e:
print('Error parsing equation : ' + teq)
print(str(e))
raise e
eq = Equation(lhs, rhs)
eq.tag(eq_type=groupname)
if len(teqg) > 1:
comp = teqg[1]
eq.tag(complementarity=comp)
equations.append(eq)
equations_groups[groupname].append(eq)
else:
for teq in raw_equations:
if '=' in teq:
lhs, rhs = str.split(teq, '=')
else:
lhs = teq
rhs = '0'
try:
lhs = eval(lhs, context)
rhs = eval(rhs, context)
except Exception as e:
print('Error parsing equations : ' + teq)
print(str(e))
eq = Equation(lhs, rhs)
equations.append(eq)
equations_groups = None
parameters_values = {}
init_values = {}
covariances = None
if 'calibration' in raw_dict:
calibration = raw_dict['calibration']
if 'parameters' in calibration:
parameters_values = [
(Parameter(k), eval(str(v), context))
for k, v in iteritems(calibration['parameters'])
]
parameters_values = dict(parameters_values)
#steady_state = raw_dict['steady_state']
if 'steady_state' in calibration:
init_values = [
(Variable(vn), eval(str(value), context))
for vn, value in iteritems(calibration['steady_state'])
]
init_values = dict(init_values)
if 'covariances' in calibration:
context['sympy'] = sympy
covariances = eval(
'sympy.Matrix({0})'.format(calibration['covariances']),
context)
else:
covariances = None # to avoid importing numpy
symbols = variables_groups
symbols['shocks'] = shocks_ordering
symbols['parameters'] = parameters_ordering
calibration_s = {}
calibration_s.update(parameters_values)
calibration_s.update(init_values)
from dolo.symbolic.model import SModel
model = SModel(equations_groups, symbols, calibration_s, covariances)
model.__data__ = raw_dict
return model
def solve_portfolio_model(model, pf_names, order=2, guess=None):
from dolo.compiler.compiler_python import GModel
if isinstance(model, GModel):
model = model.model
pf_model = model
from dolo import Variable, Parameter, Equation
import re
n_states = len(pf_model.symbols_s['states'])
states = pf_model.symbols_s['states']
steady_states = [
Parameter(v.name + '_bar') for v in pf_model.symbols_s['states']
]
n_pfs = len(pf_names)
pf_vars = [Variable(v) for v in pf_names]
res_vars = [Variable('res_' + str(i)) for i in range(n_pfs)]
pf_parms = [Parameter('K_' + str(i)) for i in range(n_pfs)]
pf_dparms = [[
Parameter('K_' + str(i) + '_' + str(j)) for j in range(n_states)
] for i in range(n_pfs)]
from sympy import Matrix
# creation of the new model
import copy
new_model = copy.copy(pf_model)
new_model.symbols_s['controls'] += res_vars
for v in res_vars + pf_vars:
new_model.calibration_s[v] = 0
new_model.symbols_s['parameters'].extend(steady_states)
for p in pf_parms + Matrix(pf_dparms)[:]:
new_model.symbols_s['parameters'].append(p)
new_model.calibration_s[p] = 0
compregex = re.compile('(.*)<=(.*)<=(.*)')
to_be_added_1 = []
to_be_added_2 = []
expressions = Matrix(pf_parms) + Matrix(pf_dparms) * (
Matrix(states) - Matrix(steady_states))
for n, eq in enumerate(new_model.equations_groups['arbitrage']):
if 'complementarity' in eq.tags:
tg = eq.tags['complementarity']
[lhs, mhs, rhs] = compregex.match(tg).groups()
mhs = new_model.eval_string(mhs)
else:
mhs = None
if mhs in pf_vars:
i = pf_vars.index(mhs)
neq = Equation(mhs, expressions[i])
neq.tag(**eq.tags)
eq_res = Equation(eq.gap, res_vars[i])
eq_res.tag(eq_type='arbitrage')
to_be_added_2.append(eq_res)
new_model.equations_groups['arbitrage'][n] = neq
to_be_added_1.append(neq)
# new_model.equations_groups['arbitrage'].extend(to_be_added_1)
new_model.equations_groups['arbitrage'].extend(to_be_added_2)
new_model.update()
print("number of equations {}".format(len(new_model.equations)))
print("number of arbitrage equations {}".format(
len(new_model.equations_groups['arbitrage'])))
print('parameters_ordering')
print("number of parameters {}".format(new_model.symbols['parameters']))
print("number of parameters {}".format(new_model.parameters))
# now, we need to solve for the optimal portfolio coefficients
from dolo.numeric.perturbations_to_states import approximate_controls
dr = approximate_controls(new_model)
print('ok')
import numpy
n_controls = len(model.symbols_s['controls'])
def constant_residuals(x, return_dr=False):
d = {}
for i in range(n_pfs):
p = pf_parms[i]
v = pf_vars[i]
d[p] = x[i]
d[v] = x[i]
new_model.set_calibration(d)
# new_model.parameters_values[p] = x[i]
# new_model.init_values[v] = x[i]
if return_dr:
dr = approximate_controls(new_model, order=1, return_dr=True)
return dr
X_bar, X_s, X_ss = approximate_controls(new_model,
order=2,
return_dr=False)
return X_bar[n_controls - n_pfs:n_controls]
if guess is not None:
x0 = numpy.array(guess)
else:
x0 = numpy.zeros(n_pfs)
from dolo.numeric.solver import solver
portfolios_0 = solver(constant_residuals, x0)
print('Zero order portfolios: {}'.format(portfolios_0))
print('Zero order portfolios: Final error: {}'.format(
constant_residuals(portfolios_0)))
if order == 1:
dr = constant_residuals(portfolios_0, return_dr=True)
return dr
def dynamic_residuals(X, return_dr=False):
x = X[:, 0]
dx = X[:, 1:]
d = {}
for i in range(n_pfs):
p = pf_parms[i]
v = pf_vars[i]
d[p] = x[i]
d[v] = x[i]
for j in range(n_states):
d[pf_dparms[i][j]] = dx[i, j]
new_model.set_calibration(d)
if return_dr:
dr = approximate_controls(new_model, order=2)
return dr
else:
[X_bar, X_s, X_ss, X_sss] = approximate_controls(new_model,
order=3,
return_dr=False)
crit = numpy.column_stack([
X_bar[n_controls - n_pfs:n_controls],
X_s[n_controls - n_pfs:n_controls, :],
])
return crit
y0 = numpy.column_stack([x0, numpy.zeros((n_pfs, n_states))])
print('Initial error:')
print(dynamic_residuals(y0))
portfolios_1 = solver(dynamic_residuals, y0)
print('First order portfolios : ')
print(portfolios_1)
print('Final error:')
print(dynamic_residuals(portfolios_1))
dr = dynamic_residuals(portfolios_1, return_dr=True)
return dr
def solve_portfolio_model(model, pf_names, order=1):
pf_model = model
from dolo import Variable, Parameter, Equation
import re
n_states = len(pf_model['variables_groups']['states'])
states = pf_model['variables_groups']['states']
steady_states = [
Parameter(v.name + '_bar')
for v in pf_model['variables_groups']['states']
]
n_pfs = len(pf_names)
pf_vars = [Variable(v, 0) for v in pf_names]
res_vars = [Variable('res_' + str(i), 0) for i in range(n_pfs)]
pf_parms = [Parameter('K_' + str(i)) for i in range(n_pfs)]
pf_dparms = [[
Parameter('K_' + str(i) + '_' + str(j)) for j in range(n_states)
] for i in range(n_pfs)]
from sympy import Matrix
# creation of the new model
import copy
print('Warning: initial model has been changed.')
new_model = copy.copy(pf_model)
new_model['variables_groups']['controls'] += res_vars
new_model.check()
for p in pf_parms + Matrix(pf_dparms)[:]:
new_model['parameters_ordering'].append(p)
new_model.parameters_values[p] = 0
compregex = re.compile('(.*)<=(.*)<=(.*)')
to_be_added = []
expressions = Matrix(pf_parms) + Matrix(pf_dparms) * (
Matrix(states) - Matrix(steady_states))
for eq in new_model['equations_groups']['arbitrage']:
if 'complementarity' in eq.tags:
tg = eq.tags['complementarity']
[lhs, mhs, rhs] = compregex.match(tg).groups()
mhs = new_model.eval_string(mhs)
else:
mhs = None
if mhs in pf_vars:
i = pf_vars.index(mhs)
eq_n = eq.tags['eq_number']
neq = Equation(mhs, expressions[i])
neq.tag(**eq.tags)
new_model['equations'][eq_n] = neq
eq_res = Equation(eq.gap, res_vars[i])
eq_res.tag(eq_type='arbitrage')
to_be_added.append(eq_res)
new_model['equations'].extend(to_be_added)
new_model.check()
new_model.check_consistency()
# now, we need to solve for the optimal portfolio coefficients
from dolo.numeric.perturbations_to_states import approximate_controls
import numpy
n_controls = len(model['variables_groups']['controls'])
def constant_residuals(x):
for i in range(n_pfs):
p = pf_parms[i]
v = pf_vars[i]
model.parameters_values[p] = x[i]
model.init_values[v] = x[i]
[X_bar, X_s, X_ss] = approximate_controls(new_model,
order=2,
return_dr=False)
return X_bar[n_controls - n_pfs:n_controls]
x0 = numpy.zeros(n_pfs)
from dolo.numeric.solver import solver
portfolios_0 = solver(constant_residuals, x0)
print('Zero order portfolios : ')
print(portfolios_0)
print('Zero order: Final error:')
print(constant_residuals(portfolios_0))
def dynamic_residuals(X, return_dr=False):
x = X[:, 0]
dx = X[:, 1:]
for i in range(n_pfs):
p = pf_parms[i]
v = pf_vars[i]
model.parameters_values[p] = x[i]
model.init_values[v] = x[i]
for j in range(n_states):
model.parameters_values[pf_dparms[i][j]] = dx[i, j]
if return_dr:
dr = approximate_controls(new_model, order=2, return_dr=True)
return dr
else:
[X_bar, X_s, X_ss, X_sss] = approximate_controls(new_model,
order=3,
return_dr=False)
crit = numpy.column_stack([
X_bar[n_controls - n_pfs:n_controls],
X_s[n_controls - n_pfs:n_controls, :],
])
return crit
y0 = numpy.column_stack([x0, numpy.zeros((n_pfs, n_states))])
print('Initial error:')
print(dynamic_residuals(y0))
portfolios_1 = solver(dynamic_residuals, y0)
print('First order portfolios : ')
print(portfolios_1)
print('Final error:')
print(dynamic_residuals(portfolios_1))
dr = dynamic_residuals(portfolios_1, return_dr=True)
return dr
def solve_portfolio_model(model, pf_names, order=2, guess=None):
from dolo.compiler.compiler_python import GModel
if isinstance(model, GModel):
model = model.model
pf_model = model
from dolo import Variable, Parameter, Equation
import re
n_states = len(pf_model.symbols_s['states'])
states = pf_model.symbols_s['states']
steady_states = [Parameter(v.name+'_bar') for v in pf_model.symbols_s['states']]
n_pfs = len(pf_names)
pf_vars = [Variable(v) for v in pf_names]
res_vars = [Variable('res_'+str(i)) for i in range(n_pfs)]
pf_parms = [Parameter('K_'+str(i)) for i in range(n_pfs)]
pf_dparms = [[Parameter('K_'+str(i)+'_'+str(j)) for j in range(n_states)] for i in range(n_pfs)]
from sympy import Matrix
# creation of the new model
import copy
new_model = copy.copy(pf_model)
new_model.symbols_s['controls'] += res_vars
for v in res_vars + pf_vars:
new_model.calibration_s[v] = 0
new_model.symbols_s['parameters'].extend(steady_states)
for p in pf_parms + Matrix(pf_dparms)[:]:
new_model.symbols_s['parameters'].append(p)
new_model.calibration_s[p] = 0
compregex = re.compile('(.*)<=(.*)<=(.*)')
to_be_added_1 = []
to_be_added_2 = []
expressions = Matrix(pf_parms) + Matrix(pf_dparms)*( Matrix(states) - Matrix(steady_states))
for n,eq in enumerate(new_model.equations_groups['arbitrage']):
if 'complementarity' in eq.tags:
tg = eq.tags['complementarity']
[lhs,mhs,rhs] = compregex.match(tg).groups()
mhs = new_model.eval_string(mhs)
else:
mhs = None
if mhs in pf_vars:
i = pf_vars.index(mhs)
neq = Equation(mhs, expressions[i])
neq.tag(**eq.tags)
eq_res = Equation(eq.gap, res_vars[i])
eq_res.tag(eq_type='arbitrage')
to_be_added_2.append(eq_res)
new_model.equations_groups['arbitrage'][n] = neq
to_be_added_1.append(neq)
# new_model.equations_groups['arbitrage'].extend(to_be_added_1)
new_model.equations_groups['arbitrage'].extend(to_be_added_2)
new_model.update()
print("number of equations {}".format(len(new_model.equations)))
print("number of arbitrage equations {}".format( len(new_model.equations_groups['arbitrage'])) )
print('parameters_ordering')
print("number of parameters {}".format(new_model.symbols['parameters']))
print("number of parameters {}".format(new_model.parameters))
# now, we need to solve for the optimal portfolio coefficients
from dolo.numeric.perturbations_to_states import approximate_controls
dr = approximate_controls(new_model)
print('ok')
import numpy
n_controls = len(model.symbols_s['controls'])
def constant_residuals(x, return_dr=False):
d = {}
for i in range(n_pfs):
p = pf_parms[i]
v = pf_vars[i]
d[p] = x[i]
d[v] = x[i]
new_model.set_calibration(d)
# new_model.parameters_values[p] = x[i]
# new_model.init_values[v] = x[i]
if return_dr:
dr = approximate_controls(new_model, order=1, return_dr=True)
return dr
X_bar, X_s, X_ss = approximate_controls(new_model, order=2, return_dr=False)
return X_bar[n_controls-n_pfs:n_controls]
if guess is not None:
x0 = numpy.array(guess)
else:
x0 = numpy.zeros(n_pfs)
from dolo.numeric.solver import solver
portfolios_0 = solver(constant_residuals, x0)
print('Zero order portfolios: {}'.format(portfolios_0))
print('Zero order portfolios: Final error: {}'.format( constant_residuals(portfolios_0) ))
if order == 1:
dr = constant_residuals(portfolios_0, return_dr=True)
return dr
def dynamic_residuals(X, return_dr=False):
x = X[:,0]
dx = X[:,1:]
d = {}
for i in range(n_pfs):
p = pf_parms[i]
v = pf_vars[i]
d[p] = x[i]
d[v] = x[i]
for j in range(n_states):
d[pf_dparms[i][j]] = dx[i,j]
new_model.set_calibration(d)
if return_dr:
dr = approximate_controls(new_model, order=2)
return dr
else:
[X_bar, X_s, X_ss, X_sss] = approximate_controls(new_model, order=3, return_dr=False)
crit = numpy.column_stack([
X_bar[n_controls-n_pfs:n_controls],
X_s[n_controls-n_pfs:n_controls,:],
])
return crit
y0 = numpy.column_stack([x0, numpy.zeros((n_pfs, n_states))])
print('Initial error:')
print(dynamic_residuals(y0))
portfolios_1 = solver(dynamic_residuals, y0)
print('First order portfolios : ')
print(portfolios_1)
print('Final error:')
print(dynamic_residuals(portfolios_1))
dr = dynamic_residuals(portfolios_1, return_dr=True)
return dr
