PageRenderTime 69ms CodeModel.GetById 20ms RepoModel.GetById 0ms app.codeStats 0ms

/pymaclab/dsge/parsers/_dsgeparser.py

https://github.com/TomAugspurger/pymaclab
Python | 2265 lines | 2226 code | 11 blank | 28 comment | 37 complexity | 867fda6981f05a46d42eff0254ad3cdd MD5 | raw file
Possible License(s): Apache-2.0 
    

  1. '''
    2. 

  2. .. module:: _dsgeparser
    3. 

  3.    :platform: Linux
    4. 

  4.    :synopsis: This is the (private) module responsible for carefully extracting meaningful information from the DSGE model templated
    5. 

  5.               files. In here we make much use of Regex patterns as we are extracting information from the mod file lines.
    6. 

  6. 

  7. .. moduleauthor:: Eric M. Scheffel <eric.scheffel@nottingham.edu.cn>
    8. 

  8. 

  9. 

  10. '''
    11. 

  11. import re
    12. 

  12. from copy import deepcopy
    13. 

  13. import numpy.matlib as mat
    14. 

  14. import numpy as np
    15. 

  15. import sys
    16. 

  16. import os
    17. 

  17. # This used to import sympycore, but should now also work with sympy
    18. 

  18. import sympycore as SP
    19. 

  19. 

  20. 

  21. #TODO: why have these as nested functions?
    22. 

  22. def populate_model_stage_one(self, secs):
    23. 

  23.     """
    24. 

  24.     1st stage population of DSGE model.  Does not need Steady State.
    25. 

  25.     """
    26. 

  26.     
    27. 

  27.     # Establish the timing convention of variables in the model file
    28. 

  28.     self = def_timing(self,**self._vtiming)    
    29. 

  29.     
    30. 

  30.     # This is a special dictionary which can be handed over to the template engines (i.e. Jinja2)
    31. 

  31.     if 'template_paramdic' not in dir(self): self.template_paramdic = {}
    32. 

  32. 

  33. 

  34.     # Get all information from the varvec section
    35. 

  35.     if all([False if 'None' in x else True for x in secs['varvec'][0]]):
    36. 

  36.         # match something like [1]  z(t):eps_z(t):techshock{exo}[log,hp]
    37. 

  37.         vtexp =  re.compile('^.*?\[.*?\]\s*(?P<vari>.+?)\s*:\s*(?P<varn>.+?)\s*\{(?P<vtype>[^\[]+)}\s*(?P<mod>\[.*?\]){0,1}')
    38. 

  38.         # match something like [15] x2(t):wrec2{con}[log,hp] OR [1] z(t):eps_z(t):techshock{exo}[log,hp]
    39. 

  39.         viiexp = re.compile('^.*?\[.*?\]\s*(?P<vari>.+?)\s*:\s*(?P<viid>.+?)\s*:\s*(?P<varn>.+?)\s*\{(?P<vtype>[^\[]+)}\s*(?P<mod>\[.*?\]){0,1}')
    40. 

  40.         voexp =  re.compile('^.*?\[.*?\]\s*(?P<vari>@.+?):(?P<varn>[^\[]+)\s*(?P<mod>\[.*?\]){0,1}')
    41. 

  41.         vardic = {}
    42. 

  42.         audic = {}
    43. 

  43.         vardic['endo'] = {}
    44. 

  44.         audic['endo'] = {}
    45. 

  45.         vardic['exo'] = {}
    46. 

  46.         audic['exo'] = {}
    47. 

  47.         vardic['con'] = {}
    48. 

  48.         audic['con'] = {}
    49. 

  49.         vardic['other'] = {}
    50. 

  50.         vardic['endo']['var'] = []
    51. 

  51.         vardic['endo']['mod'] = []
    52. 

  52.         vardic['exo']['var'] = []
    53. 

  53.         vardic['exo']['mod'] = []
    54. 

  54.         vardic['con']['var'] = []
    55. 

  55.         vardic['con']['mod'] = []
    56. 

  56.         vardic['other']['var'] = []
    57. 

  57.         vardic['other']['mod'] = []
    58. 

  58.         audic['endo']['var'] = []
    59. 

  59.         audic['endo']['mod'] = []
    60. 

  60.         audic['con']['var'] = []
    61. 

  61.         audic['con']['mod'] = []
    62. 

  62.         audic['exo']['var'] = []
    63. 

  63.         audic['exo']['mod'] = []
    64. 

  64. 

  65.         for x in secs['varvec'][0]:
    66. 

  66.             if viiexp.search(x):
    67. 

  67.                 ma = viiexp.search(x)
    68. 

  68.                 vari = ma.group('vari').strip()
    69. 

  69.                 viid = ma.group('viid').strip()
    70. 

  70.                 varn = ma.group('varn').strip()
    71. 

  71.                 vtype = ma.group('vtype').strip()
    72. 

  72.                 mods = ma.group('mod')
    73. 

  73.                 vardic[vtype]['var'].append([vari,varn,viid])
    74. 

  74.                 if mods != None:
    75. 

  75.                     mods = mods.strip()
    76. 

  76.                     if ',' in mods:
    77. 

  77.                         vardic[vtype]['mod'].append(mods[1:-1].strip().split(','))
    78. 

  78.                     else:
    79. 

  79.                         vardic[vtype]['mod'].append([mods[1:-1].strip(),])
    80. 

  80.                 else:
    81. 

  81.                     vardic[vtype]['mod'].append([])
    82. 

  82. 

  83.             elif vtexp.search(x):
    84. 

  84.                 ma = vtexp.search(x)
    85. 

  85.                 vari = ma.group('vari').strip()
    86. 

  86.                 varn = ma.group('varn').strip()
    87. 

  87.                 vtype = ma.group('vtype').strip()
    88. 

  88.                 mods = ma.group('mod')
    89. 

  89.                 vardic[vtype]['var'].append([vari,varn])
    90. 

  90.                 if mods != None:
    91. 

  91.                     mods = mods.strip()
    92. 

  92.                     if ',' in mods:
    93. 

  93.                         vardic[vtype]['mod'].append(mods[1:-1].strip().split(','))
    94. 

  94.                     else:
    95. 

  95.                         vardic[vtype]['mod'].append([mods[1:-1].strip(),])
    96. 

  96.                 else:
    97. 

  97.                     vardic[vtype]['mod'].append([])
    98. 

  98. 

  99.             elif voexp.search(x):
    100. 

  100.                 ma = voexp.search(x)
    101. 

  101.                 # Slice off the @
    102. 

  102.                 vari = ma.group('vari')[1:].strip()
    103. 

  103.                 varn = ma.group('varn').strip()
    104. 

  104.                 mods = ma.group('mod')
    105. 

  105.                 vardic['other']['var'].append([vari,varn])
    106. 

  106.                 if mods != None:
    107. 

  107.                     mods = mods.strip()
    108. 

  108.                     if ',' in mods:
    109. 

  109.                         vardic['other']['mod'].append(mods[1:-1].strip().split(','))
    110. 

  110.                     else:
    111. 

  111.                         vardic['other']['mod'].append([mods[1:-1].strip(),])
    112. 

  112.                 else:
    113. 

  113.                     vardic['other']['mod'].append([])
    114. 

  114. 

  115.         self.nendo = len(vardic['endo']['var'])
    116. 

  116.         self.nexo = len(vardic['exo']['var'])
    117. 

  117.         self.ncon = len(vardic['con']['var'])
    118. 

  118.         self.nother = len(vardic['other']['var'])
    119. 

  119.         self.nstat = self.nendo+self.nexo
    120. 

  120.         self.nall = self.nstat+self.ncon
    121. 

  121.         self.vardic = vardic
    122. 

  122.         self.audic = audic
    123. 

  123.         # Save for template instantiation
    124. 

  124.         self.template_paramdic['vardic'] = deepcopy(vardic)
    125. 

  125.     else:
    126. 

  126.         self.template_paramdic['vardic'] = False
    127. 

  127. 

  128.     # Extract the model name and description
    129. 

  129.     if all([False if 'None' in x else True for x in secs['info'][0]]):
    130. 

  130.         for x in secs['info'][0]:
    131. 

  131.             if 'Name' in x:
    132. 

  132.                 self.mod_name = x.split('=')[1].replace(';','').strip()
    133. 

  133.                 # Save for template instantiation
    134. 

  134.                 self.template_paramdic['mod_name'] = deepcopy(self.mod_name)          
    135. 

  135.             if 'Desc' in x:
    136. 

  136.                 self.mod_desc = x.split('=')[1].replace(';','').strip()
    137. 

  137.                 # Save for template instantiation
    138. 

  138.                 self.template_paramdic['mod_desc'] = deepcopy(self.mod_desc)
    139. 

  139.         if not self.template_paramdic.has_key('mod_name'):
    140. 

  140.             self.template_paramdic['mod_name'] = False
    141. 

  141.         if not self.template_paramdic.has_key('mod_desc'):
    142. 

  142.             self.template_paramdic['mod_desc'] = False
    143. 

  143. 

  144.     # Extract parameters into dictionary
    145. 

  145.     if all([False if 'None' in x else True for x in secs['params'][0]]):
    146. 

  146.         param = {}
    147. 

  147.         # need to do this so users don't have to worry about integer division
    148. 

  148.         # but preserves integer division for sympycore stuff
    149. 

  149.         safe_div = """
    150. 

  150. from __future__ import division
    151. 

  151. """
    152. 

  152.         for x in secs['params'][0]:
    153. 

  153.             if ']' in x: x = x.split(']')[1].lstrip()
    154. 

  154.             list_tmp = x.split(';')
    155. 

  155.             list_tmp = list_tmp[0].split('=')[:]
    156. 

  156.             str_tmp1 = list_tmp[0].strip()
    157. 

  157.             str_tmp2 = list_tmp[1].strip()
    158. 

  158.             #NOTE: this *should* be safe, but users should know what's
    159. 

  159.             # in the .mod file
    160. 

  160.             exec(safe_div + "param['"+str_tmp1+"']=" + str_tmp2, {}, locals())
    161. 

  161.             locals()[str_tmp1] = param[str_tmp1]
    162. 

  162.         self.paramdic = param
    163. 

  163.         # Save for template instantiation
    164. 

  164.         self.template_paramdic['paramdic'] = deepcopy(param)
    165. 

  165.     else:
    166. 

  166.         self.template_paramdic['paramdic'] = False
    167. 

  167. 

  168.     # Collect information on manual (closed-form) steady state
    169. 

  169.     if all([False if 'None' in x else True for x in secs['closedformss'][0]]):
    170. 

  170.         # Join multiline steady state definitions
    171. 

  171.         mansys = secs['closedformss'][0]
    172. 

  172.         list_tmp1 = []
    173. 

  173.         i1=0
    174. 

  174.         counter=0
    175. 

  175.         for x in mansys:
    176. 

  176.             if '...' in x:
    177. 

  177.                 counter = counter + 1
    178. 

  178.             elif '...' not in x:
    179. 

  179.                 if counter == 0:
    180. 

  180.                     # Just in case people have used [1] markers...
    181. 

  181.                     if ']' in x: x = x.split(']')[1].lstrip().rstrip()
    182. 

  182.                     list_tmp1.append(x)
    183. 

  183.                 elif counter > 0:
    184. 

  184.                     str_tmp = ''
    185. 

  185.                     for y in mansys[i1-counter:i1+1]:
    186. 

  186.                         str_tmp = str_tmp + y.replace('...','')
    187. 

  187.                     # Just in case people have used [1] markers...
    188. 

  188.                     if ']' in str_tmp: str_tmp = str_tmp.split(']')[1].lstrip().rstrip()
    189. 

  189.                     list_tmp1.append(str_tmp)
    190. 

  190.                     counter = 0 
    191. 

  191.             i1=i1+1
    192. 

  192.         self.manss_sys = list_tmp1
    193. 

  193.         # Save for template instantiation
    194. 

  194.         self.template_paramdic['manss_sys'] = deepcopy(list_tmp1)
    195. 

  195.     else:
    196. 

  196.         self.template_paramdic['manss_sys'] = False
    197. 

  197.         
    198. 

  198.     # Collect info on numerical steady state
    199. 

  199.     if all([False if 'None' in x else True for x in secs['manualss'][0]]):
    200. 

  200.         _mreg_alt = '^\s*[a-zA-Z]*\d*_bar(?!=\+|-|\*|/])\s*=\s*.*'
    201. 

  201.         _mreg = '\[\d+\]\s*[a-zA-Z]*\d*_bar(?!=\+|-|\*|/])\s*=\s*.*'
    202. 

  202.         _mreg2 = '\[\d+\]\s*[a-zA-Z]*(?!=\+|-|\*|/])\s*=\s*[0-9]*\.[0-9]*'
    203. 

  203.         _mregfocs = 'USE_FOCS=\[.*?\]'
    204. 

  204.         mregfocs = re.compile(_mregfocs)
    205. 

  205.         use_focs = False
    206. 

  206.         for lino in secs['manualss'][0]:
    207. 

  207.             if mregfocs.search(lino):
    208. 

  208.                 # Save as the list of equations the be used
    209. 

  209.                 use_focs = eval(lino.split('=')[1].replace(';','').strip())
    210. 

  210.                 self._internal_focs_used = True
    211. 

  211.         mreg = re.compile(_mreg_alt+'|'+_mreg+'|'+_mreg2)
    212. 

  212.         indx = []
    213. 

  213.         ssidic={}
    214. 

  214.         ssili = []
    215. 

  215.         list_tmp = []
    216. 

  216.         anyssi_found = False
    217. 

  217.         i1=0
    218. 

  218.         counter=0
    219. 

  219.         for x in secs['manualss'][0]:
    220. 

  220.             if mreg.search(x):
    221. 

  221.                 raw_str = x.replace(';','')
    222. 

  222.                 anyssi_found = True
    223. 

  223.                 ma = mreg.search(raw_str)
    224. 

  224.                 if ']' in ma.group(): str1 = ma.group().replace(';','').split('=')[0].split(']')[1].strip()
    225. 

  225.                 else: str1 = ma.group().replace(';','').split('=')[0].lstrip().rstrip()
    226. 

  226.                 str2 = ma.group().split('=')[1].strip()
    227. 

  227.                 # Save the result as a string here, later in mk_mssidic_subs() method we do substitutions and evaluate then
    228. 

  228.                 locals().update(self.paramdic)
    229. 

  229.                 # This captures the case where we have only variables from parameters, but no substitutions
    230. 

  230.                 if '@' not in str2:
    231. 

  231.                     ssidic[str1] = str(eval(str2))
    232. 

  232.                     locals()[str1] = eval(str2)
    233. 

  233.                 else:
    234. 

  234.                     ssidic[str1] = str2
    235. 

  235.                 ssili.append([str1,str2])
    236. 

  236.                 indx.append(i1)
    237. 

  237.             elif not mreg.search(x) and '...' in x:
    238. 

  238.                 counter = counter + 1
    239. 

  239.             elif not mreg.search(x) and '...' not in x:
    240. 

  240.                 if counter == 0:
    241. 

  241.                     if ']' in x: list_tmp.append(x.replace(';','').split(']')[1].split('=')[0].strip())
    242. 

  242.                     else: list_tmp.append(x.replace(';','').split('=')[0].strip())
    243. 

  243.                 elif counter > 0:
    244. 

  244.                     str_tmp = ''
    245. 

  245.                     for y in secs['manualss'][0][i1-counter:i1+1]:
    246. 

  246.                         str_tmp = str_tmp + y.replace('...','').strip()
    247. 

  247.                     if ']' in str_tmp: list_tmp.append(str_tmp.split(']')[1].split('=')[0].replace(';','').strip())
    248. 

  248.                     else: list_tmp.append(str_tmp.split('=')[0].replace(';','').strip())
    249. 

  249.                     counter = 0 
    250. 

  250.             i1=i1+1
    251. 

  251.         if anyssi_found:
    252. 

  252.             self.ssidic = deepcopy(ssidic)
    253. 

  253.             self.ssili = deepcopy(ssili)
    254. 

  254.             # Save for template instantiation
    255. 

  255.             self.template_paramdic['ssidic'] = deepcopy(ssidic)            
    256. 

  256.         else:
    257. 

  257.             #Make empty to be filled by other procedure
    258. 

  258.             self.ssidic = {}
    259. 

  259.             self.ssili = []
    260. 

  260.             # Save for template instantiation
    261. 

  261.             self.template_paramdic['ssidic'] = False
    262. 

  262. 

  263.         if not use_focs:
    264. 

  264.             self.ssys_list = deepcopy(list_tmp) 
    265. 

  265.             # Save for template instantiation
    266. 

  266.             self.template_paramdic['ssys_list'] = deepcopy(list_tmp)
    267. 

  267.             self.template_paramdic['use_focs'] = False
    268. 

  268.         elif use_focs and anyssi_found:
    269. 

  269.             self._use_focs = deepcopy(use_focs)
    270. 

  270.             self._ssidic = deepcopy(ssidic)
    271. 

  271.             self.ssili = deepcopy(ssili)
    272. 

  272.             # Save for template instantiation
    273. 

  273.             self.template_paramdic['ssys_list'] = False
    274. 

  274.             self.template_paramdic['use_focs'] = deepcopy(use_focs)
    275. 

  275.         elif use_focs and not anyssi_found:
    276. 

  276.             self._use_focs = deepcopy(use_focs)
    277. 

  277.             # Save for template instantiation
    278. 

  278.             self.template_paramdic['ssys_list'] = False
    279. 

  279.             self.template_paramdic['use_focs'] = deepcopy(use_focs)
    280. 

  280.             
    281. 

  281.     else:
    282. 

  282.         # Save for template instantiation
    283. 

  283.         self.template_paramdic['ssidic'] = False       
    284. 

  284.         self.template_paramdic['ssys_list'] = False
    285. 

  285.         self.template_paramdic['use_focs'] = False
    286. 

  286.         
    287. 

  287.     return self
    288. 

  288. 

  289. 

  290. ############# BELOW HERE IS ALL FOR 2ND STAGE ###########
    291. 

  291. def def_timing(self,exo=[-1,0],endo=[-1,0],con=[0,1]):
    292. 

  292.     '''
    293. 

  293.     A small method which can be used in order to set the timings in stone.
    294. 

  294.     This will then be used in other parts of the code, also in macrolab package
    295. 

  295.     '''
    296. 

  296.     self.vtiming = {}
    297. 

  297.     self.vtiming['endo'] = deepcopy(endo)
    298. 

  298.     self.vtiming['exo'] = deepcopy(exo)
    299. 

  299.     self.vtiming['con'] = deepcopy(con)
    300. 

  300.     
    301. 

  301.     return self
    302. 

  302. 

  303. def mkaug2(self,insys=None,othersys=None):
    304. 

  304. 

  305.     # Timing definitions
    306. 

  306.     endotime = self.vtiming['endo']
    307. 

  307.     exotime = self.vtiming['exo']
    308. 

  308.     contime = self.vtiming['con']
    309. 

  309.     endosp = []
    310. 

  310.     for x in self.vardic['endo']['var']:
    311. 

  311.         endosp = endosp + [[x,deepcopy(endotime)]]
    312. 

  312.     exosp = []
    313. 

  313.     for x in self.vardic['exo']['var']:
    314. 

  314.         exosp = exosp + [[x,deepcopy(exotime)]]
    315. 

  315.     consp = []
    316. 

  316.     for x in self.vardic['con']['var']:
    317. 

  317.         consp = consp + [[x,deepcopy(contime)]]
    318. 

  318. 

  319.     alldic = {}
    320. 

  320.     alldic.update(self.paramdic)
    321. 

  321.     alldic.update(self.sstate)
    322. 

  322. 

  323.     spvdic = {}
    324. 

  324.     spvdic['endo'] = endosp
    325. 

  325.     spvdic['exo'] = exosp
    326. 

  326.     spvdic['con'] = consp
    327. 

  327. 

  328.     spvdic2 = deepcopy(spvdic)
    329. 

  329. 

  330.     spvdic3 = deepcopy(spvdic2)
    331. 

  331.     spvdic3['endo'] = {}
    332. 

  332.     spvdic3['con'] = {}
    333. 

  333.     spvdic3['exo'] = {}
    334. 

  334. 

  335.     endoli = [x[0].split('(')[0].strip() for x in self.vardic['endo']['var']]
    336. 

  336.     exoli = [x[0].split('(')[0].strip() for x in self.vardic['exo']['var']]
    337. 

  337.     conli = [x[0].split('(')[0].strip() for x in self.vardic['con']['var']]
    338. 

  338. 

  339. 

  340.     patup = ('{-100,100}|None','all','{-100,100}')
    341. 

  341.     count = 0
    342. 

  342.     
    343. 

  343.     list_tmp1 = deepcopy(insys)
    344. 

  344.     for i1,line in enumerate(list_tmp1):
    345. 

  345.         iterob = self.vreg(patup,line,True,'max')
    346. 

  346.         if iterob:
    347. 

  347.             iterob = list(iterob)
    348. 

  348.         else:
    349. 

  349.             continue
    350. 

  350.         iterob.reverse()
    351. 

  351.         for vma in iterob:
    352. 

  352.             vtype = vma[1][0]
    353. 

  353.             vartime = vma[2][2]
    354. 

  354.             vari = vma[2][1]
    355. 

  355.             pos = vma[3][0]
    356. 

  356.             poe = vma[3][1]
    357. 

  357.             
    358. 

  358.             # In the following section we will replace time-shifted variables with their auxiliary counterparts
    359. 

  359.             # in the EXISTING equations of the FOCs, but no new definitions of auxiliary variables are being added
    360. 

  360.             # Depending on options passed, we may work on the FOCs or the items in NLSUBS_LIST
    361. 

  361.             if vtype == 'endo':
    362. 

  362.                 indx = endoli.index(vari)
    363. 

  363.                 if not spvdic3['endo'].has_key(vari):
    364. 

  364.                     spvdic3['endo'][vari] = []
    365. 

  365.                 if spvdic3['endo'][vari] == []:
    366. 

  366.                     spvdic3['endo'][vari].append(int(vartime))
    367. 

  367.                     spvdic3['endo'][vari].append(int(vartime))
    368. 

  368.                 elif int(vartime) < spvdic3['endo'][vari][0]: spvdic3['endo'][vari][0] = int(vartime)
    369. 

  369.                 elif int(vartime) > spvdic3['endo'][vari][1]: spvdic3['endo'][vari][1] = int(vartime)
    370. 

  370.             elif vtype == 'con':
    371. 

  371.                 indx = conli.index(vari)
    372. 

  372.                 if not spvdic3['con'].has_key(vari):
    373. 

  373.                     spvdic3['con'][vari] = []
    374. 

  374.                 if spvdic3['con'][vari] == []:
    375. 

  375.                     spvdic3['con'][vari].append(int(vartime))
    376. 

  376.                     spvdic3['con'][vari].append(int(vartime))
    377. 

  377.                 elif int(vartime) < spvdic3['con'][vari][0]: spvdic3['con'][vari][0] = int(vartime)
    378. 

  378.                 elif int(vartime) > spvdic3['con'][vari][1]: spvdic3['con'][vari][1] = int(vartime)
    379. 

  379.             elif vtype == 'exo':
    380. 

  380.                 indx = exoli.index(vari)
    381. 

  381.                 if not spvdic3['exo'].has_key(vari):
    382. 

  382.                     spvdic3['exo'][vari] = []
    383. 

  383.                 if spvdic3['exo'][vari] == []:
    384. 

  384.                     spvdic3['exo'][vari].append(int(vartime))
    385. 

  385.                     spvdic3['exo'][vari].append(int(vartime))
    386. 

  386.                 elif int(vartime) < spvdic3['exo'][vari][0]: spvdic3['exo'][vari][0] = int(vartime)
    387. 

  387.                 elif int(vartime) > spvdic3['exo'][vari][1]: spvdic3['exo'][vari][1] = int(vartime)
    388. 

  388.             else:
    389. 

  389.                 continue
    390. 

  390. 

  391.             # Check for endo
    392. 

  392.             if vtype == 'endo' and int(vartime) > spvdic['endo'][indx][1][1]:
    393. 

  393.                 spvdic2['endo'][indx][1][1] = int(vartime)
    394. 

  394.                 tind = (5-len(str(abs(endotime[1]-int(vartime)))))*'0'+str(abs(endotime[1]-int(vartime)))
    395. 

  395.                 newvar = vari+'_F'+tind+'(t)'
    396. 

  396.                 newname =  vari+'_F'+str(abs(endotime[1]-int(vartime)))
    397. 

  397.                 list_tmp1[i1] = list_tmp1[i1][:pos]+newvar.split('(')[0]+'(t)'+list_tmp1[i1][poe:]
    398. 

  398.                 for i2 in range(abs(int(vartime)-spvdic['endo'][indx][1][1])):
    399. 

  399.                     tind = (5-len(str(abs(i2+1))))*'0'+str(abs(i2+1))
    400. 

  400.                     newvar = vari+'_F'+tind+'(t)'
    401. 

  401.                     newname =  vari+'_F'+str(abs(i2+1))
    402. 

  402.                     if [newvar,newname] not in self.vardic['con']['var']:
    403. 

  403.                         self.vardic['con']['var'].append([newvar,newname])
    404. 

  404.                         self.vardic['con']['mod'].append(self.vardic['endo']['mod'][indx])
    405. 

  405.                         self.audic['con']['var'].append([newvar,newname])
    406. 

  406.                         self.audic['con']['mod'].append(self.vardic['endo']['mod'][indx])
    407. 

  407.                         if self.sstate.has_key(vari+'_bar'):
    408. 

  408.                             self.sstate[newvar.split('(')[0]+'_bar'] = self.sstate[vari+'_bar']
    409. 

  409.                         else:
    410. 

  410.                             self.sstate[newvar.split('(')[0]+'_bar'] = self.paramdic[vari+'_bar']
    411. 

  411.                     continue
    412. 

  412.             elif vtype == 'endo' and int(vartime) < spvdic['endo'][indx][1][0]:
    413. 

  413.                 spvdic2['endo'][indx][1][0] = int(vartime)
    414. 

  414.                 tind = (5-len(str(abs(endotime[0]-int(vartime)))))*'0'+str(abs(endotime[0]-int(vartime)))
    415. 

  415.                 newvar = vari+'_B'+tind+'(t)'
    416. 

  416.                 newname =  vari+'_B'+str(abs(endotime[0]-int(vartime)))
    417. 

  417.                 list_tmp1[i1] = list_tmp1[i1][:pos]+newvar.split('(')[0]+'(t-1)'+list_tmp1[i1][poe:]
    418. 

  418.                 for i2 in range(1,abs(int(vartime)-spvdic['endo'][indx][1][0])+1):
    419. 

  419.                     tind = (5-len(str(abs(i2))))*'0'+str(abs(i2))
    420. 

  420.                     newvar = vari+'_B'+tind+'(t)'
    421. 

  421.                     newname =  vari+'_B'+str(abs(i2))
    422. 

  422.                     if [newvar,newname] not in self.vardic['endo']['var']:
    423. 

  423.                         self.vardic['endo']['var'].append([newvar,newname])
    424. 

  424.                         self.vardic['endo']['mod'].append(self.vardic['endo']['mod'][indx])
    425. 

  425.                         self.audic['endo']['var'].append([newvar,newname])
    426. 

  426.                         self.audic['endo']['mod'].append(self.vardic['endo']['mod'][indx])
    427. 

  427.                         if self.sstate.has_key(vari+'_bar'):
    428. 

  428.                             self.sstate[newvar.split('(')[0]+'_bar'] = self.sstate[vari+'_bar']
    429. 

  429.                         else:
    430. 

  430.                             self.sstate[newvar.split('(')[0]+'_bar'] = self.paramdic[vari+'_bar']
    431. 

  431.                     continue
    432. 

  432. 

  433.             # Check for exo
    434. 

  434.             if vtype == 'exo' and int(vartime) > spvdic['exo'][indx][1][1]:
    435. 

  435.                 spvdic2['exo'][indx][1][1] = int(vartime)
    436. 

  436.                 tind = (5-len(str(abs(exotime[1]-int(vartime)))))*'0'+str(abs(exotime[1]-int(vartime)))
    437. 

  437.                 newvar = vari+'_F'+tind+'(t)'
    438. 

  438.                 newname =  vari+'_F'+str(abs(exotime[1]-int(vartime)))
    439. 

  439.                 list_tmp1[i1] = list_tmp1[i1][:pos]+newvar.split('(')[0]+'(t)'+list_tmp1[i1][poe:]
    440. 

  440.                 for i2 in range(abs(int(vartime)-spvdic['exo'][indx][1][1])):
    441. 

  441.                     tind = (5-len(str(abs(i2+2)-1)))*'0'+str(abs(i2+2)-1)
    442. 

  442.                     newvar = vari+'_F'+tind+'(t)'
    443. 

  443.                     newname =  vari+'_F'+str(abs(i2+1))
    444. 

  444.                     if [newvar,newname] not in self.vardic['con']['var']:
    445. 

  445.                         self.vardic['con']['var'].append([newvar,newname])
    446. 

  446.                         self.vardic['con']['mod'].append(self.vardic['exo']['mod'][indx])
    447. 

  447.                         self.audic['con']['var'].append([newvar,newname])
    448. 

  448.                         self.audic['con']['mod'].append(self.vardic['exo']['mod'][indx])
    449. 

  449.                         if self.sstate.has_key(vari+'_bar'):
    450. 

  450.                             self.sstate[newvar.split('(')[0]+'_bar'] = self.sstate[vari+'_bar']
    451. 

  451.                         else:
    452. 

  452.                             self.sstate[newvar.split('(')[0]+'_bar'] = self.paramdic[vari+'_bar']
    453. 

  453.                     continue
    454. 

  454.             elif vtype == 'exo' and int(vartime) < spvdic['exo'][indx][1][0]:
    455. 

  455.                 spvdic2['exo'][indx][1][0] = int(vartime)
    456. 

  456.                 tind = (5-len(str(abs(exotime[0]-int(vartime)))))*'0'+str(abs(exotime[0]-int(vartime)))
    457. 

  457.                 newvar = vari+'_B'+tind+'(t)'
    458. 

  458.                 newname =  vari+'_B'+str(abs(exotime[0]-int(vartime)))
    459. 

  459.                 list_tmp1[i1] = list_tmp1[i1][:pos]+newvar.split('(')[0]+'(t-1)'+list_tmp1[i1][poe:]
    460. 

  460.                 for i2 in range(abs(int(vartime)-spvdic['exo'][indx][1][0])):
    461. 

  461.                     tind = (5-len(str(abs(i2+2)-1)))*'0'+str(abs(i2+2)-1)
    462. 

  462.                     newvar = vari+'_B'+tind+'(t)'
    463. 

  463.                     newname =  vari+'_B'+str(abs(i2+1))
    464. 

  464.                     if [newvar,newname] not in self.vardic['endo']['var']:
    465. 

  465.                         self.vardic['endo']['var'].append([newvar,newname])
    466. 

  466.                         self.vardic['endo']['mod'].append(self.vardic['exo']['mod'][indx])
    467. 

  467.                         self.audic['endo']['var'].append([newvar,newname])
    468. 

  468.                         self.audic['endo']['mod'].append(self.vardic['exo']['mod'][indx])
    469. 

  469.                         if self.sstate.has_key(vari+'_bar'):
    470. 

  470.                             self.sstate[newvar.split('(')[0]+'_bar'] = self.sstate[vari+'_bar']
    471. 

  471.                         else:
    472. 

  472.                             self.sstate[newvar.split('(')[0]+'_bar'] = self.paramdic[vari+'_bar']
    473. 

  473.                     continue
    474. 

  474.             # Check for con
    475. 

  475.             if vtype == 'con' and int(vartime) > spvdic['con'][indx][1][1]:
    476. 

  476.                 spvdic2['con'][indx][1][1] = int(vartime)
    477. 

  477.                 tind = (5-len(str(abs(contime[1]-int(vartime)))))*'0'+str(abs(contime[1]-int(vartime)))
    478. 

  478.                 newvar = vari+'_F'+tind+'(t)'
    479. 

  479.                 newname =  vari+'_F'+str(abs(contime[1]-int(vartime)))
    480. 

  480.                 list_tmp1[i1] = list_tmp1[i1][:pos]+newvar.split('(')[0]+'(t)'+list_tmp1[i1][poe:]
    481. 

  481.                 for i2 in range(abs(int(vartime)-spvdic['con'][indx][1][1])):
    482. 

  482.                     tind = (5-len(str(abs(i2+2)-1)))*'0'+str(abs(i2+2)-1)
    483. 

  483.                     newvar = vari+'_F'+tind+'(t)'
    484. 

  484.                     newname =  vari+'_F'+str(abs(i2+1))
    485. 

  485.                     if [newvar,newname] not in self.vardic['con']['var']:
    486. 

  486.                         self.vardic['con']['var'].append([newvar,newname])
    487. 

  487.                         self.vardic['con']['mod'].append(self.vardic['con']['mod'][indx])
    488. 

  488.                         self.audic['con']['var'].append([newvar,newname])
    489. 

  489.                         self.audic['con']['mod'].append(self.vardic['con']['mod'][indx])
    490. 

  490.                         if self.sstate.has_key(vari+'_bar'):
    491. 

  491.                             self.sstate[newvar.split('(')[0]+'_bar'] = self.sstate[vari+'_bar']
    492. 

  492.                         else:
    493. 

  493.                             self.sstate[newvar.split('(')[0]+'_bar'] = self.paramdic[vari+'_bar']
    494. 

  494.                     continue
    495. 

  495.             elif vtype == 'con' and int(vartime) < spvdic['con'][indx][1][0] and spvdic3['con'][vari][0] < contime[0]:
    496. 

  496.                 spvdic2['con'][indx][1][0] = int(vartime)
    497. 

  497.                 tind = (5-len(str(abs(contime[0]-int(vartime)))))*'0'+str(abs(contime[0]-int(vartime)))
    498. 

  498.                 newvar = vari+'_B'+tind+'(t)'
    499. 

  499.                 newname =  vari+'_B'+str(abs(contime[0]-int(vartime)))
    500. 

  500.                 list_tmp1[i1] = list_tmp1[i1][:pos]+newvar.split('(')[0]+'(t-1)'+list_tmp1[i1][poe:]
    501. 

  501.                 for i2 in range(abs(int(vartime)-spvdic['con'][indx][1][0])):
    502. 

  502.                     tind = (5-len(str(abs(i2+2)-1)))*'0'+str(abs(i2+2)-1)
    503. 

  503.                     newvar = vari+'_B'+tind+'(t)'
    504. 

  504.                     newname =  vari+'_B'+str(abs(i2+1))
    505. 

  505.                     if [newvar,newname] not in self.vardic['endo']['var']:
    506. 

  506.                         self.vardic['endo']['var'].append([newvar,newname])
    507. 

  507.                         self.vardic['endo']['mod'].append(self.vardic['con']['mod'][indx])
    508. 

  508.                         self.audic['endo']['var'].append([newvar,newname])
    509. 

  509.                         self.audic['endo']['mod'].append(self.vardic['con']['mod'][indx])
    510. 

  510.                         if self.sstate.has_key(vari+'_bar'):
    511. 

  511.                             self.sstate[newvar.split('(')[0]+'_bar'] = self.sstate[vari+'_bar']
    512. 

  512.                         else:
    513. 

  513.                             self.sstate[newvar.split('(')[0]+'_bar'] = self.paramdic[vari+'_bar']
    514. 

  514.                     continue
    515. 

  515. 

  516.     # Save the timings which were found in the FOC equations, or update exisiting one
    517. 

  517.     if 'vtimings_found' not in dir(self):
    518. 

  518.         self.vtimings_found = deepcopy(spvdic3)
    519. 

  519.         self.vtimings_differ = deepcopy(self.vtimings_found)
    520. 

  520.     else:
    521. 

  521.         for keyo in spvdic3.keys():
    522. 

  522.             for keyo2 in spvdic3[keyo].keys():
    523. 

  523.                 if spvdic3[keyo][keyo2][0] < self.vtimings_found[keyo][keyo2][0]:
    524. 

  524.                     self.vtimings_found[keyo][keyo2][0] = spvdic3[keyo][keyo2][0]
    525. 

  525.                 if spvdic3[keyo][keyo2][1] > self.vtimings_found[keyo][keyo2][1]:
    526. 

  526.                     self.vtimings_found[keyo][keyo2][1] = spvdic3[keyo][keyo2][1]
    527. 

  527.     # Also add a second dictionary which shows the difference between what was found and the reference timing
    528. 

  528.     for keyo in self.vtimings_found.keys():
    529. 

  529.         for keyo2 in self.vtimings_found[keyo].keys():
    530. 

  530.             if keyo == 'endo': self.vtimings_differ[keyo][keyo2] =\
    531. 

  531.                list([x for x in np.array(self.vtimings_found[keyo][keyo2]) - np.array(endotime)])
    532. 

  532.             elif keyo == 'exo': self.vtimings_differ[keyo][keyo2] =\
    533. 

  533.                list([x for x in np.array(self.vtimings_found[keyo][keyo2]) - np.array(exotime)])
    534. 

  534.             elif keyo == 'con': self.vtimings_differ[keyo][keyo2] =\
    535. 

  535.                list([x for x in np.array(self.vtimings_found[keyo][keyo2]) - np.array(contime)])
    536. 

  536.                 
    537. 

  537. 

  538.     #################################################################################################
    539. 

  539.     ##
    540. 

  540.     ## In this section we will compute the declarations which have to be added to the nonlinear system
    541. 

  541.     ## in order to incorporate and include in derivations the auxiliare variables used throughout
    542. 

  542.     ##
    543. 

  543.     #################################################################################################
    544. 

  544.     list_added = []
    545. 

  545.     # Now change the system to include possible augmented variables
    546. 

  546.     endo_r = filter(lambda x: x[1] != endotime, spvdic2['endo'])
    547. 

  547.     if endo_r:
    548. 

  548.         endo_r = [[x[0],[abs(x[1][0]-endotime[0]),abs(x[1][1]-endotime[1])]] for x in endo_r ]
    549. 

  549.         # Create lags and forwards equations
    550. 

  550.         for vari in endo_r:
    551. 

  551.             varin = vari[0][0].split('(')[0]
    552. 

  552.             if vari[1][0] != 0:
    553. 

  553.                 lagor = range(abs(spvdic3['endo'][varin][0]-endotime[0]))
    554. 

  554.                 for lag in lagor:
    555. 

  555.                     
    556. 

  556.                     # Define some indices to be used
    557. 

  557.                     tindm1 = (5-len(str(lead-1)))*'0'+str(lead-1)
    558. 

  558.                     tind = (5-len(str(lead)))*'0'+str(lead)
    559. 

  559.                     tind1 = (5-len(str(lead+1)))*'0'+str(lead+1)
    560. 

  560.                     tind2 = (5-len(str(lead+2)))*'0'+str(lead+2)
    561. 

  561.                     
    562. 

  562.                     # Define the beginning definition, needs to link up with the last variable define in endotime[1]
    563. 

  563.                     if lag == lagor[0]:
    564. 

  564.                         lag_endo_diff = spvdic3['endo'][varin][0]-endotime[0]
    565. 

  565.                         if lag_endo_diff < 0:
    566. 

  566.                             list_added.append(varin+'(t-'+str(abs(lag_endo_diff))+')'+' - '+varin+'_B00001(t-1)')
    567. 

  567.                             if lag_endo_diff+1 > 0: list_added.append(varin+'_B'+tind+'(t)'+' - '+varin+'(t+'+str(lag_endo_diff-1)+')')
    568. 

  568.                             elif lag_endo_diff+1 == 0: list_added.append(varin+'_B'+tind+'(t)'+' - '+varin+'(t)')
    569. 

  569.                             elif lag_endo_diff+1 < 0: list_added.append(varin+'_B'+tind+'(t)'+' - '+varin+'(t-'+str(abs(lag_endo_diff-1))+')')
    570. 

  570.                         elif lag_endo_diff == 0:
    571. 

  571.                             list_added.append(varin+'(t)'+' - '+varin+'_B00001(t-1)')
    572. 

  572.                             if lag_endo_diff-1 > 0: list_added.append(varin+'_B'+tind+'(t)'+' - '+varin+'(t+'+str(lag_endo_diff-1)+')')
    573. 

  573.                             elif lag_endo_diff-1 == 0: list_added.append(varin+'_B'+tind+'(t)'+' - '+varin+'(t)')
    574. 

  574.                             elif lag_endo_diff-1 < 0: list_added.append(varin+'_B'+tind+'(t)'+' - '+varin+'(t-'+str(abs(lag_endo_diff-1))+')')                                        
    575. 

  575.                         elif lag_endo_diff > 0:
    576. 

  576.                             list_added.append(varin+'(t+'+str(lag_endo_diff)+')'+' - '+varin+'_B00001(t-1)')
    577. 

  577.                             if lag_endo_diff-1 > 0: list_added.append(varin+'_B'+tind+'(t)'+' - '+varin+'(t+'+str(lag_endo_diff-1)+')')
    578. 

  578.                             elif lag_endo_diff-1 == 0: list_added.append(varin+'_B'+tind+'(t)'+' - '+varin+'(t)')
    579. 

  579.                             elif lag_endo_diff-1 < 0: list_added.append(varin+'_B'+tind+'(t)'+' - '+varin+'(t-'+str(abs(lag_endo_diff-1))+')')
    580. 

  580.                         if varin+'_B'+tind1+'(t)'+' - '+varin+'_B'+tind+'(t-1)' not in list_added:
    581. 

  581.                             list_added.append(varin+'_B'+tind1+'(t)'+' - '+varin+'_B'+tind+'(t-1)')
    582. 

  582.                             
    583. 

  583.                     # For in between
    584. 

  584.                     if lag != lagor[0] and lag != lagor[-1]:
    585. 

  585.                         expro = varin+'_B'+tind+'(t)'+' - '+varin+'_B'+tindm1+'(t-1)'
    586. 

  586.                         if expro not in list_added:
    587. 

  587.                             list_added.append(expro)
    588. 

  588. 

  589.                     # Define the end tail definition
    590. 

  590.                     if lag == lagor[-1] and len(lagor) != 1:  
    591. 

  591.                         if varin+'_B'+tind+'(t)'+' - '+varin+'_B'+tindm1+'(t-1)' not in list_added:
    592. 

  592.                             list_added.append(varin+'_B'+tind+'(t)'+' - '+varin+'_B'+tindm1+'(t-1)')
    593. 

  593.                         if varin+'_B'+tind1+'(t)'+' - '+varin+'_B'+tind+'(t-1)' not in list_added:
    594. 

  594.                             list_added.append(varin+'_B'+tind1+'(t)'+' - '+varin+'_B'+tind+'(t-1)')
    595. 

  595.                     
    596. 

  596. 

  597.             leador = range(abs(spvdic3['endo'][varin][1]-endotime[1]))
    598. 

  598.             if vari[1][1] != 0:
    599. 

  599.                 for lead in leador:
    600. 

  600.                     
    601. 

  601.                     # Define some indices to be used
    602. 

  602.                     tindm1 = (5-len(str(lead-1)))*'0'+str(lead-1)
    603. 

  603.                     tind = (5-len(str(lead)))*'0'+str(lead)
    604. 

  604.                     tind1 = (5-len(str(lead+1)))*'0'+str(lead+1)
    605. 

  605.                     tind2 = (5-len(str(lead+2)))*'0'+str(lead+2)
    606. 

  606.                     
    607. 

  607.                     # Define the beginning definition, needs to link up with the last variable define in endotime[1]
    608. 

  608.                     if lead == leador[0]:
    609. 

  609.                         if endotime[1] < 0:
    610. 

  610.                             list_added.append(varin+'(t'+str(endotime[1])+')'+' - '+varin+'_F00001(t-1)')
    611. 

  611.                         elif endotime[1] == 0:
    612. 

  612.                             list_added.append(varin+'(t)'+' - '+varin+'_F00001(t-1)')
    613. 

  613.                         elif endotime[1] > 0:
    614. 

  614.                             list_added.append(varin+'(t+'+str(endotime[1])+')'+' - '+varin+'_F00001(t-1)')
    615. 

  615.                         if endotime[1]+1 < 0:
    616. 

  616.                             list_added.append(varin+'_F'+tind+'(t)'+' - '+varin+'(t-'+str(abs(endotime[1]+1))+')')
    617. 

  617.                         elif endotime[1]+1 == 0:
    618. 

  618.                             list_added.append(varin+'_F'+tind+'(t)'+' - '+varin+'(t)')
    619. 

  619.                         elif endotime[1]+1 > 0:
    620. 

  620.                             list_added.append(varin+'_F'+tind+'(t)'+' - '+varin+'(t+'+str(abs(endotime[1]+1))+')')
    621. 

  621.                                 
    622. 

  622.                     # For in between
    623. 

  623.                     if lead != leador[0] and lead != leador[-1]:
    624. 

  624.                         if varin+'_F'+tind+'(t)'+' - '+varin+'_F'+tind1+'(t-1)' not in list_added:
    625. 

  625.                             list_added.append(varin+'_F'+tind+'(t)'+' - '+varin+'_F'+tind1+'(t-1)')
    626. 

  626.                         
    627. 

  627.                     # Define the end tail definition
    628. 

  628.                     if lead == leador[-1] and len(leador) != 1:
    629. 

  629.                         if spvdic3['endo'][varin][1] > 0:
    630. 

  630.                             list_added.append(varin+'_F'+tind+'(t)'+' - '+varin+'(t+'+str(spvdic3['endo'][varin][1])+')')
    631. 

  631.                         elif spvdic3['endo'][varin][1] == 0:
    632. 

  632.                             list_added.append(varin+'_F'+tind+'(t)'+' - '+varin+'(t)')
    633. 

  633.                         elif spvdic3['endo'][varin][1] < 0:
    634. 

  634.                             list_added.append(varin+'_F'+tind+'(t)'+' - '+varin+'(t-'+str(abs(spvdic3['endo'][varin][1]))+')')  
    635. 

  635. 

  636.     exo_r = filter(lambda x: x[1] != exotime, spvdic2['exo'])
    637. 

  637.     if exo_r:
    638. 

  638.         exo_r = [[x[0],[abs(x[1][0])-abs(exotime[0]),x[1][1]-abs(exotime[1])]] for x in exo_r ]
    639. 

  639.         # Create lags and forwards equations
    640. 

  640.         for vari in exo_r:
    641. 

  641.             varin = vari[0][0].split('(')[0]
    642. 

  642.             if vari[1][0] != 0:
    643. 

  643.                 abstdiffer = abs(spvdic3['exo'][varin][0]-exotime[0])
    644. 

  644.                 lagor = range(abstdiffer)
    645. 

  645.                 for lag in lagor:
    646. 

  646.                     
    647. 

  647.                     # Define some indices to be used
    648. 

  648.                     tindm1 = (5-len(str(lag-1)))*'0'+str(lag-1)
    649. 

  649.                     tind = (5-len(str(lag)))*'0'+str(lag)
    650. 

  650.                     tind1 = (5-len(str(lag+1)))*'0'+str(lag+1)
    651. 

  651.                     tind2 = (5-len(str(lag+2)))*'0'+str(lag+2)
    652. 

  652.                     
    653. 

  653.                     # Define the beginning definition, needs to link up with the last variable define in exotime[1]
    654. 

  654.                     if lag == lagor[0]:
    655. 

  655.                         lag_exo_diff = spvdic3['exo'][varin][0]-exotime[0]
    656. 

  656.                         timor = spvdic3['exo'][varin][0]+exotime[0]
    657. 

  657.                         if lag_exo_diff < 0:
    658. 

  658.                             if timor > 0: list_added.append(varin+'_B'+tind1+'(t)'+' - '+'E(t)|'+varin+'(t+'+str(timor)+')')
    659. 

  659.                             elif timor == 0: list_added.append(varin+'_B'+tind1+'(t)'+' - '+varin+'(t)')
    660. 

  660.                             elif timor < 0: list_added.append(varin+'_B'+tind1+'(t)'+' - '+varin+'(t-'+str(abs(timor))+')')
    661. 

  661.                         elif lag_exo_diff == 0:
    662. 

  662.                             if timor > 0: list_added.append(varin+'_B'+tind1+'(t)'+' - '+'E(t)|'+varin+'(t+'+str(timor)+')')
    663. 

  663.                             elif timor == 0: list_added.append(varin+'_B'+tind1+'(t)'+' - '+varin+'(t)')
    664. 

  664.                             elif timor < 0: list_added.append(varin+'_B'+tind1+'(t)'+' - '+varin+'(t-'+str(abs(timor))+')')                                        
    665. 

  665.                         elif lag_exo_diff > 0:
    666. 

  666.                             if timor > 0: list_added.append(varin+'_B'+tind1+'(t)'+' - '+'E(t)|'+varin+'(t+'+str(timor)+')')
    667. 

  667.                             elif timor == 0: list_added.append(varin+'_B'+tind1+'(t)'+' - '+varin+'(t)')
    668. 

  668.                             elif timor < 0: list_added.append(+'_B'+tind1+'(t)'+' - '+varin+'(t-'+str(abs(timor))+')')
    669. 

  669.                             
    670. 

  670.                     # For in between
    671. 

  671.                     if lag != lagor[0] and lag != lagor[-1] and len(lagor) != 1:
    672. 

  672.                         expro = varin+'_B'+tind+'(t)'+' - '+varin+'_B'+tindm1+'(t-1)'
    673. 

  673.                         if expro not in list_added:
    674. 

  674.                             list_added.append(expro)
    675. 

  675. 

  676.                     # Define the end tail definition
    677. 

  677.                     if lag == lagor[-1] and len(lagor) != 1:  
    678. 

  678.                         if varin+'_B'+tind1+'(t)'+' - '+varin+'_B'+tind+'(t-1)' not in list_added:
    679. 

  679.                             list_added.append(varin+'_B'+tind1+'(t)'+' - '+varin+'_B'+tind+'(t-1)')
    680. 

  680.             
    681. 

  681.             abstdiffer = abs(spvdic3['exo'][varin][1]-exotime[1])       
    682. 

  682.             leador = range(abstdiffer)
    683. 

  683.             if vari[1][1] != 0:
    684. 

  684.                 for lead in leador:
    685. 

  685.                     
    686. 

  686.                     # Define some indices to be used
    687. 

  687.                     tindm1 = (5-len(str(lead-1)))*'0'+str(lead-1)
    688. 

  688.                     tind = (5-len(str(lead)))*'0'+str(lead)
    689. 

  689.                     tind1 = (5-len(str(lead+1)))*'0'+str(lead+1)
    690. 

  690.                     tind2 = (5-len(str(lead+2)))*'0'+str(lead+2)
    691. 

  691.                     
    692. 

  692.                     # Define the beginning definition, needs to link up with the last variable define in endotime[1]
    693. 

  693.                     if lead == leador[0]:
    694. 

  694.                         if exotime[1]+1 < 0:
    695. 

  695.                             list_added.append(varin+'_F'+tind1+'(t)'+' - '+varin+'(t-'+str(abs(exotime[1]+1))+')')
    696. 

  696.                         elif exotime[1]+1 == 0:
    697. 

  697.                             list_added.append(varin+'_F'+tind1+'(t)'+' - '+varin+'(t)')
    698. 

  698.                         elif exotime[1]+1 > 0:
    699. 

  699.                             list_added.append(varin+'_F'+tind1+'(t)'+' - '+'E(t)|'+varin+'(t+'+str(abs(exotime[1]+1))+')')
    700. 

  700.                                 
    701. 

  701.                     # For in between
    702. 

  702.                     if lead != leador[0] and lead != leador[-1]:
    703. 

  703.                         if varin+'_F'+tind1+'(t)'+' - '+varin+'_F'+tind2+'(t-1)' not in list_added:
    704. 

  704.                             list_added.append(varin+'_F'+tind1+'(t)'+' - '+varin+'_F'+tind2+'(t-1)')
    705. 

  705.                         
    706. 

  706.                     # Define the end tail definition
    707. 

  707.                     if lead == leador[-1] and len(leador) != 1:
    708. 

  708.                         if spvdic3['exo'][varin][1] > 0:
    709. 

  709.                             list_added.append(varin+'_F'+tind1+'(t)'+' - '+'E(t)|'+varin+'(t+'+str(spvdic3['exo'][varin][1])+')')
    710. 

  710.                         elif spvdic3['exo'][varin][1] == 0:
    711. 

  711.                             list_added.append(varin+'_F'+tind1+'(t)'+' - '+varin+'(t)')
    712. 

  712.                         elif spvdic3['exo'][varin][1] < 0:
    713. 

  713.                             list_added.append(varin+'_F'+tind1+'(t)'+' - '+varin+'(t-'+str(abs(spvdic3['exo'][varin][1]))+')')
    714. 

  714.                             
    715. 

  715.     con_r = filter(lambda x: x[1] != contime, spvdic2['con'])
    716. 

  716.     if con_r:
    717. 

  717.         con_r = [[x[0],[abs(x[1][0])-abs(contime[0]),x[1][1]-abs(contime[1])]] for x in con_r ]
    718. 

  718.         # Create lags and forwards equations
    719. 

  719.         for vari in con_r:
    720. 

  720.             varin = vari[0][0].split('(')[0]
    721. 

  721.             if vari[1][0] != 0:
    722. 

  722.                 abstdiffer = abs(spvdic3['con'][varin][0]-contime[0])
    723. 

  723.                 lagor = range(abstdiffer)
    724. 

  724.                 for lag in lagor:
    725. 

  725.                     
    726. 

  726.                     # Define some indices to be used
    727. 

  727.                     tindm1 = (5-len(str(lag-1)))*'0'+str(lag-1)
    728. 

  728.                     tind = (5-len(str(lag)))*'0'+str(lag)
    729. 

  729.                     tind1 = (5-len(str(lag+1)))*'0'+str(lag+1)
    730. 

  730.                     tind2 = (5-len(str(lag+2)))*'0'+str(lag+2)
    731. 

  731.                     
    732. 

  732.                     # Define the beginning definition, needs to link up with the last variable define in contime[1]
    733. 

  733.                     if lag == lagor[0]:
    734. 

  734.                         lag_con_diff = spvdic3['con'][varin][0]-contime[0]
    735. 

  735.                         timor = spvdic3['con'][varin][0]+contime[0]+1
    736. 

  736.                         if lag_con_diff < 0:
    737. 

  737.                             if timor > 0: list_added.append(varin+'_B'+tind1+'(t)'+' - '+'E(t)|'+varin+'(t+'+str(timor)+')')
    738. 

  738.                             elif timor == 0: list_added.append(varin+'_B'+tind1+'(t)'+' - '+varin+'(t)')
    739. 

  739.                             elif timor < 0: list_added.append(varin+'_B'+tind1+'(t)'+' - '+varin+'(t-'+str(abs(timor))+')')
    740. 

  740.                         elif lag_con_diff == 0:
    741. 

  741.                             if timor > 0: list_added.append(varin+'_B'+tind1+'(t)'+' - '+'E(t)|'+varin+'(t+'+str(timor)+')')
    742. 

  742.                             elif timor == 0: list_added.append(varin+'_B'+tind1+'(t)'+' - '+varin+'(t)')
    743. 

  743.                             elif timor < 0: list_added.append(varin+'_B'+tind1+'(t)'+' - '+varin+'(t-'+str(abs(timor))+')')                                        
    744. 

  744.                         elif lag_con_diff > 0:
    745. 

  745.                             if timor > 0: list_added.append(varin+'_B'+tind1+'(t)'+' - '+'E(t)|'+varin+'(t+'+str(timor)+')')
    746. 

  746.                             elif timor == 0: list_added.append(varin+'_B'+tind1+'(t)'+' - '+varin+'(t)')
    747. 

  747.                             elif timor < 0: list_added.append(+'_B'+tind1+'(t)'+' - '+varin+'(t-'+str(abs(timor))+')')
    748. 

  748.                             
    749. 

  749.                     # For in between
    750. 

  750.                     if lag != lagor[0] and lag != lagor[-1] and len(lagor) != 1:
    751. 

  751.                         expro = varin+'_B'+tind+'(t)'+' - '+varin+'_B'+tindm1+'(t-1)'
    752. 

  752.                         if expro not in list_added:
    753. 

  753.                             list_added.append(expro)
    754. 

  754. 

  755.                     # Define the end tail definition
    756. 

  756.                     if lag == lagor[-1] and len(lagor) != 1:  
    757. 

  757.                         if varin+'_B'+tind1+'(t)'+' - '+varin+'_B'+tind+'(t-1)' not in list_added:
    758. 

  758.                             list_added.append(varin+'_B'+tind1+'(t)'+' - '+varin+'_B'+tind+'(t-1)')
    759. 

  759.             
    760. 

  760.             abstdiffer = abs(spvdic3['con'][varin][1]-contime[1])       
    761. 

  761.             leador = range(abstdiffer)
    762. 

  762.             if vari[1][1] != 0:
    763. 

  763.                 for lead in leador:
    764. 

  764.                     
    765. 

  765.                     # Define some indices to be used
    766. 

  766.                     tindm1 = (5-len(str(lead-1)))*'0'+str(lead-1)
    767. 

  767.                     tind = (5-len(str(lead)))*'0'+str(lead)
    768. 

  768.                     tind1 = (5-len(str(lead+1)))*'0'+str(lead+1)
    769. 

  769.                     tind2 = (5-len(str(lead+2)))*'0'+str(lead+2)
    770. 

  770.                     
    771. 

  771.                     
    772. 

  772.                     # Define the beginning definition, needs to link up with the last variable define in endotime[1]
    773. 

  773.                     if lead == leador[0]:
    774. 

  774.                         if contime[1]+1 < 0:
    775. 

  775.                             list_added.append(varin+'_F'+tind1+'(t)'+' - '+varin+'(t-'+str(abs(contime[1]+1))+')')
    776. 

  776.                         elif contime[1]+1 == 0:
    777. 

  777.                             list_added.append(varin+'_F'+tind1+'(t)'+' - '+varin+'(t)')
    778. 

  778.                         elif contime[1]+1 > 0:
    779. 

  779.                             list_added.append(varin+'_F'+tind1+'(t)'+' - '+'E(t)|'+varin+'(t+'+str(abs(contime[1]+1))+')')
    780. 

  780.                                 
    781. 

  781.                     # For in between
    782. 

  782.                     if lead != leador[0] and lead != leador[-1]:
    783. 

  783.                         if varin+'_F'+tind1+'(t)'+' - '+varin+'_F'+tind2+'(t-1)' not in list_added:
    784. 

  784.                             list_added.append(varin+'_F'+tind1+'(t)'+' - '+varin+'_F'+tind2+'(t-1)')
    785. 

  785.                         
    786. 

  786.                     # Define the end tail definition
    787. 

  787.                     if lead == leador[-1] and len(leador) != 1:
    788. 

  788.                         if spvdic3['con'][varin][1] > 0:
    789. 

  789.                             list_added.append(varin+'_F'+tind1+'(t)'+' - '+'E(t)|'+varin+'(t+'+str(spvdic3['con'][varin][1])+')')
    790. 

  790.                         elif spvdic3['con'][varin][1] == 0:
    791. 

  791.                             list_added.append(varin+'_F'+tind1+'(t)'+' - '+varin+'(t)')
    792. 

  792.                         elif spvdic3['con'][varin][1] < 0:
    793. 

  793.                             list_added.append(varin+'_F'+tind1+'(t)'+' - '+varin+'(t-'+str(abs(spvdic3['con'][varin][1]))+')')
    794. 

  794. 

  795.     # If only on system was passed in then we just return the modified equations with the added equations attached at bottom
    796. 

  796.     # If two systems were passed, then we return the substituted out system of equations (in nlsubs_list) and the declarations added
    797. 

  797.     # to the bottom of the usual FOC system of equations, BUT ONLY if they are not already included
    798. 

  798.     if othersys == None:
    799. 

  799.         for lino in list_added:
    800. 

  800.             if lino not in list_tmp1: list_tmp1.append(lino)
    801. 

  801.         return self, deepcopy(list_tmp1)
    802. 

  802.     elif othersys != None:
    803. 

  803.         for lino in list_added:
    804. 

  804.             if lino not in othersys:
    805. 

  805.                 othersys.append(lino)
    806. 

  806.         return self, (list_tmp1,othersys)
    807. 

  807. 

  808. 

  809. def mk_subs_dic(self, secs):
    810. 

  810.     # Make the substitution system by joining lines and stripping
    811. 

  811.     list_tmp2 = []
    812. 

  812.     # This list is used to catch the @ALL instructions and store them
    813. 

  813.     list_tmp3 = []
    814. 

  814.     list_tmp3_ind = []
    815. 

  815.     # A list which collects all elements, to be handed to the template_paramdic for template parsing
    816. 

  816.     list_tmp4 = []
    817. 

  817.     i1=0
    818. 

  818.     linecounter=0
    819. 

  819.     for x in secs['vsfocs'][0]:
    820. 

  820.         if x.endswith(("...","\\")):
    821. 

  821.             linecounter += 1
    822. 

  822.         else:
    823. 

  823.             if linecounter == 0:
    824. 

  824.                 ################# Catch @ALL expressions and store################
    825. 

  825.                 if "@ALL" in x:
    826. 

  826.                     intor = []
    827. 

  827.                     intor1 = x.split('@ALL')[1].replace(';','')
    828. 

  828.                     intor.append('@ALL')
    829. 

  829.                     intor.append(intor1)
    830. 

  830.                     list_tmp4.append(intor)
    831. 

  831.                     raw_str = x.split(';')[0].split('@ALL')[1].split('{')[1].split('}')[0]
    832. 

  832.                     list_tmp3.append(raw_str.split(','))
    833. 

  833.                     list_tmp3_ind.append(i1)
    834. 

  834.                     continue
    835. 

  835.                 ##################################################################
    836. 

  836.                 line = x.replace(';','').split(']')[1].strip()
    837. 

  837.             elif linecounter > 0: # have a multiline equation
    838. 

  838.                 str_tmp = ''
    839. 

  839.                 for y in secs['vsfocs'][0][i1-linecounter:i1+1]:
    840. 

  840.                     str_tmp += y.replace('...','').replace(';','').replace('//','').strip()
    841. 

  841.                 ################# Catch @ALL expressions and store################
    842. 

  842.                 if "@ALL" in str_tmp:
    843. 

  843.                     intor = []
    844. 

  844.                     intor1 = x.split('@ALL')[1].replace(';','')
    845. 

  845.                     intor.append('@ALL')
    846. 

  846.                     intor.append(intor1)
    847. 

  847.                     list_tmp4.append(intor)
    848. 

  848.                     raw_str = str_tmp.split('@ALL')[1].split('{')[1].split('}')[0]
    849. 

  849.                     list_tmp3.append(raw_str.split(','))
    850. 

  850.                     list_tmp3_ind.append(i1)
    851. 

  851.                     continue
    852. 

  852.                 ##################################################################
    853. 

  853.                 if ']' in str_tmp:
    854. 

  854.                     line = str_tmp.split(']')[1].strip()
    855. 

  855.                 else:
    856. 

  856.                     line = str_tmp.strip()
    857. 

  857.                 linecounter = 0 
    858. 

  858.         i1 += 1
    859. 

  859.         splitline = line.split('=')
    860. 

  860.         # Only consider the first split of = found, this is used because of subs_ind
    861. 

  861.         if len(splitline) > 2:
    862. 

  862.             tmpstr = ''
    863. 

  863.             for elem in splitline[1:]:
    864. 

  864.                 tmpstr = tmpstr+'='+elem
    865. 

  865.             tmpstr = tmpstr[1:]
    866. 

  866.             splitline = [splitline[0],tmpstr]
    867. 

  867.         list_tmp4.append([splitline[0].strip(), splitline[1].strip()])
    868. 

  868.         list_tmp2.append([splitline[0].strip(), splitline[1].strip()])
    869. 

  869.     self.allsubs_raw1 = deepcopy(list_tmp3)
    870. 

  870.     self.allsubs_index = deepcopy(list_tmp3_ind)
    871. 

  871.     self.nlsubs_raw1 = deepcopy(list_tmp2)
    872. 

  872.     self.nlsubsdic = dict(list_tmp2)
    873. 

  873.     if list_tmp4 != []: self.template_paramdic['subs_list'] = deepcopy(list_tmp4)
    874. 

  874.     else: self.template_paramdic['subs_list'] = False
    875. 

  875.     return self
    876. 

  876. 

  877. def subs_in_subs_all(self):
    878. 

  878.     list_tmp3 = deepcopy(self.allsubs_raw1)
    879. 

  879.     list_tmp2 = deepcopy(self.nlsubs_raw1)
    880. 

  880.     # Replace substitutions inside substitutions, for both time-subscripted and steady state vars!
    881. 

  881.     mreg = re.compile('@DISCOUNT|@(E\(t.*?\)\|){0,1}.*?\(t.*?\)|@(E\(t.*?\)\|){0,1}.*?_bar')
    882. 

  882.     variables = [x[0] for x in list_tmp2] # do this once
    883. 

  883.     for i,x in enumerate(list_tmp3):
    884. 

  884.         expr = list_tmp3[i][0]
    885. 

  885.         while mreg.search(expr):
    886. 

  886.             ma = mreg.search(expr)
    887. 

  887.             indx = variables.index(ma.group())
    888. 

  888.             expr = list_tmp2[indx][1]
    889. 

  889.             list_tmp3[i][0] = expr
    890. 

  890.     self.allsubs_raw2 = deepcopy(list_tmp3)
    891. 

  891.     return self
    892. 

  892. 

  893. def mk_all(self):
    894. 

  894.     list_tmp1 = deepcopy(self.allsubs_raw2)
    895. 

  895.     list_tmp2 = deepcopy(self.allsubs_raw1)
    896. 

  896.     list_tmp3 = deepcopy(self.nlsubs_raw1)
    897. 

  897.     subsli = [x[0] for x in list_tmp3]
    898. 

  898.     repldic_li = []
    899. 

  899.     do_ss = False
    900. 

  900.     for i1,elem in enumerate(list_tmp1):
    901. 

  901.         repldic = {}
    902. 

  902.         if 'SS' in elem: do_ss = True
    903. 

  903.         stem = list_tmp2[i1][0].split('(')[0]
    904. 

  904.         stem_time = '('+list_tmp2[i1][0].split('(')[1]
    905. 

  905.         # Do the simplest SS conversion
    906. 

  906.         if stem+'_bar' not in subsli: repldic[stem+'_bar'] = 'SS{'+stem+stem_time+'}'
    907. 

  907.         if '-' in elem[1]:
    908. 

  908.             chron = range(int(elem[1].split('-')[0].split('[')[1]),int(elem[1].split('-')[1].split(']')[0])+1)
    909. 

  909.         else:
    910. 

  910.             chron = elem[2].split('[')[1].split(']')[0].split(',')
    911. 

  911.             chron = [int(x) for x in chron]
    912. 

  912.         # Do current-period differentiation and SS jobs first
    913. 

  913.         patup = ('{-10,10}|None','endo|con|exo|other','{-10,10}')
    914. 

  914.         varli = self.vreg(patup,list_tmp1[i1][0],True,'max')
    915. 

  915.         for chrono in chron:
    916. 

  916.             if chrono == 0:
    917. 

  917.                 for varo in varli:
    918. 

  918.                     if varo[1][0] == 'con' and int(varo[2][2]) == 0:
    919. 

  919.                         if stem+varo[2][1]+stem_time not in subsli:
    920. 

  920.                             repldic[stem+varo[2][1]+stem_time] = 'DIFF{'+stem+stem_time+','+varo[0]+'}'
    921. 

  921.                         if stem+varo[2][1]+'_bar' not in subsli:
    922. 

  922.                             repldic[stem+varo[2][1]+'_bar'] = 'SS{'+stem+varo[2][1]+stem_time+'}'
    923. 

  923.                     elif varo[1][0] == 'endo' and int(varo[2][2]) == -1:
    924. 

  924.                         if stem+varo[2][1]+stem_time not in subsli:
    925. 

  925.                             repldic[stem+varo[2][1]+stem_time] = 'DIFF{'+stem+stem_time+','+varo[0]+'}'
    926. 

  926.                         if stem+varo[2][1]+'_bar' not in subsli:
    927. 

  927.                             repldic[stem+varo[2][1]+'_bar'] = 'SS{'+stem+varo[2][1]+stem_time+'}'
    928. 

  928.             else:
    929. 

  929.                 if stem_time == '(t)':
    930. 

  930.                     stem_time_new = '(t+'+str(chrono)+')'
    931. 

  931.                 elif '+' in stem_time:
    932. 

  932.                     old_t = int(stem_time.split('+')[1].split(')')[0])
    933. 

  933.                     stem_time_new = '(t+'+str(old_t+chrono)+')'
    934. 

  934.                 elif '-' in stem_time:
    935. 

  935.                     old_t = int('-'+stem_time.split('-')[1].split(')')[0])
    936. 

  936.                     stem_time_new = '(t+'+str(old_t+chrono)+')'
    937. 

  937.                 for varo in varli:
    938. 

  938.                     if chrono > 0:
    939. 

  939.                         if varo[1][0] == 'con' and int(varo[2][2]) == 0:
    940. 

  940.                             if stem+stem_time_new not in subsli:
    941. 

  941.                                 repldic[stem+stem_time_new] = 'FF_'+str(chrono)+'{'+stem+stem_time+'}'
    942. 

  942.                             if stem+varo[2][1]+stem_time_new not in subsli:
    943. 

  943.                                 repldic[stem+varo[2][1]+stem_time_new] = 'DIFF{'+stem+stem_time_new+','+'FF_'+str(chrono)+'{'+varo[0]+'}'+'}'
    944. 

  944.                         elif varo[1][0] == 'endo' and int(varo[2][2]) == -1:
    945. 

  945.                             if stem+stem_time_new not in subsli:
    946. 

  946.                                 repldic[stem+stem_time_new] = 'FF_'+str(chrono)+'{'+stem+stem_time+'}'
    947. 

  947.                             if stem+varo[2][1]+stem_time_new not in subsli:
    948. 

  948.                                 repldic[stem+varo[2][1]+stem_time_new] = 'DIFF{'+stem+stem_time_new+','+'FF_'+str(chrono)+'{'+varo[0]+'}'+'}'
    949. 

  949.                     elif chrono < 0:
    950. 

  950.                         if varo[1][0] == 'con' and int(varo[2][2]) == 0:
    951. 

  951.                             if stem+stem_time_new not in subsli:
    952. 

  952.                                 repldic[stem+stem_time_new] = 'BB_'+str(abs(chrono))+'{'+stem+stem_time+'}'
    953. 

  953.                             if stem+varo[2][1]+stem_time_new not in subsli:
    954. 

  954.                                 repldic[stem+varo[2][1]+stem_time_new] = 'DIFF{'+stem+stem_time_new+','+'BB_'+str((chrono))+'{'+varo[0]+'}'+'}'
    955. 

  955.                         elif varo[1][0] == 'endo' and int(varo[2][2]) == -1:
    956. 

  956.                             if stem+stem_time_new not in subsli:
    957. 

  957.                                 repldic[stem+stem_time_new] = 'BB_'+str(abs(chrono))+'{'+stem+stem_time+'}'
    958. 

  958.                             if stem+varo[2][1]+stem_time_new not in subsli:
    959. 

  959.                                 repldic[stem+varo[2][1]+stem_time_new] = 'DIFF{'+stem+stem_time_new+','+'BB_'+str(abs(chrono))+'{'+varo[0]+'}'+'}'
    960. 

  960.         repldic_li.append(repldic)
    961. 

  961.     repldic_li.reverse()
    962. 

  962.     indexli = deepcopy(self.allsubs_index)
    963. 

  963.     indexli.reverse()
    964. 

  964.     for i1,indexo in enumerate(indexli):
    965. 

  965.         self.nlsubs_raw1 = self.nlsubs_raw1[:indexo]+[list(x) for x in repldic_li[i1].items()]+self.nlsubs_raw1[indexo:]
    966. 

  966.     del self.allsubs_index
    967. 

  967.     return self
    968. 

  968.                 
    969. 

  969.             
    970. 

  970.             
    971. 

  971. 

  972. def subs_in_subs(self):
    973. 

  973.     list_tmp2 = deepcopy(self.nlsubs_raw1)
    974. 

  974.     list_tmp3 = deepcopy(self.allsubs_raw1)
    975. 

  975.     # Replace substitutions inside substitutions, for both time-subscripted and steady state vars!
    976. 

  976.     mreg = re.compile('@DISCOUNT|@(E\(t.*?\)\|){0,1}.*?\(t.*?\)|@(E\(t.*?\)\|){0,1}.*?_bar')
    977. 

  977.     variables = [x[0] for x in list_tmp2] # do this once
    978. 

  978.     self.subs_vars = deepcopy(variables)
    979. 

  979.     for i,x in enumerate(list_tmp2):
    980. 

  980.         rhs_eq = list_tmp2[i][1]
    981. 

  981.         while mreg.search(rhs_eq):
    982. 

  982.             ma = mreg.search(rhs_eq)
    983. 

  983.             pos, poe = ma.span()
    984. 

  984.             indx = variables.index(ma.group())
    985. 

  985.             # Important: When substituting in, put the term between brackets!
    986. 

  986.             rhs_eq = rhs_eq[:pos]+'('+list_tmp2[indx][1]+')'+rhs_eq[poe:]
    987. 

  987.         # Don't do below anymore as the term above has been inserted between brackets, so okay that way
    988. 

  988.         '''
    989. 

  989.         # Finally get rid of possible `+-` or `-+` occurences
    990. 

  990.         while '+-' in rhs_eq or '-+' in rhs_eq or '++' in rhs_eq:
    991. 

  991.             rhs_eq = rhs_eq.replace('+-','-')
    992. 

  992.             rhs_eq = rhs_eq.replace('-+','-')
    993. 

  993.             rhs_eq = rhs_eq.replace('++','+')
    994. 

  994.         '''
    995. 

  995.         list_tmp2[i][1] = rhs_eq
    996. 

  996.     self.nlsubs_raw2 = deepcopy(list_tmp2)
    997. 

  997.     return self
    998. 

  998. 

  999. def ff_chron_str(self,str1='',ff_int=1,vtype='all'):
    1000. 

  1000.     '''
    1001. 

  1001.     This forwards all variables in an algebraic string expression by ff_int,
    1002. 

  1002.     but it leaves the timing of the expectations operator untouched.
    1003. 

  1003.     '''
    1004. 

  1004.     _mregv1b = '(?<!E)\(t(?P<oper>[\+|-]{0,1})(?P<counto>\d{0,2})\)'
    1005. 

  1005.     _mregv1c = '(?<=E)\(t(?P<oper>[\+|-]{0,1})(?P<counto>\d{0,2})\)(?=\|)'
    1006. 

  1006.     mregv1b = re.compile(_mregv1b)
    1007. 

  1007.     mregv1c = re.compile(_mregv1c)
    1008. 

  1008.     patup = ('{-10,10}|None','endo|con|exo|iid|other','{-10,10}')
    1009. 

  1009.     reg_li = self.vreg(patup,str1,True,'max')
    1010. 

  1010.     if type(reg_li) == type(False):
    1011. 

  1011.         print "ERROR at: ",str1
    1012. 

  1012.         sys.exit()    
    1013. 

  1013.     var_li = list(reg_li)
    1014. 

  1014.     var_li.reverse()
    1015. 

  1015.     for varo in var_li:
    1016. 

  1016.         if vtype != 'all' and varo[1][0] != vtype:
    1017. 

  1017.             continue
    1018. 

  1018.         elif vtype != 'all' and varo[1][0] != vtype:
    1019. 

  1019.             continue
    1020. 

  1020.         elif vtype != 'all' and varo[1][0] != vtype:
    1021. 

  1021.             continue
    1022. 

  1022.         elif vtype != 'all' and varo[1][0] != vtype:
    1023. 

  1023.             continue
    1024. 

  1024.         varn = varo[0]
    1025. 

  1025.         ma = mregv1b.search(varn)
    1026. 

  1026.         starts = ma.start()
    1027. 

  1027.         ends = ma.end()
    1028. 

  1028.         matot = ma.group()
    1029. 

  1029.         oper = ma.group('oper')
    1030. 

  1030.         counto = ma.group('counto')
    1031. 

  1031.         varpos = varo[3]
    1032. 

  1032.         if oper == '':
    1033. 

  1033.             oper = '+'
    1034. 

  1034.             counto = int(ff_int)
    1035. 

  1035.         elif oper == '+':
    1036. 

  1036.             counto = int(counto)+ff_int
    1037. 

  1037.             counto = str(counto)
    1038. 

  1038.         elif oper == '-':
    1039. 

  1039.             counto = -int(counto)+ff_int
    1040. 

  1040.             counto = str(counto)
    1041. 

  1041.             if counto == '0':
    1042. 

  1042.                 oper = ''
    1043. 

  1043.                 counto = ''
    1044. 

  1044.             elif counto[0] == '-':
    1045. 

  1045.                 oper == '-'
    1046. 

  1046.                 counto = counto[1]
    1047. 

  1047.             else:
    1048. 

  1048.                 oper = '+'
    1049. 

  1049.                 counto = str(counto)
    1050. 

  1050.         # Split off expectations operator if present
    1051. 

  1051.         if '|' in varn:
    1052. 

  1052.             expos = varn.split('|')[0]
    1053. 

  1053.             rems = varn.split('|')[1]
    1054. 

  1054.         else:
    1055. 

  1055.             expos = ''
    1056. 

  1056.             rems = varn
    1057. 

  1057.         if expos == '':
    1058. 

  1058.             varn_new = rems.split('(')[0].replace('-','').replace('+','')+'(t'+str(oper)+str(counto)+')'
    1059. 

  1059.         else:
    1060. 

  1060.             varn_new = expos+'|'+rems.split('(')[0].replace('-','').replace('+','')+'(t'+str(oper)+str(counto)+')'
    1061. 

  1061.         # Add an expectations term if needed, but only if it is not already inside the original variable
    1062. 

  1062.         if oper == '+' and int(counto) > 0:
    1063. 

  1063.             if not mregv1c.search(varn_new): varn_new = 'E(t)|'+varn_new
    1064. 

  1064.         str1 = str1[:varpos[0]]+varn_new+str1[varpos[1]:]
    1065. 

  1065.     return str1
    1066. 

  1066. 

  1067. def bb_chron_str(self,str1='',bb_int=1,vtype='all'):
    1068. 

  1068.     '''
    1069. 

  1069.     This backwards (lags) all variables in an algebraic string expression by bb_int,
    1070. 

  1070.     but it leaves the timing of the expectations operator untouched.
    1071. 

  1071.     '''
    1072. 

  1072.     _mregv1b = '(?<!E)\(t(?P<oper>[\+|-]{0,1})(?P<counto>\d{0,2})\)'
    1073. 

  1073.     mregv1b = re.compile(_mregv1b)    
    1074. 

  1074.     patup = ('{-10,10}|None','endo|con|exo|iid|other','{-10,10}')
    1075. 

  1075.     var_li = list(self.vreg(patup,str1,True,'max'))
    1076. 

  1076.     var_li.reverse()
    1077. 

  1077.     for varo in var_li:
    1078. 

  1078.         if vtype != 'all' and varo[1][0] != vtype:
    1079. 

  1079.             continue
    1080. 

  1080.         elif vtype != 'all' and varo[1][0] != vtype:
    1081. 

  1081.             continue
    1082. 

  1082.         elif vtype != 'all' and varo[1][0] != vtype:
    1083. 

  1083.             continue
    1084. 

  1084.         elif vtype != 'all' and varo[1][0] != vtype:
    1085. 

  1085.             continue
    1086. 

  1086.         varn = varo[0]
    1087. 

  1087.         ma = mregv1b.search(varn)
    1088. 

  1088.         starts = ma.start()
    1089. 

  1089.         ends = ma.end()
    1090. 

  1090.         matot = ma.group()
    1091. 

  1091.         oper = ma.group('oper')
    1092. 

  1092.         counto = ma.group('counto')
    1093. 

  1093.         varpos = varo[3]
    1094. 

  1094.         if oper == '':
    1095. 

  1095.             oper = '-'
    1096. 

  1096.             counto = int(bb_int)
    1097. 

  1097.         elif oper == '+':
    1098. 

  1098.             counto = int(counto)-bb_int
    1099. 

  1099.             counto = str(counto)
    1100. 

  1100.             if counto == '0':
    1101. 

  1101.                 oper = ''
    1102. 

  1102.                 counto = ''
    1103. 

  1103.             elif counto[0] == '-':
    1104. 

  1104.                 oper == '-'
    1105. 

  1105.                 counto = counto[1]
    1106. 

  1106.             else:
    1107. 

  1107.                 oper = '+'
    1108. 

  1108.                 counto = str(counto)
    1109. 

  1109.         elif oper == '-':
    1110. 

  1110.             counto = -int(counto)-bb_int
    1111. 

  1111.             counto = str(counto)[1]
    1112. 

  1112.         if 'E(t)|' not in varn:
    1113. 

  1113.             varn_new = varn.split('(')[0].replace('-','').replace('+','')+'(t'+str(oper)+str(counto)+')'
    1114. 

  1114.         elif 'E(t)|' in varn and counto == '':
    1115. 

  1115.             varn_new = varn.split('E(t)|')[1].split('(')[0].replace('-','').replace('+','')+'(t'+str(oper)+str(counto)+')'            
    1116. 

  1116.         elif 'E(t)|' in varn and int(counto) > 0:
    1117. 

  1117.             varn_new = 'E(t)|'+varn.split('E(t)|')[1].split('(')[0].replace('-','').replace('+','')+'(t'+str(oper)+str(counto)+')'
    1118. 

  1118.         elif 'E(t)|' in varn and int(counto) <= 0:
    1119. 

  1119.             varn_new = varn.split('E(t)|')[1].split('(')[0].replace('-','').replace('+','')+'(t'+str(oper)+str(counto)+')'
    1120. 

  1120.         # Compare this line with ff_chron_str, here I do not add any expectations term
    1121. 

  1121.         str1 = str1[:varpos[0]]+varn_new+str1[varpos[1]:]
    1122. 

  1122.     return str1
    1123. 

  1123. 

  1124. def ss_chron_str(self,str1=''):
    1125. 

  1125.     '''
    1126. 

  1126.     This turns all variables in an algebraic string expression into steady state equivalents.
    1127. 

  1127.     '''
    1128. 

  1128.     patup = ('{-10,10}|None','endo|con|exo|other','{-10,10}')
    1129. 

  1129.     try:
    1130. 

  1130.         var_li = list(self.vreg(patup,str1,True,'max'))
    1131. 

  1131.     except:
    1132. 

  1132.         print "Model parsing error, problem with processing this text string:\n"+"'"+str1+"'."
    1133. 

  1133.         sys.exit()
    1134. 

  1134. 

  1135.     var_li.reverse()
    1136. 

  1136.     for varo in var_li:
    1137. 

  1137.         varn = varo[0]
    1138. 

  1138.         varpos = varo[3]
    1139. 

  1139.         if '|' in varn:
    1140. 

  1140.             varn_new = varn.split('|')[1].split('(')[0]+'_bar'
    1141. 

  1141.         else:
    1142. 

  1142.             varn_new = varn.split('(')[0]+'_bar'
    1143. 

  1143.         str1 = str1[:varpos[0]]+varn_new+str1[varpos[1]:]
    1144. 

  1144.     return str1
    1145. 

  1145. 

  1146. def chg_vtimings(self,eqli,vdico):
    1147. 

  1147.     vtiming = self._vtiming
    1148. 

  1148.     for keyo in vdico.keys():
    1149. 

  1149.         if vdico[keyo] != vtiming[keyo]:
    1150. 

  1150.             diffli = list(np.array(vdico[keyo]) - np.array(vtiming[keyo]))
    1151. 

  1151.             if diffli[0] < 0:
    1152. 

  1152.                 for i1,lino in enumerate(eqli):
    1153. 

  1153.                     if keyo == 'exo':
    1154. 

  1154.                         eqli[i1] = bb_chron_str(self,str1=eqli[i1],bb_int=abs(diffli[0]),vtype=keyo)
    1155. 

  1155.                         eqli[i1] = bb_chron_str(self,str1=eqli[i1],bb_int=abs(diffli[0]),vtype='iid')
    1156. 

  1156.                     else:
    1157. 

  1157.                         eqli[i1] = bb_chron_str(self,str1=eqli[i1],bb_int=abs(diffli[0]),vtype=keyo)
    1158. 

  1158.             elif diffli[0] > 0:
    1159. 

  1159.                 for i1,lino in enumerate(eqli):
    1160. 

  1160.                     if keyo == 'exo':
    1161. 

  1161.                         eqli[i1] = ff_chron_str(self,str1=eqli[i1],ff_int=abs(diffli[0]),vtype=keyo)
    1162. 

  1162.                         eqli[i1] = ff_chron_str(self,str1=eqli[i1],ff_int=abs(diffli[0]),vtype='iid')
    1163. 

  1163.                     else:
    1164. 

  1164.                         eqli[i1] = ff_chron_str(self,str1=eqli[i1],ff_int=abs(diffli[0]),vtype=keyo)
    1165. 

  1165.     return eqli
    1166. 

  1166. 

  1167. def mk_steady(self):
    1168. 

  1168.     list_tmp2 = deepcopy(self.nlsubs_raw2)
    1169. 

  1169.     _mreg = 'SS\{.*?\}'
    1170. 

  1170.     mreg = re.compile(_mreg)
    1171. 

  1171.     for i1,elem in enumerate(list_tmp2):
    1172. 

  1172.         # If there is an unreplaced DIFF inside the SS, then skip for now...
    1173. 

  1173.         if list_tmp2[i1][1][:2] == 'SS' and 'DIFF' in list_tmp2[i1][1][2:] : continue
    1174. 

  1174.         while mreg.search(list_tmp2[i1][1]):
    1175. 

  1175.             ma = mreg.search(list_tmp2[i1][1])
    1176. 

  1176.             matn = ma.group()
    1177. 

  1177.             starts = ma.start()
    1178. 

  1178.             ends = ma.end()
    1179. 

  1179.             str_tmp = matn
    1180. 

  1180.             str_tmp = str_tmp.split('{')[1].split('}')[0]
    1181. 

  1181.             str_tmp = ss_chron_str(self,str1=str_tmp)
    1182. 

  1182.             list_tmp2[i1][1] = list_tmp2[i1][1][:starts]+str_tmp+list_tmp2[i1][1][ends:]
    1183. 

  1183.     self.nlsubs_raw2 = deepcopy(list_tmp2)  
    1184. 

  1184.     return self
    1185. 

  1185. 

  1186. def mk_steady2(self):
    1187. 

  1187.     list_tmp2 = deepcopy(self.foceqs2)
    1188. 

  1188.     patup = ('{-10,10}|None','endo|con|exo|other','{-10,10}')
    1189. 

  1189.     vreg = self.vreg
    1190. 

  1190.     for i1,elem in enumerate(list_tmp2):
    1191. 

  1191.         varli = list(vreg(patup,list_tmp2[i1],True,'max'))
    1192. 

  1192.         varli.reverse()
    1193. 

  1193.         for varo in varli:
    1194. 

  1194.             vpos = varo[3]
    1195. 

  1195.             list_tmp2[i1] = list_tmp2[i1][:vpos[0]]+varo[2][1]+'_bar'+list_tmp2[i1][vpos[1]:]
    1196. 

  1196.     self.foceqss = deepcopy(list_tmp2)  
    1197. 

  1197.     return self
    1198. 

  1198. 

  1199. def mk_timeshift(self):
    1200. 

  1200.     list_tmp2 = deepcopy(self.nlsubs_raw2)
    1201. 

  1201.     _mreg = '(?<=\*)FF[_](?P<fint>\d{1,2})\{.*?\}'
    1202. 

  1202.     _mreg2 = '(?<=\*)BB[_](?P<bint>\d{1,2})\{.*?\}'
    1203. 

  1203.     _mreg_b = '(?<!\*)FF[_](?P<fint>\d{1,2})\{.*?\}'
    1204. 

  1204.     _mreg2_b = '(?<!\*)BB[_](?P<bint>\d{1,2})\{.*?\}'
    1205. 

  1205.     _mreg3 = '\s*DIFF{.*?,.*?}\s*'
    1206. 

  1206.     mreg = re.compile(_mreg)
    1207. 

  1207.     mreg2 = re.compile(_mreg2)
    1208. 

  1208.     mregb= re.compile(_mreg_b)
    1209. 

  1209.     mreg2b = re.compile(_mreg2_b)
    1210. 

  1210.     mreg3 = re.compile(_mreg3)
    1211. 

  1211.     for i1,elem in enumerate(list_tmp2):
    1212. 

  1212.         # First search for forward shifting terms
    1213. 

  1213.         while mreg.search(list_tmp2[i1][1]):
    1214. 

  1214.             ma = mreg.search(list_tmp2[i1][1])
    1215. 

  1215.             matn = ma.group()
    1216. 

  1216.             # Skip if the is a part which needs to be differentiated
    1217. 

  1217.             if mreg3.search(matn): break            
    1218. 

  1218.             starts = ma.start()
    1219. 

  1219.             ends = ma.end()
    1220. 

  1220.             fint = int(ma.group('fint'))
    1221. 

  1221.             str_tmp = matn
    1222. 

  1222.             str_tmp = str_tmp.split('{')[1].split('}')[0]
    1223. 

  1223.             str_tmp = ff_chron_str(self,str1=str_tmp,ff_int=fint)
    1224. 

  1224.             list_tmp2[i1][1] = list_tmp2[i1][1][:starts]+str_tmp+list_tmp2[i1][1][ends:]
    1225. 

  1225.         # First search for forward shifting terms
    1226. 

  1226.         while mregb.search(list_tmp2[i1][1]):
    1227. 

  1227.             ma = mregb.search(list_tmp2[i1][1])
    1228. 

  1228.             matn = ma.group()
    1229. 

  1229.             # Skip if the is a part which needs to be differentiated
    1230. 

  1230.             if mreg3.search(matn): break            
    1231. 

  1231.             starts = ma.start()
    1232. 

  1232.             ends = ma.end()
    1233. 

  1233.             fint = int(ma.group('fint'))
    1234. 

  1234.             str_tmp = matn
    1235. 

  1235.             str_tmp = str_tmp.split('{')[1].split('}')[0]
    1236. 

  1236.             str_tmp = ff_chron_str(self,str1=str_tmp,ff_int=fint)
    1237. 

  1237.             list_tmp2[i1][1] = list_tmp2[i1][1][:starts]+str_tmp+list_tmp2[i1][1][ends:]
    1238. 

  1238.         # Now search for backward shifting terms
    1239. 

  1239.         while mreg2.search(list_tmp2[i1][1]):
    1240. 

  1240.             ma = mreg2.search(list_tmp2[i1][1])
    1241. 

  1241.             matn = ma.group()
    1242. 

  1242.             # Skip if the is a part which needs to be differentiated
    1243. 

  1243.             if mreg3.search(matn): break  
    1244. 

  1244.             starts = ma.start()
    1245. 

  1245.             ends = ma.end()
    1246. 

  1246.             bint = int(ma.group('bint'))
    1247. 

  1247.             str_tmp = matn
    1248. 

  1248.             str_tmp = str_tmp.split('{')[1].split('}')[0]
    1249. 

  1249.             str_tmp = bb_chron_str(self,str1=str_tmp,bb_int=bint)
    1250. 

  1250.             list_tmp2[i1][1] = list_tmp2[i1][1][:starts]+str_tmp+list_tmp2[i1][1][ends:]
    1251. 

  1251.         # Now search for backward shifting terms
    1252. 

  1252.         while mreg2b.search(list_tmp2[i1][1]):
    1253. 

  1253.             ma = mreg2b.search(list_tmp2[i1][1])
    1254. 

  1254.             matn = ma.group()
    1255. 

  1255.             # Skip if the is a part which needs to be differentiated
    1256. 

  1256.             if mreg3.search(matn): break  
    1257. 

  1257.             starts = ma.start()
    1258. 

  1258.             ends = ma.end()
    1259. 

  1259.             bint = int(ma.group('bint'))
    1260. 

  1260.             str_tmp = matn
    1261. 

  1261.             str_tmp = str_tmp.split('{')[1].split('}')[0]
    1262. 

  1262.             str_tmp = bb_chron_str(self,str1=str_tmp,bb_int=bint)
    1263. 

  1263.             list_tmp2[i1][1] = list_tmp2[i1][1][:starts]+str_tmp+list_tmp2[i1][1][ends:]
    1264. 

  1264.     self.nlsubs_raw2 = deepcopy(list_tmp2)  
    1265. 

  1265.     return self
    1266. 

  1266. 

  1267. def ext_differ_out(self):
    1268. 

  1268.     '''
    1269. 

  1269.     This function will check differentiation instructions and augment the original one
    1270. 

  1270.     for timeshifts and the discount factor
    1271. 

  1271.     '''
    1272. 

  1272.     list_tmp2 = deepcopy(self.nlsubs_raw2)
    1273. 

  1273.     # Also allow for differentiation in substitution list
    1274. 

  1274.     _mreg = '\s*DIFF{.*?,.*?}\s*'
    1275. 

  1275.     mreg = re.compile(_mreg)
    1276. 

  1276.     _mregv1 = '\w+\d*_bar'
    1277. 

  1277.     patup = ('{-10,10}|None','endo|con|exo|other','{-10,10}')
    1278. 

  1278.     for kk1,elem in enumerate(list_tmp2):
    1279. 

  1279.         # Skip any line in which the steady state needs to be take before DIFF
    1280. 

  1280.         if list_tmp2[kk1][1][:4] == 'DIFF' and 'SS{' in list_tmp2[kk1][1]: continue
    1281. 

  1281.         # Also skip cases such as @r_bar = DIFF{z_bar*k_bar**(rho)*l_bar**(1-rho),k_bar}
    1282. 

  1282.         if list_tmp2[kk1][1][:4] == 'DIFF' and not self.vreg(patup,list_tmp2[kk1][1],True,'max') and\
    1283. 

  1283.            "_bar" in list_tmp2[kk1][1].split(',')[1]: continue        
    1284. 

  1284.         if mreg.search(list_tmp2[kk1][1]):
    1285. 

  1285.             maoutli = mreg.finditer(list_tmp2[kk1][1])
    1286. 

  1286.             maoutli = [elem for elem in maoutli]
    1287. 

  1287.             maoutli.reverse()
    1288. 

  1288.             for maout in maoutli:
    1289. 

  1289.                 expout = maout.group()
    1290. 

  1290.                 starts_out = maout.start()
    1291. 

  1291.                 ends_out = maout.end()
    1292. 

  1292.                 evalstr = expout.replace('DIFF','')
    1293. 

  1293.                 evalstr = evalstr.replace('{','')
    1294. 

  1294.                 evalstr = evalstr.replace('}','')
    1295. 

  1295.                 differo = evalstr.split(',')[1]
    1296. 

  1296.                 evalstr = evalstr.split(',')[0]
    1297. 

  1297.                 # When the variable differo is steady state then we can skip this test
    1298. 

  1298.                 if '_bar' in differo: continue
    1299. 

  1299.                 # Should be only one variable, so take the first element
    1300. 

  1300.                 diff_li = list(self.vreg(patup,differo,True,'max'))[0]
    1301. 

  1301.                 var_li = list(self.vreg(patup,evalstr,True,'max'))
    1302. 

  1302.                 # Expectations timing and differos stem name
    1303. 

  1303.                 diff_conf = diff_li[2][:2]
    1304. 

  1304.                 # The differos time subscript
    1305. 

  1305.                 diff_conf2 = int(diff_li[2][-1])
    1306. 

  1306.                 # Check for case that we need to augment the expression to be differentiated
    1307. 

  1307.                 modcase = False
    1308. 

  1308.                 chrondiff = []
    1309. 

  1309.                 for elem in var_li:
    1310. 

  1310.                     if elem[2][:2] == diff_conf and int(elem[2][-1]) != diff_conf2:
    1311. 

  1311.                         chrondiff.append((-1)*(diff_conf2+int(elem[2][-1])))
    1312. 

  1312.                         modcase = True
    1313. 

  1313.                 if modcase:
    1314. 

  1314.                     if '@DISCOUNT' not in dict(self.nlsubs_raw2).keys():
    1315. 

  1315.                         print "ERROR: For this model you need to define the discount rate explicitly!"
    1316. 

  1316.                         print "You can do this by inserting the special reserved @DISCOUNT variable into the substitution section"
    1317. 

  1317.                         sys.exit()
    1318. 

  1318.                     else:
    1319. 

  1319.                         disco = dict(self.nlsubs_raw2)['@DISCOUNT']
    1320. 

  1320.                     maxfor = max(chrondiff)
    1321. 

  1321.                     minfor = min(chrondiff)
    1322. 

  1322.                     finalexp = 'DIFF{'+evalstr
    1323. 

  1323.                     for kk2 in range(minfor,maxfor+1):
    1324. 

  1324.                         if kk2 == 0: continue
    1325. 

  1325.                         elif kk2 > 0: finalexp += '+'+disco+'**'+'('+str(kk2)+')'+'*FF_'+str(kk2)+'{'+evalstr+'}'
    1326. 

  1326.                         elif kk2 < 0: finalexp += '+'+disco+'**'+'('+str(-kk2)+')'+'*BB_'+str(kk2)+'{'+evalstr+'}'
    1327. 

  1327.                     finalexp += ','+differo+'}'
    1328. 

  1328.                     list_tmp2[kk1][1] = list_tmp2[kk1][1][:starts_out]+finalexp+list_tmp2[kk1][1][ends_out+1:]
    1329. 

  1329.     self.nlsubs_raw2 = deepcopy(list_tmp2)
    1330. 

  1330.     return self
    1331. 

  1331.             
    1332. 

  1332. 

  1333. 

  1334. def differ_out(self):
    1335. 

  1335.     # Copy in raw nlsubs which has substitutions inside
    1336. 

  1336.     # substitutions already replaced by previous function call
    1337. 

  1337.     list_tmp2 = deepcopy(self.nlsubs_raw2)
    1338. 

  1338.     # Also allow for differentiation in substitution list
    1339. 

  1339.     _mreg = '\s*DIFF{.*?,.*?}\s*'
    1340. 

  1340.     mreg = re.compile(_mreg)
    1341. 

  1341.     _mregv1 = '\w+\d*_bar'
    1342. 

  1342.     _mregv1b = '(?<!E)\(t[\+|-]{0,1}\d{0,2}\)'
    1343. 

  1343.     mregv1b = re.compile(_mregv1b)
    1344. 

  1344.     _mregv1b2 = '(?<!E)__ll__t[\+|-]{0,1}\d{0,2}__rr__'
    1345. 

  1345.     mregv1b2 = re.compile(_mregv1b)
    1346. 

  1346.     _mregv1bb = '\(t[\+|-]\d{1,2}\)'    
    1347. 

  1347.     mregv1bb = re.compile(_mregv1bb)
    1348. 

  1348.     _mregv1bb2 = '__l__t[\+|-]\d{1,2}__r__'    
    1349. 

  1349.     mregv1bb2 = re.compile(_mregv1bb2)    
    1350. 

  1350.     _mregv1c = '\([p+|m+]\)'
    1351. 

  1351.     mregv1c = re.compile(_mregv1c)
    1352. 

  1352.     _mregv1d = 'E\(t[\+|-]{0,1}\d{0,2}\)\|'
    1353. 

  1353.     mregv1d = re.compile(_mregv1d)
    1354. 

  1354.     _mregv1e = 'E\[t[\+|-]{0,1}\d{0,2}]\|'
    1355. 

  1355.     mregv1e = re.compile(_mregv1e)
    1356. 

  1356.     _mreglog = 'LOG\(.*?\)'
    1357. 

  1357.     _mregexp = 'EXP\(.*?\)'
    1358. 

  1358.     mregle_ng = re.compile(_mregexp+'|'+_mreglog)
    1359. 

  1359.     _mreglog2 = 'LOG\[.*?]'
    1360. 

  1360.     _mregexp2 = 'EXP\[.*?]'
    1361. 

  1361.     mregle2_ng = re.compile(_mregexp2+'|'+_mreglog2)
    1362. 

  1362.     _mreglog = 'LOG\(.*\)'
    1363. 

  1363.     _mregexp = 'EXP\(.*\)'
    1364. 

  1364.     mregle_gg = re.compile(_mregexp+'|'+_mreglog)
    1365. 

  1365.     _mreglog2 = 'LOG\[.*]'
    1366. 

  1366.     _mregexp2 = 'EXP\[.*]'
    1367. 

  1367.     mregle2_gg = re.compile(_mregexp2+'|'+_mreglog2)
    1368. 

  1368.     _mregsh = '(?<!DI)FF[_]\d{1,2}|BB[_]\d{1,2}'
    1369. 

  1369.     mregsh = re.compile(_mregsh)
    1370. 

  1370.     patup = ('{-10,10}|None','endo|con|exo|other','{-10,10}')
    1371. 

  1371.     # Collect some necessary info for steady state substitutions
    1372. 

  1372.     var_bar = []
    1373. 

  1373.     for elem in ['con','endo','exo','other']:
    1374. 

  1374.         tmp_li = [x[0].split('(')[0]+'_bar' for x in self.vardic[elem]['var']]
    1375. 

  1375.         for elem2 in tmp_li:
    1376. 

  1376.             var_bar.append(elem2)
    1377. 

  1377.     for kk1,elem in enumerate(list_tmp2):
    1378. 

  1378.         # Skip any line in which
    1379. 

  1379.         if list_tmp2[kk1][1][:4] == 'DIFF' and 'SS{' in list_tmp2[kk1][1]: continue
    1380. 

  1380.         while mreg.search(list_tmp2[kk1][1]):
    1381. 

  1381.             maout = mreg.search(list_tmp2[kk1][1])
    1382. 

  1382.             expout = maout.group()
    1383. 

  1383.             starts_out = maout.end()
    1384. 

  1384.             ends_out = maout.start()
    1385. 

  1385.             evalstr = expout.replace('DIFF','')
    1386. 

  1386.             evalstr = evalstr.replace('{','')
    1387. 

  1387.             evalstr = evalstr.replace('}','')
    1388. 

  1388.             differo = evalstr.split(',')[1]
    1389. 

  1389.             # Skip if differo still has uncomputed timeshifter
    1390. 

  1390.             if mregsh.search(differo): break
    1391. 

  1391.             # Also skip if evalstr has uncomputed timeshifter
    1392. 

  1392.             if mregsh.search(evalstr): break
    1393. 

  1393.             evalstr = evalstr.split(',')[0]
    1394. 

  1394.             time_vars = False
    1395. 

  1395.             var_li = self.vreg(patup,evalstr,True,'max')
    1396. 

  1396.             if var_li: time_vars = True
    1397. 

  1397.             #########################################################
    1398. 

  1398.             # Do for steady state expressions, as is very easy, CASE1
    1399. 

  1399.             #########################################################
    1400. 

  1400.             if '_bar' in evalstr and not time_vars and '_bar' in differo:
    1401. 

  1401.                 # Now substitute out exp and log in terms of sympycore expressions
    1402. 

  1402.                 elog = re.compile('LOG\(')
    1403. 

  1403.                 while elog.search(evalstr):
    1404. 

  1404.                     ma = elog.search(evalstr)
    1405. 

  1405.                     pos = ma.span()[0]
    1406. 

  1406.                     poe = ma.span()[1]
    1407. 

  1407.                     evalstr = evalstr[:pos]+'SP.log('+evalstr[poe:]
    1408. 

  1408.                 eexp = re.compile('EXP\(')
    1409. 

  1409.                 while eexp.search(evalstr):
    1410. 

  1410.                     ma = eexp.search(evalstr)
    1411. 

  1411.                     pos = ma.span()[0]
    1412. 

  1412.                     poe = ma.span()[1]
    1413. 

  1413.                     evalstr = evalstr[:pos]+'SP.exp('+evalstr[poe:]
    1414. 

  1414.                 # Now populate scope with sympy symbols
    1415. 

  1415.                 tmp_dic={}
    1416. 

  1416.                 for elem in var_bar:
    1417. 

  1417.                     tmp_dic[elem] = SP.Symbol(elem)
    1418. 

  1418.                 locals().update(tmp_dic)
    1419. 

  1419.                 tmp_dic = {}
    1420. 

  1420.                 for elem in self.paramdic.keys():
    1421. 

  1421.                     tmp_dic[elem] = SP.Symbol(elem)
    1422. 

  1422.                 locals().update(tmp_dic)
    1423. 

  1423.                 # Also expose any variables from the ssidic, just in case
    1424. 

  1424.                 tmp_dic = {}
    1425. 

  1425.                 for elem in self.ssidic.keys():
    1426. 

  1426.                     tmp_dic[elem] = SP.Symbol(elem)
    1427. 

  1427.                 locals().update(tmp_dic)
    1428. 

  1428.                 # Also expose the differo variable
    1429. 

  1429.                 locals()[differo] = SP.Symbol(differo)
    1430. 

  1430.                 # Population of scope done, now do calculation and continue in loop
    1431. 

  1431.                 expr_bar = eval(evalstr)
    1432. 

  1432.                 resstr = expr_bar.diff(locals()[str(differo)])
    1433. 

  1433.                 list_tmp2[kk1][1] = str(resstr)
    1434. 

  1434.                 continue
    1435. 

  1435.             ##############################################################################
    1436. 

  1436.             # Do for steady state expressions, as is very easy, CASE2, needs working varli
    1437. 

  1437.             ##############################################################################
    1438. 

  1438.             
    1439. 

  1439.             ############## Generate varli only here, as it was not needed above (it was, but only for testing) ############### 
    1440. 

  1440.             try:
    1441. 

  1441.                 var_li = list(self.vreg(patup,evalstr,True,'max'))
    1442. 

  1442.                 if var_li: time_vars = True
    1443. 

  1443.             except:
    1444. 

  1444.                 print "Model parsing error, problem with processing this text string:\n"+"'"+list_tmp2[kk1][0]+" = "+list_tmp2[kk1][1]+"'."
    1445. 

  1445.                 sys.exit()
    1446. 

  1446.             ###################################################################################################################
    1447. 

  1447. 

  1448.             if '_bar' not in evalstr and not time_vars and '_bar' in differo:
    1449. 

  1449.                 # First replace all chronological variables in evalstr with _bar equivalents
    1450. 

  1450.                 varbar_li = deepcopy(var_li)
    1451. 

  1451.                 varbar_li.reverse()
    1452. 

  1452.                 for varo in varbar_li:
    1453. 

  1453.                     vpos = varo[3]
    1454. 

  1454.                     evalstr = evalstr[:vpos[0]]+varo[2][1]+'_bar'+evalstr[vpos[1]:]
    1455. 

  1455.                 # Now substitute out exp and log in terms of sympycore expressions
    1456. 

  1456.                 elog = re.compile('LOG\(')
    1457. 

  1457.                 while elog.search(evalstr):
    1458. 

  1458.                     ma = elog.search(evalstr)
    1459. 

  1459.                     pos = ma.span()[0]
    1460. 

  1460.                     poe = ma.span()[1]
    1461. 

  1461.                     evalstr = evalstr[:pos]+'SP.log('+evalstr[poe:]
    1462. 

  1462.                 eexp = re.compile('EXP\(')
    1463. 

  1463.                 while eexp.search(evalstr):
    1464. 

  1464.                     ma = eexp.search(evalstr)
    1465. 

  1465.                     pos = ma.span()[0]
    1466. 

  1466.                     poe = ma.span()[1]
    1467. 

  1467.                     evalstr = evalstr[:pos]+'SP.exp('+evalstr[poe:]
    1468. 

  1468.                 # Now populate scope with sympy symbols
    1469. 

  1469.                 tmp_dic={}
    1470. 

  1470.                 for elem in var_bar:
    1471. 

  1471.                     tmp_dic[elem] = SP.Symbol(elem)
    1472. 

  1472.                 locals().update(tmp_dic)
    1473. 

  1473.                 tmp_dic = {}
    1474. 

  1474.                 for elem in self.paramdic.keys():
    1475. 

  1475.                     tmp_dic[elem] = SP.Symbol(elem)
    1476. 

  1476.                 locals().update(tmp_dic)
    1477. 

  1477.                 # Also expose any variables from the ssidic, just in case
    1478. 

  1478.                 tmp_dic = {}
    1479. 

  1479.                 for elem in self.ssidic.keys():
    1480. 

  1480.                     tmp_dic[elem] = SP.Symbol(elem)
    1481. 

  1481.                 locals().update(tmp_dic)
    1482. 

  1482.                 # Also expose the differo variable
    1483. 

  1483.                 locals()[differo] = SP.Symbol(differo)
    1484. 

  1484.                 # Population of scope done, now do calculation and continue in loop
    1485. 

  1485.                 expr_bar = eval(evalstr)
    1486. 

  1486.                 resstr = expr_bar.diff(locals()[str(differo)])
    1487. 

  1487.                 list_tmp2[kk1][1] = str(resstr)
    1488. 

  1488.                 continue
    1489. 

  1489.             ###################################################
    1490. 

  1490.             # Steady State branch ends here
    1491. 

  1491.             ###################################################
    1492. 

  1492.             var_li2 = deepcopy(var_li)
    1493. 

  1493.             var_li2.reverse()
    1494. 

  1494.             ss_li = [x[2][1]+'_bar' for x in var_li2]
    1495. 

  1495.             # Replace t+1 or t-1 with something without the operators, in evalstr
    1496. 

  1496.             for jj1,elem in enumerate(var_li2):
    1497. 

  1497.                 tmp_li = list(elem)
    1498. 

  1498.                 # Replace expectations operators with something else inside evalstr
    1499. 

  1499.                 if mregv1d.search(tmp_li[0]):
    1500. 

  1500.                     ma = mregv1d.search(tmp_li[0])
    1501. 

  1501.                     vname = ma.group()
    1502. 

  1502.                     ends = ma.end()
    1503. 

  1503.                     starts = ma.start()
    1504. 

  1504.                     vname = vname.replace('(','__ll__')
    1505. 

  1505.                     vname = vname.replace(')','__rr__')
    1506. 

  1506.                     vname = vname.replace('|','DELIM__')
    1507. 

  1507.                     tmp_li[0] = tmp_li[0][:starts]+vname+tmp_li[0][ends:]                      
    1508. 

  1508.                 evalstr = evalstr[:elem[3][0]]+tmp_li[0].\
    1509. 

  1509.                 replace('(','__l__').\
    1510. 

  1510.                 replace(')','__r__').\
    1511. 

  1511.                 replace('|','DELIM__')+\
    1512. 

  1512.                 evalstr[elem[3][1]:]
    1513. 

  1513. 

  1514.             # Replace expectations operators with something else inside varli
    1515. 

  1515.             for i1,varo in enumerate(var_li):
    1516. 

  1516.                 if mregv1d.search(varo[0]):
    1517. 

  1517.                     str1 = varo[0].split('|')[1]
    1518. 

  1518.                     str2 = varo[0].split('|')[0]
    1519. 

  1519.                     str2 = str2.replace('(','__ll__')
    1520. 

  1520.                     str2 = str2.replace(')','__rr__')
    1521. 

  1521.                     var_li[i1] = list(varo)
    1522. 

  1522.                     var_li[i1][0] = str2+'DELIM__'+str1
    1523. 

  1523.             # Replace the LOGs and EXPs with square brackets
    1524. 

  1524.             while mregle_ng.search(evalstr):
    1525. 

  1525.                 ma = mregle_ng.search(evalstr)
    1526. 

  1526.                 starts = ma.start()
    1527. 

  1527.                 ends = ma.end()
    1528. 

  1528.                 evalstr = evalstr[:ends-1] + ']' + evalstr[ends:]
    1529. 

  1529.                 evalstr = evalstr[:starts+3] + '[' + evalstr[starts+4:]
    1530. 

  1530.             # Replace t+1 or t-1 with something without the operators, inside var_li
    1531. 

  1531.             for i1,varo in enumerate(var_li):
    1532. 

  1532.                 var_li[i1] = list(varo)
    1533. 

  1533.                 ma = mregv1bb.search(varo[0])
    1534. 

  1534.                 if ma:
    1535. 

  1535.                     ends = ma.end()
    1536. 

  1536.                     starts = ma.start()
    1537. 

  1537.                     if '+' in varo[0]:
    1538. 

  1538.                         str1 = varo[0].split('(')[0]
    1539. 

  1539.                         counto = varo[0].split('+')[1][0]
    1540. 

  1540.                         var_li[i1][0] = str1+'__l__'+int(counto)*'p' + '__r__'
    1541. 

  1541.                     if '-' in varo[0]:
    1542. 

  1542.                         str1 = varo[0].split('(')[0]
    1543. 

  1543.                         counto = varo[0].split('-')[1][0]
    1544. 

  1544.                         var_li[i1][0] = str1+'__l__'+int(counto)*'m' + '__r__'
    1545. 

  1545.             while mregv1bb2.search(evalstr):
    1546. 

  1546.                 ma = mregv1bb2.search(evalstr)
    1547. 

  1547.                 varn = ma.group()
    1548. 

  1548.                 ends = ma.end()
    1549. 

  1549.                 starts = ma.start()
    1550. 

  1550.                 if '+' in varn:
    1551. 

  1551.                     str1 = varn.split('__l__')[0]
    1552. 

  1552.                     counto = varn.split('+')[1][0]
    1553. 

  1553.                     varn_new = str1+'__l__'+int(counto)*'p' + '__r__'
    1554. 

  1554.                     evalstr = evalstr[:starts]+varn_new+evalstr[ends:]
    1555. 

  1555.                 if '-' in varn:
    1556. 

  1556.                     str1 = varn.split('__l__')[0]
    1557. 

  1557.                     counto = varn.split('-')[1][0]
    1558. 

  1558.                     varn_new = str1+'__l__'+int(counto)*'m' + '__r__'
    1559. 

  1559.                     evalstr = evalstr[:starts]+varn_new+evalstr[ends:]
    1560. 

  1560.             # Replace left and right round brackets for variables and expose to sympycore
    1561. 

  1561.             for i1,varo in enumerate(var_li):
    1562. 

  1562.                 str_tmp2 = var_li[i1][0]
    1563. 

  1563.                 str_tmp2 = str_tmp2.replace('(','__l__')
    1564. 

  1564.                 str_tmp2 = str_tmp2.replace(')','__r__')
    1565. 

  1565.                 locals()[str_tmp2] = SP.Symbol(str_tmp2)
    1566. 

  1566.             for varo in self.paramdic.keys(): locals()[varo] = SP.Symbol(varo)
    1567. 

  1567.             # Replace left and right round brackets for the differo variable and expose to sympycore
    1568. 

  1568.             str_tmp3 = deepcopy(differo)
    1569. 

  1569.             # First, also check for (t+x),(t-x) or (t) in differo and replace with something readable by sympycore
    1570. 

  1570.             while mregv1b.search(str_tmp3):
    1571. 

  1571.                 ma = mregv1b.search(str_tmp3)
    1572. 

  1572.                 ends = ma.end()
    1573. 

  1573.                 starts = ma.start()
    1574. 

  1574.                 if '+' in str_tmp3:
    1575. 

  1575.                     counto = str_tmp3.split('+')[-1][0]
    1576. 

  1576.                     post = str_tmp3[starts:]
    1577. 

  1577.                     pre = str_tmp3[:starts]
    1578. 

  1578.                     # Also replace brackets
    1579. 

  1579.                     if ')' in pre: pre = pre.replace(')','__rr__')
    1580. 

  1580.                     if '(' in pre: pre = pre.replace('(','__ll__')
    1581. 

  1581.                     if ')' in post: post = post.replace(')','__r__')
    1582. 

  1582.                     if '(' in post: post = post.replace('(','__l__')                    
    1583. 

  1583.                     str_tmp3 = pre+'__l__'+int(counto)*'p' + '__r__' 
    1584. 

  1584.                 elif '-' in str_tmp3:
    1585. 

  1585.                     counto = str_tmp3.split('-')[-1][0]
    1586. 

  1586.                     post = str_tmp3[starts:]
    1587. 

  1587.                     pre = str_tmp3[:starts]
    1588. 

  1588.                     # Also replace brackets
    1589. 

  1589.                     if ')' in pre: pre = pre.replace(')','__rr__')
    1590. 

  1590.                     if '(' in pre: pre = pre.replace('(','__ll__')
    1591. 

  1591.                     if ')' in post: post = post.replace(')','__r__')
    1592. 

  1592.                     if '(' in post: post = post.replace('(','__l__')                    
    1593. 

  1593.                     str_tmp3 = pre+'__l__'+int(counto)*'m' + '__r__'
    1594. 

  1594.                 else:
    1595. 

  1595.                     post = str_tmp3[starts:]
    1596. 

  1596.                     pre = str_tmp3[:starts]
    1597. 

  1597.                     # Also replace brackets
    1598. 

  1598.                     if ')' in pre: pre = pre.replace(')','__rr__')
    1599. 

  1599.                     if '(' in pre: pre = pre.replace('(','__ll__')
    1600. 

  1600.                     if ')' in post: post = post.replace(')','__r__')
    1601. 

  1601.                     if '(' in post: post = post.replace('(','__l__')                    
    1602. 

  1602.                     str_tmp3 = pre+'__l__'+'t' + '__r__'                    
    1603. 

  1603.             differo_new = deepcopy(str_tmp3)
    1604. 

  1604.             # Also replace the delimiter when expectations are present in differo
    1605. 

  1605.             while '|' in differo_new: differo_new = differo_new.replace('|','DELIM__')
    1606. 

  1606.             locals()[differo_new] = SP.Symbol(differo_new)
    1607. 

  1607.             # Replace left and right brackets for the entire expression before calling diff
    1608. 

  1608.             var_li.reverse()
    1609. 

  1609.             for varo in var_li:
    1610. 

  1610.                 varn_orig = varo[0]
    1611. 

  1611.                 varn = varo[0].replace(')','__r__')
    1612. 

  1612.                 varn = varn.replace('(','__l__')
    1613. 

  1613.                 evalstr = evalstr.replace(varn_orig, varn)
    1614. 

  1614.             # Replace the LOGs and EXPs with round brackets again
    1615. 

  1615.             while mregle2_ng.search(evalstr):
    1616. 

  1616.                 ma = mregle2_ng.search(evalstr)
    1617. 

  1617.                 starts = ma.start()
    1618. 

  1618.                 ends = ma.end()
    1619. 

  1619.                 evalstr = evalstr[:ends-1] + ')' + evalstr[ends:]
    1620. 

  1620.                 evalstr = evalstr[:starts+3] + '(' + evalstr[starts+4:]
    1621. 

  1621.             # Now substitute out exp and log in terms of sympycore expressions
    1622. 

  1622.             elog = re.compile('LOG\(')
    1623. 

  1623.             while elog.search(evalstr):
    1624. 

  1624.                 ma = elog.search(evalstr)
    1625. 

  1625.                 pos = ma.span()[0]
    1626. 

  1626.                 poe = ma.span()[1]
    1627. 

  1627.                 evalstr = evalstr[:pos]+'SP.log('+evalstr[poe:]
    1628. 

  1628.             eexp = re.compile('EXP\(')
    1629. 

  1629.             while eexp.search(evalstr):
    1630. 

  1630.                 ma = eexp.search(evalstr)
    1631. 

  1631.                 pos = ma.span()[0]
    1632. 

  1632.                 poe = ma.span()[1]
    1633. 

  1633.                 evalstr = evalstr[:pos]+'SP.exp('+evalstr[poe:]
    1634. 

  1634.             # Now evaluate and differentiate
    1635. 

  1635.             # Before evaluating expose the self.paramdic and self.ssidic to locals
    1636. 

  1636.             tmp_dic = {}
    1637. 

  1637.             for elem in self.paramdic.keys():
    1638. 

  1638.                 tmp_dic[elem] = SP.Symbol(elem)
    1639. 

  1639.             locals().update(tmp_dic)
    1640. 

  1640.             # Also expose any variables from the ssidic, just in case
    1641. 

  1641.             if 'ssidic' in dir(self):
    1642. 

  1642.                 tmp_dic = {}
    1643. 

  1643.                 for elem in self.ssidic.keys():
    1644. 

  1644.                     tmp_dic[elem] = SP.Symbol(elem)
    1645. 

  1645.                 locals().update(tmp_dic)
    1646. 

  1646.             # Also expose any variables from the ss_li, just in case
    1647. 

  1647.             tmp_dic = {}
    1648. 

  1648.             for elem in ss_li:
    1649. 

  1649.                 tmp_dic[elem] = SP.Symbol(elem)
    1650. 

  1650.             locals().update(tmp_dic)
    1651. 

  1651.             expr = eval(evalstr)
    1652. 

  1652.             try:
    1653. 

  1653.                 expr = eval(evalstr)
    1654. 

  1654.             except:
    1655. 

  1655.                 print "Parse ERROR: Could not evaluate/differentiate expression: "
    1656. 

  1656.                 print list_tmp2[kk1][0]+" = "+list_tmp2[kk1][1]
    1657. 

  1657.                 sys.exit()
    1658. 

  1658.             resstr = expr.diff(locals()[str(differo_new)])
    1659. 

  1659.             resstr = str(resstr)
    1660. 

  1660.             # Now switch back to normal notation with brackets
    1661. 

  1661.             while '__l__' in resstr:
    1662. 

  1662.                 resstr = resstr.replace('__l__','(')
    1663. 

  1663.             while '__r__' in resstr:
    1664. 

  1664.                 resstr = resstr.replace('__r__',')')
    1665. 

  1665.             while '__ll__' in resstr:
    1666. 

  1666.                 resstr = resstr.replace('__ll__','(')
    1667. 

  1667.             while '__rr__' in resstr:
    1668. 

  1668.                 resstr = resstr.replace('__rr__',')')
    1669. 

  1669.             # Also replace the DELIM with |
    1670. 

  1670.             while 'DELIM__' in resstr: resstr = resstr.replace('DELIM__','|')
    1671. 

  1671.             # Now also switch back to normal t+1/t-x notation
    1672. 

  1672.             while mregv1c.search(resstr):
    1673. 

  1673.                 ma = mregv1c.search(resstr)
    1674. 

  1674.                 ends = ma.end()
    1675. 

  1675.                 starts = ma.start()
    1676. 

  1676.                 str3 = ma.group()
    1677. 

  1677.                 lengo = len(str3[1:-1])
    1678. 

  1678.                 if 'p' in str3: resstr = resstr[:starts]+'(t+'+str(lengo)+')'+resstr[ends:]
    1679. 

  1679.                 elif 'm' in str3: resstr = resstr[:starts]+'(t-'+str(lengo)+')'+resstr[ends:]
    1680. 

  1680.             # Replace with the differentiate term, but also take brackets around it just in case    
    1681. 

  1681.             list_tmp2[kk1][1] = list_tmp2[kk1][1].replace(expout,'('+resstr+')')
    1682. 

  1682.     self.nlsubs_raw2 = deepcopy(list_tmp2)
    1683. 

  1683.     self.nlsubs = deepcopy(dict(list_tmp2))
    1684. 

  1684.     self.nlsubs_list = deepcopy(list_tmp2)
    1685. 

  1685.     return self
    1686. 

  1686. 

  1687. def premknonlinsys(self,secs):
    1688. 

  1688.     '''
    1689. 

  1689.     This takes the raw lines of the FOCs and does some joining, splitting and stripping
    1690. 

  1690.     '''
    1691. 

  1691.     # Make the non-linear system by joining lines and stripping
    1692. 

  1692.     list_tmp1 = []
    1693. 

  1693.     i1 = 0
    1694. 

  1694.     linecounter = 0
    1695. 

  1695.     for x in secs['focs'][0]:
    1696. 

  1696.         if x.endswith(('...','\\')):
    1697. 

  1697.             linecounter += 1
    1698. 

  1698.         else:
    1699. 

  1699.             if linecounter == 0:
    1700. 

  1700.                 if ']' in x: line = x.replace(';','').split(']')[1].strip()
    1701. 

  1701.                 else: line = x.replace(';','').strip()
    1702. 

  1702.                 line = line.split('=')[0].strip()
    1703. 

  1703.                 list_tmp1.append(line)
    1704. 

  1704.             elif linecounter > 0:
    1705. 

  1705.                 str_tmp = ''
    1706. 

  1706.                 for y in secs['focs'][0][i1-linecounter:i1+1]:
    1707. 

  1707.                     if ']' in y: str_tmp += y.split(']')[1].replace('...','').replace('\\','').replace(';','').strip()
    1708. 

  1708.                     else: str_tmp += y.replace('...','').replace('\\','').replace(';','').strip()
    1709. 

  1709.                 if ']' in x: line = str_tmp.split(']')[1].strip()
    1710. 

  1710.                 else: line = str_tmp.strip()
    1711. 

  1711.                 linecounter = 0 
    1712. 

  1712.                 line = line.split('=')[0].strip()
    1713. 

  1713.                 list_tmp1.append(line)
    1714. 

  1714.         i1 += 1
    1715. 

  1715.     self.foceqs = deepcopy(list_tmp1)
    1716. 

  1716.     return self
    1717. 

  1717. 

  1718. def premknonlinsys2(self, secs):
    1719. 

  1719.     list_tmp1 = deepcopy(self.foceqs)
    1720. 

  1720.     variables = deepcopy(self.subs_vars)
    1721. 

  1721.     subs_found = []
    1722. 

  1722.     i1 = 0    
    1723. 

  1723.     for x in list_tmp1:
    1724. 

  1724.         # substitute out in main nonlinear equation system
    1725. 

  1725.         list_tmp2 = deepcopy(self.nlsubs_list)
    1726. 

  1726.         mreg = re.compile('@(E\(t.*?\)\|){0,1}.*?\(t.*?\)')
    1727. 

  1727.         for i,x in enumerate(list_tmp1):
    1728. 

  1728.             rhs_eq = list_tmp1[i]
    1729. 

  1729.             while mreg.search(rhs_eq):
    1730. 

  1730.                 ma = mreg.search(rhs_eq)
    1731. 

  1731.                 subv = ma.group()
    1732. 

  1732.                 if subv not in subs_found: subs_found.append(subv)
    1733. 

  1733.                 pos, poe = ma.span()
    1734. 

  1734.                 indx = variables.index(subv)
    1735. 

  1735.                 rhs_eq = rhs_eq[:pos]+'('+list_tmp2[indx][1]+')'+\
    1736. 

  1736.                     rhs_eq[poe:]
    1737. 

  1737.             list_tmp1[i] = rhs_eq
    1738. 

  1738.         i1+=1
    1739. 

  1739.     self.foceqs2 = deepcopy(list_tmp1)
    1740. 

  1740.     self.subs_found = deepcopy(subs_found)
    1741. 

  1741.     
    1742. 

  1742.     # Remove the elements from nlsubs_list which were not found in the nlsys_list!
    1743. 

  1743.     # This is important because pymaclab also generates equations (and auxiliary variables)
    1744. 

  1744.     # for the expressions declared in the nonlinear substitution system
    1745. 

  1745.     self.nlsubs_list = [x for x in self.nlsubs_list if x[0] in self.subs_found]
    1746. 

  1746.     for i1,elem in enumerate(self.vardic['other']['var']):
    1747. 

  1747.         if '@'+elem[0] not in self.subs_found:
    1748. 

  1748.             self.vardic['other']['var'].pop(i1)
    1749. 

  1749.             self.vardic['other']['mod'].pop(i1)
    1750. 

  1750. 

  1751.     return self
    1752. 

  1752. 

  1753. def mknonlinsys(self, secs):
    1754. 

  1754.     """
    1755. 

  1755.     Create Non-Linear FOC System
    1756. 

  1756.     """
    1757. 

  1757.     # Here we introduce time-shifted auxiliary variables into the system of FOCs if needed
    1758. 

  1758.     # and also add them to the vardic and audic, also new variables get added to bottom of nlsys_list
    1759. 

  1759.     # The returned list is just the new augmented nlsys_list with the auxiliary variables in the system
    1760. 

  1760.     list_tmp1 = deepcopy(self.foceqs2)
    1761. 

  1761.     self, list_tmp1 = mkaug2(self,insys=list_tmp1,othersys=None)
    1762. 

  1762. 

  1763.     if all([False if 'None' in x else True for x in secs['vsfocs'][0]]):
    1764. 

  1764.         ## The point of this section below this conditional test is to replace variables
    1765. 

  1765.         ## inside nlsubs_list with their time-shifted (auxiliary) equivalent
    1766. 

  1766.         ## When doing so we may need to add newly found auxiliary variables to the bottom of nlsys_list
    1767. 

  1767.         variables = deepcopy(self.subs_vars)
    1768. 

  1768.         
    1769. 

  1769.         # Here we do the substitutions inside the variable substitution list, outup contains two lists
    1770. 

  1770.         list_tmp3 = [x[1] for x in deepcopy(self.nlsubs_list)]
    1771. 

  1771.         self, outtup = mkaug2(self,insys=list_tmp3,othersys=list_tmp1)
    1772. 

  1772. 

  1773.         # Then the equation expressions (declarations) with substituted time elements get inserted back in
    1774. 

  1774.         list_tmp3 = outtup[0] # This is the system of substitutions
    1775. 

  1775.         list_tmp2 = deepcopy(self.nlsubs_list) # This is the old system of substitutions, needs updating
    1776. 

  1776.         list_tmp1 = outtup[1] # This is the FOC system
    1777. 

  1777.         for i1,x in enumerate(list_tmp3):
    1778. 

  1778.             list_tmp2[i1][1] = list_tmp3[i1]
    1779. 

  1779. 

  1780. 

  1781.         # Below all other objects get updated in order to take information into account
    1782. 

  1782.         # which was computed in the above
    1783. 

  1783.         self.nlsubs = dict(list_tmp2)
    1784. 

  1784.         nlsubs2 = {}
    1785. 

  1785.         for x in [x[0] for x in self.vardic['other']['var']]:
    1786. 

  1786.             nlsubs2[x] = self.nlsubs['@'+x]
    1787. 

  1787.         self.nlsubs2 = nlsubs2
    1788. 

  1788. 

  1789.         # Create ordered nlsubsys
    1790. 

  1790.         if self.vardic['other']['var']:
    1791. 

  1791.             nlsubsys = []
    1792. 

  1792.             varother = self.vardic['other']['var']
    1793. 

  1793.             for vari in [x[0] for x in varother]:
    1794. 

  1794.                 nlsubsys.append(nlsubs2[vari])
    1795. 

  1795.             self.nlsubsys = nlsubsys
    1796. 

  1796. 

  1797.     # Count the number of distinct forward expectations
    1798. 

  1798.     # AND the no of equations that contain them
    1799. 

  1799.     ffli = []
    1800. 

  1800.     count = 0
    1801. 

  1801.     patup = ('0','endo|con|exo','{1,10}')
    1802. 

  1802.     for line in list_tmp1[:-self.nexo]:
    1803. 

  1803.         outli = self.vreg(patup,line,True,'min')
    1804. 

  1804.         if outli:
    1805. 

  1805.             count = count + 1
    1806. 

  1806.             for elem in [x[0] for x in outli]:
    1807. 

  1807.                 if elem not in ffli:
    1808. 

  1808.                     ffli.append(elem)
    1809. 

  1809.     self.ffen = count
    1810. 

  1810.     self.ffli = ffli
    1811. 

  1811.     self.fflin = len(ffli)
    1812. 

  1812. 

  1813.     # Now create simplified vdic with possibly new augmented vars
    1814. 

  1814.     vdic = dict([[x,self.vardic[x]['var']] for x in self.vardic.keys()])
    1815. 

  1815.     self.vdic = vdic
    1816. 

  1816. 

  1817.     # Finally, recomputed nendo, ncon, etc.
    1818. 

  1818.     self.nendo = len(self.vardic['endo']['var'])
    1819. 

  1819.     self.nexo = len(self.vardic['exo']['var'])
    1820. 

  1820.     self.ncon = len(self.vardic['con']['var'])
    1821. 

  1821.     self.nother = len(self.vardic['other']['var'])
    1822. 

  1822.     self.nstat = self.nendo+self.nexo
    1823. 

  1823.     self.nall = self.nstat+self.ncon
    1824. 

  1824. 

  1825.     self.nlsys_list = deepcopy(list_tmp1)
    1826. 

  1826.     return self
    1827. 

  1827. 

  1828. def mkloglinsys2(self, inlist):
    1829. 

  1829.     """
    1830. 

  1830.     This function simply takes the left-hand side
    1831. 

  1831.     of each equation and takes it over to the
    1832. 

  1832.     right-hand side with a minus sign in front.
    1833. 

  1833.     Now we have equations of the form g(x)=0.
    1834. 

  1834.     Also takes care of fact that the term may
    1835. 

  1835.     already be negative. Also takes into account
    1836. 

  1836.     that some equations have already been written
    1837. 

  1837.     as g(x)=0!
    1838. 

  1838.     """
    1839. 

  1839.     _revar='(E\(t-{0,1}\+{0,1}\d*\)\|){0,1}[a-z]*(\(t-{0,1}\+{0,1}\d*\)){1,1}'
    1840. 

  1840.     re_var = re.compile(_revar)
    1841. 

  1841.     list_tmp1 = deepcopy(inlist)
    1842. 

  1842.     str_tmp2 = ''
    1843. 

  1843.     i1 = 0
    1844. 

  1844.     while i1 < len(list_tmp1):
    1845. 

  1845. 

  1846.         if list_tmp1[i1].split('=')[0].strip().strip(';') == '0':
    1847. 

  1847.             list_tmp1[i1] = list_tmp1[i1].split('=')[1].strip().strip(';')
    1848. 

  1848.             i1 = i1 + 1
    1849. 

  1849.             continue
    1850. 

  1850.         elif list_tmp1[i1].split('=')[1].strip().strip(';') == '0':
    1851. 

  1851.             list_tmp1[i1] = list_tmp1[i1].split('=')[0].strip().strip(';')
    1852. 

  1852.             i1 = i1 + 1
    1853. 

  1853.             continue
    1854. 

  1854. 

  1855.         list_tmp1[i1] = list_tmp1[i1].strip(';')[:]
    1856. 

  1856.         str_tmp2 = list_tmp1[i1].split('=')[0].strip()
    1857. 

  1857.         list_tmp1[i1] = list_tmp1[i1].split('=')[1].strip()
    1858. 

  1858. 

  1859.         while re_var.search(str_tmp2):
    1860. 

  1860.             ma1 = re_var.search(str_tmp2)
    1861. 

  1861.             pos1 = ma1.span()[0]
    1862. 

  1862.             poe1 = ma1.span()[1]
    1863. 

  1863.             # for coeff*var and coeff not begins with '-', but '+'
    1864. 

  1864.             if pos1 > 1 and str_tmp2[0] != '-' and str_tmp2[0] == '+':
    1865. 

  1865.                 coeff = '-'+str_tmp2[1:pos1]
    1866. 

  1866.                 vari = ma1.group(0)
    1867. 

  1867.                 str_tmp2=str_tmp2[poe1:]
    1868. 

  1868.                 if str_tmp2 == '':
    1869. 

  1869.                     str_tmp2 = '@'
    1870. 

  1870.             # for coeff*var and coeff not begins with '+', but '-'      
    1871. 

  1871.             elif pos1 > 1 and str_tmp2[0] != '+' and str_tmp2[0] == '-':
    1872. 

  1872.                 coeff = '+'+str_tmp2[1:pos1]
    1873. 

  1873.                 vari = ma1.group(0)
    1874. 

  1874.                 str_tmp2=str_tmp2[poe1:]
    1875. 

  1875.                 if str_tmp2 == '':
    1876. 

  1876.                     str_tmp2 = '@'
    1877. 

  1877.             # for coeff*var and coeff not begins with '+' and not begins with '-'
    1878. 

  1878.             elif pos1 > 1 and str_tmp2[0] != '+' and str_tmp2[0] != '-':
    1879. 

  1879.                 coeff = '-'+str_tmp2[:pos1]
    1880. 

  1880.                 vari = ma1.group(0)
    1881. 

  1881.                 str_tmp2=str_tmp2[poe1:]
    1882. 

  1882.                 if str_tmp2 == '':
    1883. 

  1883.                     str_tmp2 = '@'
    1884. 

  1884.             # for coeff == '-'
    1885. 

  1885.             elif pos1 == 1 and str_tmp2[0] == '-':
    1886. 

  1886.                 coeff = '+'
    1887. 

  1887.                 vari = ma1.group(0)
    1888. 

  1888.                 str_tmp2=str_tmp2[poe1:]
    1889. 

  1889.             # for coeff == '+'
    1890. 

  1890.             elif pos1 == 1 and str_tmp2[0] == '+':
    1891. 

  1891.                 coeff = '-'
    1892. 

  1892.                 vari = ma1.group(0)
    1893. 

  1893.                 str_tmp2=str_tmp2[poe1:]
    1894. 

  1894.             # for var*coeff
    1895. 

  1895.             elif pos1 == 0 and len(re_var.findall(str_tmp2)) > 1\
    1896. 

  1896.                  and str_tmp2[poe1] != '-' and str_tmp2[poe1] != '+':
    1897. 

  1897.                 ma2 = re_var.search(str_tmp2[poe1:])
    1898. 

  1898.                 pos2 = ma2.span()[0]+poe1
    1899. 

  1899.                 coeff = '-'+str_tmp2[poe1:pos2]
    1900. 

  1900.                 vari = ma1.group(0)
    1901. 

  1901.                 str_tmp2=str_tmp2[pos2:]
    1902. 

  1902.             # for last bit
    1903. 

  1903.             elif pos1 == 0 and len(re_var.findall(str_tmp2)) == 1:
    1904. 

  1904.                 coeff = '-'+str_tmp2[1:][poe1-1:]
    1905. 

  1905.                 vari = ma1.group(0)
    1906. 

  1906.                 str_tmp2=''
    1907. 

  1907.             # for coeff == ''
    1908. 

  1908.             elif pos1 == 0 and len(re_var.findall(str_tmp2)) > 1 and str_tmp2[poe1] == '-':
    1909. 

  1909.                 coeff = '-'
    1910. 

  1910.                 vari = ma1.group(0)
    1911. 

  1911.                 str_tmp2=str_tmp2[poe1:]
    1912. 

  1912.             # for coeff == ''
    1913. 

  1913.             elif pos1 == 0 and len(re_var.findall(str_tmp2)) > 1 and str_tmp2[poe1] == '+':
    1914. 

  1914.                 coeff = '-'
    1915. 

  1915.                 vari = ma1.group(0)
    1916. 

  1916.                 str_tmp2=str_tmp2[poe1:]
    1917. 

  1917.             # for last bit
    1918. 

  1918.             elif pos1 == 0 and len(re_var.findall(str_tmp2)) == 1:
    1919. 

  1919.                 coeff = '-'
    1920. 

  1920.                 vari = ma1.group(0)
    1921. 

  1921.                 str_tmp2=''
    1922. 

  1922. 

  1923.             if coeff[-1] != '*' and coeff != '-':
    1924. 

  1924.                 coeff = coeff+'*'
    1925. 

  1925.             list_tmp1[i1] = list_tmp1[i1]+coeff+vari
    1926. 

  1926.         str_tmp2 = ''   
    1927. 

  1927.         i1 = i1 + 1
    1928. 

  1928.     self.nlsys_list = deepcopy(list_tmp1)
    1929. 

  1929.     return list_tmp1
    1930. 

  1930. 

  1931. def subs_in_loglinsys(self):
    1932. 

  1932.     list_tmp1 = deepcopy(self.llsys_list)
    1933. 

  1933.     subsdic = deepcopy(self.nlsubs)
    1934. 

  1934.     for i1,eqo in enumerate(list_tmp1):
    1935. 

  1935.         while "@" in list_tmp1[i1]:
    1936. 

  1936.             for keyo in subsdic.keys():
    1937. 

  1937.                 if keyo in list_tmp1[i1]: list_tmp1[i1] = list_tmp1[i1].replace(keyo,subsdic[keyo])
    1938. 

  1938.     return list_tmp1
    1939. 

  1939. 

  1940. # Creates the log-linear system
    1941. 

  1941. def mkloglinsys1(secs):
    1942. 

  1942.     list_tmp = []
    1943. 

  1943.     i1=0
    1944. 

  1944.     counter=0
    1945. 

  1945.     for x in secs['modeq'][0]:
    1946. 

  1946.         if '...' in x:
    1947. 

  1947.             counter = counter + 1
    1948. 

  1948.         elif '...' not in x:
    1949. 

  1949.             if counter == 0:
    1950. 

  1950.                 list_tmp.append(x.replace(';','').split(']')[1].strip())
    1951. 

  1951.             elif counter > 0:
    1952. 

  1952.                 str_tmp = ''
    1953. 

  1953.                 for y in secs['modeq'][0][i1-counter:i1+1]:
    1954. 

  1954.                     str_tmp = str_tmp + y.replace('...','').replace(';','').strip()
    1955. 

  1955.                 list_tmp.append(str_tmp.split(']')[1].strip())
    1956. 

  1956.                 counter = 0 
    1957. 

  1957.         i1=i1+1
    1958. 

  1958.     return list_tmp
    1959. 

  1959. 

  1960. # Create a Variance-Covariance matrix
    1961. 

  1961. def mksigmat(self, secs):
    1962. 

  1962.     str_tmp1 = []
    1963. 

  1963.     str_tmp1 = secs['vcvm'][0][0].split('[')[1].rstrip()
    1964. 

  1964.     if str_tmp1[-2:] == '];':
    1965. 

  1965.         str_tmp1=str_tmp1[:-2]
    1966. 

  1966.     if len(secs['vcvm']) > 1:
    1967. 

  1967.         for x in secs['vcvm'][0][1:]:
    1968. 

  1968.             if x[-2:] != '];':
    1969. 

  1969.                 str_tmp1=str_tmp1+x.lstrip().rstrip()[:]
    1970. 

  1970.             elif x[-2:] == '];':
    1971. 

  1971.                 str_tmp1=str_tmp1+x.lstrip().rstrip()[:-2]
    1972. 

  1972.     locals().update(self.paramdic)
    1973. 

  1973.     locals().update(self.sstate)
    1974. 

  1974.     list_tmp1 = str_tmp1.split(';')
    1975. 

  1975.     len1 = len(list_tmp1[0].split())
    1976. 

  1976.     mat1=mat.zeros((len1,len1))
    1977. 

  1977.     i1=0
    1978. 

  1978.     for x in list_tmp1:
    1979. 

  1979.         i2=0
    1980. 

  1980.         # Just another trap, only to be sure...
    1981. 

  1981.         if ']' in x: x = x.replace(']','')
    1982. 

  1982.         if '[' in x: x = x.replace('[','')
    1983. 

  1983.         for y in x.split():
    1984. 

  1984.             mat1[i1,i2] = float(eval(y))
    1985. 

  1985.             i2=i2+1
    1986. 

  1986.         i1=i1+1
    1987. 

  1987.     return mat1 
    1988. 

  1988. 

  1989. def mkeqtype(self):
    1990. 

  1990.     lsys = self.llsys_list
    1991. 

  1991.     tup1 = ('{-1,1}|None','iid|exo','{-1,1}')
    1992. 

  1992.     tup2 = ('{-1,1}|None','all','{-1,1}')
    1993. 

  1993.     tup3 = ('{-1,1}','all','{-1,1}')
    1994. 

  1994.     err_indx = []
    1995. 

  1995.     det_indx = []
    1996. 

  1996.     exp_indx = []
    1997. 

  1997.     for x,y in zip(lsys,range(len(lsys))):
    1998. 

  1998.         if self.vreg(('{-1,1}','all','{-1,1}'),x,False,'max'):
    1999. 

  1999.             exp_indx.append(y)
    2000. 

  2000.         elif self.vreg((None,'exo|iid','{-1,1}'),x,False,'max'):
    2001. 

  2001.             if len(self.vreg((None,'exo|iid','{-1,1}'),x,True,'max'))==\
    2002. 

  2002.                len(self.vreg(('{-1,1}|None','all','{-1,1}'),x,True,'max')):
    2003. 

  2003.                 err_indx.append(y)
    2004. 

  2004.             else:
    2005. 

  2005.                 det_indx.append(y)
    2006. 

  2006.         else:
    2007. 

  2007.             det_indx.append(y)
    2008. 

  2008. 

  2009.     self.eqindx = {}
    2010. 

  2010.     self.eqindx['err'] = err_indx
    2011. 

  2011.     self.eqindx['det'] = det_indx
    2012. 

  2012.     self.eqindx['exp'] = exp_indx
    2013. 

  2013.     return self
    2014. 

  2014. 

  2015. # Make symbolic system and numeric as well
    2016. 

  2016. def mksymsys(self):
    2017. 

  2017.     _mreg = 'E{1,1}[^(]'
    2018. 

  2018.     mreg = re.compile(_mreg)
    2019. 

  2019.     func = []
    2020. 

  2020.     subli = []
    2021. 

  2021.     patup = ('{-10,10}|None','all','{-10,10}')
    2022. 

  2022.     for x in self.sstate.keys()+self.paramdic.keys():
    2023. 

  2023.         locals()[x] = eval("SP.Symbol('"+x+"')")
    2024. 

  2024.     for y in self.llsys_list:
    2025. 

  2025.         str_tmp = y[:]
    2026. 

  2026.         while 'EXP(' in str_tmp:
    2027. 

  2027.             str_tmp = str_tmp.replace('EXP(','SP.exp(')
    2028. 

  2028.         while 'LOG(' in str_tmp:
    2029. 

  2029.             str_tmp = str_tmp.replace('LOG(','SP.log(')
    2030. 

  2030.         vali = [x[0] for x in self.vreg(patup,y,True,'min')]
    2031. 

  2031.         vali2 = [[x,'sub'+str(u)] for x,u in zip(vali,range(0,len(vali),1))]
    2032. 

  2032.         vali3 = [(x[0],x[3]) for x in self.vreg(patup,str_tmp,True,'max')]
    2033. 

  2033.         vali3.reverse()
    2034. 

  2034.         valdic = dict(vali2)
    2035. 

  2035.         for x in vali3:
    2036. 

  2036.             str_tmp = str_tmp[:x[1][0]] + valdic[x[0]] + str_tmp[x[1][1]:]
    2037. 

  2037.         subli.append(valdic)
    2038. 

  2038.         for x in valdic.values():
    2039. 

  2039.             locals()[x] = eval("SP.Symbol('"+x+"')")
    2040. 

  2040.         func.append(eval(str_tmp))
    2041. 

  2041.     diffli = []
    2042. 

  2042.     i1 = 0
    2043. 

  2043.     for x in func:
    2044. 

  2044.         diffdic = {}
    2045. 

  2045.         for y in subli[i1].items():
    2046. 

  2046.             diffdic[y[0]] = eval('SP.diff(func[i1],'+y[1]+')')
    2047. 

  2047.         diffli.append(diffdic)
    2048. 

  2048.         i1=i1+1
    2049. 

  2049.     self.diffli1 = diffli
    2050. 

  2050.     diffli2 = []
    2051. 

  2051.     locals().update(self.sstate)
    2052. 

  2052.     locals().update(self.paramdic)
    2053. 

  2053.     for x in self.diffli1:
    2054. 

  2054.         tmpdic={}
    2055. 

  2055.         for y in x.keys():
    2056. 

  2056. #            tmpdic[y] = eval(x[y].tostr())
    2057. 

  2057.             str_tmp2 = str(x[y])
    2058. 

  2058.             while mreg.search(str_tmp2):
    2059. 

  2059.                 maout = [por for por in mreg.finditer(str_tmp2)]
    2060. 

  2060.                 maout.reverse()
    2061. 

  2061.                 for mato in maout:
    2062. 

  2062.                     starts = mato.span()[0]
    2063. 

  2063.                     ends = mato.span()[1]
    2064. 

  2064.                     expo = mato.group()
    2065. 

  2065.                     str_tmp2 = str_tmp2[:starts]+'np.exp(1)'+str_tmp2[ends-1:]
    2066. 

  2066.             tmpdic[y] = eval(str_tmp2)
    2067. 

  2067. 

  2068.         diffli2.append(tmpdic) 
    2069. 

  2069.     self.diffli2 = diffli2
    2070. 

  2070.     return self
    2071. 

  2071. 

  2072. 

  2073. #This function is needed in population stage 1, at the end
    2074. 

  2074. def mk_msstate_subs(self):
    2075. 

  2075.     """
    2076. 

  2076.     This function takes the manually defined numerical sstate conditions and then replaces
    2077. 

  2077.     any @terms with the corresponding substitutions
    2078. 

  2078.     """
    2079. 

  2079.     _mreg = '@[a-zA-Z]*_bar'
    2080. 

  2080.     mreg = re.compile(_mreg)
    2081. 

  2081.     tmp_list = deepcopy(self.ssys_list)
    2082. 

  2082.     sub_dic = deepcopy(self.nlsubs)
    2083. 

  2083.     for i1,x in enumerate(tmp_list):
    2084. 

  2084.         while mreg.search(tmp_list[i1]):
    2085. 

  2085.             ma = mreg.search(tmp_list[i1])
    2086. 

  2086.             str_tmp = ma.group()
    2087. 

  2087.             tmp_list[i1] = tmp_list[i1].replace(str_tmp,'('+sub_dic[str_tmp]+')')
    2088. 

  2088.     self.ssys_list = deepcopy(tmp_list)
    2089. 

  2089.     return self
    2090. 

  2090. 

  2091. def mk_mssidic_subs(self):
    2092. 

  2092.     """
    2093. 

  2093.     This function takes the manually defined numerical sstate's ssidic and then replaces
    2094. 

  2094.     any @terms with the corresponding substitutions and evaluates as it goes along
    2095. 

  2095.     """
    2096. 

  2096.     _mreg = '@[a-zA-Z]*\d*_bar'
    2097. 

  2097.     mreg = re.compile(_mreg)
    2098. 

  2098.     tmp_list = deepcopy(self.ssili)
    2099. 

  2099.     sub_dic = deepcopy(self.nlsubs)
    2100. 

  2100.     for i1,x in enumerate(tmp_list):
    2101. 

  2101.         while mreg.search(tmp_list[i1][1]):
    2102. 

  2102.             ma = mreg.search(tmp_list[i1][1])
    2103. 

  2103.             str_tmp = ma.group()
    2104. 

  2104.             tmp_list[i1][1] = tmp_list[i1][1].replace(str_tmp,'('+sub_dic[str_tmp]+')')
    2105. 

  2105.         locals().update(self.paramdic)
    2106. 

  2106.         tmp_dic = {}
    2107. 

  2107.         tmp_dic[tmp_list[i1][0]] = eval(tmp_list[i1][1])
    2108. 

  2108.         locals().update(tmp_dic)
    2109. 

  2109.         # Update ssidic
    2110. 

  2110.         self.ssidic.update(tmp_dic)
    2111. 

  2111.     self.ssili = deepcopy(tmp_list)
    2112. 

  2112.     return self
    2113. 

  2113. 

  2114. #This function is needed in population stage 1, at the end
    2115. 

  2115. def mk_cfstate_subs(self):
    2116. 

  2116.     """
    2117. 

  2117.     This function takes the closed form defined numerical sstate conditions and then replaces
    2118. 

  2118.     any @terms with the corresponding substitutions
    2119. 

  2119.     """
    2120. 

  2120.     _mreg = '@[a-zA-Z]*_bar'
    2121. 

  2121.     mreg = re.compile(_mreg)
    2122. 

  2122.     tmp_list = deepcopy(self.manss_sys)
    2123. 

  2123.     sub_dic = deepcopy(self.nlsubs)
    2124. 

  2124.     for i1,x in enumerate(tmp_list):
    2125. 

  2125.         while mreg.search(tmp_list[i1]):
    2126. 

  2126.             ma = mreg.search(tmp_list[i1])
    2127. 

  2127.             str_tmp = ma.group()
    2128. 

  2128.             tmp_list[i1] = tmp_list[i1].replace(str_tmp,'('+sub_dic[str_tmp]+')')
    2129. 

  2129.     self.manss_sys = deepcopy(tmp_list)
    2130. 

  2130.     return self
    2131. 

  2131. 

  2132. def subs_indic(self):
    2133. 

  2133.     '''
    2134. 

  2134.     This function replaces indicator function occurrences inside the substitution system
    2135. 

  2135.     '''
    2136. 

  2136.     list_tmp1 = deepcopy(self.nlsubs_raw1)
    2137. 

  2137.     _mreg = '\S{0,1}\s*@I{(?P<cond>.*?)}{(?P<expr>.*?)}'
    2138. 

  2138.     mreg = re.compile(_mreg)
    2139. 

  2139.     for i1,lino in enumerate(list_tmp1):
    2140. 

  2140.         while mreg.search(list_tmp1[i1][1]):
    2141. 

  2141.             ma = mreg.search(list_tmp1[i1][1])
    2142. 

  2142.             pos, poe = ma.span()
    2143. 

  2143.             condi = ma.group('cond')
    2144. 

  2144.             expr = ma.group('expr')
    2145. 

  2145.             # Expose parameters
    2146. 

  2146.             locals().update(self.paramdic)
    2147. 

  2147.             if eval(condi):
    2148. 

  2148.                 list_tmp1[i1][1] = list_tmp1[i1][1][:pos] + expr + list_tmp1[i1][1][poe:]
    2149. 

  2149.             else:
    2150. 

  2150.                 list_tmp1[i1][1] = list_tmp1[i1][1][:pos] + list_tmp1[i1][1][poe:]
    2151. 

  2151.     self.nlsubs_raw1 = deepcopy(list_tmp1)
    2152. 

  2152.     return self
    2153. 

  2153. 

  2154. # Extra population stage factored out, which is needed before steady state calculations
    2155. 

  2155. def populate_model_stage_one_a(self, secs):
    2156. 

  2156.     # Check and calculate the substitution list and dictionary
    2157. 

  2157.     if any([False if 'None' in x else True for x in secs['vsfocs'][0]]):
    2158. 

  2158.         # Create the raw nlsubs list 1
    2159. 

  2159.         self = mk_subs_dic(self, secs)       
    2160. 

  2160.         
    2161. 

  2161. 

  2162. # Extra population stage factored out, which is needed before steady state calculations
    2163. 

  2163. def populate_model_stage_one_b(self, secs):
    2164. 

  2164.     # Check and calculate the substitution list and dictionary
    2165. 

  2165.     if any([False if 'None' in x else True for x in secs['vsfocs'][0]]):
    2166. 

  2166.         # Deal with indicator functions inside substitutions
    2167. 

  2167.         self = subs_indic(self)         
    2168. 

  2168.         # Substitute out in @ALL list for expressions, then do expressions
    2169. 

  2169.         self = subs_in_subs_all(self)
    2170. 

  2170.         self = mk_all(self)
    2171. 

  2171.         # Create the raw nlsubs list 2 by replacing substitutions inside substitutions
    2172. 

  2172.         self = subs_in_subs(self)
    2173. 

  2173.         # Apply steady state transformation where needed
    2174. 

  2174.         self = mk_steady(self)
    2175. 

  2175.         # Extend the differ out before doing the differ out
    2176. 

  2176.         self = ext_differ_out(self)
    2177. 

  2177.         # Apply timeshifts where needed
    2178. 

  2178.         self = mk_timeshift(self)
    2179. 

  2179.         # Make a first differentiation pass for DIFFs inside timeshifters
    2180. 

  2180.         self = differ_out(self)
    2181. 

  2181.         # Apply timeshifts where needed
    2182. 

  2182.         self = mk_timeshift(self)
    2183. 

  2183.         # Apply steady state transformation where needed
    2184. 

  2184.         self = mk_steady(self)
    2185. 

  2185.         # Extend the differ out before doing the differ out
    2186. 

  2186.         self = ext_differ_out(self)
    2187. 

  2187.         # Make second differentiation pass for remaining DIFFs
    2188. 

  2188.         self = differ_out(self)
    2189. 

  2189.         # Apply timeshifts where needed
    2190. 

  2190.         self = mk_timeshift(self)       
    2191. 

  2191.     return self
    2192. 

  2192. 

  2193. def populate_model_stage_one_bb(self, secs):
    2194. 

  2194.     # Do substitutions inside the numerical steady state list
    2195. 

  2195.     # Check and do substitutions
    2196. 

  2196.     if all([False if 'None' in x else True for x in secs['vsfocs'][0]]) and\
    2197. 

  2197.        all([False if 'None' in x else True for x in secs['manualss'][0]]):
    2198. 

  2198.         # Do this only if USE_FOCS has not been used, otherwise ssys_list would be missing
    2199. 

  2199.         if '_internal_focs_used' not in dir(self): self = mk_msstate_subs(self)
    2200. 

  2200.     # Do substitutions inside the numerical steady state list, but the ssidic
    2201. 

  2201.     # Check and do substitutions
    2202. 

  2202.     if all([False if 'None' in x else True for x in secs['vsfocs'][0]]) and\
    2203. 

  2203.        all([False if 'None' in x else True for x in secs['manualss'][0]]):
    2204. 

  2204.         self = mk_mssidic_subs(self)
    2205. 

  2205.         # Also save a copy of substituted and evaluated ssili with starting values
    2206. 

  2206.         self.template_paramdic['ssili'] = deepcopy(self.ssidic.items())
    2207. 

  2207.     # Do substitutions inside the closed form steady state list
    2208. 

  2208.     # Check and do substitutions
    2209. 

  2209.     if all([False if 'None' in x else True for x in secs['vsfocs'][0]]) and\
    2210. 

  2210.        all([False if 'None' in x else True for x in secs['closedformss'][0]]):
    2211. 

  2211.         self = mk_cfstate_subs(self)
    2212. 

  2212.     # Prepare the nonlinear FOC system but only stripping the raw format
    2213. 

  2213.     if all([False if 'None' in x else True for x in secs['focs'][0]]):
    2214. 

  2214.         self = premknonlinsys(self,secs)
    2215. 

  2215.         # Save for template instantiation
    2216. 

  2216.         self.template_paramdic['focs_list'] = self.foceqs
    2217. 

  2217.         if all([False if 'None' in x else True for x in secs['vsfocs'][0]]):
    2218. 

  2218.             # This takes the stripped system and does @ replacements
    2219. 

  2219.             self = premknonlinsys2(self,secs)
    2220. 

  2220.         else:
    2221. 

  2221.             self.foceqs2 = deepcopy(self.foceqs)
    2222. 

  2222.         # Also create a steady state version
    2223. 

  2223.         self = mk_steady2(self)
    2224. 

  2224.         # Also save a copy of the focs with replaced substitutions, but change timing to Dynare !
    2225. 

  2225.         foceqs2 = chg_vtimings(self,deepcopy(self.foceqs2),{'con':[0,1],'endo':[-1,0],'exo':[-1,0]})
    2226. 

  2226.         self.template_paramdic['focs_list2'] = deepcopy(self.foceqs2)
    2227. 

  2227.         self.template_paramdic['focs_dynare'] = deepcopy(foceqs2)
    2228. 

  2228.     else:
    2229. 

  2229.         # Save for template instantiation
    2230. 

  2230.         self.template_paramdic['focs_list'] = False
    2231. 

  2231.     return self
    2232. 

  2232. 

  2233. 

  2234. def populate_model_stage_two(self, secs):
    2235. 

  2235.     """
    2236. 

  2236.     2nd stage population of DSGE model.  Needs Steady State.
    2237. 

  2237.     """
    2238. 

  2238.     # Creates nonlinear foc system
    2239. 

  2239.     if all([False if 'None' in x else True for x in secs['focs'][0]]):
    2240. 

  2240.         self = mknonlinsys(self, secs)
    2241. 

  2241. 

  2242.     # Creates loglinear system
    2243. 

  2243.     if all([False if 'None' in x else True for x in secs['modeq'][0]]):
    2244. 

  2244.         llsys_list = mkloglinsys1(secs)
    2245. 

  2245.         self.llsys_list = mkloglinsys2(self,llsys_list)
    2246. 

  2246.         self.llsys_list = subs_in_loglinsys(self)
    2247. 

  2247.         # Save for template instantiation
    2248. 

  2248.         self.template_paramdic['llsys_list'] = deepcopy(self.llsys_list)
    2249. 

  2249.         self = mksymsys(self) # creates symbolic and numerical system
    2250. 

  2250.         self = mkeqtype(self) # creates variance/covariance
    2251. 

  2251.     else:
    2252. 

  2252.         # Save for template instantiation
    2253. 

  2253.         self.template_paramdic['llsys_list'] = False
    2254. 

  2254. 

  2255.     # Creates variance/covariance
    2256. 

  2256.     if all([False if 'None' in x else True for x in secs['vcvm'][0]]) and\
    2257. 

  2257.        'sstate' in dir(self):
    2258. 

  2258.         self.sigma = mksigmat(self, secs)
    2259. 

  2259.         # Save for template instantiation
    2260. 

  2260.         self.template_paramdic['sigma'] = deepcopy(self.sigma)
    2261. 

  2261.     else:
    2262. 

  2262.         # Save for template instantiation
    2263. 

  2263.         self.template_paramdic['sigma'] = False
    2264. 

  2264. 

  2265.     return self
    2266. 

  2266.