1
2 import copy
3 from sympy import __version__ as sympy_version
4 print("Sympy version is : " + sympy_version)
5 from sympy import *
6
7
8 import misc.calculus
9 import re
10
12 '''
13 Define a new variable with : x = Variable('x')
14 Then x(k) returns the value with lag k
15 Internally x(-k) is a symbol with name x_bk
16 '''
17
18
19
20
21 basename = None
22 name = None
23 init_value = None
24 end_value = None
25
33
35 newlag = self.lag + lag
36 if newlag < 0:
37 newname = self.basename + "_b" + str(- newlag)
38
39 elif newlag > 0:
40 newname = self.basename + "_f" + str( newlag )
41
42 else:
43 newname = self.basename
44 v = Variable(newname)
45 v.lag = newlag
46 v.basename = self.basename
47 return v
48
49 - def tostr(self, level=0):
50 precedence = self.precedence
51 if self.lag != 0:
52 result = self.basename + "(" + str(self.lag) + ")"
53 else:
54 result = self.basename
55 if precedence<=level:
56 return('(%s)' % (result))
57 return result
58
74
76
77 name = None
78
79 - def __init__(self, lhs, rhs, name=None,is_endogenous=True):
80 super(Equality,self).__init__()
81 self.name = name
82 self.is_endogenous=is_endogenous
83 return(None)
84
86 return( -self.lhs + self.rhs)
87
147
149
150
151
152
153
154 f_eq_n = []
155 f_eq = []
156 f_vars = set([])
157 for i in range(len(self.equations)):
158 eq = self.equations[i]
159 all_atoms = eq.atoms()
160 f_var = []
161 for a in all_atoms:
162 if (a.__class__ == Variable) and (a(-a.lag) in self.variables):
163 if a.lag > 0:
164 f_var.append(a)
165 if len(f_var)>0:
166 f_eq_n.append(i)
167 f_eq.append(eq)
168 f_vars = f_vars.union(f_var)
169 f_vars = list(f_vars)
170 return([f_vars,f_eq,f_eq_n])
171
173 '''
174 returns the jacobian of the equations with respect to
175 all_variables_f,all_variables,all_variables_b
176 where all_variables == variables + exovariables
177 '''
178
179 all_variables = self.variables + self.exovariables
180 vec = map(lambda v: v(1), all_variables) + all_variables + map(lambda v: v(-1), all_variables)
181 vec = Matrix([vec])
182
183 f = Matrix( map(lambda eq: eq.gap(),self.equations) )
184 return f.T.jacobian(vec)
185
187
188 pf_model = self.copy()
189 pf_model.fname = pf_model.fname + "_pf"
190
191 [f_vars,f_eq,f_eq_n] = pf_model.future_variables()
192
193 f_vars_c = map(lambda v: v(-v.lag), f_vars)
194
195 nf_eq_n = list(set(range(len(self.equations))).difference(f_eq_n))
196 nf_eq = map(lambda (n): self.equations[n], nf_eq_n)
197
198 nf_eq = map(lambda eq: eq.gap(), nf_eq)
199 f_eq = map(lambda eq: eq.gap(), f_eq)
200
201 A = Matrix(len(nf_eq),len(self.exovariables), lambda i,j : Variable("A_"+str(i+1)+str(j+1)))
202 for a in A:
203 pf_model.variables.append(a)
204
205
206
207 f = Matrix(nf_eq)
208 f_X = f.jacobian(f_vars_c)
209 for v in pf_model.exovariables:
210 f_X = f_X.subs(v,0)
211 f_E = f.jacobian(Matrix(self.exovariables))
212 for v in pf_model.exovariables:
213 f_E = f_E.subs(v,0)
214 f_ = f_X * A + f_E
215
216
217
218
219 s_f_eq = []
220 for i in range(len(f_eq)):
221 eq = f_eq[i]
222 for k in range(len(f_vars)):
223 v = f_vars[k]
224 dv = (A[k,:] * Matrix(self.exovariables))[0,0]
225 eq = eq.subs(v,v+dv)
226 seq = Calculus.second_order_taylorisation(eq, self.exovariables, self.covariances)
227 s_f_eq.append(Equality(0,seq))
228
229 for eq in f_:
230 pf_model.equations.append(Equation(0,eq,"Another moment condition") )
231
232 for i in range(len(f_eq)):
233 pf_model.equations[f_eq_n[i]] = s_f_eq[i]
234
235 return(pf_model)
236