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