() Model med forventninger B og Taylorregel 3 () Der er sat j-led i ITV, IPV og TTDV relationer For at fange kædeindeks () Der er sat dummy ind i xxxEB () Der er sat j-led ind i xxxET relationerne, da identiteterne ikke passer. () LF er ændret så ligningerne er ens med Z-dummy og xxxDLF, der slår konjunktureffekten fra. () xxxX og xxxM er omdefineret til nationalregnskabs definition () De tre handelsvarer er taget ud... og lavet til en. () XGSD, MGSV, PXGS og PMGS kan eksogeniseres nu () Betalingsbalance og handelsbalance indgår ikke længere i rentestrukturen For lange rente For USA og Tyskland () () ********************* () * EURO * () ********************* () PCPN FRML _GJ_D_ EURPCPN = DEUPCPN*(DEUGDP/EURGDP) + BELPCPN*(BELGDP/EURGDP) + NLDPCPN*(NLDGDP/EURGDP) +FRAPCPN*(FRAGDP/EURGDP) + ESPPCPN*(ESPGDP/EURGDP) + ITAPCPN*(ITAGDP/EURGDP) $ () VALUTAKURS () FRML _GJ_D_Z LOG(EUREXC) = LOG(EUREXP) + (LOG(1+EURIRS/100)-LOG(1+USAIRS/100)) $ FRML _GJ_D_Z EUREXP = EUREXB $ FRML _GJ_D_Z EUREXB = EUREXB(-1) + 1/3*(EUREXC-EUREXB(-1)) $ () RENTE () FRML _GJ_D_Z EURGDP = DEUGDP + BELGDP + NLDGDP + FRAGDP + ESPGDP + ITAGDP $ FRML _GJ_D_Z EURPGDP = DEUPGDP*(DEUGDP/EURGDP) + BELPGDP*(BELGDP/EURGDP) + NLDPGDP*(NLDGDP/EURGDP) +FRAPGDP*(FRAGDP/EURGDP) + ESPPGDP*(ESPGDP/EURGDP) + ITAPGDP*(ITAGDP/EURGDP) $ FRML _GJ_D_Z EURGDPV = EURGDP/EURPGDP $ FRML _GJ_D_Z EURIRS = 150*DLOG(EURPCPN) + 50*DLOG(EURGDPV) $ () () ********************* () * DNK * () ********************* () () HOUSEHOLD DEMAND () () FRML _GJRD_ DLOG(DNKCPV) = .709*(.7*(DLOG(DNKYDRH)) +.3*(DLOG(DNKYDRH(-1)))) -.01474*(DNKIRL-DNKIRL(-3))/3 -.205*(LOG(DNKCPV(-1)/DNKYDRH(-1))) -.02274 $ FRML _GJRD_ DLOG(DNKIHV) = 3.500*(DLOG(DNKYDRH))/2 -.06065*(DNKIRL-DNKIRL(-2))/2 -.0648$ () () BUSINESS INVESTMENT () FRML ZDNKGAP DNKGAP = LOG(DNKYFBV)-.7*LOG(DNKEB+DNKES)-.3*LOG(DNKKBV) -DNKGAPT*TID-DNKGAPK $ FRML GDNKUC DNKUC = DNKPIB*(DNKIRL+15) $ FRML _GJRD_ DLOG(DNKKBV) = 0.71154*DLOG(DNKKBV(-1)) + 0.10353*(DLOG(DNKYFBV)) + 0.02113*(LOG(DNKYFBV(-1)/DNKKBV(-1)) -0.7*LOG(DNKUC(-1)/DNKWSSE(-1))) + TDNKKBV + 1.52263 $ FRML GDNKIBV DNKIBV = DNKKBV-DNKKBV(-1)+DNKAKBV*DNKKBV(-1) $ FRML _DJ_ DNKITV = DNKIHV + DNKIBV + DNKIGV $ () () () EXPORT VOLUMES () FRML GDNKXGSDU DNKXGSDU = XDNKSWE*LOG(SWEMGSD) + XDNKNOR*LOG(NORMGSD) + XDNKFIN*LOG(FINMGSD) + XDNKDEU*LOG(DEUMGSD) + XDNKGBR*LOG(GBRMGSD) + XDNKFRA*LOG(FRAMGSD) + XDNKITA*LOG(ITAMGSD) + XDNKBEL*LOG(BELMGSD) + XDNKNLD*LOG(NLDMGSD) + XDNKESP*LOG(ESPMGSD) + XDNKYPN*LOG(YPNMGSD) + XDNKUSA*LOG(USAMGSD) + XDNKPOL*LOG(POLMGSD) + XDNKCZE*LOG(CZEMGSD) + XDNKAUS*LOG(AUSMGSD) + XDNKAUT*LOG(AUTMGSD) + XDNKCAN*LOG(CANMGSD) + XDNKCHL*LOG(CHLMGSD) + XDNKEST*LOG(ESTMGSD) + XDNKGRC*LOG(GRCMGSD) + XDNKHUN*LOG(HUNMGSD) + XDNKISL*LOG(ISLMGSD) + XDNKIRL*LOG(IRLMGSD) + XDNKISR*LOG(ISRMGSD) + XDNKKOR*LOG(KORMGSD) + XDNKLUX*LOG(LUXMGSD) + XDNKNZL*LOG(NZLMGSD) + XDNKMEX*LOG(MEXMGSD) + XDNKPRT*LOG(PRTMGSD) + XDNKSVK*LOG(SVKMGSD) + XDNKSVN*LOG(SVNMGSD) + XDNKCHE*LOG(CHEMGSD) + XDNKTUR*LOG(TURMGSD) + XDNKDAE*LOG(DAEMGSD) + XDNKOOP*LOG(OOPMGSD) + XDNKBRA*LOG(BRAMGSD) + XDNKRUS*LOG(RUSMGSD) + XDNKIND*LOG(INDMGSD) + XDNKCHN*LOG(CHNMGSD) + XDNKIDN*LOG(IDNMGSD) + XDNKZAF*LOG(ZAFMGSD) + XDNKRWD*LOG(RWDMGSD) $ FRML _GJRD DLOG(DNKXGSD) = (DNKXGSDU-DNKXGSDU(-1)) $ FRML IDNKXGSV DNKXGSV = DNKXGSD*USAEXCH/(DNKEXCH*DNKPXGS) $ () () IMPORT () FRML _GJ_ DNKWMV = .199*DNKCPV + .177*DNKCGNV + .155*DNKIHV +.555*(DNKIBV+DNKISKV) + .175*DNKIGV +.285*DNKXGSV $ FRML _GJRD DLOG(DNKMGSV) = 1.1*DLOG(DNKWMV) + 0.16703 *DLOG(DNKPYFB/DNKPMGS) - 0.1000*(LOG(DNKMGSV(-1)/DNKWMV(-1)) -0.5*LOG(DNKPYFB(-1)/DNKPMGS(-1)) -0.13799) + 0.01269 $ FRML IDNKMGSD DNKMGSD = DNKMGSV*DNKPMGS*DNKEXCH/USAEXCH $ () () () LABOUR MARKET () FRML _GJ_D DNKLF = DNKPOPT*(DNKLF(-1)/DNKPOPT(-1) +(1-DNKDLF)*(.325*DLOG(DNKET) - .00054))$ () FRML _DJ_ DNKEBN = (1/0.70)*LOG(DNKYFBV)-((1-0.70)/0.70)*LOG(DNKKBV) $ FRML _DJ_ DNKEBW = LOG(DNKYFBV)+0.3*LOG(DNKUC/DNKWSSE) $ FRML _GJRD DLOG(DNKEP) = 0.55020*DLOG(DNKYFBV)+0.24980*DLOG(DNKYFBV(-1)) -0.06873*(LOG(DNKEP(-1))-DNKEBW(-1)) +0.09681 $ FRML _D__D DNKEB = DNKEP - DNKES $ FRML GDNKEE DNKEE = DNKEB + DNKEG $ FRML _DJ_ DNKET = DNKEE + DNKES $ FRML IDNKUN DNKUN = DNKLF - DNKET $ FRML IDNKUNR DNKUNR = (DNKUN/DNKLF)*100 $ () () WAGES () FRML GDNKWU DNKWU = (11.11*LOG(SWEWSSE)+ 7.99*LOG(NORWSSE)+ 24.20*LOG(DEUWSSE)+ 7.09*LOG(GBRWSSE)+ 4.64*LOG(USAWSSE))/55.03 $ () FRML IDNKEYFB DNKEYFB = (DNKYFBV/(DNKEB+DNKES))/BDNKEYFB $ FRML _GJRD DLOG(DNKWR) = .682*(LOG(DNKPYFB)-LOG(DNKPYFB(-1))) +.530*(DNKWU-DNKWU(-1)) -.00352*(DNKUNR(-1) -.4*(DNKUNR(-2)+DNKUNR(-3)+DNKUNR(-4))/3) +.532*(LOG(DNKPCP/DNKPYFB)-LOG(DNKPCP(-1)/DNKPYFB(-1))) -.198*LOG(DNKWSSE(-1)/(DNKPYFB(-1)*DNKEYFB(-1))) +1.0982 $ FRML GDNKWSSE DNKWSSE = DNKKWSSE*DNKWR + JDNKWSSE $ FRML GDNKWRG DNKWRG = DNKKWRG*DNKWR + JDNKWRG $ () () DOMESTIC PRICES () () FRML GDNKPCPN DNKPCPN = DNKPCPN(-1)*(.24*(DNKPMGS/DNKPMGS(-1))+ .76*(DNKPYFB/DNKPYFB(-1))) + JDNKPCPN $ FRML IDNKPCP DNKPCP = (1+DNKTTI)*DNKPCPN $ FRML GDNKPCGN DNKPCGN = DNKPCGN(-1)*(.27*(DNKPMGS/DNKPMGS(-1))+ .73*(DNKPYFB/DNKPYFB(-1))) + JDNKPCGN $ FRML GDNKPIHN DNKPIHN = DNKPIHN(-1)*(.19*(DNKPMGS/DNKPMGS(-1))+ .81*(DNKPYFB/DNKPYFB(-1))) + JDNKPIHN $ FRML IDNKPIH DNKPIH = (1+DNKTTI)*DNKPIHN $ FRML GDNKPIB DNKPIB = DNKPIB(-1)*(.39*(DNKPMGS/DNKPMGS(-1))+ .61*(DNKPYFB/DNKPYFB(-1))) + JDNKPIB $ FRML GDNKPIG DNKPIG = DNKPIG(-1)*(.20*(DNKPMGS/DNKPMGS(-1))+ .80*(DNKPYFB/DNKPYFB(-1))) + JDNKPIG $ FRML GDNKPISK DNKPISK = DNKPIB + JDNKPISK $ FRML IDNKULCB DNKULC = ((DNKWSSE*(DNKES+DNKEB))/DNKYFBV)/BDNKULC $ FRML IDNKUCCB DNKUCCB = (DNKPIB*((DNKIRL+DNKIRL(-1)+DNKIRL(-2)+DNKIRL(-3) +DNKIRL(-4)+DNKIRL(-5)+DNKIRL(-6))/7+15) *DNKKBV/DNKYFBV)/BDNKUCCB $ FRML _GJRD DLOG(DNKPYFB) = .71816*(LOG(DNKULC)-LOG(DNKULC(-1))) +.10019*(LOG(DNKPMGS)-LOG(DNKPMGS(-1))) +.63083*(DNKGAP-DNKGAP(-1)) -.10164*(LOG(DNKPYFB(-1))-.70*LOG(DNKULC(-1)) -.3*LOG(DNKUCCB(-1))+0.06411) +.01415 $ () () IMPORT PRICES () FRML GDNKPMGSU DNKPMGSU = MDNKSWE*LOG(SWEPXGS/DNKEXCH*SWEEXCH) + MDNKNOR*LOG(NORPXGS/DNKEXCH*NOREXCH) + MDNKFIN*LOG(FINPXGS/DNKEXCH*FINEXCH) + MDNKDEU*LOG(DEUPXGS/DNKEXCH*DEUEXCH) + MDNKGBR*LOG(GBRPXGS/DNKEXCH*GBREXCH) + MDNKFRA*LOG(FRAPXGS/DNKEXCH*FRAEXCH) + MDNKITA*LOG(ITAPXGS/DNKEXCH*ITAEXCH) + MDNKBEL*LOG(BELPXGS/DNKEXCH*BELEXCH) + MDNKNLD*LOG(NLDPXGS/DNKEXCH*NLDEXCH) + MDNKESP*LOG(ESPPXGS/DNKEXCH*ESPEXCH) + MDNKYPN*LOG(YPNPXGS/DNKEXCH*YPNEXCH) + MDNKUSA*LOG(USAPXGS/DNKEXCH*USAEXCH) + MDNKPOL*LOG(POLPXGS/DNKEXCH*POLEXCH) + MDNKCZE*LOG(CZEPXGS/DNKEXCH*CZEEXCH) + MDNKAUS*LOG(AUSPXGS/DNKEXCH*AUSEXCH) + MDNKAUT*LOG(AUTPXGS/DNKEXCH*AUTEXCH) + MDNKCAN*LOG(CANPXGS/DNKEXCH*CANEXCH) + MDNKCHL*LOG(CHLPXGS/DNKEXCH*CHLEXCH) + MDNKEST*LOG(ESTPXGS/DNKEXCH*ESTEXCH) + MDNKGRC*LOG(GRCPXGS/DNKEXCH*GRCEXCH) + MDNKHUN*LOG(HUNPXGS/DNKEXCH*HUNEXCH) + MDNKISL*LOG(ISLPXGS/DNKEXCH*ISLEXCH) + MDNKIRL*LOG(IRLPXGS/DNKEXCH*IRLEXCH) + MDNKISR*LOG(ISRPXGS/DNKEXCH*ISREXCH) + MDNKKOR*LOG(KORPXGS/DNKEXCH*KOREXCH) + MDNKLUX*LOG(LUXPXGS/DNKEXCH*LUXEXCH) + MDNKMEX*LOG(MEXPXGS/DNKEXCH*MEXEXCH) + MDNKNZL*LOG(NZLPXGS/DNKEXCH*NZLEXCH) + MDNKPRT*LOG(PRTPXGS/DNKEXCH*PRTEXCH) + MDNKSVK*LOG(SVKPXGS/DNKEXCH*SVKEXCH) + MDNKSVN*LOG(SVNPXGS/DNKEXCH*SVNEXCH) + MDNKCHE*LOG(CHEPXGS/DNKEXCH*CHEEXCH) + MDNKTUR*LOG(TURPXGS/DNKEXCH*TUREXCH) + MDNKDAE*LOG(DAEPXGS/DNKEXCH*DAEEXCH) + MDNKOOP*LOG(OOPPXGS/DNKEXCH*OOPEXCH) + MDNKBRA*LOG(BRAPXGS/DNKEXCH*BRAEXCH) + MDNKRUS*LOG(RUSPXGS/DNKEXCH*RUSEXCH) + MDNKIND*LOG(INDPXGS/DNKEXCH*INDEXCH) + MDNKCHN*LOG(CHNPXGS/DNKEXCH*CHNEXCH) + MDNKIDN*LOG(IDNPXGS/DNKEXCH*IDNEXCH) + MDNKZAF*LOG(ZAFPXGS/DNKEXCH*ZAFEXCH) + MDNKRWD*LOG(RWDPXGS/DNKEXCH*RWDEXCH) $ FRML _GJRD DLOG(DNKPMGS) = (DNKPMGSU-DNKPMGSU(-1)) $ () () EXPORT PRICES () FRML _GJR_ DLOG(DNKPXIN) = .32*DLOG(DNKPMGS)+.68*DLOG(DNKPYFB) $ FRML GDNKPXGSU DNKPXGSU = XDNKSWE*LOG(SWEPMGS/DNKEXCH*SWEEXCH) + XDNKNOR*LOG(NORPMGS/DNKEXCH*NOREXCH) + XDNKFIN*LOG(FINPMGS/DNKEXCH*FINEXCH) + XDNKDEU*LOG(DEUPMGS/DNKEXCH*DEUEXCH) + XDNKGBR*LOG(GBRPMGS/DNKEXCH*GBREXCH) + XDNKFRA*LOG(FRAPMGS/DNKEXCH*FRAEXCH) + XDNKITA*LOG(ITAPMGS/DNKEXCH*ITAEXCH) + XDNKBEL*LOG(BELPMGS/DNKEXCH*BELEXCH) + XDNKNLD*LOG(NLDPMGS/DNKEXCH*NLDEXCH) + XDNKESP*LOG(ESPPMGS/DNKEXCH*ESPEXCH) + XDNKYPN*LOG(YPNPMGS/DNKEXCH*YPNEXCH) + XDNKUSA*LOG(USAPMGS/DNKEXCH*USAEXCH) + XDNKPOL*LOG(POLPMGS/DNKEXCH*POLEXCH) + XDNKCZE*LOG(CZEPMGS/DNKEXCH*CZEEXCH) + XDNKAUS*LOG(AUSPMGS/DNKEXCH*AUSEXCH) + XDNKAUT*LOG(AUTPMGS/DNKEXCH*AUTEXCH) + XDNKCAN*LOG(CANPMGS/DNKEXCH*CANEXCH) + XDNKCHL*LOG(CHLPMGS/DNKEXCH*CHLEXCH) + XDNKEST*LOG(ESTPMGS/DNKEXCH*ESTEXCH) + XDNKGRC*LOG(GRCPMGS/DNKEXCH*GRCEXCH) + XDNKHUN*LOG(HUNPMGS/DNKEXCH*HUNEXCH) + XDNKISL*LOG(ISLPMGS/DNKEXCH*ISLEXCH) + XDNKIRL*LOG(IRLPMGS/DNKEXCH*IRLEXCH) + XDNKISR*LOG(ISRPMGS/DNKEXCH*ISREXCH) + XDNKKOR*LOG(KORPMGS/DNKEXCH*KOREXCH) + XDNKLUX*LOG(LUXPMGS/DNKEXCH*LUXEXCH) + XDNKMEX*LOG(MEXPMGS/DNKEXCH*MEXEXCH) + XDNKNZL*LOG(NZLPMGS/DNKEXCH*NZLEXCH) + XDNKPRT*LOG(PRTPMGS/DNKEXCH*PRTEXCH) + XDNKSVK*LOG(SVKPMGS/DNKEXCH*SVKEXCH) + XDNKSVN*LOG(SVNPMGS/DNKEXCH*SVNEXCH) + XDNKCHE*LOG(CHEPMGS/DNKEXCH*CHEEXCH) + XDNKTUR*LOG(TURPMGS/DNKEXCH*TUREXCH) + XDNKDAE*LOG(DAEPMGS/DNKEXCH*DAEEXCH) + XDNKOOP*LOG(OOPPMGS/DNKEXCH*OOPEXCH) + XDNKBRA*LOG(BRAPMGS/DNKEXCH*BRAEXCH) + XDNKRUS*LOG(RUSPMGS/DNKEXCH*RUSEXCH) + XDNKIND*LOG(INDPMGS/DNKEXCH*INDEXCH) + XDNKCHN*LOG(CHNPMGS/DNKEXCH*CHNEXCH) + XDNKIDN*LOG(IDNPMGS/DNKEXCH*IDNEXCH) + XDNKZAF*LOG(ZAFPMGS/DNKEXCH*ZAFEXCH) + XDNKRWD*LOG(RWDPMGS/DNKEXCH*RWDEXCH) $ FRML _GJRD DLOG(DNKPXGS) = .3143*(DNKPXGSU-DNKPXGSU(-1))+.6857*DLOG(DNKPXIN) $ () () THE GOVERNMENT SECTOR () FRML GDNKCGWV DNKCGWV = DNKEG*BDNKCGWV $ FRML GDNKCGNV DNKCGNV = DNKCGNV(-1)*(DNKCGWV/DNKCGWV(-1))*(1-DDNKCGNV) + JDNKCGNV $ FRML IDNKCGV DNKCGV = DNKCGWV + DNKCGNV $ FRML IDNKCGW DNKCGW = DNKCGWV*DNKWRG/(BDNKCGWV*1000) $ FRML IDNKCG DNKCG = DNKCGW + DNKCGNV*DNKPCGN $ FRML IDNKIG DNKIG = DNKIGV*DNKPIG $ FRML GDNKCFKG DNKCFKG = DNKTCFKG*DNKCG $ FRML GDNKSSRG DNKSSRG = DNKTSSRG*DNKWSSS + JDNKSSRG $ FRML GDNKTY DNKTY = DNKTTY*DNKYP + JDNKTY $ FRML GDNKTI DNKTI = DNKTTI*(DNKCPV*DNKPCP+DNKIHV*DNKPIH)/(1+DNKTTI) +JDNKTI $ FRML GDNKTRRH DNKTRRH = (.475+JDNKTTRH)*DNKUN*(DNKWSSE(-1)/1000) +(1.12151*DNKPOPT-3032.54)*(DNKWSSE(-1)/1000) +JDNKTRRH $ FRML GDNKYIO DNKYIO = -((DNKIRL+DNKIRL(-1)+DNKIRL(-2))/300) *(DNKGNFL(-1))*(1-DYIO)+DYIO*ZDNKYIO + JDNKYIO $ FRML IDNKNLG DNKNLG = DNKSSRG + DNKTY + DNKTI + DNKYIO - DNKCG - DNKIG - DNKIENTG - DNKTRRH - DNKTRO - DNKKIG $ FRML IDNKGNFL DNKGNFL = DNKGNFL(-1) -DNKNLG + BDNKGNFL $ () () PRODUCTION AND INCOMES () FRML IDNKGDP DNKGDP = DNKCPV*DNKPCP + DNKCG + DNKIG + DNKIBV*DNKPIB+DNKIENTG +DNKIHV*DNKPIH + DNKISKV*DNKPISK +DNKXGSV*DNKPXGS - DNKMGSV*DNKPMGS + DNKDGDP $ FRML IDNKGDPV DNKGDPV = DNKCPV+ DNKCGV+ DNKIGV+ DNKIBV+ DNKIHV+ DNKISKV + DNKXGSV- DNKMGSV +DNKDGDPV $ FRML IDNKYF DNKYF = DNKGDP - DNKTI $ FRML IDNKYFB DNKYFB = DNKYF - DNKCGW - DNKCFKG $ FRML IDNKYFBV DNKYFBV = DNKYFB/DNKPYFB $ FRML IDNKWSSS DNKWSSS = (DNKEB*DNKWSSE + DNKEG*DNKWRG)/1000 $ FRML IDNKYRP DNKYRP = DNKYF - DNKWSSS - DNKCFKG $ FRML GDNKDP DNKDP = DNKTDP*(DNKKBV*DNKPIB) $ FRML IDNKYIP DNKYIP = DNKYIE - DNKYIO $ FRML GDNKYP DNKYP = DNKWSSS - DNKSSRG + DNKYRP - DNKDP + DNKYIP + DNKTRRH + JDNKYP $ FRML IDNKYDH DNKYDH = DNKYP - DNKTY + JDNKYDH $ FRML IDNKYDRH DNKYDRH = DNKYDH/DNKPCP $ () () CURRENT BALANCE () FRML IDNKXGS DNKXGS = DNKXGSV*DNKPXGS $ FRML IDNKMGS DNKMGS = DNKMGSV*DNKPMGS $ FRML _GJ_D DNKYIE = (DNKYIE(-1) +DNKYIE(-1)* (2*((DEUEXCH/DNKEXCH)/(DEUEXCH(-1)/DNKEXCH(-1))-1) +((USAEXCH/DNKEXCH)/(USAEXCH(-1)/DNKEXCH(-1))-1))/3 +DNKYIE(-1)* ((2*((DEUEXCH/DNKEXCH) /(DEUEXCH(-1)/DNKEXCH(-1))) *((DEUIRS/DEUIRS(-3))**(1/3)-1) +((USAEXCH/DNKEXCH)/(USAEXCH(-1)/DNKEXCH(-1))) *((USAIRS/USAIRS(-3))**(1/3)-1))/3) +((2*((DEUEXCH/DNKEXCH)/(DEUEXCH(-1)/DNKEXCH(-1))) *.01*DEUIRS+((DNKEXCH/USAEXCH) /(USAEXCH(-1)/DNKEXCH(-1)))*.01*USAIRS)/3) *DNKCB(-1)) $ FRML IDNKCB DNKCB = DNKXGS - DNKMGS + DNKYIE +DNKCBR $ () () FINANCIAL SECTOR () FRML GDNKIRS DNKIRS = eurirs + jdnkirs $ () FRML GDNKIRS DNKIRS = DDNKIRS*DNKIRS(-1)+(DNKD1IRS*(EURIRS-EURIRS(-1)) () +DNKD2IRS*100*LOG(DNKPCPN) () +DNKD3IRS*100*LOG(DNKPCPN(-1)) () +DNKD4IRS*100*LOG(DNKPCPN(-2)) () +DNKD5IRS*100*LOG(DNKGDPV) () +DNKD6IRS*(100*(-DNKNLG/DNKGDP)) () +DNKD7IRS*(100*(-DNKCB/DNKGDP))) + JDNKIRS $ FRML GDNKIRL DNKIRL = (1-DDNKIRL)*100*(-1+EXP(.725*LOG(1+DNKIRL(-1)/100) +.776*LOG(1+DNKIRS/100)-.501*LOG(1+DNKIRS(-1)/100) +.00387)) +DNKDXIRL*(DNKIRL(-1)+DEUIRL-DEUIRL(-1) +(((DNKPCPN/DNKPCPN(-1)) -(DNKPCPN(-2)/DNKPCPN(-3)))/2 -((DEUPCPN/DEUPCPN(-1)) -(DEUPCPN(-2)/DEUPCPN(-3)))/2)*100) +DNKD1IRL*(DNKIRL(-1)+DNKIRS-DNKIRS(-1))+JDNKIRL $ () FRML _GJ_D DNKEXCH = DNKEXCH(-1)*(DEUEXCH/DEUEXCH(-1)) $ FRML _GJ_D DNKEXCH = DNKEXCH(-1)*(EUREXC/EUREXC(-1)) $ () () MAIN ECONOMIC QVOTAS AND OTHER VARIABLES () FRML IDNKBNLG DNKBNLG = (DNKNLG/DNKGDP)*100 $ FRML IDNKBCB DNKBCB = (DNKCB/DNKGDP)*100 $ FRML IDNKBCP DNKBCP = (DNKCPV/DNKYDRH)*100 $ FRML IDNKBM DNKBM = (DNKMGSV/DNKGDPV)*100 $ FRML IDNKBIP DNKBIP = (DNKIPV/DNKGDPV)*100 $ FRML IDNKBIB DNKBIB = (DNKIBV/DNKYFBV)*100 $ FRML IDNKBW DNKBW = (DNKWSSS/DNKYF)*100 $ FRML _DJ_ DNKIPV = DNKIBV + DNKIHV $ FRML _DJ_ DNKTDDV = DNKGDPV - DNKNGSV $ FRML IDNKNGSV DNKNGSV = DNKXGSV - DNKMGSV $ () () ********************* () * SWE * () ********************* () () HOUSEHOLD DEMAND () FRML _GJRD SWECPV = (EXP(LOG(SWECPV(-1)) +.473*(LOG(SWEYDRH-.5*(SWEYIP/SWEPCP)) -LOG(SWEYDRH(-2)-.5*(SWEYIP(-2)/SWEPCP(-2))))/2 -.00672*(SWEIRL(-1)-(SWEIRL(-2)+SWEIRL(-3))/2) -.155*(LOG(SWECPV(-1)/SWEYDRH(-1))) +.00630))$ FRML _GJRD SWEIHV = (EXP(.735*LOG(SWEIHV(-1)) +1.500*(LOG((SWEYF-SWETY+SWETRRH)/SWEPCP) -LOG((SWEYF(-2)-SWETY(-2)+SWETRRH(-2))/SWEPCP(-2)))/2 -.0661*(SWEIRL-SWEIRL(-3))/3 +1.1275 -.4735))$ () () BUSINESS INVESTMENT () FRML ISWEGAP SWEGAP = LOG(SWEYFBV)-.71*LOG(SWEEB+SWEES)-.29*LOG(SWEKBV) -SWEGAPT*TID-SWEGAPK $ FRML GSWEUC SWEUC = SWEPIB*(SWEIRL+15) $ FRML _GJRD_ DLOG(SWEKBV) = 0.47793*DLOG(SWEKBV(-1)) + 0.09545*DLOG(SWEYFBV) + 0.12055*DLOG(SWEYFBV(-1)) + 0.02000*(LOG(SWEYFBV(-1)/SWEKBV(-1)) -0.71*LOG(SWEUC(-1)/SWEWSSE(-1))) + TSWEKBV + 0.01309*D1989 + 1.62564 $ FRML GSWEIBV SWEIBV = SWEKBV-SWEKBV(-1)+SWEAKBV*SWEKBV(-1) $ FRML _DJ_ SWEITV = SWEIHV + SWEIBV + SWEIGV $ () () EXPORT VOLUMES () FRML GSWEXGSDU SWEXGSDU = XSWEDNK*LOG(DNKMGSD) + XSWENOR*LOG(NORMGSD) + XSWEFIN*LOG(FINMGSD) + XSWEDEU*LOG(DEUMGSD) + XSWEGBR*LOG(GBRMGSD) + XSWEFRA*LOG(FRAMGSD) + XSWEITA*LOG(ITAMGSD) + XSWEBEL*LOG(BELMGSD) + XSWENLD*LOG(NLDMGSD) + XSWEESP*LOG(ESPMGSD) + XSWEYPN*LOG(YPNMGSD) + XSWEUSA*LOG(USAMGSD) + XSWEPOL*LOG(POLMGSD) + XSWECZE*LOG(CZEMGSD) + XSWEAUS*LOG(AUSMGSD) + XSWEAUT*LOG(AUTMGSD) + XSWECAN*LOG(CANMGSD) + XSWECHL*LOG(CHLMGSD) + XSWEEST*LOG(ESTMGSD) + XSWEGRC*LOG(GRCMGSD) + XSWEHUN*LOG(HUNMGSD) + XSWEISL*LOG(ISLMGSD) + XSWEIRL*LOG(IRLMGSD) + XSWEISR*LOG(ISRMGSD) + XSWEKOR*LOG(KORMGSD) + XSWELUX*LOG(LUXMGSD) + XSWEMEX*LOG(MEXMGSD) + XSWENZL*LOG(NZLMGSD) + XSWEPRT*LOG(PRTMGSD) + XSWESVK*LOG(SVKMGSD) + XSWESVN*LOG(SVNMGSD) + XSWECHE*LOG(CHEMGSD) + XSWETUR*LOG(TURMGSD) + XSWEDAE*LOG(DAEMGSD) + XSWEOOP*LOG(OOPMGSD) + XSWEBRA*LOG(BRAMGSD) + XSWERUS*LOG(RUSMGSD) + XSWEIND*LOG(INDMGSD) + XSWECHN*LOG(CHNMGSD) + XSWEIDN*LOG(IDNMGSD) + XSWEZAF*LOG(ZAFMGSD) + XSWERWD*LOG(RWDMGSD) $ FRML _GJRD DLOG(SWEXGSD) = (SWEXGSDU-SWEXGSDU(-1)) $ FRML ISWEXGSV SWEXGSV = (SWEXGSD/SWEEXCH*USAEXCH)/SWEPXGS $ () () IMPORT () () FRML _GJ_ SWEWMV = .215*SWECPV + .229*SWECGNV + .289*SWEIHV +.289*(SWEIBV+SWEISKV) + .289*SWEIGV +.275*SWEXGSV $ FRML _GJRD DLOG(SWEMGSV) = 1.500*DLOG(SWEWMV) - 0.100*(LOG(SWEMGSV(-1))-LOG(SWEWMV(-1)) -0.31485*LOG(SWEPYFB(-1)/SWEPMGS(-1))-0.08691) - 0.00373 $ FRML ISWEMGSD SWEMGSD = SWEMGSV*SWEPMGS*SWEEXCH/USAEXCH $ () () LABOUR MARKET () () FRML _GJ_D_ SWELF = SWEPOPT*((SWELF(-1)/SWEPOPT(-1)) + (1-SWEDLF)*(.392*DLOG(SWEET) - .0013)) $ () FRML _DJ_ SWEEBN = (1/0.71)*LOG(SWEYFBV)-((1-0.71)/0.71)*LOG(SWEKBV) $ FRML _DJ_ SWEEBW = LOG(SWEYFBV)+0.29*LOG(SWEUC/SWEWSSE) $ FRML _GJRD DLOG(SWEEP) = 0.37437*DLOG(SWEYFBV)+0.42563*DLOG(SWEYFBV(-1)) -0.05*(LOG(SWEEP(-1))-SWEEBW(-1)) +0.05880 $ FRML _D__D SWEEB = SWEEP - SWEES $ FRML GSWEEE SWEEE = SWEEB + SWEEG $ FRML _DJ_ SWEET = SWEEE + SWEES $ FRML ISWEUN SWEUN = SWELF - SWEET $ FRML ISWEUNR SWEUNR = (SWEUN/SWELF)*100 $ () () WAGES () FRML GSWEWU SWEWU = (6.03*LOG(DNKWSSE)+ 7.57*LOG(NORWSSE)+ 11.80*LOG(DEUWSSE)+ 9.09*LOG(GBRWSSE)+ 8.87*LOG(USAWSSE))/43.36 $ FRML ISWEEYFB SWEEYFB = (SWEYFBV/(SWEEB+SWEES))/BSWEEYFB $ FRML _GJRD DLOG(SWEWR) = .56534*(DLOG(SWEPYFB)) +.46579*(SWEWU-SWEWU(-1)) -.010*(SWEUNR(-1)-.6*SWEUNR(-2)) -.43102*LOG(SWEWSSE(-1)/(SWEPYFB(-1)*SWEEYFB(-1))) +2.49145 $ FRML GSWEWSSE SWEWSSE = SWEKWSSE*SWEWR + JSWEWSSE $ FRML GSWEWRG SWEWRG = SWEKWRG*SWEWR + JSWEWRG $ () () DOMESTIC PRICES () () FRML GSWEPCPN SWEPCPN = SWEPCPN(-1)*(.25*(SWEPMGS/SWEPMGS(-1))+ .75*(SWEPYFB/SWEPYFB(-1))) + JSWEPCPN $ FRML ISWEPCP SWEPCP = (1+SWETTI)*SWEPCPN $ FRML GSWEPCGN SWEPCGN = SWEPCGN(-1)*(.29*(SWEPMGS/SWEPMGS(-1))+ .71*(SWEPYFB/SWEPYFB(-1))) + JSWEPCGN $ FRML GSWEPIHN SWEPIHN = SWEPIHN(-1)*(.31*(SWEPMGS/SWEPMGS(-1))+ .69*(SWEPYFB/SWEPYFB(-1))) + JSWEPIHN $ FRML ISWEPIH SWEPIH = (1+SWETTI)*SWEPIHN $ FRML GSWEPIB SWEPIB = SWEPIB(-1)*(.31*(SWEPMGS/SWEPMGS(-1))+ .69*(SWEPYFB/SWEPYFB(-1))) + JSWEPIB $ FRML GSWEPIG SWEPIG = SWEPIG(-1)*(.31*(SWEPMGS/SWEPMGS(-1))+ .69*(SWEPYFB/SWEPYFB(-1))) + JSWEPIG $ FRML GSWEPISK SWEPISK = SWEPIB + JSWEPISK $ FRML GSWEULC SWEULC = ((SWEWSSE*(SWEEB+SWEES))/SWEYFBV)/BSWEULC $ FRML GSWEUCCB SWEUCCB = (SWEPIB*((SWEIRL+SWEIRL(-1)+SWEIRL(-2)+SWEIRL(-3) +SWEIRL(-4)+SWEIRL(-5)+SWEIRL(-6))/7+15) *SWEKBV/SWEYFBV)/BSWEUCCB $ () OPRINDELIGE LIGNING FRML _GJRD DLOG(SWEPYFB) = .53715*(LOG(SWEULC)-LOG(SWEULC(-1))) +.06464*(LOG(SWEPMGS)-LOG(SWEPMGS(-1))) +.25817*(SWEGAP-SWEGAP(-1)) -.39074*(LOG(SWEPYFB(-1))-.71*LOG(SWEULC(-1)) -.29*LOG(SWEUCCB(-1))+0.12155) +.02116 $ () () IMPORT PRICES () FRML GSWEPMGSU SWEPMGSU = MSWEDNK*LOG(DNKPXGS/SWEEXCH*DNKEXCH) + MSWENOR*LOG(NORPXGS/SWEEXCH*NOREXCH) + MSWEFIN*LOG(FINPXGS/SWEEXCH*FINEXCH) + MSWEDEU*LOG(DEUPXGS/SWEEXCH*DEUEXCH) + MSWEGBR*LOG(GBRPXGS/SWEEXCH*GBREXCH) + MSWEFRA*LOG(FRAPXGS/SWEEXCH*FRAEXCH) + MSWEITA*LOG(ITAPXGS/SWEEXCH*ITAEXCH) + MSWEBEL*LOG(BELPXGS/SWEEXCH*BELEXCH) + MSWENLD*LOG(NLDPXGS/SWEEXCH*NLDEXCH) + MSWEESP*LOG(ESPPXGS/SWEEXCH*ESPEXCH) + MSWEYPN*LOG(YPNPXGS/SWEEXCH*YPNEXCH) + MSWEUSA*LOG(USAPXGS/SWEEXCH*USAEXCH) + MSWEPOL*LOG(POLPXGS/SWEEXCH*POLEXCH) + MSWECZE*LOG(CZEPXGS/SWEEXCH*CZEEXCH) + MSWEAUS*LOG(AUSPXGS/SWEEXCH*AUSEXCH) + MSWEAUT*LOG(AUTPXGS/SWEEXCH*AUTEXCH) + MSWECAN*LOG(CANPXGS/SWEEXCH*CANEXCH) + MSWECHL*LOG(CHLPXGS/SWEEXCH*CHLEXCH) + MSWEEST*LOG(ESTPXGS/SWEEXCH*ESTEXCH) + MSWEGRC*LOG(GRCPXGS/SWEEXCH*GRCEXCH) + MSWEHUN*LOG(HUNPXGS/SWEEXCH*HUNEXCH) + MSWEISL*LOG(ISLPXGS/SWEEXCH*ISLEXCH) + MSWEIRL*LOG(IRLPXGS/SWEEXCH*IRLEXCH) + MSWEISR*LOG(ISRPXGS/SWEEXCH*ISREXCH) + MSWEKOR*LOG(KORPXGS/SWEEXCH*KOREXCH) + MSWELUX*LOG(LUXPXGS/SWEEXCH*LUXEXCH) + MSWEMEX*LOG(MEXPXGS/SWEEXCH*MEXEXCH) + MSWENZL*LOG(NZLPXGS/SWEEXCH*NZLEXCH) + MSWEPRT*LOG(PRTPXGS/SWEEXCH*PRTEXCH) + MSWESVK*LOG(SVKPXGS/SWEEXCH*SVKEXCH) + MSWESVN*LOG(SVNPXGS/SWEEXCH*SVNEXCH) + MSWECHE*LOG(CHEPXGS/SWEEXCH*CHEEXCH) + MSWETUR*LOG(TURPXGS/SWEEXCH*TUREXCH) + MSWEDAE*LOG(DAEPXGS/SWEEXCH*DAEEXCH) + MSWEOOP*LOG(OOPPXGS/SWEEXCH*OOPEXCH) + MSWEBRA*LOG(BRAPXGS/SWEEXCH*BRAEXCH) + MSWERUS*LOG(RUSPXGS/SWEEXCH*RUSEXCH) + MSWEIND*LOG(INDPXGS/SWEEXCH*INDEXCH) + MSWECHN*LOG(CHNPXGS/SWEEXCH*CHNEXCH) + MSWEIDN*LOG(IDNPXGS/SWEEXCH*IDNEXCH) + MSWEZAF*LOG(ZAFPXGS/SWEEXCH*ZAFEXCH) + MSWERWD*LOG(RWDPXGS/SWEEXCH*RWDEXCH) $ () FRML _GJRD DLOG(SWEPMGS) = (SWEPMGSU-SWEPMGSU(-1)) $ () () EXPORT PRICES () FRML _GJR_ DLOG(SWEPXIN) = .31*DLOG(SWEPMGS)+.69*DLOG(SWEPYFB) $ FRML GSWEPXGSU SWEPXGSU = XSWEDNK*LOG(DNKPMGS/SWEEXCH*DNKEXCH) + XSWENOR*LOG(NORPMGS/SWEEXCH*NOREXCH) + XSWEFIN*LOG(FINPMGS/SWEEXCH*FINEXCH) + XSWEDEU*LOG(DEUPMGS/SWEEXCH*DEUEXCH) + XSWEGBR*LOG(GBRPMGS/SWEEXCH*GBREXCH) + XSWEFRA*LOG(FRAPMGS/SWEEXCH*FRAEXCH) + XSWEITA*LOG(ITAPMGS/SWEEXCH*ITAEXCH) + XSWEBEL*LOG(BELPMGS/SWEEXCH*BELEXCH) + XSWENLD*LOG(NLDPMGS/SWEEXCH*NLDEXCH) + XSWEESP*LOG(ESPPMGS/SWEEXCH*ESPEXCH) + XSWEYPN*LOG(YPNPMGS/SWEEXCH*YPNEXCH) + XSWEUSA*LOG(USAPMGS/SWEEXCH*USAEXCH) + XSWEPOL*LOG(POLPMGS/SWEEXCH*POLEXCH) + XSWECZE*LOG(CZEPMGS/SWEEXCH*CZEEXCH) + XSWEAUS*LOG(AUSPMGS/SWEEXCH*AUSEXCH) + XSWEAUT*LOG(AUTPMGS/SWEEXCH*AUTEXCH) + XSWECAN*LOG(CANPMGS/SWEEXCH*CANEXCH) + XSWECHL*LOG(CHLPMGS/SWEEXCH*CHLEXCH) + XSWEEST*LOG(ESTPMGS/SWEEXCH*ESTEXCH) + XSWEGRC*LOG(GRCPMGS/SWEEXCH*GRCEXCH) + XSWEHUN*LOG(HUNPMGS/SWEEXCH*HUNEXCH) + XSWEISL*LOG(ISLPMGS/SWEEXCH*ISLEXCH) + XSWEIRL*LOG(IRLPMGS/SWEEXCH*IRLEXCH) + XSWEISR*LOG(ISRPMGS/SWEEXCH*ISREXCH) + XSWEKOR*LOG(KORPMGS/SWEEXCH*KOREXCH) + XSWELUX*LOG(LUXPMGS/SWEEXCH*LUXEXCH) + XSWEMEX*LOG(MEXPMGS/SWEEXCH*MEXEXCH) + XSWENZL*LOG(NZLPMGS/SWEEXCH*NZLEXCH) + XSWEPRT*LOG(PRTPMGS/SWEEXCH*PRTEXCH) + XSWESVK*LOG(SVKPMGS/SWEEXCH*SVKEXCH) + XSWESVN*LOG(SVNPMGS/SWEEXCH*SVNEXCH) + XSWECHE*LOG(CHEPMGS/SWEEXCH*CHEEXCH) + XSWETUR*LOG(TURPMGS/SWEEXCH*TUREXCH) + XSWEDAE*LOG(DAEPMGS/SWEEXCH*DAEEXCH) + XSWEOOP*LOG(OOPPMGS/SWEEXCH*OOPEXCH) + XSWEBRA*LOG(BRAPMGS/SWEEXCH*BRAEXCH) + XSWERUS*LOG(RUSPMGS/SWEEXCH*RUSEXCH) + XSWEIND*LOG(INDPMGS/SWEEXCH*INDEXCH) + XSWECHN*LOG(CHNPMGS/SWEEXCH*CHNEXCH) + XSWEIDN*LOG(IDNPMGS/SWEEXCH*IDNEXCH) + XSWEZAF*LOG(ZAFPMGS/SWEEXCH*ZAFEXCH) + XSWERWD*LOG(RWDPMGS/SWEEXCH*RWDEXCH) $ () FRML _GJRD DLOG(SWEPXGS) = .0922*(SWEPXGSU-SWEPXGSU(-1))+.9078*DLOG(SWEPXIN) $ () () THE GOVERNMENT SECTOR () () FRML GSWECGWV SWECGWV = SWEEG*BSWECGWV $ FRML _GJ_D SWECGNV = SWECGNV(-1)*(SWECGWV/SWECGWV(-1))$ FRML ISWECGV SWECGV = SWECGWV + SWECGNV $ FRML ISWECGW SWECGW = SWECGWV*SWEWRG/(BSWECGWV*1000) $ FRML ISWECG SWECG = SWECGW + SWECGNV*SWEPCGN $ FRML ISWEIG SWEIG = SWEIGV*SWEPIG $ FRML GSWECFKG SWECFKG = SWETCFKG*SWECG $ FRML GSWESSRG SWESSRG = SWETSSRG*SWEWSSS + JSWESSRG $ FRML GSWETY SWETY = SWETTY*SWEYP + JSWETY $ FRML GSWETI SWETI = SWETTI*(SWECPV*SWEPCP+SWEIHV*SWEPIH)/(1+SWETTI) + JSWETI $ FRML GSWETRRH SWETRRH = (.478+JSWETTRH)*SWEUN*SWEWSSE(-1)/1000 +(1.44441*SWEPOPT-6620.46)*SWEWSSE(-1)/1000 + JSWETRRH $ FRML GSWEYIO SWEYIO = -((SWEIRL+SWEIRL(-1)+SWEIRL(-2))/300) *(SWEGNFL(-1))*(1-DYIO)+DYIO*ZSWEYIO + JSWEYIO $ FRML ISWENLG SWENLG = SWESSRG + SWETY + SWETI + SWEYIO - SWECG - SWEIG - SWEIENTG - SWETRRH - SWETRO - SWEKIG $ FRML ISWEGNFL SWEGNFL = SWEGNFL(-1) -SWENLG + BSWEGNFL $ () () PRODUCTION AND INCOMES () () FRML ISWEGDP SWEGDP = SWECPV*SWEPCP + SWECG + SWEIG + SWEIBV*SWEPIB+SWEIENTG +SWEIHV*SWEPIH + SWEISKV*SWEPISK +SWEXGSV*SWEPXGS - SWEMGSV*SWEPMGS + SWEDGDP $ FRML ISWEGDPV SWEGDPV = SWECPV+ SWECGV+ SWEIGV+ SWEIBV+ SWEIHV+ SWEISKV + SWEXGSV- SWEMGSV + SWEDGDPV $ FRML ISWEYF SWEYF = SWEGDP - SWETI $ FRML ISWEYFB SWEYFB = SWEYF - SWECGW - SWECFKG $ FRML ISWEYFBV SWEYFBV = SWEYFB/SWEPYFB $ FRML ISWEWSSS SWEWSSS = (SWEEB*SWEWSSE + SWEEG*SWEWRG)/1000 $ FRML ISWEYRP SWEYRP = SWEYF - SWEWSSS - SWECFKG $ FRML GSWEDP SWEDP = SWETDP*(SWEKBV*SWEPIB) $ FRML ISWEYIP SWEYIP = SWEYIE - SWEYIO $ FRML GSWEYP SWEYP = SWEWSSS - SWESSRG + SWEYRP - SWEDP + SWEYIP + SWETRRH + JSWEYP $ FRML ISWEYDH SWEYDH = SWEYP - SWETY + JSWEYDH $ FRML ISWEYDRH SWEYDRH = SWEYDH/SWEPCP $ () () CURRENT BALANCE () () FRML ISWEX SWEXGS = SWEXGSV*SWEPXGS $ FRML ISWEM SWEMGS = SWEMGSV*SWEPMGS $ FRML _GJ_D SWEYIE = (SWEYIE(-1) +SWEYIE(-1)*(2*((DEUEXCH/SWEEXCH) /(DEUEXCH(-1)/SWEEXCH(-1))-1) +((USAEXCH/SWEEXCH)/(USAEXCH(-1)/SWEEXCH(-1))-1))/3 +SWEYIE(-1)*((2*((DEUEXCH/SWEEXCH) /(DEUEXCH(-1)/SWEEXCH(-1))) *((DEUIRS/DEUIRS(-3))**(1/3)-1) +((USAEXCH/SWEEXCH)/(USAEXCH(-1)/SWEEXCH(-1))) *((USAIRS/USAIRS(-3))**(1/3)-1))/3) +((2*((DEUEXCH/SWEEXCH)/(DEUEXCH(-1)/SWEEXCH(-1))) *.01*DEUIRS+((USAEXCH/SWEEXCH) /(USAEXCH(-1)/SWEEXCH(-1)))*.01*USAIRS)/3) *SWECB(-1))$ FRML ISWECB SWECB = SWEXGS - SWEMGS + SWEYIE +SWECBR $ () OVENSTAENDE SUSPEKT JVF BASIS () () FINANCIAL SECTOR () () FRML _GJ_D_Z SWEIRS = 150*DLOG(SWEPCPN) + 50*DLOG(SWEGDPV) $ () FRML GSWEIRS SWEIRS = DSWEIRS*SWEIRS(-1)+(SWED1IRS*(EURIRS-EURIRS(-1)) () +SWED2IRS*100*LOG(SWEPCPN) () +SWED3IRS*100*LOG(SWEPCPN(-1)) () +SWED4IRS*100*LOG(SWEPCPN(-2)) () +SWED5IRS*100*LOG(SWEGDPV) () +SWED6IRS*(100*(-SWENLG/SWEGDP)) () +SWED7IRS*(100*(-SWECB/SWEGDP))) + JSWEIRS $ FRML GSWEIRL SWEIRL = (1-DSWEIRL)*100*(-1+EXP(.812*LOG(1+SWEIRL(-1)/100) +.587*LOG(1+SWEIRS/100)-.399*LOG(1+SWEIRS(-1)/100) +.002)) +SWEDXIRL*(SWEIRL(-1)+DEUIRL-DEUIRL(-1) +(((SWEPCPN/SWEPCPN(-1)) -(SWEPCPN(-2)/SWEPCPN(-3)))/2 -((DEUPCPN/DEUPCPN(-1)) -(DEUPCPN(-2)/DEUPCPN(-3)))/2)*100) +SWED1IRL*(SWEIRL(-1)+SWEIRS-SWEIRS(-1)) + JSWEIRL $ FRML _GJ_D_Z LOG(SWEEXCH) = LOG(SWEEXP) + (LOG(1+SWEIRS/100)-LOG(1+USAIRS/100)) $ FRML _GJ_D_Z SWEEXP = SWEEXB $ FRML _GJ_D_Z SWEEXB = SWEEXB(-1) + 1/3*(SWEEXCH-SWEEXB(-1)) $ () () MAIN ECONOMIC QVOTAS AND OTHER VARIABLES () () FRML ISWEBNLG SWEBNLG = (SWENLG/SWEGDP)*100 $ FRML ISWEBCB SWEBCB = (SWECB/SWEGDP)*100 $ FRML ISWEBCP SWEBCP = (SWECPV/SWEYDRH)*100 $ FRML ISWEBM SWEBM = (SWEMGSV/SWEGDPV)*100 $ FRML ISWEBIP SWEBIP = (SWEIPV/SWEGDPV)*100 $ FRML ISWEBIB SWEBIB = (SWEIBV/SWEYFBV)*100 $ FRML ISWEBW SWEBW = (SWEWSSS/SWEYF)*100 $ FRML _DJ_ SWEIPV = SWEIBV + SWEIHV $ FRML _DJ_ SWETDDV = SWEGDPV - SWENGSV $ FRML ISWENGSV SWENGSV = SWEXGSV - SWEMGSV $ () () () ********************* () * NOR * () ********************* () () HOUSEHOLD DEMAND () () () FRML _GJRD NORCPV = (EXP(LOG(NORCPV(-1)) +.446*(LOG(NORYDRH)-LOG(NORYDRH(-2)))/2 -.279*(LOG(NORCPV(-1)/NORYDRH(-1))) -.00681*(NORIRL-NORIRL(-2))/2 -.00156*TID + 3.1000))$ FRML _GJRD NORIHV = (.9563*(NORIHV(-1)) +1.793*(LOG(NORYFBV)-(LOG(NORYFBV(-1)) +LOG(NORYFBV(-2))+LOG(NORYFBV(-3)))/3) -.0217*((NORIRL(-1)-(NORPCP(-1)/NORPCP(-2)-1)*100) -(NORIRL(-3)-(NORPCP(-3)/NORPCP(-4)-1)*100))/2 +.0396)$ () () BUSINESS INVESTMENT () () FRML INORGAP NORGAP = LOG(NORYFBV)-.65*LOG(NOREB+NORES)-.35*LOG(NORKBV) -NORGAPT*TID-NORGAPK $ FRML GNORUC NORUC = NORPIB*(NORIRL+10) $ FRML _GJRD_ DLOG(NORKBV) = 0.87238*DLOG(NORKBV(-1)) + 0.21176*DLOG(NORYFBV(-1)) + 0.02000*(LOG(NORYFBV(-1)/NORKBV(-1)) -0.65*LOG(NORUC(-1)/NORWSSE(-1))) + TNORKBV - 0.01478*D2003 + 0.98826 $ FRML GNORIBV NORIBV = NORKBV-NORKBV(-1)+NORAKBV*NORKBV(-1) $ FRML _DJ_ NORITV = NORIHV + NORIBV + NORIGV $ () () EXPORT VOLUMES () FRML GNORXGSDU NORXGSDU = XNORDNK*LOG(DNKMGSD) + XNORSWE*LOG(SWEMGSD) + XNORFIN*LOG(FINMGSD) + XNORDEU*LOG(DEUMGSD) + XNORGBR*LOG(GBRMGSD) + XNORFRA*LOG(FRAMGSD) + XNORITA*LOG(ITAMGSD) + XNORBEL*LOG(BELMGSD) + XNORNLD*LOG(NLDMGSD) + XNORESP*LOG(ESPMGSD) + XNORYPN*LOG(YPNMGSD) + XNORUSA*LOG(USAMGSD) + XNORPOL*LOG(POLMGSD) + XNORCZE*LOG(CZEMGSD) + XNORAUS*LOG(AUSMGSD) + XNORAUT*LOG(AUTMGSD) + XNORCAN*LOG(CANMGSD) + XNORCHL*LOG(CHLMGSD) + XNOREST*LOG(ESTMGSD) + XNORGRC*LOG(GRCMGSD) + XNORHUN*LOG(HUNMGSD) + XNORISL*LOG(ISLMGSD) + XNORIRL*LOG(IRLMGSD) + XNORISR*LOG(ISRMGSD) + XNORKOR*LOG(KORMGSD) + XNORLUX*LOG(LUXMGSD) + XNORMEX*LOG(MEXMGSD) + XNORNZL*LOG(NZLMGSD) + XNORPRT*LOG(PRTMGSD) + XNORSVK*LOG(SVKMGSD) + XNORSVN*LOG(SVNMGSD) + XNORCHE*LOG(CHEMGSD) + XNORTUR*LOG(TURMGSD) + XNORDAE*LOG(DAEMGSD) + XNOROOP*LOG(OOPMGSD) + XNORBRA*LOG(BRAMGSD) + XNORRUS*LOG(RUSMGSD) + XNORIND*LOG(INDMGSD) + XNORCHN*LOG(CHNMGSD) + XNORIDN*LOG(IDNMGSD) + XNORZAF*LOG(ZAFMGSD) + XNORRWD*LOG(RWDMGSD) $ FRML _GJRD DLOG(NORXGSD) = (NORXGSDU-NORXGSDU(-1)) $ FRML INORXGSV NORXGSV = (NORXGSD/NOREXCH*USAEXCH)/NORPXGS $ () () IMPORT () FRML _GJ_ NORWMV = .278*NORCPV + .366*NORCGNV + .205*NORIHV +.535*(NORIBV+NORISKV) + .205*NORIGV +.219*NORXGSV $ FRML _GJRD DLOG(NORMGSV) = 1.37213*DLOG(NORWMV) - 0.22902*(LOG(NORMGSV(-1)/NORWMV(-1)) - 0.29839 *LOG(NORPYFB(-1)/NORPMGS(-1))+0.15681) - 0.00888 $ () FRML INORMGSD NORMGSD = NORMGSV*NORPMGS*NOREXCH/USAEXCH $ () () LABOUR MARKET () () FRML _GJ_D NORLF = NORPOPT*((NORLF(-1)/NORPOPT(-1)) + (1-NORDLF)*(.506*DLOG(NORET) - .00259)) $ () FRML _DJ_ NOREBN = (1/0.65)*LOG(NORYFBV)-((1-0.65)/0.65)*LOG(NORKBV) $ FRML _DJ_ NOREBW = LOG(NORYFBV)+0.35*LOG(NORUC/NORWSSE) $ FRML _GJRD DLOG(NOREP) = 0.19744*DLOG(NORYFBV)+0.66290*DLOG(NORYFBV(-1)) -0.02557*(LOG(NOREP(-1))-NOREBW(-1)) +0.01255 $ FRML _D__D NOREB = NOREP - NORES $ FRML GNOREE NOREE = NOREB + NOREG $ FRML _DJ_ NORET = NOREE + NORES $ FRML INORUN NORUN = NORLF - NORET $ FRML INORUNR NORUNR = (NORUN/NORLF)*100 $ () () WAGES () FRML GNORWU NORWU = (6.17*LOG(DNKWSSE)+ 13.76*LOG(SWEWSSE)+ 14.61*LOG(DEUWSSE)+ 11.03*LOG(GBRWSSE)+ 6.82*LOG(USAWSSE))/52.39 $ FRML INOREYFB NOREYFB = (NORYFBV/(NOREB+NORES))/BNOREYFB $ FRML _GJRD DLOG(NORWR) = .42572*(DLOG(NORPYFB)) +.52992*(NORWU-NORWU(-1)) -.00917*(NORUNR(-1)-.4*((NORUNR(-2)+NORUNR(-3))/2)) +.53077*(DLOG(NORPCP/NORPYFB)) -.07660*LOG(NORWSSE(-1)/(NORPYFB(-1)*NOREYFB(-1))) + 0.46765 $ FRML GNORWSSE NORWSSE = NORKWSSE*NORWR + JNORWSSE $ FRML GNORWRG NORWRG = NORKWRG*NORWR + JNORWRG $ () () DOMESTIC PRICES () () FRML GNORPCPN NORPCPN = NORPCPN(-1)*(.30*(NORPMGS/NORPMGS(-1))+ .70*(NORPYFB/NORPYFB(-1))) + JNORPCPN $ FRML INORPCP NORPCP = (1+NORTTI)*NORPCPN $ FRML GNORPCGN NORPCGN = NORPCGN(-1)*(.43*(NORPMGS/NORPMGS(-1))+ .57*(NORPYFB/NORPYFB(-1))) + JNORPCGN $ FRML GNORPIHN NORPIHN = NORPIHN(-1)*(.22*(NORPMGS/NORPMGS(-1))+ .78*(NORPYFB/NORPYFB(-1))) + JNORPIHN $ FRML INORPIH NORPIH = (1+NORTTI)*NORPIHN $ FRML GNORPIB NORPIB = NORPIB(-1)*(.55*(NORPMGS/NORPMGS(-1))+ .45*(NORPYFB/NORPYFB(-1))) + JNORPIB $ FRML GNORPIG NORPIG = NORPIG(-1)*(.22*(NORPMGS/NORPMGS(-1))+ .78*(NORPYFB/NORPYFB(-1))) + JNORPIG $ FRML GNORPISK NORPISK = NORPIB + JNORPISK $ FRML GNORULC NORULC = ((NORWSSE*(NOREB+NORES))/NORYFBV)/BNORULC $ FRML GNORUCCB NORUCCB = (NORPIB*((NORIRL+NORIRL(-1)+NORIRL(-2)+NORIRL(-3) +NORIRL(-4)+NORIRL(-5)+NORIRL(-6))/7+10) *NORKBV/NORYFBV)/BNORUCCB $ FRML _GJRD Dlog(NORPYFB) = .48650*(LOG(NORULC)-LOG(NORULC(-1))) +.37820*(LOG(NORPMGS)-LOG(NORPMGS(-1))) +.250*(NORGAP-NORGAP(-1)) -.10181*(LOG(NORPYFB(-1))-.65*LOG(NORULC(-1)) -.35*LOG(NORUCCB(-1))+0.13449) +.01239 $ () () IMPORT PRICES () FRML GNORPMGSU NORPMGSU = MNORDNK*LOG(DNKPXGS/NOREXCH*DNKEXCH) + MNORSWE*LOG(SWEPXGS/NOREXCH*SWEEXCH) + MNORFIN*LOG(FINPXGS/NOREXCH*FINEXCH) + MNORDEU*LOG(DEUPXGS/NOREXCH*DEUEXCH) + MNORGBR*LOG(GBRPXGS/NOREXCH*GBREXCH) + MNORFRA*LOG(FRAPXGS/NOREXCH*FRAEXCH) + MNORITA*LOG(ITAPXGS/NOREXCH*ITAEXCH) + MNORBEL*LOG(BELPXGS/NOREXCH*BELEXCH) + MNORNLD*LOG(NLDPXGS/NOREXCH*NLDEXCH) + MNORESP*LOG(ESPPXGS/NOREXCH*ESPEXCH) + MNORYPN*LOG(YPNPXGS/NOREXCH*YPNEXCH) + MNORUSA*LOG(USAPXGS/NOREXCH*USAEXCH) + MNORPOL*LOG(POLPXGS/NOREXCH*POLEXCH) + MNORCZE*LOG(CZEPXGS/NOREXCH*CZEEXCH) + MNORAUS*LOG(AUSPXGS/NOREXCH*AUSEXCH) + MNORAUT*LOG(AUTPXGS/NOREXCH*AUTEXCH) + MNORCAN*LOG(CANPXGS/NOREXCH*CANEXCH) + MNORCHL*LOG(CHLPXGS/NOREXCH*CHLEXCH) + MNOREST*LOG(ESTPXGS/NOREXCH*ESTEXCH) + MNORGRC*LOG(GRCPXGS/NOREXCH*GRCEXCH) + MNORHUN*LOG(HUNPXGS/NOREXCH*HUNEXCH) + MNORISL*LOG(ISLPXGS/NOREXCH*ISLEXCH) + MNORIRL*LOG(IRLPXGS/NOREXCH*IRLEXCH) + MNORISR*LOG(ISRPXGS/NOREXCH*ISREXCH) + MNORKOR*LOG(KORPXGS/NOREXCH*KOREXCH) + MNORLUX*LOG(LUXPXGS/NOREXCH*LUXEXCH) + MNORMEX*LOG(MEXPXGS/NOREXCH*MEXEXCH) + MNORNZL*LOG(NZLPXGS/NOREXCH*NZLEXCH) + MNORPRT*LOG(PRTPXGS/NOREXCH*PRTEXCH) + MNORSVK*LOG(SVKPXGS/NOREXCH*SVKEXCH) + MNORSVN*LOG(SVNPXGS/NOREXCH*SVNEXCH) + MNORCHE*LOG(CHEPXGS/NOREXCH*CHEEXCH) + MNORTUR*LOG(TURPXGS/NOREXCH*TUREXCH) + MNORDAE*LOG(DAEPXGS/NOREXCH*DAEEXCH) + MNOROOP*LOG(OOPPXGS/NOREXCH*OOPEXCH) + MNORBRA*LOG(BRAPXGS/NOREXCH*BRAEXCH) + MNORRUS*LOG(RUSPXGS/NOREXCH*RUSEXCH) + MNORIND*LOG(INDPXGS/NOREXCH*INDEXCH) + MNORCHN*LOG(CHNPXGS/NOREXCH*CHNEXCH) + MNORIDN*LOG(IDNPXGS/NOREXCH*IDNEXCH) + MNORZAF*LOG(ZAFPXGS/NOREXCH*ZAFEXCH) + MNORRWD*LOG(RWDPXGS/NOREXCH*RWDEXCH) $ FRML _GJRD DLOG(NORPMGS) = (NORPMGSU-NORPMGSU(-1)) $ () EXPORT PRICES () FRML _GJR DLOG(NORPXIN)= .27*DLOG(NORPMGS)+ .73*DLOG(NORPYFB) $ () FRML GNORPXGSU NORPXGSU = XNORDNK*LOG(DNKPMGS/NOREXCH*DNKEXCH) + XNORSWE*LOG(SWEPMGS/NOREXCH*SWEEXCH) + XNORFIN*LOG(FINPMGS/NOREXCH*FINEXCH) + XNORDEU*LOG(DEUPMGS/NOREXCH*DEUEXCH) + XNORGBR*LOG(GBRPMGS/NOREXCH*GBREXCH) + XNORFRA*LOG(FRAPMGS/NOREXCH*FRAEXCH) + XNORITA*LOG(ITAPMGS/NOREXCH*ITAEXCH) + XNORBEL*LOG(BELPMGS/NOREXCH*BELEXCH) + XNORNLD*LOG(NLDPMGS/NOREXCH*NLDEXCH) + XNORESP*LOG(ESPPMGS/NOREXCH*ESPEXCH) + XNORYPN*LOG(YPNPMGS/NOREXCH*YPNEXCH) + XNORUSA*LOG(USAPMGS/NOREXCH*USAEXCH) + XNORPOL*LOG(POLPMGS/NOREXCH*POLEXCH) + XNORCZE*LOG(CZEPMGS/NOREXCH*CZEEXCH) + XNORAUS*LOG(AUSPMGS/NOREXCH*AUSEXCH) + XNORAUT*LOG(AUTPMGS/NOREXCH*AUTEXCH) + XNORCAN*LOG(CANPMGS/NOREXCH*CANEXCH) + XNORCHL*LOG(CHLPMGS/NOREXCH*CHLEXCH) + XNOREST*LOG(ESTPMGS/NOREXCH*ESTEXCH) + XNORGRC*LOG(GRCPMGS/NOREXCH*GRCEXCH) + XNORHUN*LOG(HUNPMGS/NOREXCH*HUNEXCH) + XNORISL*LOG(ISLPMGS/NOREXCH*ISLEXCH) + XNORIRL*LOG(IRLPMGS/NOREXCH*IRLEXCH) + XNORISR*LOG(ISRPMGS/NOREXCH*ISREXCH) + XNORKOR*LOG(KORPMGS/NOREXCH*KOREXCH) + XNORLUX*LOG(LUXPMGS/NOREXCH*LUXEXCH) + XNORMEX*LOG(MEXPMGS/NOREXCH*MEXEXCH) + XNORNZL*LOG(NZLPMGS/NOREXCH*NZLEXCH) + XNORPRT*LOG(PRTPMGS/NOREXCH*PRTEXCH) + XNORSVK*LOG(SVKPMGS/NOREXCH*SVKEXCH) + XNORSVN*LOG(SVNPMGS/NOREXCH*SVNEXCH) + XNORCHE*LOG(CHEPMGS/NOREXCH*CHEEXCH) + XNORTUR*LOG(TURPMGS/NOREXCH*TUREXCH) + XNORDAE*LOG(DAEPMGS/NOREXCH*DAEEXCH) + XNOROOP*LOG(OOPPMGS/NOREXCH*OOPEXCH) + XNORBRA*LOG(BRAPMGS/NOREXCH*BRAEXCH) + XNORRUS*LOG(RUSPMGS/NOREXCH*RUSEXCH) + XNORIND*LOG(INDPMGS/NOREXCH*INDEXCH) + XNORCHN*LOG(CHNPMGS/NOREXCH*CHNEXCH) + XNORIDN*LOG(IDNPMGS/NOREXCH*IDNEXCH) + XNORZAF*LOG(ZAFPMGS/NOREXCH*ZAFEXCH) + XNORRWD*LOG(RWDPMGS/NOREXCH*RWDEXCH) $ FRML _GJRD DLOG(NORPXGS) = 1.0 *DLOG(NORPXIN) $ () () THE GOVERNMENT SECTOR () () FRML GNORCGWV NORCGWV = NOREG*BNORCGWV $ FRML _GJ_D NORCGNV = NORCGNV(-1)*(NORCGWV/NORCGWV(-1))$ FRML INORCGV NORCGV = NORCGWV + NORCGNV $ FRML INORCGW NORCGW = NORCGWV*NORWRG/(BNORCGWV*1000) $ FRML INORCG NORCG = NORCGW + NORCGNV*NORPCGN $ FRML INORIG NORIG = NORIGV*NORPIG $ FRML GNORCFKG NORCFKG = NORTCFKG*NORCG $ FRML GNORSSRG NORSSRG = NORTSSRG*NORWSSS + JNORSSRG $ FRML GNORTY NORTY = NORTTY*NORYP + JNORTY $ FRML GNORTI NORTI = NORTTI*(NORCPV*NORPCP+NORIHV*NORPIH)/(1+NORTTI) +JNORTI $ FRML GNORTRRH NORTRRH = (.342+JNORTTRH)*NORUN*(NORWSSE(-1)/1000) +(.92188*NORPOPT-1986.63)*(NORWSSE(-1)/1000) + JNORTRRH $ FRML GNORYIO NORYIO = -((NORIRL+NORIRL(-1)+NORIRL(-2))/300) *(NORGNFL(-1))*(1-DYIO)+DYIO*ZNORYIO + JNORYIO $ FRML INORNLG NORNLG = NORSSRG + NORTY + NORTI + NORYIO - NORCG - NORIG - NORIENTG - NORTRRH - NORTRO - NORKIG $ FRML INORGNFL NORGNFL = NORGNFL(-1) -NORNLG + BNORGNFL $ () () PRODUCTION AND INCOMES () () FRML INORGDP NORGDP = NORCPV*NORPCP + NORCG + NORIG + NORIBV*NORPIB+NORIENTG +NORIHV*NORPIH + NORISKV*NORPISK +NORXGSV*NORPXGS - NORMGSV*NORPMGS + NORDGDP$ FRML INORGDPV NORGDPV = NORCPV+ NORCGV+ NORIGV+ NORIBV+ NORIHV+ NORISKV + NORXGSV- NORMGSV + NORDGDPV$ FRML INORYF NORYF = NORGDP - NORTI $ FRML INORYFB NORYFB = NORYF - NORCGW - NORCFKG $ FRML INORYFBV NORYFBV = NORYFB/NORPYFB $ FRML INORWSSS NORWSSS = (NOREB*NORWSSE + NOREG*NORWRG)/1000 $ FRML INORYRP NORYRP = NORYF - NORWSSS - NORCFKG $ FRML GNORDP NORDP = NORTDP*(NORKBV*NORPIB) $ FRML INORYIP NORYIP = NORYIE - NORYIO $ FRML GNORYP NORYP = NORWSSS - NORSSRG + NORYRP - NORDP + NORYIP + NORTRRH + JNORYP $ FRML INORYDH NORYDH = NORYP - NORTY + JNORYDH $ FRML INORYDRH NORYDRH = NORYDH/NORPCP $ () () CURRENT BALANCE () () FRML INORX NORXGS = NORXGSV*NORPXGS $ FRML INORM NORMGS = NORMGSV*NORPMGS $ FRML _GJ_D NORYIE = (NORYIE(-1) +NORYIE(-1)* (2*((DEUEXCH/NOREXCH)/(DEUEXCH(-1)/NOREXCH(-1))-1) +((USAEXCH/NOREXCH)/(USAEXCH(-1)/NOREXCH(-1))-1))/3 +NORYIE(-1)* ((2*((DEUEXCH/NOREXCH)/(DEUEXCH(-1)/NOREXCH(-1))) *((DEUIRS/DEUIRS(-3))**(1/3)-1) +((USAEXCH/NOREXCH)/(USAEXCH(-1)/NOREXCH(-1))) *((USAIRS/USAIRS(-3))**(1/3)-1))/3) +((2*((DEUEXCH/NOREXCH)/(DEUEXCH(-1)/NOREXCH(-1))) *.01*DEUIRS +((USAEXCH/NOREXCH)/(USAEXCH(-1)/NOREXCH(-1))) *.01*USAIRS)/3)*NORCB(-1))$ FRML INORCB NORCB = NORXGS - NORMGS + NORYIE +NORCBR $ () () FINANCIAL SECTOR () () FRML _GJ_D_Z NORIRS = 150*DLOG(NORPCPN) + 50*DLOG(NORGDPV) $ () FRML GNORIRS NORIRS = DNORIRS*NORIRS(-1)+(NORD1IRS*(EURIRS-EURIRS(-1)) () +NORD2IRS*100*LOG(NORPCPN) () +NORD3IRS*100*LOG(NORPCPN(-1)) () +NORD4IRS*100*LOG(NORPCPN(-2)) () +NORD5IRS*100*LOG(NORGDPV) () +NORD6IRS*(100*(-NORNLG/NORGDP)) () +NORD7IRS*(100*(-NORCB/NORGDP))) + JNORIRS $ FRML GNORIRL NORIRL = (1-DNORIRL)*100*(-1+EXP(.749*LOG(1+NORIRL(-1)/100) +.576*LOG(1+NORIRS/100)-.325*LOG(1+NORIRS(-1)/100) -.0009)) +NORDXIRL*(NORIRL(-1)+DEUIRL-DEUIRL(-1) +(((NORPCPN/NORPCPN(-1)) -(NORPCPN(-2)/NORPCPN(-3)))/2 -((DEUPCPN/DEUPCPN(-1)) -(DEUPCPN(-2)/DEUPCPN(-3)))/2)*100) +NORD1IRL*(NORIRL(-1)+NORIRS-NORIRS(-1)) + JNORIRL $ FRML _GJ_D_Z LOG(NOREXCH) = LOG(NOREXP) + (LOG(1+NORIRS/100)-LOG(1+USAIRS/100)) $ FRML _GJ_D_Z NOREXP = NOREXB $ FRML _GJ_D_Z NOREXB = NOREXB(-1) + 1/3*(NOREXCH-NOREXB(-1)) $ () () MAIN ECONOMIC QVOTAS AND OTHER VARIABLES () () FRML INORBNLG NORBNLG = (NORNLG/NORGDP)*100 $ FRML INORBCB NORBCB = (NORCB/NORGDP)*100 $ FRML INORBCP NORBCP = (NORCPV/NORYDRH)*100 $ FRML INORBM NORBM = (NORMGSV/NORGDPV)*100 $ FRML INORBIP NORBIP = (NORIPV/NORGDPV)*100 $ FRML INORBIB NORBIB = (NORIBV/NORYFBV)*100 $ FRML INORBW NORBW = (NORWSSS/NORYF)*100 $ FRML _DJ_ NORIPV = NORIBV + NORIHV $ FRML _DJ_ NORTDDV = NORGDPV - NORNGSV - NORDGDPV $ FRML INORNGSV NORNGSV = NORXGSV - NORMGSV $ () () () ********************* () * FIN * () ********************* () () HOUSEHOLD DEMAND () () FRML _GJRD FINCPV =(EXP(LOG(FINCPV(-1)) +.506*(.50*LOG(FINYDRH-.5*FINYIP/FINPCP) -.50*LOG(FINYDRH(-2)-.5*FINYIP(-2)/FINPCP(-2))) -.00626*(FINIRL-FINIRL(-3))/3 -.256*(LOG(FINCPV(-1)/FINYDRH(-1))) +.06575 ))$ FRML _GJRD FINIHV =(EXP(.943*LOG(FINIHV(-1)) +1.29*(.25*LOG(FINYFBV)+.5*LOG(FINYFBV(-1)) -.75*LOG(FINYFBV(-2))) -.0150*(.75*FINIRL-.5*FINIRL(-1)-.25*FINIRL(-2)) +.178 -.108))$ () () BUSINESS INVESTMENT () () FRML IFINGAP FINGAP = LOG(FINYFBV)-.73*LOG(FINEB+FINES)-.27*LOG(FINKBV) -FINGAPT*TID-FINGAPK $ FRML GFINUC FINUC = FINPIB*(FINIRL+15) $ FRML _GJRD_ DLOG(FINKBV) = 0.81535*DLOG(FINKBV(-1)) + 0.08996*DLOG(FINYFBV) + 0.02000*(LOG(FINYFBV(-1)/FINKBV(-1)) -0.73*LOG(FINUC(-1)/FINWSSE(-1))) + TFINKBV - 0.01092*D1978 + 2.05578 $ FRML GFINIBV FINIBV = FINKBV-FINKBV(-1)+FINAKBV*FINKBV(-1) $ FRML _DJ_ FINITV = FINIHV + FINIBV + FINIGV $ () () EXPORT VOLUMES () FRML GFINXGSDU FINXGSDU = XFINDNK*LOG(DNKMGSD) + XFINSWE*LOG(SWEMGSD) + XFINNOR*LOG(NORMGSD) + XFINDEU*LOG(DEUMGSD) + XFINGBR*LOG(GBRMGSD) + XFINFRA*LOG(FRAMGSD) + XFINITA*LOG(ITAMGSD) + XFINBEL*LOG(BELMGSD) + XFINNLD*LOG(NLDMGSD) + XFINESP*LOG(ESPMGSD) + XFINYPN*LOG(YPNMGSD) + XFINUSA*LOG(USAMGSD) + XFINPOL*LOG(POLMGSD) + XFINCZE*LOG(CZEMGSD) + XFINAUS*LOG(AUSMGSD) + XFINAUT*LOG(AUTMGSD) + XFINCAN*LOG(CANMGSD) + XFINCHL*LOG(CHLMGSD) + XFINEST*LOG(ESTMGSD) + XFINGRC*LOG(GRCMGSD) + XFINHUN*LOG(HUNMGSD) + XFINISL*LOG(ISLMGSD) + XFINIRL*LOG(IRLMGSD) + XFINISR*LOG(ISRMGSD) + XFINKOR*LOG(KORMGSD) + XFINLUX*LOG(LUXMGSD) + XFINMEX*LOG(MEXMGSD) + XFINNZL*LOG(NZLMGSD) + XFINPRT*LOG(PRTMGSD) + XFINSVK*LOG(SVKMGSD) + XFINSVN*LOG(SVNMGSD) + XFINCHE*LOG(CHEMGSD) + XFINTUR*LOG(TURMGSD) + XFINDAE*LOG(DAEMGSD) + XFINOOP*LOG(OOPMGSD) + XFINBRA*LOG(BRAMGSD) + XFINRUS*LOG(RUSMGSD) + XFININD*LOG(INDMGSD) + XFINCHN*LOG(CHNMGSD) + XFINIDN*LOG(IDNMGSD) + XFINZAF*LOG(ZAFMGSD) + XFINRWD*LOG(RWDMGSD) $ FRML _GJRD DLOG(FINXGSD) = (FINXGSDU-FINXGSDU(-1)) $ FRML IFINXGSV FINXGSV = (FINXGSD/FINEXCH*USAEXCH)/FINPXGS $ () () IMPORT () () FRML _GJ_ FINWMV = .167*FINCPV + .098*FINCGNV + .164*FINIHV +.464*(FINIBV+FINISKV) + .164*FINIGV +.197*FINXGSV $ FRML _GJRD DLOG(FINMGSV) = 1.151*DLOG(FINWMV) - 0.100*(LOG(FINMGSV(-1)/FINWMV(-1)) -0.792*LOG(FINPYFB(-1)/FINPMGS(-1)) -0.1724) +0.0090 $ () FRML IFINMGSD FINMGSD = FINMGSV*FINPMGS*FINEXCH/USAEXCH $ () () LABOUR MARKET () () FRML _GJ_D FINLF = FINPOPT*((FINLF(-1)/FINPOPT(-1)) + (1-FINDLF)*(.1851*DLOG(FINET) - .00020)) $ () FRML _DJ_ FINEBN = (1/0.73)*LOG(FINYFBV)-((1-0.73)/0.73)*LOG(FINKBV) $ FRML _DJ_ FINEBW = LOG(FINYFBV)+0.27*LOG(FINUC/FINWSSE) $ FRML _GJRD DLOG(FINEP) = 0.49631*DLOG(FINYFBV)+0.43857*DLOG(FINYFBV(-1)) -0.01740*(LOG(FINEP(-1))-FINEBW(-1)) +0.02745 $ FRML _D__D FINEB = FINEP - FINES $ FRML GFINEE FINEE = FINEB + FINEG $ FRML _DJ_ FINET = FINEE + FINES $ FRML IFINUN FINUN = FINLF - FINET $ FRML IFINUNR FINUNR = (FINUN/FINLF)*100 $ () () WAGES () FRML GFINWU FINWU = (10.22*LOG(SWEWSSE)+ 12.77*LOG(DEUWSSE)+ 9.96*LOG(GBRWSSE)+ 4.27*LOG(FRAWSSE)+ 7.26*LOG(USAWSSE))/44.48 $ FRML IFINEYFB FINEYFB = (FINYFBV/(FINEB+FINES))/BFINEYFB $ FRML _GJRD DLOG(FINWR) = .69625*(DLOG(FINPYFB)) +.26822*(FINWU-FINWU(-1)) -.01019*(FINUNR(-1)-.8*FINUNR(-2)) +.36794*DLOG(FINEYFB) -.07884*LOG(FINWSSE(-1)/(FINPYFB(-1)*FINEYFB(-1))) +0.29252 $ FRML GFINWSSE FINWSSE = FINKWSSE*FINWR + JFINWSSE $ FRML GFINWRG FINWRG = FINKWRG*FINWR + JFINWRG $ () () DOMESTIC PRICES () () FRML GFINPCPN FINPCPN = FINPCPN(-1)*(.22*(FINPMGS/FINPMGS(-1))+ .78*(FINPYFB/FINPYFB(-1))) + JFINPCPN $ FRML IFINPCP FINPCP = (1+FINTTI)*FINPCPN $ FRML GFINPCGN FINPCGN = FINPCGN(-1)*(.20*(FINPMGS/FINPMGS(-1))+ .80*(FINPYFB/FINPYFB(-1))) + JFINPCGN $ FRML GFINPIHN FINPIHN = FINPIHN(-1)*(.20*(FINPMGS/FINPMGS(-1))+ .80*(FINPYFB/FINPYFB(-1))) + JFINPIHN $ FRML IFINPIH FINPIH = (1+FINTTI)*FINPIHN $ FRML GFINPIB FINPIB = FINPIB(-1)*(.50*(FINPMGS/FINPMGS(-1))+ .50*(FINPYFB/FINPYFB(-1))) + JFINPIB $ FRML GFINPIG FINPIG = FINPIG(-1)*(.20*(FINPMGS/FINPMGS(-1))+ .80*(FINPYFB/FINPYFB(-1))) + JFINPIG $ FRML GFINPISK FINPISK = FINPIB + JFINPISK $ FRML GFINULC FINULC = ((FINWSSE*(FINEB+FINES))/FINYFBV)/BFINULC $ FRML GFINUCCB FINUCCB = (FINPIB*((FINIRL+FINIRL(-1)+FINIRL(-2)+FINIRL(-3) +FINIRL(-4)+FINIRL(-5)+FINIRL(-6))/7+15) *FINKBV/FINYFBV)/BFINUCCB $ FRML _GJRD DLOG(FINPYFB) = .63808*(LOG(FINULC)-LOG(FINULC(-1))) +.15592*(LOG(FINPMGS)-LOG(FINPMGS(-1))) +.60931*(FINGAP-FINGAP(-1)) -.09867*(LOG(FINPYFB(-1))-.73*LOG(FINULC(-1)) -.27*LOG(FINUCCB(-1))+0.07738) +.01740 $ () () IMPORT PRICES () FRML GFINPMGSU FINPMGSU = MFINDNK*LOG(DNKPXGS/FINEXCH*DNKEXCH) + MFINSWE*LOG(SWEPXGS/FINEXCH*SWEEXCH) + MFINNOR*LOG(NORPXGS/FINEXCH*NOREXCH) + MFINDEU*LOG(DEUPXGS/FINEXCH*DEUEXCH) + MFINGBR*LOG(GBRPXGS/FINEXCH*GBREXCH) + MFINFRA*LOG(FRAPXGS/FINEXCH*FRAEXCH) + MFINITA*LOG(ITAPXGS/FINEXCH*ITAEXCH) + MFINBEL*LOG(BELPXGS/FINEXCH*BELEXCH) + MFINNLD*LOG(NLDPXGS/FINEXCH*NLDEXCH) + MFINESP*LOG(ESPPXGS/FINEXCH*ESPEXCH) + MFINYPN*LOG(YPNPXGS/FINEXCH*YPNEXCH) + MFINUSA*LOG(USAPXGS/FINEXCH*USAEXCH) + MFINPOL*LOG(POLPXGS/FINEXCH*POLEXCH) + MFINCZE*LOG(CZEPXGS/FINEXCH*CZEEXCH) + MFINAUS*LOG(AUSPXGS/FINEXCH*AUSEXCH) + MFINAUT*LOG(AUTPXGS/FINEXCH*AUTEXCH) + MFINCAN*LOG(CANPXGS/FINEXCH*CANEXCH) + MFINCHL*LOG(CHLPXGS/FINEXCH*CHLEXCH) + MFINEST*LOG(ESTPXGS/FINEXCH*ESTEXCH) + MFINGRC*LOG(GRCPXGS/FINEXCH*GRCEXCH) + MFINHUN*LOG(HUNPXGS/FINEXCH*HUNEXCH) + MFINISL*LOG(ISLPXGS/FINEXCH*ISLEXCH) + MFINIRL*LOG(IRLPXGS/FINEXCH*IRLEXCH) + MFINISR*LOG(ISRPXGS/FINEXCH*ISREXCH) + MFINKOR*LOG(KORPXGS/FINEXCH*KOREXCH) + MFINLUX*LOG(LUXPXGS/FINEXCH*LUXEXCH) + MFINMEX*LOG(MEXPXGS/FINEXCH*MEXEXCH) + MFINNZL*LOG(NZLPXGS/FINEXCH*NZLEXCH) + MFINPRT*LOG(PRTPXGS/FINEXCH*PRTEXCH) + MFINSVK*LOG(SVKPXGS/FINEXCH*SVKEXCH) + MFINSVN*LOG(SVNPXGS/FINEXCH*SVNEXCH) + MFINCHE*LOG(CHEPXGS/FINEXCH*CHEEXCH) + MFINTUR*LOG(TURPXGS/FINEXCH*TUREXCH) + MFINDAE*LOG(DAEPXGS/FINEXCH*DAEEXCH) + MFINOOP*LOG(OOPPXGS/FINEXCH*OOPEXCH) + MFINBRA*LOG(BRAPXGS/FINEXCH*BRAEXCH) + MFINRUS*LOG(RUSPXGS/FINEXCH*RUSEXCH) + MFININD*LOG(INDPXGS/FINEXCH*INDEXCH) + MFINCHN*LOG(CHNPXGS/FINEXCH*CHNEXCH) + MFINIDN*LOG(IDNPXGS/FINEXCH*IDNEXCH) + MFINZAF*LOG(ZAFPXGS/FINEXCH*ZAFEXCH) + MFINRWD*LOG(RWDPXGS/FINEXCH*RWDEXCH) $ FRML _GJRD DLOG(FINPMGS) = (FINPMGSU-FINPMGSU(-1)) $ () () EXPORT PRICES () FRML _GJR DLOG(FINPXIN) = .23*DLOG(FINPMGS)+ .77*DLOG(FINPYFB) $ FRML GFINPXGSU FINPXGSU = XFINDNK*LOG(DNKPMGS/FINEXCH*DNKEXCH) + XFINSWE*LOG(SWEPMGS/FINEXCH*SWEEXCH) + XFINNOR*LOG(NORPMGS/FINEXCH*NOREXCH) + XFINDEU*LOG(DEUPMGS/FINEXCH*DEUEXCH) + XFINGBR*LOG(GBRPMGS/FINEXCH*GBREXCH) + XFINFRA*LOG(FRAPMGS/FINEXCH*FRAEXCH) + XFINITA*LOG(ITAPMGS/FINEXCH*ITAEXCH) + XFINBEL*LOG(BELPMGS/FINEXCH*BELEXCH) + XFINNLD*LOG(NLDPMGS/FINEXCH*NLDEXCH) + XFINESP*LOG(ESPPMGS/FINEXCH*ESPEXCH) + XFINYPN*LOG(YPNPMGS/FINEXCH*YPNEXCH) + XFINUSA*LOG(USAPMGS/FINEXCH*USAEXCH) + XFINPOL*LOG(POLPMGS/FINEXCH*POLEXCH) + XFINCZE*LOG(CZEPMGS/FINEXCH*CZEEXCH) + XFINAUS*LOG(AUSPMGS/FINEXCH*AUSEXCH) + XFINAUT*LOG(AUTPMGS/FINEXCH*AUTEXCH) + XFINCAN*LOG(CANPMGS/FINEXCH*CANEXCH) + XFINCHL*LOG(CHLPMGS/FINEXCH*CHLEXCH) + XFINEST*LOG(ESTPMGS/FINEXCH*ESTEXCH) + XFINGRC*LOG(GRCPMGS/FINEXCH*GRCEXCH) + XFINHUN*LOG(HUNPMGS/FINEXCH*HUNEXCH) + XFINISL*LOG(ISLPMGS/FINEXCH*ISLEXCH) + XFINIRL*LOG(IRLPMGS/FINEXCH*IRLEXCH) + XFINISR*LOG(ISRPMGS/FINEXCH*ISREXCH) + XFINKOR*LOG(KORPMGS/FINEXCH*KOREXCH) + XFINLUX*LOG(LUXPMGS/FINEXCH*LUXEXCH) + XFINMEX*LOG(MEXPMGS/FINEXCH*MEXEXCH) + XFINNZL*LOG(NZLPMGS/FINEXCH*NZLEXCH) + XFINPRT*LOG(PRTPMGS/FINEXCH*PRTEXCH) + XFINSVK*LOG(SVKPMGS/FINEXCH*SVKEXCH) + XFINSVN*LOG(SVNPMGS/FINEXCH*SVNEXCH) + XFINCHE*LOG(CHEPMGS/FINEXCH*CHEEXCH) + XFINTUR*LOG(TURPMGS/FINEXCH*TUREXCH) + XFINDAE*LOG(DAEPMGS/FINEXCH*DAEEXCH) + XFINOOP*LOG(OOPPMGS/FINEXCH*OOPEXCH) + XFINBRA*LOG(BRAPMGS/FINEXCH*BRAEXCH) + XFINRUS*LOG(RUSPMGS/FINEXCH*RUSEXCH) + XFININD*LOG(INDPMGS/FINEXCH*INDEXCH) + XFINCHN*LOG(CHNPMGS/FINEXCH*CHNEXCH) + XFINIDN*LOG(IDNPMGS/FINEXCH*IDNEXCH) + XFINZAF*LOG(ZAFPMGS/FINEXCH*ZAFEXCH) + XFINRWD*LOG(RWDPMGS/FINEXCH*RWDEXCH) $ FRML _GJRD DLOG(FINPXGS) = 1.00*DLOG(FINPXIN) $ () () THE GOVERNMENT SECTOR () () FRML GFINCGWV FINCGWV = FINEG*BFINCGWV $ FRML _GJ_D FINCGNV = FINCGNV(-1)*(FINCGWV/FINCGWV(-1))$ FRML IFINCGV FINCGV = FINCGWV + FINCGNV $ FRML IFINCGW FINCGW = FINCGWV*FINWRG/(BFINCGWV*1000) $ FRML IFINCG FINCG = FINCGW + FINCGNV*FINPCGN $ FRML IFINIG FINIG = FINIGV*FINPIG $ FRML GFINCFKG FINCFKG = FINTCFKG*FINCG $ FRML GFINSSRG FINSSRG = FINTSSRG*FINWSSS + JFINSSRG $ FRML GFINTY FINTY = FINTTY*FINYP + JFINTY $ FRML GFINTI FINTI = FINTTI*(FINCPV*FINPCP+FINIHV*FINPIH)/(1+FINTTI) +JFINTI $ FRML GFINTRRH FINTRRH = (.401+JFINTTRH)*FINUN*(FINWSSE(-1)/1000) +(.77763*FINPOPT-1991.21)*(FINWSSE(-1)/1000) +JFINTRRH $ FRML GFINYIO FINYIO = -((FINIRL+FINIRL(-1)+FINIRL(-2))/300) *(FINGNFL(-1))*(1-DYIO)+DYIO*ZFINYIO + JFINYIO $ FRML IFINNLG FINNLG = FINSSRG + FINTY + FINTI + FINYIO - FINCG - FINIG - FINIENTG - FINTRRH - FINTRO - FINKIG $ FRML IFINGNFL FINGNFL = FINGNFL(-1) -FINNLG + BFINGNFL $ () () PRODUCTION AND INCOMES () () FRML IFINGDP FINGDP = FINCPV*FINPCP + FINCG + FINIG + FINIBV*FINPIB+FINIENTG +FINIHV*FINPIH + FINISKV*FINPISK +FINXGSV*FINPXGS - FINMGSV*FINPMGS + FINDGDP $ FRML IFINGDPV FINGDPV = FINCPV+ FINCGV+ FINIGV+ FINIBV+ FINIHV+ FINISKV + FINXGSV- FINMGSV + FINDGDPV $ FRML IFINYF FINYF = FINGDP - FINTI $ FRML IFINYFB FINYFB = FINYF - FINCGW - FINCFKG $ FRML IFINYFBV FINYFBV = FINYFB/FINPYFB $ FRML IFINWSSS FINWSSS = (FINEB*FINWSSE + FINEG*FINWRG)/1000 $ FRML IFINYRP FINYRP = FINYF - FINWSSS - FINCFKG $ FRML GFINDP FINDP = FINTDP*(FINKBV*FINPIB) $ FRML IFINYIP FINYIP = FINYIE - FINYIO $ FRML GFINYP FINYP = FINWSSS - FINSSRG + FINYRP - FINDP + FINYIP + FINTRRH + JFINYP $ FRML IFINYDH FINYDH = FINYP - FINTY + JFINYDH $ FRML IFINYDRH FINYDRH = FINYDH/FINPCP $ () () CURRENT BALANCE () () FRML IFINX FINXGS = FINXGSV*FINPXGS $ FRML IFINM FINMGS = FINMGSV*FINPMGS $ FRML _GJ_D FINYIE = (FINYIE(-1) +FINYIE(-1)* (2*((DEUEXCH/FINEXCH)/(DEUEXCH(-1)/FINEXCH(-1))-1) +((USAEXCH/FINEXCH)/(USAEXCH(-1)/FINEXCH(-1))-1))/3 +FINYIE(-1)* ((2*((DEUEXCH/FINEXCH)/(DEUEXCH(-1)/FINEXCH(-1))) *((DEUIRS/DEUIRS(-3))**(1/3)-1) +((USAEXCH/FINEXCH)/(USAEXCH(-1)/FINEXCH(-1))) *((USAIRS/USAIRS(-3))**(1/3)-1))/3) +((2*((DEUEXCH/FINEXCH)/(DEUEXCH(-1)/FINEXCH(-1))) *.01*DEUIRS +((USAEXCH/FINEXCH)/(USAEXCH(-1)/FINEXCH(-1))) *.01*USAIRS)/3) *FINCB(-1))$ FRML IFINCB FINCB = FINXGS - FINMGS + FINYIE +FINCBR $ () () FINANCIAL SECTOR () () FRML GFINIRS FINIRS = eurirs + jfinirs $ FRML GFINIRL FINIRL = (1-DFINIRL)*100*(-1+EXP(.884*LOG(1+FINIRL(-1)/100) +.404*LOG(1+FINIRS/100)-.288*LOG(1+FINIRS(-1)/100) -.00045)) +FINDXIRL*(FINIRL(-1)+DEUIRL-DEUIRL(-1) +(((FINPCPN/FINPCPN(-1)) -(FINPCPN(-2)/FINPCPN(-3)))/2 -((DEUPCPN/DEUPCPN(-1)) -(DEUPCPN(-2)/DEUPCPN(-3)))/2)*100) +FIND1IRL*(FINIRL(-1)+DEUIRL-DEUIRL(-1))+JFINIRL $ () FRML _GJ_D FINEXCH = FINEXCH(-1)*(DEUEXCH/DEUEXCH(-1)) $ FRML _GJ_D FINEXCH = FINEXCH(-1)*(EUREXC/EUREXC(-1)) $ () () MAIN ECONOMIC QVOTAS AND OTHER VARIABLES () () FRML IFINBNLG FINBNLG = (FINNLG/FINGDP)*100 $ FRML IFINBCB FINBCB = (FINCB/FINGDP)*100 $ FRML IFINBCP FINBCP = (FINCPV/FINYDRH)*100 $ FRML IFINBM FINBM = (FINMGSV/FINGDPV)*100 $ FRML IFINBIP FINBIP = (FINIPV/FINGDPV)*100 $ FRML IFINBIB FINBIB = (FINIBV/FINYFBV)*100 $ FRML IFINBW FINBW = (FINWSSS/FINYF)*100 $ FRML _DJ_ FINIPV = FINIBV + FINIHV $ FRML _DJ_ FINTDDV = FINGDPV - FINNGSV - FINDGDPV $ FRML IFINNGSV FINNGSV = FINXGSV - FINMGSV $ () () () ********************* () * DEU * () ********************* () () HOUSEHOLD DEMAND () () FRML _GJRD DEUCPV = (EXP(LOG(DEUCPV(-1)) +.700*(LOG((DEUYDH-.5*DEUYIP)/DEUPCP) -LOG((DEUYDH(-2)-.5*DEUYIP(-2))/DEUPCP(-2)))/2 -.00473*(DEUIRL-DEUIRL(-3))/3 -.100*LOG(DEUCPV(-1)/DEUYDRH(-1)) -.00469))$ () FRML _GJRD DEUIHV = (EXP(LOG(DEUIHV(-1)) +1.621*(LOG(DEUYFBV)-LOG(DEUYFBV(-2)))/2 -.0130*(DEUIRL(-1)-DEUIRL(-2)) -.01345))$ () () BUSINESS INVESTMENT () () FRML IDEUGAP DEUGAP = LOG(DEUYFBV)-.69*LOG(DEUEB+DEUES)-.31*LOG(DEUKBV) -DEUGAPT*TID-DEUGAPK $ FRML GDEUUC DEUUC = DEUPIB*(DEUIRL+10) $ FRML _GJRD_ DLOG(DEUKBV) = 0.75905*DLOG(DEUKBV(-1)) + 0.15308*DLOG(DEUYFBV(-1)) + 0.03000*(LOG(DEUYFBV(-1)/DEUKBV(-1)) -0.69*LOG(DEUUC(-1)/DEUWSSE(-1))) + TDEUKBV + 1.75389 $ () FRML GDEUIBV DEUIBV = DEUKBV-DEUKBV(-1)+DEUAKBV*DEUKBV(-1) $ FRML _DJ_ DEUITV = DEUIHV + DEUIBV + DEUIGV $ () () EXPORT VOLUMES () FRML GDEUXGSDU DEUXGSDU = XDEUDNK*LOG(DNKMGSD) + XDEUSWE*LOG(SWEMGSD) + XDEUNOR*LOG(NORMGSD) + XDEUFIN*LOG(FINMGSD) + XDEUGBR*LOG(GBRMGSD) + XDEUFRA*LOG(FRAMGSD) + XDEUITA*LOG(ITAMGSD) + XDEUBEL*LOG(BELMGSD) + XDEUNLD*LOG(NLDMGSD) + XDEUESP*LOG(ESPMGSD) + XDEUYPN*LOG(YPNMGSD) + XDEUUSA*LOG(USAMGSD) + XDEUPOL*LOG(POLMGSD) + XDEUCZE*LOG(CZEMGSD) + XDEUAUS*LOG(AUSMGSD) + XDEUAUT*LOG(AUTMGSD) + XDEUCAN*LOG(CANMGSD) + XDEUCHL*LOG(CHLMGSD) + XDEUEST*LOG(ESTMGSD) + XDEUGRC*LOG(GRCMGSD) + XDEUHUN*LOG(HUNMGSD) + XDEUISL*LOG(ISLMGSD) + XDEUIRL*LOG(IRLMGSD) + XDEUISR*LOG(ISRMGSD) + XDEUKOR*LOG(KORMGSD) + XDEULUX*LOG(LUXMGSD) + XDEUMEX*LOG(MEXMGSD) + XDEUNZL*LOG(NZLMGSD) + XDEUPRT*LOG(PRTMGSD) + XDEUSVK*LOG(SVKMGSD) + XDEUSVN*LOG(SVNMGSD) + XDEUCHE*LOG(CHEMGSD) + XDEUTUR*LOG(TURMGSD) + XDEUDAE*LOG(DAEMGSD) + XDEUOOP*LOG(OOPMGSD) + XDEUBRA*LOG(BRAMGSD) + XDEURUS*LOG(RUSMGSD) + XDEUIND*LOG(INDMGSD) + XDEUCHN*LOG(CHNMGSD) + XDEUIDN*LOG(IDNMGSD) + XDEUZAF*LOG(ZAFMGSD) + XDEURWD*LOG(RWDMGSD) $ FRML _GJRD DLOG(DEUXGSD) = (DEUXGSDU-DEUXGSDU(-1)) $ FRML IDEUXGSV DEUXGSV = DEUXGSD/(DEUEXCH*DEUPXGS)*USAEXCH $ () () IMPORT () () FRML _GJ_ DEUWMV = .190*DEUCPV + .140*DEUCGNV + .184*DEUIHV +.184*(DEUIBV+DEUISKV) + .184*DEUIGV +.186*DEUXGSV $ FRML _GJRD DLOG(DEUMGSV) = 1.15647*DLOG(DEUWMV) - 0.1000*(LOG(DEUMGSV(-1)/DEUWMV(-1)) -0.83700*LOG(DEUPYFB(-1)/DEUPMGS(-1)) -0.20809 ) + 0.01396 $ () FRML IDEUMGSD DEUMGSD = DEUMGSV*DEUPMGS*DEUEXCH/USAEXCH $ () () LABOUR MARKET () () FRML _GJ_D DEULF = DEUPOPT*((DEULF(-1)/DEUPOPT(-1)) + (1-DEUDLF)*(.085*DLOG(DEUET) - .00082 - .00267)) $ () FRML _DJ_ DEUEBN = (1/0.69)*LOG(DEUYFBV)-((1-0.69)/0.69)*LOG(DEUKBV) $ FRML _DJ_ DEUEBW = LOG(DEUYFBV)+0.31*LOG(DEUUC/DEUWSSE) $ FRML _GJRD DLOG(DEUEP) = 0.55922*DLOG(DEUYFBV)+0.24078*DLOG(DEUYFBV(-1)) -0.05*(LOG(DEUEP(-1))-DEUEBW(-1)) +0.15440 $ FRML _D__D DEUEB = DEUEP - DEUES $ FRML GDEUEE DEUEE = DEUEB + DEUEG $ FRML _DJ_ DEUET = DEUEE + DEUES $ FRML IDEUUN DEUUN = DEULF - DEUET + JDEUUN $ FRML IDEUUNR DEUUNR = (DEUUN/DEULF)*100 $ () () WAGES () FRML GDEUWU DEUWU = (8.04*LOG(GBRWSSE)+ 11.43*LOG(FRAWSSE)+ 6.92*LOG(ITAWSSE)+ 6.64*LOG(NLDWSSE)+ 7.98*LOG(USAWSSE))/41.01 $ FRML IDEUEYFB DEUEYFB = (DEUYFBV/(DEUEB+DEUES))/BDEUEYFB $ FRML _GJRD DLOG(DEUWR) = 1.0*(DLOG(DEUPYFB)) -.01207*(DEUUNR(-1)-0.8*DEUUNR(-2)) +.82311*(DLOG(DEUEYFB)) -.13730*LOG(DEUWSSE(-1)/(DEUPYFB(-1)*DEUEYFB(-1))) +0.47932 $ FRML GDEUWSSE DEUWSSE = DEUKWSSE*DEUWR + JDEUWSSE $ FRML GDEUWRG DEUWRG = DEUKWRG*DEUWR + JDEUWRG $ () () DOMESTIC PRICES () () FRML GDEUPCPN DEUPCPN = DEUPCPN(-1)*(.17*(DEUPMGS/DEUPMGS(-1))+ .83*(DEUPYFB/DEUPYFB(-1))) + JDEUPCPN $ FRML IDEUPCP DEUPCP = (1+DEUTTI)*DEUPCPN $ FRML GDEUPCGN DEUPCGN = DEUPCGN(-1)*(.19*(DEUPMGS/DEUPMGS(-1))+ .81*(DEUPYFB/DEUPYFB(-1))) + JDEUPCGN $ FRML GDEUPIB DEUPIB = DEUPIB(-1)*(.15*(DEUPMGS/DEUPMGS(-1))+ .85*(DEUPYFB/DEUPYFB(-1))) + JDEUPIB $ FRML GDEUPIHN DEUPIHN = DEUPIHN(-1)*(DEUPIB/DEUPIB(-1)) + JDEUPIHN $ FRML IDEUPIH DEUPIH = (1+DEUTTI)*DEUPIHN $ FRML GDEUPIG DEUPIG = DEUPIG(-1)*(DEUPIB/DEUPIB(-1)) + JDEUPIG $ FRML GDEUPISK DEUPISK = DEUPIB + JDEUPISK $ FRML GDEUULC DEUULC = ((DEUWSSE*(DEUEB+DEUES))/DEUYFBV)/BDEUULC $ FRML GDEUUCCB DEUUCCB = (DEUPIB*((DEUIRL+DEUIRL(-1)+DEUIRL(-2)+DEUIRL(-3) +DEUIRL(-4)+DEUIRL(-5)+DEUIRL(-6))/7+10) *DEUKBV/DEUYFBV)/BDEUUCCB $ FRML _GJRD Dlog(DEUPYFB) = .60752*(LOG(DEUULC)-LOG(DEUULC(-1))) +.14663*(DEUGAP-DEUGAP(-1)) -.07808*(LOG(DEUPYFB(-1))-.69*LOG(DEUULC(-1)) -.31*LOG(DEUUCCB(-1))-0.00547) +.00725 $ () () IMPORT PRICES () FRML GDEUPMGSU DEUPMGSU = MDEUDNK*LOG(DNKPXGS/DEUEXCH*DNKEXCH) + MDEUSWE*LOG(SWEPXGS/DEUEXCH*SWEEXCH) + MDEUNOR*LOG(NORPXGS/DEUEXCH*NOREXCH) + MDEUFIN*LOG(FINPXGS/DEUEXCH*FINEXCH) + MDEUGBR*LOG(GBRPXGS/DEUEXCH*GBREXCH) + MDEUFRA*LOG(FRAPXGS/DEUEXCH*FRAEXCH) + MDEUITA*LOG(ITAPXGS/DEUEXCH*ITAEXCH) + MDEUBEL*LOG(BELPXGS/DEUEXCH*BELEXCH) + MDEUNLD*LOG(NLDPXGS/DEUEXCH*NLDEXCH) + MDEUESP*LOG(ESPPXGS/DEUEXCH*ESPEXCH) + MDEUYPN*LOG(YPNPXGS/DEUEXCH*YPNEXCH) + MDEUUSA*LOG(USAPXGS/DEUEXCH*USAEXCH) + MDEUPOL*LOG(POLPXGS/DEUEXCH*POLEXCH) + MDEUCZE*LOG(CZEPXGS/DEUEXCH*CZEEXCH) + MDEUAUS*LOG(AUSPXGS/DEUEXCH*AUSEXCH) + MDEUAUT*LOG(AUTPXGS/DEUEXCH*AUTEXCH) + MDEUCAN*LOG(CANPXGS/DEUEXCH*CANEXCH) + MDEUCHL*LOG(CHLPXGS/DEUEXCH*CHLEXCH) + MDEUEST*LOG(ESTPXGS/DEUEXCH*ESTEXCH) + MDEUGRC*LOG(GRCPXGS/DEUEXCH*GRCEXCH) + MDEUHUN*LOG(HUNPXGS/DEUEXCH*HUNEXCH) + MDEUISL*LOG(ISLPXGS/DEUEXCH*ISLEXCH) + MDEUIRL*LOG(IRLPXGS/DEUEXCH*IRLEXCH) + MDEUISR*LOG(ISRPXGS/DEUEXCH*ISREXCH) + MDEUKOR*LOG(KORPXGS/DEUEXCH*KOREXCH) + MDEULUX*LOG(LUXPXGS/DEUEXCH*LUXEXCH) + MDEUMEX*LOG(MEXPXGS/DEUEXCH*MEXEXCH) + MDEUNZL*LOG(NZLPXGS/DEUEXCH*NZLEXCH) + MDEUPRT*LOG(PRTPXGS/DEUEXCH*PRTEXCH) + MDEUSVK*LOG(SVKPXGS/DEUEXCH*SVKEXCH) + MDEUSVN*LOG(SVNPXGS/DEUEXCH*SVNEXCH) + MDEUCHE*LOG(CHEPXGS/DEUEXCH*CHEEXCH) + MDEUTUR*LOG(TURPXGS/DEUEXCH*TUREXCH) + MDEUDAE*LOG(DAEPXGS/DEUEXCH*DAEEXCH) + MDEUOOP*LOG(OOPPXGS/DEUEXCH*OOPEXCH) + MDEUBRA*LOG(BRAPXGS/DEUEXCH*BRAEXCH) + MDEURUS*LOG(RUSPXGS/DEUEXCH*RUSEXCH) + MDEUIND*LOG(INDPXGS/DEUEXCH*INDEXCH) + MDEUCHN*LOG(CHNPXGS/DEUEXCH*CHNEXCH) + MDEUIDN*LOG(IDNPXGS/DEUEXCH*IDNEXCH) + MDEUZAF*LOG(ZAFPXGS/DEUEXCH*ZAFEXCH) + MDEURWD*LOG(RWDPXGS/DEUEXCH*RWDEXCH) $ FRML _GJRD DLOG(DEUPMGS) = (DEUPMGSU-DEUPMGSU(-1)) $ () EXPORT PRICES () FRML _GJR DLOG(DEUPXIN) = .21*DLOG(DEUPMGS)+ .79*DLOG(DEUPYFB) $ FRML GDEUPXGSU DEUPXGSU = XDEUDNK*LOG(DNKPMGS/DEUEXCH*DNKEXCH) + XDEUSWE*LOG(SWEPMGS/DEUEXCH*SWEEXCH) + XDEUNOR*LOG(NORPMGS/DEUEXCH*NOREXCH) + XDEUFIN*LOG(FINPMGS/DEUEXCH*FINEXCH) + XDEUGBR*LOG(GBRPMGS/DEUEXCH*GBREXCH) + XDEUFRA*LOG(FRAPMGS/DEUEXCH*FRAEXCH) + XDEUITA*LOG(ITAPMGS/DEUEXCH*ITAEXCH) + XDEUBEL*LOG(BELPMGS/DEUEXCH*BELEXCH) + XDEUNLD*LOG(NLDPMGS/DEUEXCH*NLDEXCH) + XDEUESP*LOG(ESPPMGS/DEUEXCH*ESPEXCH) + XDEUYPN*LOG(YPNPMGS/DEUEXCH*YPNEXCH) + XDEUUSA*LOG(USAPMGS/DEUEXCH*USAEXCH) + XDEUPOL*LOG(POLPMGS/DEUEXCH*POLEXCH) + XDEUCZE*LOG(CZEPMGS/DEUEXCH*CZEEXCH) + XDEUAUS*LOG(AUSPMGS/DEUEXCH*AUSEXCH) + XDEUAUT*LOG(AUTPMGS/DEUEXCH*AUTEXCH) + XDEUCAN*LOG(CANPMGS/DEUEXCH*CANEXCH) + XDEUCHL*LOG(CHLPMGS/DEUEXCH*CHLEXCH) + XDEUEST*LOG(ESTPMGS/DEUEXCH*ESTEXCH) + XDEUGRC*LOG(GRCPMGS/DEUEXCH*GRCEXCH) + XDEUHUN*LOG(HUNPMGS/DEUEXCH*HUNEXCH) + XDEUISL*LOG(ISLPMGS/DEUEXCH*ISLEXCH) + XDEUIRL*LOG(IRLPMGS/DEUEXCH*IRLEXCH) + XDEUISR*LOG(ISRPMGS/DEUEXCH*ISREXCH) + XDEUKOR*LOG(KORPMGS/DEUEXCH*KOREXCH) + XDEULUX*LOG(LUXPMGS/DEUEXCH*LUXEXCH) + XDEUMEX*LOG(MEXPMGS/DEUEXCH*MEXEXCH) + XDEUNZL*LOG(NZLPMGS/DEUEXCH*NZLEXCH) + XDEUPRT*LOG(PRTPMGS/DEUEXCH*PRTEXCH) + XDEUSVK*LOG(SVKPMGS/DEUEXCH*SVKEXCH) + XDEUSVN*LOG(SVNPMGS/DEUEXCH*SVNEXCH) + XDEUCHE*LOG(CHEPMGS/DEUEXCH*CHEEXCH) + XDEUTUR*LOG(TURPMGS/DEUEXCH*TUREXCH) + XDEUDAE*LOG(DAEPMGS/DEUEXCH*DAEEXCH) + XDEUOOP*LOG(OOPPMGS/DEUEXCH*OOPEXCH) + XDEUBRA*LOG(BRAPMGS/DEUEXCH*BRAEXCH) + XDEURUS*LOG(RUSPMGS/DEUEXCH*RUSEXCH) + XDEUIND*LOG(INDPMGS/DEUEXCH*INDEXCH) + XDEUCHN*LOG(CHNPMGS/DEUEXCH*CHNEXCH) + XDEUIDN*LOG(IDNPMGS/DEUEXCH*IDNEXCH) + XDEUZAF*LOG(ZAFPMGS/DEUEXCH*ZAFEXCH) + XDEURWD*LOG(RWDPMGS/DEUEXCH*RWDEXCH) $ FRML _GJRD DLOG(DEUPXGS) = 0.09777 * (DEUPXGSU-DEUPXGSU(-1)) + 0.90223 *dlog(DEUPXIN) $ () () THE GOVERNMENT SECTOR () () FRML GDEUCGWV DEUCGWV = DEUEG * BDEUCGWV $ FRML GDEUCGNV DEUCGNV = DEUCGNV(-1)*(DEUCGWV/DEUCGWV(-1))*(1-DDEUCGNV) + JDEUCGNV $ FRML IDEUCGV DEUCGV = DEUCGWV + DEUCGNV $ FRML IDEUCGW DEUCGW = DEUCGWV*DEUWRG/(BDEUCGWV*1000) $ FRML IDEUCG DEUCG = DEUCGW + DEUCGNV*DEUPCGN $ FRML IDEUIG DEUIG = DEUIGV*DEUPIG $ FRML GDEUCFKG DEUCFKG = DEUTCFKG*DEUCG $ FRML GDEUSSRG DEUSSRG = DEUTSSRG*DEUWSSS + JDEUSSRG $ FRML GDEUTY DEUTY = DEUTTY*DEUYP + JDEUTY $ FRML GDEUTI DEUTI = DEUTTI*(DEUCPV*DEUPCP+DEUIHV*DEUPIH)/(1+DEUTTI) +JDEUTI $ FRML GDEUTRRH DEUTRRH = (.334+JDEUTTRH)*DEUUN*(DEUWSSE(-1)/1000) + (.25088*DEUPOPT - 3522.81)* (DEUWSSE(-1)/1000) +JDEUTRRH $ FRML GDEUYIO DEUYIO = -((DEUIRL+DEUIRL(-1)+DEUIRL(-2))/300) *DEUGNFL(-1)*(1-DYIO)+DYIO*ZDEUYIO + JDEUYIO $ FRML IDEUNLG DEUNLG = DEUSSRG + DEUTY + DEUTI + DEUYIO - DEUCG - DEUIG - DEUIENTG - DEUTRRH - DEUTRO - DEUKIG $ FRML IDEUGNFL DEUGNFL = DEUGNFL(-1) -DEUNLG + BDEUGNFL $ () () PRODUCTION AND INCOMES () () FRML IDEUGDP DEUGDP = DEUCPV*DEUPCP + DEUCG + DEUIG + DEUIBV*DEUPIB+DEUIENTG +DEUIHV*DEUPIH + DEUISKV*DEUPISK +DEUXGSV*DEUPXGS - DEUMGSV*DEUPMGS + DEUDGDP $ FRML IDEUGDPV DEUGDPV = DEUCPV+ DEUCGV+ DEUIGV+ DEUIBV+ DEUIHV+ DEUISKV + DEUXGSV- DEUMGSV + DEUDGDPV $ FRML IDEUYF DEUYF = DEUGDP - DEUTI $ FRML IDEUYFB DEUYFB = DEUYF - DEUCGW - DEUCFKG $ FRML IDEUYFBV DEUYFBV = DEUYFB/DEUPYFB $ FRML IDEUWSSS DEUWSSS = (DEUEB*DEUWSSE + DEUEG*DEUWRG)/1000 $ FRML IDEUYRP DEUYRP = DEUYF - DEUWSSS - DEUCFKG $ FRML GDEUDP DEUDP = DEUTDP*(DEUKBV*DEUPIB) $ FRML IDEUYIP DEUYIP = DEUYIE - DEUYIO $ FRML GDEUYP DEUYP = DEUWSSS - DEUSSRG + DEUYRP - DEUDP + DEUYIP + DEUTRRH + JDEUYP $ FRML IDEUYDH DEUYDH = DEUYP - DEUTY + JDEUYDH $ FRML IDEUYDRH DEUYDRH = DEUYDH/DEUPCP $ () () CURRENT BALANCE () () FRML IDEUX DEUXGS = DEUXGSV*DEUPXGS $ FRML IDEUM DEUMGS = DEUMGSV*DEUPMGS $ FRML _GJ_D DEUYIE = (DEUYIE(-1) +DEUYIE(-1)*(.5*((USAEXCH/DEUEXCH) /(USAEXCH(-1)/DEUEXCH(-1))-1)) +DEUYIE(-1)*(.5*((USAEXCH/DEUEXCH) /(USAEXCH(-1)/DEUEXCH(-1))) *((USAIRS/USAIRS(-3))**(1/3)-1) +.5*((DEUIRS/DEUIRS(-3))**(1/3)-1)) +(.5*((USAEXCH/DEUEXCH)/(USAEXCH(-1)/DEUEXCH(-1))) *.01*USAIRS+.5*.01*DEUIRS)*DEUCB(-1))$ FRML IDEUCB DEUCB = DEUXGS - DEUMGS + DEUYIE +DEUCBR $ () () FINANCIAL SECTOR () () FRML GDEUIRS DEUIRS = eurirs + jdeuirs$ FRML GDEUIRL DEUIRL = (1-DDEUIRL)*100*(-1+EXP(.9056*LOG(1+DEUIRL(-1)/100) +.3025*LOG(1+DEUIRS/100)-.2081*LOG(1+DEUIRS(-1)/100) -.00065)) +DEUD1IRL*(DEUIRL(-1)+DEUIRS-DEUIRS(-1))+JDEUIRL $ () FRML _GJ_D DEUEXCH = 1/EXP( () LOG(USAEXCH(-1)*USAPYFB(-1)/(DEUEXCH(-1)*DEUPYFB(-1))) () -1*(LOG((1+DEUIRS/100)/(1+USAIRS/100)) () -LOG((1+DEUIRS(-1)/100)/(1+USAIRS(-1)/100))) () -2.9171*LOG((1+DEUIRL(-1)/100)/(1+USAIRL(-1)/100)) () -.3024*LOG(USAEXCH(-1)*USAPYFB(-1)/( () DEUEXCH(-1)*DEUPYFB(-1))) () -.00658*TID+13.1959) () *USAPYFB*USAEXCH/DEUPYFB $ FRML _GJ_D DEUEXCH = DEUEXCH(-1)*(EUREXC/EUREXC(-1)) $ () () MAIN ECONOMIC QVOTAS AND OTHER VARIABLES () () FRML IDEUBNLG DEUBNLG = (DEUNLG/DEUGDP)*100 $ FRML IDEUBCB DEUBCB = (DEUCB/DEUGDP)*100 $ FRML IDEUBCP DEUBCP = (DEUCPV/DEUYDRH)*100 $ FRML IDEUBM DEUBM = (DEUMGSV/DEUGDPV)*100 $ FRML IDEUBIP DEUBIP = (DEUIPV/DEUGDPV)*100 $ FRML IDEUBIB DEUBIB = (DEUIBV/DEUYFBV)*100 $ FRML IDEUBW DEUBW = (DEUWSSS/DEUYF)*100 $ FRML _DJ_ DEUIPV = DEUIBV + DEUIHV $ FRML _DJ_ DEUTDDV = DEUGDPV - DEUNGSV $ FRML IDEUNGSV DEUNGSV = DEUXGSV - DEUMGSV $ () () ******************* () * BEL * () ******************* () () HOUSEHOLD DEMAND () () FRML _GJRD BELCPV = EXP(LOG(BELCPV(-1)) +.649*(.75*LOG(BELYDRH-.7*BELYIP/BELPCP) -.50*LOG(BELYDRH(-1)-.7*BELYIP(-1)/BELPCP(-1)) -.25*LOG(BELYDRH(-2)-.7*BELYIP(-2)/BELPCP(-2))) -.015*(.75*BELIRL-.50*BELIRL(-1)-.25*BELIRL(-2)) -.310*LOG(BELCPV(-1)/BELYDRH(-1)) -.04509)$ FRML _GJRD BELIHV = (EXP(.927*LOG(BELIHV(-1)) +2.30*(LOG(BELYFBV)-LOG(BELYFBV(-2)))/2 -.0100*(BELIRL-BELIRL(-2))/2 +.380))$ () BUSINESS INVESTMENT () () FRML IBELGAP BELGAP = LOG(BELYFBV)-.70*LOG(BELEB+BELES)-.30*LOG(BELKBV) -BELGAPT*TID-BELGAPK $ FRML GBELUC BELUC = BELPIB*(BELIRL+15) $ FRML _GJRD_ DLOG(BELKBV) = 0.69433*DLOG(BELKBV(-1)) + 0.12186*DLOG(BELYFBV) + 0.04578*DLOG(BELYFBV(-1)) + 0.02000*(LOG(BELYFBV(-1)/BELKBV(-1)) -0.70*LOG(BELUC(-1)/BELWSSE(-1))) + TBELKBV + 0.00606*D2005 + 1.06060 $ FRML GBELIBV BELIBV = BELKBV-BELKBV(-1)+BELAKBV*BELKBV(-1) $ FRML _DJ_ BELITV = BELIHV + BELIBV + BELIGV $ () () EXPORT VOLUMES () () FRML GBELXGSDU BELXGSDU = XBELDNK*LOG(DNKMGSD) + XBELSWE*LOG(SWEMGSD) + XBELNOR*LOG(NORMGSD) + XBELFIN*LOG(FINMGSD) + XBELGBR*LOG(GBRMGSD) + XBELFRA*LOG(FRAMGSD) + XBELITA*LOG(ITAMGSD) + XBELDEU*LOG(DEUMGSD) + XBELNLD*LOG(NLDMGSD) + XBELESP*LOG(ESPMGSD) + XBELYPN*LOG(YPNMGSD) + XBELUSA*LOG(USAMGSD) + XBELPOL*LOG(POLMGSD) + XBELCZE*LOG(CZEMGSD) + XBELAUS*LOG(AUSMGSD) + XBELAUT*LOG(AUTMGSD) + XBELCAN*LOG(CANMGSD) + XBELCHL*LOG(CHLMGSD) + XBELEST*LOG(ESTMGSD) + XBELGRC*LOG(GRCMGSD) + XBELHUN*LOG(HUNMGSD) + XBELISL*LOG(ISLMGSD) + XBELIRL*LOG(IRLMGSD) + XBELISR*LOG(ISRMGSD) + XBELKOR*LOG(KORMGSD) + XBELLUX*LOG(LUXMGSD) + XBELMEX*LOG(MEXMGSD) + XBELNZL*LOG(NZLMGSD) + XBELPRT*LOG(PRTMGSD) + XBELSVK*LOG(SVKMGSD) + XBELSVN*LOG(SVNMGSD) + XBELCHE*LOG(CHEMGSD) + XBELTUR*LOG(TURMGSD) + XBELDAE*LOG(DAEMGSD) + XBELOOP*LOG(OOPMGSD) + XBELBRA*LOG(BRAMGSD) + XBELRUS*LOG(RUSMGSD) + XBELIND*LOG(INDMGSD) + XBELCHN*LOG(CHNMGSD) + XBELIDN*LOG(IDNMGSD) + XBELZAF*LOG(ZAFMGSD) + XBELRWD*LOG(RWDMGSD) $ FRML _GJRD DLOG(BELXGSD)= (BELXGSDU-BELXGSDU(-1)) $ FRML IBELXGSV BELXGSV = (BELXGSD*USAEXCH)/(BELEXCH*BELPXGS) $ () () IMPORT () () FRML _GJ_ BELWMV = .309*BELCPV + .272*BELCGNV + .259*BELIHV +.659*(BELIBV+BELISKV) + .259*BELIGV +.399*BELXGSV $ FRML _GJRD Dlog(BELMGSV) = 1.303*Dlog(BELWMV) + 0.077*dlog(BELPYFB/BELPMGS) - 0.100*(Log(BELMGSV(-1)/BELWMV(-1)) -0.574*Log(BELPYFB(-1)/BELPMGS(-1))-0.1423) - 0.00126 $ () FRML IBELMGSD BELMGSD = BELMGSV*BELPMGS*BELEXCH/USAEXCH $ () () LABOUR MARKET () () FRML _GJ_D BELLF = BELPOPT*((BELLF(-1)/BELPOPT(-1)) + (1-BELDLF)*(.146*DLOG(BELET) - .1396)) $ () FRML _DJ_ BELEBN = (1/0.70)*LOG(BELYFBV)-((1-0.70)/0.70)*LOG(BELKBV) $ FRML _DJ_ BELEBW = LOG(BELYFBV)+0.3*LOG(BELUC/BELWSSE) $ FRML _GJRD DLOG(BELEP) = 0.48752*DLOG(BELYFBV)+0.31248*DLOG(BELYFBV(-1)) -0.05518*(LOG(BELEP(-1))-BELEBW(-1)) +0.15159 $ FRML _D__D BELEB = BELEP - BELES $ FRML GBELEE BELEE = BELEB + BELEG $ FRML _DJ_ BELET = BELEE + BELES $ FRML IBELUN BELUN = BELLF - BELET $ FRML IBELUNR BELUNR = (BELUN/BELLF)*100 $ () () WAGES () FRML IBELEYFB BELEYFB = (BELYFBV/(BELEB+BELES))/BBELEYFB $ FRML _GJRD DLOG(BELWR) = .94374*(DLOG(BELPYFB)) -0.00801*(BELUNR(-1)-.2*BELUNR(-2)) +.47672*(DLOG(BELPCP/BELPYFB)) -.1500*LOG(BELWSSE(-1)/(BELPYFB(-1)*BELEYFB(-1))) +0.60735 $ FRML GBELWSSE BELWSSE = BELKWSSE*BELWR + JBELWSSE $ FRML GBELWRG BELWRG = BELKWRG*BELWR + JBELWRG $ () () DOMESTIC PRICES () () FRML GBELPCPN BELPCPN = BELPCPN(-1)*(.36*(BELPMGS/BELPMGS(-1))+ .64*(BELPYFB/BELPYFB(-1))) + JBELPCPN $ FRML IBELPCP BELPCP = (1+BELTTI)*BELPCPN $ FRML GBELPCGN BELPCGN = BELPCGN(-1)*(.36*(BELPMGS/BELPMGS(-1))+ .64*(BELPYFB/BELPYFB(-1))) + JBELPCGN $ FRML GBELPIHN BELPIHN = BELPIHN(-1)*(.28*(BELPMGS/BELPMGS(-1))+ .72*(BELPYFB/BELPYFB(-1))) + JBELPIHN $ FRML IBELPIH BELPIH = (1+BELTTI)*BELPIHN $ FRML GBELPIB BELPIB = BELPIB(-1)*(.68*(BELPMGS/BELPMGS(-1))+ .32*(BELPYFB/BELPYFB(-1))) + JBELPIB $ FRML GBELPIG BELPIG = BELPIG(-1)*(.28*(BELPMGS/BELPMGS(-1))+ .72*(BELPYFB/BELPYFB(-1))) + JBELPIG $ FRML GBELPISK BELPISK = BELPIB + JBELPISK $ FRML GBELULCB BELULC = (BELWSSE*(BELEB+BELES)/BELYFBV)/BBELULC $ FRML GBELUCCB BELUCCB = (BELPIB*((BELIRL+BELIRL(-1)+BELIRL(-2)+BELIRL(-3) +BELIRL(-4)+BELIRL(-5)+BELIRL(-6))/7+15) *BELKBV/BELYFBV)/BBELUCCB $ FRML _GJRD DLOG(BELPYFB) = 0.65571*(LOG(BELULC)-LOG(BELULC(-1))) +.05669*(LOG(BELPMGS)-LOG(BELPMGS(-1))) +.2500*(BELGAP-BELGAP(-1)) -.10215*(LOG(BELPYFB(-1))-.70*LOG(BELULC(-1)) -.30*LOG(BELUCCB(-1))+0.02606) +.01062 $ () () IMPORT PRICES () FRML GBELPMGSU BELPMGSU = MBELDNK*LOG(DNKPXGS/BELEXCH*DNKEXCH) + MBELSWE*LOG(SWEPXGS/BELEXCH*SWEEXCH) + MBELNOR*LOG(NORPXGS/BELEXCH*NOREXCH) + MBELFIN*LOG(FINPXGS/BELEXCH*FINEXCH) + MBELGBR*LOG(GBRPXGS/BELEXCH*GBREXCH) + MBELFRA*LOG(FRAPXGS/BELEXCH*FRAEXCH) + MBELITA*LOG(ITAPXGS/BELEXCH*ITAEXCH) + MBELDEU*LOG(DEUPXGS/BELEXCH*DEUEXCH) + MBELNLD*LOG(NLDPXGS/BELEXCH*NLDEXCH) + MBELESP*LOG(ESPPXGS/BELEXCH*ESPEXCH) + MBELYPN*LOG(YPNPXGS/BELEXCH*YPNEXCH) + MBELUSA*LOG(USAPXGS/BELEXCH*USAEXCH) + MBELPOL*LOG(POLPXGS/BELEXCH*POLEXCH) + MBELCZE*LOG(CZEPXGS/BELEXCH*CZEEXCH) + MBELAUS*LOG(AUSPXGS/BELEXCH*AUSEXCH) + MBELAUT*LOG(AUTPXGS/BELEXCH*AUTEXCH) + MBELCAN*LOG(CANPXGS/BELEXCH*CANEXCH) + MBELCHL*LOG(CHLPXGS/BELEXCH*CHLEXCH) + MBELEST*LOG(ESTPXGS/BELEXCH*ESTEXCH) + MBELGRC*LOG(GRCPXGS/BELEXCH*GRCEXCH) + MBELHUN*LOG(HUNPXGS/BELEXCH*HUNEXCH) + MBELISL*LOG(ISLPXGS/BELEXCH*ISLEXCH) + MBELIRL*LOG(IRLPXGS/BELEXCH*IRLEXCH) + MBELISR*LOG(ISRPXGS/BELEXCH*ISREXCH) + MBELKOR*LOG(KORPXGS/BELEXCH*KOREXCH) + MBELLUX*LOG(LUXPXGS/BELEXCH*LUXEXCH) + MBELMEX*LOG(MEXPXGS/BELEXCH*MEXEXCH) + MBELNZL*LOG(NZLPXGS/BELEXCH*NZLEXCH) + MBELPRT*LOG(PRTPXGS/BELEXCH*PRTEXCH) + MBELSVK*LOG(SVKPXGS/BELEXCH*SVKEXCH) + MBELSVN*LOG(SVNPXGS/BELEXCH*SVNEXCH) + MBELCHE*LOG(CHEPXGS/BELEXCH*CHEEXCH) + MBELTUR*LOG(TURPXGS/BELEXCH*TUREXCH) + MBELDAE*LOG(DAEPXGS/BELEXCH*DAEEXCH) + MBELOOP*LOG(OOPPXGS/BELEXCH*OOPEXCH) + MBELBRA*LOG(BRAPXGS/BELEXCH*BRAEXCH) + MBELRUS*LOG(RUSPXGS/BELEXCH*RUSEXCH) + MBELIND*LOG(INDPXGS/BELEXCH*INDEXCH) + MBELCHN*LOG(CHNPXGS/BELEXCH*CHNEXCH) + MBELIDN*LOG(IDNPXGS/BELEXCH*IDNEXCH) + MBELZAF*LOG(ZAFPXGS/BELEXCH*ZAFEXCH) + MBELRWD*LOG(RWDPXGS/BELEXCH*RWDEXCH) $ FRML _GJRD DLOG(BELPMGS) = (BELPMGSU-BELPMGSU(-1)) $ () () EXPORT PRICES () () FRML _GJR DLOG(BELPXIN) = .44*DLOG(BELPMGS)+.56*DLOG(BELPYFB) $ FRML GBELPXGSU BELPXGSU = XBELDNK*LOG(DNKPMGS/BELEXCH*DNKEXCH) + XBELSWE*LOG(SWEPMGS/BELEXCH*SWEEXCH) + XBELNOR*LOG(NORPMGS/BELEXCH*NOREXCH) + XBELFIN*LOG(FINPMGS/BELEXCH*FINEXCH) + XBELGBR*LOG(GBRPMGS/BELEXCH*GBREXCH) + XBELFRA*LOG(FRAPMGS/BELEXCH*FRAEXCH) + XBELITA*LOG(ITAPMGS/BELEXCH*ITAEXCH) + XBELDEU*LOG(DEUPMGS/BELEXCH*DEUEXCH) + XBELNLD*LOG(NLDPMGS/BELEXCH*NLDEXCH) + XBELESP*LOG(ESPPMGS/BELEXCH*ESPEXCH) + XBELYPN*LOG(YPNPMGS/BELEXCH*YPNEXCH) + XBELUSA*LOG(USAPMGS/BELEXCH*USAEXCH) + XBELPOL*LOG(POLPMGS/BELEXCH*POLEXCH) + XBELCZE*LOG(CZEPMGS/BELEXCH*CZEEXCH) + XBELAUS*LOG(AUSPMGS/BELEXCH*AUSEXCH) + XBELAUT*LOG(AUTPMGS/BELEXCH*AUTEXCH) + XBELCAN*LOG(CANPMGS/BELEXCH*CANEXCH) + XBELCHL*LOG(CHLPMGS/BELEXCH*CHLEXCH) + XBELEST*LOG(ESTPMGS/BELEXCH*ESTEXCH) + XBELGRC*LOG(GRCPMGS/BELEXCH*GRCEXCH) + XBELHUN*LOG(HUNPMGS/BELEXCH*HUNEXCH) + XBELISL*LOG(ISLPMGS/BELEXCH*ISLEXCH) + XBELIRL*LOG(IRLPMGS/BELEXCH*IRLEXCH) + XBELISR*LOG(ISRPMGS/BELEXCH*ISREXCH) + XBELKOR*LOG(KORPMGS/BELEXCH*KOREXCH) + XBELLUX*LOG(LUXPMGS/BELEXCH*LUXEXCH) + XBELMEX*LOG(MEXPMGS/BELEXCH*MEXEXCH) + XBELNZL*LOG(NZLPMGS/BELEXCH*NZLEXCH) + XBELPRT*LOG(PRTPMGS/BELEXCH*PRTEXCH) + XBELSVK*LOG(SVKPMGS/BELEXCH*SVKEXCH) + XBELSVN*LOG(SVNPMGS/BELEXCH*SVNEXCH) + XBELCHE*LOG(CHEPMGS/BELEXCH*CHEEXCH) + XBELTUR*LOG(TURPMGS/BELEXCH*TUREXCH) + XBELDAE*LOG(DAEPMGS/BELEXCH*DAEEXCH) + XBELOOP*LOG(OOPPMGS/BELEXCH*OOPEXCH) + XBELBRA*LOG(BRAPMGS/BELEXCH*BRAEXCH) + XBELRUS*LOG(RUSPMGS/BELEXCH*RUSEXCH) + XBELIND*LOG(INDPMGS/BELEXCH*INDEXCH) + XBELCHN*LOG(CHNPMGS/BELEXCH*CHNEXCH) + XBELIDN*LOG(IDNPMGS/BELEXCH*IDNEXCH) + XBELZAF*LOG(ZAFPMGS/BELEXCH*ZAFEXCH) + XBELRWD*LOG(RWDPMGS/BELEXCH*RWDEXCH) $ FRML _GJRD DLOG(BELPXGS) = 0.37767 * (BELPXGSU-BELPXGSU(-1)) + 0.62233 * DLOG(BELPXIN) $ () () THE GOVERNMENT SECTOR () () FRML GBELCGWV BELCGWV = BELEG*BBELCGWV $ FRML _GJ_D BELCGNV = BELCGNV(-1)*(BELCGWV/BELCGWV(-1))$ FRML IBELCGV BELCGV = BELCGWV + BELCGNV $ FRML IBELCGW BELCGW = BELCGWV*BELWRG/(BBELCGWV*1000) $ FRML IBELCG BELCG = BELCGW + BELCGNV*BELPCGN $ FRML IBELIG BELIG = BELIGV*BELPIG $ FRML GBELCFKG BELCFKG = BELTCFKG*BELCG $ FRML GBELSSRG BELSSRG = BELTSSRG*BELWSSS + JBELSSRG $ FRML GBELTY BELTY = BELTTY*BELYP + JBELTY $ FRML GBELTI BELTI = BELTTI*(BELCPV*BELPCP+BELIHV*BELPIH)/(1+BELTTI) +JBELTI $ FRML GBELTRRH BELTRRH = (.229+JBELTTRH)*BELUN*(BELWSSE(-1)/1000) +(.15661*BELPOPT+24.2126)*(BELWSSE(-1)/1000) +JBELTRRH $ FRML GBELYIO BELYIO = -((BELIRL+BELIRL(-1)+BELIRL(-2))/300) *(BELGNFL(-1))*(1-DYIO)+DYIO*ZBELYIO + JBELYIO $ FRML IBELNLG BELNLG = BELSSRG + BELTY + BELTI + BELYIO - BELCG - BELIG - BELIENTG - BELTRRH - BELTRO - BELKIG $ FRML IBELGNFL BELGNFL = BELGNFL(-1) -BELNLG + BBELGNFL $ () () PRODUCTION AND INCOMES () () FRML IBELGDP BELGDP = BELCPV*BELPCP + BELCG + BELIG + BELIBV*BELPIB+BELIENTG +BELIHV*BELPIH + BELISKV*BELPISK +BELXGSV*BELPXGS - BELMGSV*BELPMGS + BELDGDP $ FRML IBELGDPV BELGDPV = BELCPV+ BELCGV+ BELIGV+ BELIBV+ BELIHV+ BELISKV + BELXGSV- BELMGSV + BELDGDPV $ FRML IBELYF BELYF = BELGDP - BELTI $ FRML IBELYFB BELYFB = BELYF - BELCGW - BELCFKG $ FRML IBELYFBV BELYFBV = BELYFB/BELPYFB $ FRML IBELWSSS BELWSSS = (BELEB*BELWSSE + BELEG*BELWRG)/1000 $ FRML IBELYRP BELYRP = BELYF - BELWSSS - BELCFKG $ FRML GBELDP BELDP = BELTDP*(BELKBV*BELPIB) $ FRML IBELYIP BELYIP = BELYIE - BELYIO $ FRML GBELYP BELYP = BELWSSS - BELSSRG + BELYRP - BELDP + BELYIP + BELTRRH + JBELYP $ FRML IBELYDH BELYDH = BELYP - BELTY + JBELYDH $ FRML IBELYDRH BELYDRH = BELYDH/BELPCP $ () () CURRENT BALANCE () () FRML IBELX BELXGS = BELXGSV*BELPXGS $ FRML BELM BELMGS = BELMGSV*BELPMGS $ FRML _GJ_D BELYIE = (BELYIE(-1) +BELYIE(-1) *(2*((DEUEXCH/BELEXCH)/(DEUEXCH(-1)/BELEXCH(-1))-1) +((USAEXCH/BELEXCH)/(USAEXCH(-1)/BELEXCH(-1))-1))/3 +BELYIE(-1) *((2*((DEUEXCH/BELEXCH)/(DEUEXCH(-1)/BELEXCH(-1))) *((DEUIRS/DEUIRS(-3))**(1/3)-1) +((USAEXCH/BELEXCH)/(USAEXCH(-1)/BELEXCH(-1))) *((USAIRS/USAIRS(-3))**(1/3)-1))/3) +((2*((DEUEXCH/BELEXCH)/(DEUEXCH(-1)/BELEXCH(-1))) *.01*DEUIRS +((USAEXCH/BELEXCH)/(USAEXCH(-1)/BELEXCH(-1))) *.01*USAIRS)/3) *BELCB(-1))$ FRML IBELCB BELCB = BELXGS - BELMGS + BELYIE +BELCBR $ () () FINANCIAL SECTOR () () FRML GBELIRS BELIRS = eurirs + jbelirs$ FRML GBELIRL BELIRL = (1-DBELIRL)*100*(-1+EXP(.753*LOG(1+BELIRL(-1)/100) +.381*LOG(1+BELIRS/100)-.134*LOG(1+BELIRS(-1)/100) +.00218)) +BELDXIRL*(BELIRL(-1)+DEUIRL-DEUIRL(-1) +(((BELPCPN/BELPCPN(-1)) -(BELPCPN(-2)/BELPCPN(-3)))/2 -((DEUPCPN/DEUPCPN(-1)) -(DEUPCPN(-2)/DEUPCPN(-3)))/2)*100) +BELD1IRL*(BELIRL(-1)+DEUIRL-DEUIRL(-1))+JBELIRL $ () () FRML _GJ_D BELEXCH = BELEXCH(-1)*(DEUEXCH/DEUEXCH(-1)) $ FRML _GJ_D BELEXCH = BELEXCH(-1)*(EUREXC/EUREXC(-1)) $ () () MAIN ECONOMIC QVOTAS AND OTHER VARIABLES () () FRML IBELBNLG BELBNLG = (BELNLG/BELGDP)*100 $ FRML IBELBCB BELBCB = (BELCB/BELGDP)*100 $ FRML IBELBCP BELBCP = (BELCPV/BELYDRH)*100 $ FRML IBELBM BELBM = (BELMGSV/BELGDPV)*100 $ FRML IBELBIP BELBIP = (BELIPV/BELGDPV)*100 $ FRML IBELBIB BELBIB = (BELIBV/BELYFBV)*100 $ FRML IBELBW BELBW = (BELWSSS/BELYF)*100 $ FRML _DJ_ BELIPV = BELIBV + BELIHV $ FRML _DJ_ BELTDDV = BELGDPV - BELNGSV $ FRML IBELNGSV BELNGSV = BELXGSV - BELMGSV $ () () () ******************* () * NLD * () ******************* () () HOUSEHOLD DEMAND () () FRML _GJRD NLDCPV = (EXP(LOG(NLDCPV(-1)) +.592*(.75*LOG(NLDYDRH-.5*NLDYIP/NLDPCP) -.5*LOG(NLDYDRH(-1)-.5*NLDYIP(-1)/NLDPCP(-1)) -.25*LOG(NLDYDRH(-2)-.5*NLDYIP(-2)/NLDPCP(-2))) -.392*(LOG(NLDCPV(-1)/NLDYDRH(-1))) -.0136*(NLDIRL-NLDIRL(-3))/3 -.00078))$ FRML _GJRD NLDIHV = (EXP(.800*LOG(NLDIHV(-1)) +1.433*(LOG(NLDYFBV)-LOG(NLDYFBV(-2)))/2 -.0417*(.5*NLDIRL-.25*NLDIRL(-1)-.25*NLDIRL(-3)) +.6143))$ () () BUSINESS INVESTMENT () () FRML INLDGAP NLDGAP = LOG(NLDYFBV)-.66*LOG(NLDEB+NLDES)-.34*LOG(NLDKBV) -NLDGAPT*TID-NLDGAPK $ FRML GNLDUC NLDUC = NLDPIB*(NLDIRL+10) $ FRML _GJRD_ DLOG(NLDKBV) = 0.51932*DLOG(NLDKBV(-1)) + 0.10562*DLOG(NLDYFBV) + 0.10405*DLOG(NLDYFBV(-1)) + 0.02000*(LOG(NLDYFBV(-1)/NLDKBV(-1)) -0.66*LOG(NLDUC(-1)/NLDWSSE(-1))) + TNLDKBV + 0.80955$ FRML GNLDIBV NLDIBV = NLDKBV-NLDKBV(-1)+NLDAKBV*NLDKBV(-1) $ FRML _DJ_ NLDITV = NLDIHV + NLDIBV + NLDIGV $ () () EXPORT VOLUMES () FRML GNLDXGSDU NLDXGSDU = XNLDDNK*LOG(DNKMGSD) + XNLDSWE*LOG(SWEMGSD) + XNLDNOR*LOG(NORMGSD) + XNLDFIN*LOG(FINMGSD) + XNLDGBR*LOG(GBRMGSD) + XNLDFRA*LOG(FRAMGSD) + XNLDITA*LOG(ITAMGSD) + XNLDDEU*LOG(DEUMGSD) + XNLDBEL*LOG(BELMGSD) + XNLDESP*LOG(ESPMGSD) + XNLDYPN*LOG(YPNMGSD) + XNLDUSA*LOG(USAMGSD) + XNLDPOL*LOG(POLMGSD) + XNLDCZE*LOG(CZEMGSD) + XNLDAUS*LOG(AUSMGSD) + XNLDAUT*LOG(AUTMGSD) + XNLDCAN*LOG(CANMGSD) + XNLDCHL*LOG(CHLMGSD) + XNLDEST*LOG(ESTMGSD) + XNLDGRC*LOG(GRCMGSD) + XNLDHUN*LOG(HUNMGSD) + XNLDISL*LOG(ISLMGSD) + XNLDIRL*LOG(IRLMGSD) + XNLDISR*LOG(ISRMGSD) + XNLDKOR*LOG(KORMGSD) + XNLDLUX*LOG(LUXMGSD) + XNLDMEX*LOG(MEXMGSD) + XNLDNZL*LOG(NZLMGSD) + XNLDPRT*LOG(PRTMGSD) + XNLDSVK*LOG(SVKMGSD) + XNLDSVN*LOG(SVNMGSD) + XNLDCHE*LOG(CHEMGSD) + XNLDTUR*LOG(TURMGSD) + XNLDDAE*LOG(DAEMGSD) + XNLDOOP*LOG(OOPMGSD) + XNLDBRA*LOG(BRAMGSD) + XNLDRUS*LOG(RUSMGSD) + XNLDIND*LOG(INDMGSD) + XNLDCHN*LOG(CHNMGSD) + XNLDIDN*LOG(IDNMGSD) + XNLDZAF*LOG(ZAFMGSD) + XNLDRWD*LOG(RWDMGSD) $ FRML _GJRD DLOG(NLDXGSD) = (NLDXGSDU-NLDXGSDU(-1)) $ () FRML INLDXGSV NLDXGSV = NLDXGSD*USAEXCH/(NLDEXCH*NLDPXGS) $ () () IMPORT () () FRML _GJ_ NLDWMV = .300*NLDCPV + .170*NLDCGNV + .198*NLDIHV +.448*(NLDIBV+NLDISKV) + .248*NLDIGV +.294*NLDXGSV $ FRML _GJRD Dlog(NLDMGSV) = .3739*Dlog(NLDWMV) + 0.257*Dlog(NLDPYFB/NLDPMGS) - 0.1500*(Log(NLDMGSV(-1)/NLDWMV(-1))-1.140*Log(NLDPYFB(-1)/NLDPMGS(-1))-0.2499) + 0.03431 $ () FRML INLDMGSD NLDMGSD = NLDMGSV*NLDPMGS*NLDEXCH/USAEXCH $ () () LABOUR MARKET () () FRML _GJ_D NLDLF = NLDPOPT*((NLDLF(-1)/NLDPOPT(-1)) + (1-NLDDLF)*(.2427*DLOG(NLDET) + 0.0027)) $ () FRML _DJ_ NLDEBN = (1/0.66)*LOG(NLDYFBV)-((1-0.66)/0.66)*LOG(NLDKBV) $ FRML _DJ_ NLDEBW = LOG(NLDYFBV)+0.34*LOG(NLDUC/NLDWSSE) $ FRML _GJRD DLOG(NLDEP) = 0.54809*DLOG(NLDYFBV)+0.45191*DLOG(NLDYFBV(-1)) -0.16804*(LOG(NLDEP(-1))-NLDEBW(-1)) +0.54827 $ FRML _D__D NLDEB = NLDEP - NLDES $ FRML GNLDEE NLDEE = NLDEB + NLDEG $ FRML _DJ_ NLDET = NLDEE + NLDES $ FRML INLDUN NLDUN = NLDLF - NLDET $ FRML INLDUNR NLDUNR = (NLDUN/NLDLF)*100 $ () () WAGES () FRML GNLDWU NLDWU = (24.64*LOG(DEUWSSE)+ 10.66*LOG(GBRWSSE)+ 10.78*LOG(FRAWSSE)+ 13.14*LOG(BELWSSE)+ 4.09*LOG(USAWSSE))/63.31 $ FRML INLDEYFB NLDEYFB = (NLDYFBV/(NLDEB+NLDES))/BNLDEYFB $ FRML _GJRD DLOG(NLDWR) = .70125*(DLOG(NLDPYFB)) +.64895*(NLDWU-NLDWU(-1)) -.00714*(NLDUNR(-1)-.4*(NLDUNR(-2))) -.42803*LOG(NLDWSSE(-1)/(NLDPYFB(-1)*NLDEYFB(-1))) +1.46581 $ FRML GNLDWSSE NLDWSSE = NLDKWSSE*NLDWR + JNLDWSSE $ FRML GNLDWRG NLDWRG = NLDKWRG*NLDWR + JNLDWRG $ () () DOMESTIC PRICES () () FRML GNLDPCPN NLDPCPN = NLDPCPN(-1)*(.35*(NLDPMGS/NLDPMGS(-1))+ .65*(NLDPYFB/NLDPYFB(-1))) + JNLDPCPN $ FRML INLDPCP NLDPCP = (1+NLDTTI)*NLDPCPN $ FRML GNLDPCGN NLDPCGN = NLDPCGN(-1)*(.27*(NLDPMGS/NLDPMGS(-1))+ .73*(NLDPYFB/NLDPYFB(-1))) + JNLDPCGN $ FRML GNLDPIHN NLDPIHN = NLDPIHN(-1)*(.22*(NLDPMGS/NLDPMGS(-1))+ .78*(NLDPYFB/NLDPYFB(-1))) + JNLDPIHN $ FRML INLDPIH NLDPIH = (1+NLDTTI)*NLDPIHN $ FRML GNLDPIB NLDPIB = NLDPIB(-1)*(.47*(NLDPMGS/NLDPMGS(-1))+ .53*(NLDPYFB/NLDPYFB(-1))) + JNLDPIB $ FRML GNLDPIG NLDPIG = NLDPIG(-1)*(.27*(NLDPMGS/NLDPMGS(-1))+ .73*(NLDPYFB/NLDPYFB(-1))) + JNLDPIG $ FRML GNLDPISK NLDPISK = NLDPIB + JNLDPISK $ FRML GNLDULC NLDULC = ((NLDWSSE*(NLDEB+NLDES))/NLDYFBV)/BNLDULC $ FRML GNLDUCCB NLDUCCB = (NLDPIB*((NLDIRL+NLDIRL(-1)+NLDIRL(-2)+NLDIRL(-3) +NLDIRL(-4)+NLDIRL(-5)+NLDIRL(-6))/7+10) *NLDKBV/NLDYFBV)/BNLDUCCB $ FRML _GJRD DLOG(NLDPYFB) = .46536*(LOG(NLDULC)-LOG(NLDULC(-1))) +.07107*(LOG(NLDPMGS)-LOG(NLDPMGS(-1))) +.4000*(NLDGAP-NLDGAP(-1)) -.14529*(LOG(NLDPYFB(-1))-.66*LOG(NLDULC(-1)) -.34*LOG(NLDUCCB(-1))+0.07197) +.01766 $ () () IMPORT PRICES () FRML GNLDPMGSU NLDPMGSU = MNLDDNK*LOG(DNKPXGS/NLDEXCH*DNKEXCH) + MNLDSWE*LOG(SWEPXGS/NLDEXCH*SWEEXCH) + MNLDNOR*LOG(NORPXGS/NLDEXCH*NOREXCH) + MNLDFIN*LOG(FINPXGS/NLDEXCH*FINEXCH) + MNLDGBR*LOG(GBRPXGS/NLDEXCH*GBREXCH) + MNLDFRA*LOG(FRAPXGS/NLDEXCH*FRAEXCH) + MNLDITA*LOG(ITAPXGS/NLDEXCH*ITAEXCH) + MNLDDEU*LOG(DEUPXGS/NLDEXCH*DEUEXCH) + MNLDBEL*LOG(BELPXGS/NLDEXCH*BELEXCH) + MNLDESP*LOG(ESPPXGS/NLDEXCH*ESPEXCH) + MNLDYPN*LOG(YPNPXGS/NLDEXCH*YPNEXCH) + MNLDUSA*LOG(USAPXGS/NLDEXCH*USAEXCH) + MNLDPOL*LOG(POLPXGS/NLDEXCH*POLEXCH) + MNLDCZE*LOG(CZEPXGS/NLDEXCH*CZEEXCH) + MNLDAUS*LOG(AUSPXGS/NLDEXCH*AUSEXCH) + MNLDAUT*LOG(AUTPXGS/NLDEXCH*AUTEXCH) + MNLDCAN*LOG(CANPXGS/NLDEXCH*CANEXCH) + MNLDCHL*LOG(CHLPXGS/NLDEXCH*CHLEXCH) + MNLDEST*LOG(ESTPXGS/NLDEXCH*ESTEXCH) + MNLDGRC*LOG(GRCPXGS/NLDEXCH*GRCEXCH) + MNLDHUN*LOG(HUNPXGS/NLDEXCH*HUNEXCH) + MNLDISL*LOG(ISLPXGS/NLDEXCH*ISLEXCH) + MNLDIRL*LOG(IRLPXGS/NLDEXCH*IRLEXCH) + MNLDISR*LOG(ISRPXGS/NLDEXCH*ISREXCH) + MNLDKOR*LOG(KORPXGS/NLDEXCH*KOREXCH) + MNLDLUX*LOG(LUXPXGS/NLDEXCH*LUXEXCH) + MNLDMEX*LOG(MEXPXGS/NLDEXCH*MEXEXCH) + MNLDNZL*LOG(NZLPXGS/NLDEXCH*NZLEXCH) + MNLDPRT*LOG(PRTPXGS/NLDEXCH*PRTEXCH) + MNLDSVK*LOG(SVKPXGS/NLDEXCH*SVKEXCH) + MNLDSVN*LOG(SVNPXGS/NLDEXCH*SVNEXCH) + MNLDCHE*LOG(CHEPXGS/NLDEXCH*CHEEXCH) + MNLDTUR*LOG(TURPXGS/NLDEXCH*TUREXCH) + MNLDDAE*LOG(DAEPXGS/NLDEXCH*DAEEXCH) + MNLDOOP*LOG(OOPPXGS/NLDEXCH*OOPEXCH) + MNLDBRA*LOG(BRAPXGS/NLDEXCH*BRAEXCH) + MNLDRUS*LOG(RUSPXGS/NLDEXCH*RUSEXCH) + MNLDIND*LOG(INDPXGS/NLDEXCH*INDEXCH) + MNLDCHN*LOG(CHNPXGS/NLDEXCH*CHNEXCH) + MNLDIDN*LOG(IDNPXGS/NLDEXCH*IDNEXCH) + MNLDZAF*LOG(ZAFPXGS/NLDEXCH*ZAFEXCH) + MNLDRWD*LOG(RWDPXGS/NLDEXCH*RWDEXCH) $ FRML _GJRD_ DLOG(NLDPMGS) = (NLDPMGSU-NLDPMGSU(-1)) $ () () EXPORT PRICES () () FRML _GJR DLOG(NLDPXIN) = .37*DLOG(NLDPMGS) + .63*DLOG(NLDPYFB) $ FRML GNLDPXGSU NLDPXGSU = XNLDDNK*LOG(DNKPMGS/NLDEXCH*DNKEXCH) + XNLDSWE*LOG(SWEPMGS/NLDEXCH*SWEEXCH) + XNLDNOR*LOG(NORPMGS/NLDEXCH*NOREXCH) + XNLDFIN*LOG(FINPMGS/NLDEXCH*FINEXCH) + XNLDGBR*LOG(GBRPMGS/NLDEXCH*GBREXCH) + XNLDFRA*LOG(FRAPMGS/NLDEXCH*FRAEXCH) + XNLDITA*LOG(ITAPMGS/NLDEXCH*ITAEXCH) + XNLDDEU*LOG(DEUPMGS/NLDEXCH*DEUEXCH) + XNLDBEL*LOG(BELPMGS/NLDEXCH*BELEXCH) + XNLDESP*LOG(ESPPMGS/NLDEXCH*ESPEXCH) + XNLDYPN*LOG(YPNPMGS/NLDEXCH*YPNEXCH) + XNLDUSA*LOG(USAPMGS/NLDEXCH*USAEXCH) + XNLDPOL*LOG(POLPMGS/NLDEXCH*POLEXCH) + XNLDCZE*LOG(CZEPMGS/NLDEXCH*CZEEXCH) + XNLDAUS*LOG(AUSPMGS/NLDEXCH*AUSEXCH) + XNLDAUT*LOG(AUTPMGS/NLDEXCH*AUTEXCH) + XNLDCAN*LOG(CANPMGS/NLDEXCH*CANEXCH) + XNLDCHL*LOG(CHLPMGS/NLDEXCH*CHLEXCH) + XNLDEST*LOG(ESTPMGS/NLDEXCH*ESTEXCH) + XNLDGRC*LOG(GRCPMGS/NLDEXCH*GRCEXCH) + XNLDHUN*LOG(HUNPMGS/NLDEXCH*HUNEXCH) + XNLDISL*LOG(ISLPMGS/NLDEXCH*ISLEXCH) + XNLDIRL*LOG(IRLPMGS/NLDEXCH*IRLEXCH) + XNLDISR*LOG(ISRPMGS/NLDEXCH*ISREXCH) + XNLDKOR*LOG(KORPMGS/NLDEXCH*KOREXCH) + XNLDLUX*LOG(LUXPMGS/NLDEXCH*LUXEXCH) + XNLDMEX*LOG(MEXPMGS/NLDEXCH*MEXEXCH) + XNLDNZL*LOG(NZLPMGS/NLDEXCH*NZLEXCH) + XNLDPRT*LOG(PRTPMGS/NLDEXCH*PRTEXCH) + XNLDSVK*LOG(SVKPMGS/NLDEXCH*SVKEXCH) + XNLDSVN*LOG(SVNPMGS/NLDEXCH*SVNEXCH) + XNLDCHE*LOG(CHEPMGS/NLDEXCH*CHEEXCH) + XNLDTUR*LOG(TURPMGS/NLDEXCH*TUREXCH) + XNLDDAE*LOG(DAEPMGS/NLDEXCH*DAEEXCH) + XNLDOOP*LOG(OOPPMGS/NLDEXCH*OOPEXCH) + XNLDBRA*LOG(BRAPMGS/NLDEXCH*BRAEXCH) + XNLDRUS*LOG(RUSPMGS/NLDEXCH*RUSEXCH) + XNLDIND*LOG(INDPMGS/NLDEXCH*INDEXCH) + XNLDCHN*LOG(CHNPMGS/NLDEXCH*CHNEXCH) + XNLDIDN*LOG(IDNPMGS/NLDEXCH*IDNEXCH) + XNLDZAF*LOG(ZAFPMGS/NLDEXCH*ZAFEXCH) + XNLDRWD*LOG(RWDPMGS/NLDEXCH*RWDEXCH) $ FRML _GJRD DLOG(NLDPXGS) = 0.33671 * (NLDPXGSU-NLDPXGSU(-1)) + 0.66329 * DLOG(NLDPXIN) $ () () () THE GOVERNMENT SECTOR () () FRML GNLDCGWV NLDCGWV = NLDEG*BNLDCGWV $ FRML _GJ_D NLDCGNV = NLDCGNV(-1)*(NLDCGWV/NLDCGWV(-1))$ FRML INLDCGV NLDCGV = NLDCGWV + NLDCGNV $ FRML INLDCGW NLDCGW = NLDCGWV*NLDWRG/(BNLDCGWV*1000) $ FRML INLDCG NLDCG = NLDCGW + NLDCGNV*NLDPCGN $ FRML INLDIG NLDIG = NLDIGV*NLDPIG $ FRML GNLDCFKG NLDCFKG = NLDTCFKG*NLDCG $ FRML GNLDSSRG NLDSSRG = NLDTSSRG*NLDWSSS + JNLDSSRG $ FRML GNLDTY NLDTY = NLDTTY*NLDYP + JNLDTY $ FRML GNLDTI NLDTI = NLDTTI*(NLDCPV*NLDPCP+NLDIHV*NLDPIH)/(1+NLDTTI) +JNLDTI $ FRML GNLDTRRH NLDTRRH = (.425+JNLDTTRH)*NLDUN*(NLDWSSE(-1)/1000) +(.38867*NLDPOPT-1722.52)*(NLDWSSE(-1)/1000) +JNLDTRRH $ FRML GNLDYIO NLDYIO = -((NLDIRL+NLDIRL(-1)+NLDIRL(-2))/300) *(NLDGNFL(-1))*(1-DYIO)+DYIO*ZNLDYIO + JNLDYIO $ FRML INLDNLG NLDNLG = NLDSSRG + NLDTY + NLDTI + NLDYIO - NLDCG - NLDIG - NLDIENTG - NLDTRRH - NLDTRO - NLDKIG $ FRML INLDGNFL NLDGNFL = NLDGNFL(-1) -NLDNLG + BNLDGNFL $ () () PRODUCTION AND INCOMES () () FRML INLDGDP NLDGDP = NLDCPV*NLDPCP + NLDCG + NLDIG + NLDIBV*NLDPIB+NLDIENT +NLDIHV*NLDPIH + NLDISKV*NLDPISK +NLDXGSV*NLDPXGS - NLDMGSV*NLDPMGS + NLDDGDP $ FRML INLDGDPV NLDGDPV = NLDCPV+ NLDCGV+ NLDIGV+ NLDIBV+ NLDIHV+ NLDISKV + NLDXGSV- NLDMGSV + NLDDGDPV $ FRML INLDYF NLDYF = NLDGDP - NLDTI $ FRML INLDYFB NLDYFB = NLDYF - NLDCGW - NLDCFKG $ FRML INLDYFBV NLDYFBV = NLDYFB/NLDPYFB $ FRML INLDWSSS NLDWSSS = (NLDEB*NLDWSSE + NLDEG*NLDWRG)/1000 $ FRML INLDYRP NLDYRP = NLDYF - NLDWSSS - NLDCFKG $ FRML GNLDDP NLDDP = NLDTDP*(NLDKBV*NLDPIB) $ FRML INLDYIP NLDYIP = NLDYIE - NLDYIO $ FRML GNLDYP NLDYP = NLDWSSS - NLDSSRG + NLDYRP - NLDDP + NLDYIP + NLDTRRH + JNLDYP $ FRML INLDYDH NLDYDH = NLDYP - NLDTY + JNLDYDH $ FRML INLDYDRH NLDYDRH = NLDYDH/NLDPCP $ () () CURRENT BALANCE () () FRML INLDX NLDXGS = NLDXGSV*NLDPXGS $ FRML INLDM NLDMGS = NLDMGSV*NLDPMGS $ FRML _GJ_D NLDYIE = (NLDYIE(-1) +NLDYIE(-1)* (2*((DEUEXCH/NLDEXCH)/(DEUEXCH(-1)/NLDEXCH(-1))-1) +((USAEXCH/NLDEXCH)/(USAEXCH(-1)/NLDEXCH(-1))-1))/3 +NLDYIE(-1)* ((2*((DEUEXCH/NLDEXCH)/(DEUEXCH(-1)/NLDEXCH(-1))) *((DEUIRS/DEUIRS(-3))**(1/3)-1) +((USAEXCH/NLDEXCH)/(USAEXCH(-1)/NLDEXCH(-1))) *((USAIRS/USAIRS(-3))**(1/3)-1))/3) +((2*((DEUEXCH/NLDEXCH)/(DEUEXCH(-1)/NLDEXCH(-1))) *.01*DEUIRS +((USAEXCH/NLDEXCH)/(USAEXCH(-1)/NLDEXCH(-1))) *.01*USAIRS)/3) *NLDCB(-1))$ FRML INLDCB NLDCB = NLDXGS - NLDMGS + NLDYIE +NLDCBR $ () () FINANCIAL SECTOR () () FRML GNLDIRS NLDIRS = eurirs + jnldirs$ FRML GNLDIRL NLDIRL = (1-DNLDIRL)*100*(-1+EXP(.708*LOG(1+NLDIRL(-1)/100) +.378*LOG(1+NLDIRS/100)-.085*LOG(1+NLDIRS(-1)/100) +.00385)) +NLDDXIRL*(NLDIRL(-1)+DEUIRL-DEUIRL(-1) +(((NLDPCPN/NLDPCPN(-1)) -(NLDPCPN(-2)/NLDPCPN(-3)))/2 -((DEUPCPN/DEUPCPN(-1)) -(DEUPCPN(-2)/DEUPCPN(-3)))/2)*100) +NLDD1IRL*(NLDIRL(-1)+DEUIRL-DEUIRL(-1))+JNLDIRL $ () FRML _GJ_D NLDEXCH = NLDEXCH(-1)*(DEUEXCH/DEUEXCH(-1)) $ FRML _GJ_D NLDEXCH = NLDEXCH(-1)*(EUREXC/EUREXC(-1)) $ () () MAIN ECONOMIC QVOTAS AND OTHER VARIABLES () () FRML INLDBNLG NLDBNLG = (NLDNLG/NLDGDP)*100 $ FRML INLDBCB NLDBCB = (NLDCB/NLDGDP)*100 $ FRML INLDBCP NLDBCP = (NLDCPV/NLDYDRH)*100 $ FRML INLDBM NLDBM = (NLDMGSV/NLDGDPV)*100 $ FRML INLDBIP NLDBIP = (NLDIPV/NLDGDPV)*100 $ FRML INLDBIB NLDBIB = (NLDIBV/NLDYFBV)*100 $ FRML INLDBW NLDBW = (NLDWSSS/NLDYF)*100 $ FRML _DJ_ NLDIPV = NLDIBV + NLDIHV $ FRML _DJ_ NLDTDDV = NLDGDPV - NLDNGSV - NLDDGDPV $ FRML INLDNGSV NLDNGSV = NLDXGSV - NLDMGSV $ () () () ********************* () * GBR * () ********************* () () HOUSEHOLD DEMAND () () FRML _GJRD GBRCPV = (EXP(LOG(GBRCPV(-1)) +.734*(.9*LOG((GBRYDH-.5*GBRYIP)/GBRPCP) -.8*LOG((GBRYDH(-1)-.5*GBRYIP(-1))/GBRPCP(-1)) -.1*LOG((GBRYDH(-2)-.5*GBRYIP(-2))/GBRPCP(-2))) -.10*(LOG(GBRCPV(-1)/GBRYDRH(-1))) -.00713*(GBRIRL-GBRIRL(-3))/3 -.00143))$ FRML _GJRD GBRIHV = (EXP(.741*LOG(GBRIHV(-1)) +1.606*(LOG(GBRYDRH-.5*GBRYIP/GBRPCP) - LOG(GBRYDRH(-2)-.5*GBRYIP(-2)/GBRPCP(-2)))/2 -.0200*(GBRIRL-GBRIRL(-1)) +.661))$ () () BUSINESS INVESTMENT () () FRML IGBRGAP GBRGAP = LOG(GBRYFBV)-.70*LOG(GBREB+GBRES)-.30*LOG(GBRKBV) -GBRGAPT*TID-GBRGAPK $ FRML GGBRUC GBRUC = GBRPIB*(GBRIRL+15) $ FRML _GJRD_ DLOG(GBRKBV) = 0.85155*DLOG(GBRKBV(-1)) + 0.07372*DLOG(GBRYFBV) + 0.06129*DLOG(GBRYFBV(-1)) + 0.01115*(LOG(GBRYFBV(-1)/GBRKBV(-1)) -0.70*LOG(GBRUC(-1)/GBRWSSE(-1))) + TGBRKBV + 0.01039*D1998 + 0.84439 $ FRML GGBRIBV GBRIBV = GBRKBV-GBRKBV(-1)+GBRAKBV*GBRKBV(-1) $ FRML _DJ_ GBRITV = GBRIHV + GBRIBV + GBRIGV $ () () EXPORT VOLUMES () () FRML GGBRXGSDU GBRXGSDU = XGBRDNK*LOG(DNKMGSD) + XGBRSWE*LOG(SWEMGSD) + XGBRNOR*LOG(NORMGSD) + XGBRFIN*LOG(FINMGSD) + XGBRNLD*LOG(NLDMGSD) + XGBRFRA*LOG(FRAMGSD) + XGBRITA*LOG(ITAMGSD) + XGBRDEU*LOG(DEUMGSD) + XGBRBEL*LOG(BELMGSD) + XGBRESP*LOG(ESPMGSD) + XGBRYPN*LOG(YPNMGSD) + XGBRUSA*LOG(USAMGSD) + XGBRPOL*LOG(POLMGSD) + XGBRCZE*LOG(CZEMGSD) + XGBRAUS*LOG(AUSMGSD) + XGBRAUT*LOG(AUTMGSD) + XGBRCAN*LOG(CANMGSD) + XGBRCHL*LOG(CHLMGSD) + XGBREST*LOG(ESTMGSD) + XGBRGRC*LOG(GRCMGSD) + XGBRHUN*LOG(HUNMGSD) + XGBRISL*LOG(ISLMGSD) + XGBRIRL*LOG(IRLMGSD) + XGBRISR*LOG(ISRMGSD) + XGBRKOR*LOG(KORMGSD) + XGBRLUX*LOG(LUXMGSD) + XGBRMEX*LOG(MEXMGSD) + XGBRNZL*LOG(NZLMGSD) + XGBRPRT*LOG(PRTMGSD) + XGBRSVK*LOG(SVKMGSD) + XGBRSVN*LOG(SVNMGSD) + XGBRCHE*LOG(CHEMGSD) + XGBRTUR*LOG(TURMGSD) + XGBRDAE*LOG(DAEMGSD) + XGBROOP*LOG(OOPMGSD) + XGBRBRA*LOG(BRAMGSD) + XGBRRUS*LOG(RUSMGSD) + XGBRIND*LOG(INDMGSD) + XGBRCHN*LOG(CHNMGSD) + XGBRIDN*LOG(IDNMGSD) + XGBRZAF*LOG(ZAFMGSD) + XGBRRWD*LOG(RWDMGSD) $ FRML _GJRD DLOG(GBRXGSD)= (GBRXGSDU-GBRXGSDU(-1)) $ FRML IGBRXGSV GBRXGSV = GBRXGSD*USAEXCH/(GBREXCH*GBRPXGS) $ () () IMPORT () FRML _GJ_ GBRWMV = .180*GBRCPV + .215*GBRCGNV + .222*GBRIHV +.222*(GBRIBV+GBRISKV) + .222*GBRIGV +.232*GBRXGSV $ () FRML _GJRD Dlog(GBRMGSV) = 1.50008*Dlog(GBRWMV) - 0.05*(Log(GBRMGSV(-1)/GBRWMV(-1))-0.84514*Log(GBRPYFB(-1)/GBRPMGS(-1))-0.16720) - 0.00284 $ () FRML IGBRMGSD GBRMGSD = GBRMGSV*GBRPMGS*GBREXCH/USAEXCH $ () () LABOUR MARKET () () FRML _GJ_D GBRLF = GBRPOPT*((GBRLF(-1)/GBRPOPT(-1)) + (1-GBRDLF)*(.228*DLOG(GBRET) + .00024)) $ () FRML _DJ_ GBREBN = (1/0.70)*LOG(GBRYFBV)-((1-0.70)/0.70)*LOG(GBRKBV) $ FRML _DJ_ GBREBW = LOG(GBRYFBV)+0.30*LOG(GBRUC/GBRWSSE) $ FRML _GJRD DLOG(GBREP) = 0.37982*DLOG(GBRYFBV)+0.42018*DLOG(GBRYFBV(-1)) -0.02713*(LOG(GBREP(-1))-GBREBW(-1)) +0.07454 $ FRML _D__D GBREB = GBREP - GBRES $ FRML GGBREE GBREE = GBREB + GBREG $ FRML _DJ_ GBRET = GBREE + GBRES $ FRML IGBRUN GBRUN = GBRLF - GBRET $ FRML IGBRUNR GBRUNR = (GBRUN/GBRLF)*100 $ () () WAGES () FRML GGBRWU GBRWU = (12.93*LOG(DEUWSSE)+ 8.90*LOG(FRAWSSE)+ 5.64*LOG(BELWSSE)+ 7.57*LOG(NLDWSSE)+ 11.80*LOG(USAWSSE))/46.84 $ FRML IGBREYFB GBREYFB = (GBRYFBV/(GBREB+GBRES))/BGBREYFB $ FRML _GJRD DLOG(GBRWR) = .98046*(DLOG(GBRPYFB)) -.0033*(GBRUNR(-1)-.8*((GBRUNR(-2)+GBRUNR(-3))/2)) +.47479*DLOG(GBREYFB) -.38720*LOG(GBRWSSE(-1)/(GBRPYFB(-1)*GBREYFB(-1))) +1.15858 $ FRML GGBRWSSE GBRWSSE = GBRKWSSE*GBRWR + JGBRWSSE $ FRML GGBRWRG GBRWRG = GBRKWRG*GBRWR + JGBRWRG $ () () DOMESTIC PRICES () () FRML GGBRPCPN GBRPCPN = GBRPCPN(-1)*(.19*(GBRPMGS/GBRPMGS(-1))+ .81*(GBRPYFB/GBRPYFB(-1))) + JGBRPCPN $ FRML IGBRPCP GBRPCP = (1+GBRTTI)*GBRPCPN $ FRML GGBRPCGN GBRPCGN = GBRPCGN(-1)*(.27*(GBRPMGS/GBRPMGS(-1))+ .73*(GBRPYFB/GBRPYFB(-1))) + JGBRPCGN $ FRML GGBRPIB GBRPIB = GBRPIB(-1)*(.22*(GBRPMGS/GBRPMGS(-1))+ .78*(GBRPYFB/GBRPYFB(-1))) + JGBRPIB $ FRML GGBRPIHN GBRPIHN = GBRPIHN(-1)*(GBRPIB/GBRPIB(-1)) + JGBRPIHN $ FRML IGBRPIH GBRPIH = (1+GBRTTI)*GBRPIHN $ FRML GGBRPIG GBRPIG = GBRPIG(-1)*(GBRPIB/GBRPIB(-1)) + JGBRPIG $ FRML GGBRPISK GBRPISK = GBRPIB + JGBRPISK $ FRML GGBRULCB GBRULC = ((GBRWSSE*(GBREB+GBRES))/GBRYFBV)/BGBRULC $ FRML GGBRUCCB GBRUCCB = (GBRPIB*((GBRIRL+GBRIRL(-1)+GBRIRL(-2)+GBRIRL(-3) +GBRIRL(-4)+GBRIRL(-5)+GBRIRL(-6))/7+15) *GBRKBV/GBRYFBV)/BGBRUCCB $ FRML _GJRD DLOG(GBRPYFB) = .79480*(LOG(GBRULC)-LOG(GBRULC(-1))) +.37898*(GBRGAP-GBRGAP(-1)) -.08233*(LOG(GBRPYFB(-1))-.70*LOG(GBRULC(-1)) -.30*LOG(GBRUCCB(-1))+0.07910) +.01280 $ () () IMPORT PRICES () FRML GGBRPMGSU GBRPMGSU = MGBRDNK*LOG(DNKPXGS/GBREXCH*DNKEXCH) + MGBRSWE*LOG(SWEPXGS/GBREXCH*SWEEXCH) + MGBRNOR*LOG(NORPXGS/GBREXCH*NOREXCH) + MGBRFIN*LOG(FINPXGS/GBREXCH*FINEXCH) + MGBRNLD*LOG(NLDPXGS/GBREXCH*NLDEXCH) + MGBRFRA*LOG(FRAPXGS/GBREXCH*FRAEXCH) + MGBRITA*LOG(ITAPXGS/GBREXCH*ITAEXCH) + MGBRDEU*LOG(DEUPXGS/GBREXCH*DEUEXCH) + MGBRBEL*LOG(BELPXGS/GBREXCH*BELEXCH) + MGBRESP*LOG(ESPPXGS/GBREXCH*ESPEXCH) + MGBRYPN*LOG(YPNPXGS/GBREXCH*YPNEXCH) + MGBRUSA*LOG(USAPXGS/GBREXCH*USAEXCH) + MGBRPOL*LOG(POLPXGS/GBREXCH*POLEXCH) + MGBRCZE*LOG(CZEPXGS/GBREXCH*CZEEXCH) + MGBRAUS*LOG(AUSPXGS/GBREXCH*AUSEXCH) + MGBRAUT*LOG(AUTPXGS/GBREXCH*AUTEXCH) + MGBRCAN*LOG(CANPXGS/GBREXCH*CANEXCH) + MGBRCHL*LOG(CHLPXGS/GBREXCH*CHLEXCH) + MGBREST*LOG(ESTPXGS/GBREXCH*ESTEXCH) + MGBRGRC*LOG(GRCPXGS/GBREXCH*GRCEXCH) + MGBRHUN*LOG(HUNPXGS/GBREXCH*HUNEXCH) + MGBRISL*LOG(ISLPXGS/GBREXCH*ISLEXCH) + MGBRIRL*LOG(IRLPXGS/GBREXCH*IRLEXCH) + MGBRISR*LOG(ISRPXGS/GBREXCH*ISREXCH) + MGBRKOR*LOG(KORPXGS/GBREXCH*KOREXCH) + MGBRLUX*LOG(LUXPXGS/GBREXCH*LUXEXCH) + MGBRMEX*LOG(MEXPXGS/GBREXCH*MEXEXCH) + MGBRNZL*LOG(NZLPXGS/GBREXCH*NZLEXCH) + MGBRPRT*LOG(PRTPXGS/GBREXCH*PRTEXCH) + MGBRSVK*LOG(SVKPXGS/GBREXCH*SVKEXCH) + MGBRSVN*LOG(SVNPXGS/GBREXCH*SVNEXCH) + MGBRCHE*LOG(CHEPXGS/GBREXCH*CHEEXCH) + MGBRTUR*LOG(TURPXGS/GBREXCH*TUREXCH) + MGBRDAE*LOG(DAEPXGS/GBREXCH*DAEEXCH) + MGBROOP*LOG(OOPPXGS/GBREXCH*OOPEXCH) + MGBRBRA*LOG(BRAPXGS/GBREXCH*BRAEXCH) + MGBRRUS*LOG(RUSPXGS/GBREXCH*RUSEXCH) + MGBRIND*LOG(INDPXGS/GBREXCH*INDEXCH) + MGBRCHN*LOG(CHNPXGS/GBREXCH*CHNEXCH) + MGBRIDN*LOG(IDNPXGS/GBREXCH*IDNEXCH) + MGBRZAF*LOG(ZAFPXGS/GBREXCH*ZAFEXCH) + MGBRRWD*LOG(RWDPXGS/GBREXCH*RWDEXCH) $ FRML _GJRD DLOG(GBRPMGS) = (GBRPMGSU-GBRPMGSU(-1)) $ () EXPORT PRICES () () FRML _GJR DLOG(GBRPXIN) = .27*DLOG(GBRPMGS)+.73*DLOG(GBRPYFB) $ FRML GGBRPXGSU GBRPXGSU = XGBRDNK*LOG(DNKPMGS/GBREXCH*DNKEXCH) + XGBRSWE*LOG(SWEPMGS/GBREXCH*SWEEXCH) + XGBRNOR*LOG(NORPMGS/GBREXCH*NOREXCH) + XGBRFIN*LOG(FINPMGS/GBREXCH*FINEXCH) + XGBRNLD*LOG(NLDPMGS/GBREXCH*NLDEXCH) + XGBRFRA*LOG(FRAPMGS/GBREXCH*FRAEXCH) + XGBRITA*LOG(ITAPMGS/GBREXCH*ITAEXCH) + XGBRDEU*LOG(DEUPMGS/GBREXCH*DEUEXCH) + XGBRBEL*LOG(BELPMGS/GBREXCH*BELEXCH) + XGBRESP*LOG(ESPPMGS/GBREXCH*ESPEXCH) + XGBRYPN*LOG(YPNPMGS/GBREXCH*YPNEXCH) + XGBRUSA*LOG(USAPMGS/GBREXCH*USAEXCH) + XGBRPOL*LOG(POLPMGS/GBREXCH*POLEXCH) + XGBRCZE*LOG(CZEPMGS/GBREXCH*CZEEXCH) + XGBRAUS*LOG(AUSPMGS/GBREXCH*AUSEXCH) + XGBRAUT*LOG(AUTPMGS/GBREXCH*AUTEXCH) + XGBRCAN*LOG(CANPMGS/GBREXCH*CANEXCH) + XGBRCHL*LOG(CHLPMGS/GBREXCH*CHLEXCH) + XGBREST*LOG(ESTPMGS/GBREXCH*ESTEXCH) + XGBRGRC*LOG(GRCPMGS/GBREXCH*GRCEXCH) + XGBRHUN*LOG(HUNPMGS/GBREXCH*HUNEXCH) + XGBRISL*LOG(ISLPMGS/GBREXCH*ISLEXCH) + XGBRIRL*LOG(IRLPMGS/GBREXCH*IRLEXCH) + XGBRISR*LOG(ISRPMGS/GBREXCH*ISREXCH) + XGBRKOR*LOG(KORPMGS/GBREXCH*KOREXCH) + XGBRLUX*LOG(LUXPMGS/GBREXCH*LUXEXCH) + XGBRMEX*LOG(MEXPMGS/GBREXCH*MEXEXCH) + XGBRNZL*LOG(NZLPMGS/GBREXCH*NZLEXCH) + XGBRPRT*LOG(PRTPMGS/GBREXCH*PRTEXCH) + XGBRSVK*LOG(SVKPMGS/GBREXCH*SVKEXCH) + XGBRSVN*LOG(SVNPMGS/GBREXCH*SVNEXCH) + XGBRCHE*LOG(CHEPMGS/GBREXCH*CHEEXCH) + XGBRTUR*LOG(TURPMGS/GBREXCH*TUREXCH) + XGBRDAE*LOG(DAEPMGS/GBREXCH*DAEEXCH) + XGBROOP*LOG(OOPPMGS/GBREXCH*OOPEXCH) + XGBRBRA*LOG(BRAPMGS/GBREXCH*BRAEXCH) + XGBRRUS*LOG(RUSPMGS/GBREXCH*RUSEXCH) + XGBRIND*LOG(INDPMGS/GBREXCH*INDEXCH) + XGBRCHN*LOG(CHNPMGS/GBREXCH*CHNEXCH) + XGBRIDN*LOG(IDNPMGS/GBREXCH*IDNEXCH) + XGBRZAF*LOG(ZAFPMGS/GBREXCH*ZAFEXCH) + XGBRRWD*LOG(RWDPMGS/GBREXCH*RWDEXCH) $ FRML _GJRD_ DLOG(GBRPXGS) = 0.38215 * (GBRPXGSU-GBRPXGSU(-1)) + 0.61785 * DLOG(GBRPXIN) $ () () THE GOVERNMENT SECTOR () () FRML GGBRCGWV GBRCGWV = GBREG*BGBRCGWV $ FRML _GJ_D GBRCGNV = GBRCGNV(-1)*(GBRCGWV/GBRCGWV(-1))$ FRML IGBRCGV GBRCGV = GBRCGWV + GBRCGNV $ FRML IGBRCGW GBRCGW = GBRCGWV*GBRWRG/(BGBRCGWV*1000) $ FRML IGBRCG GBRCG = GBRCGW + GBRCGNV*GBRPCGN $ FRML IGBRIG GBRIG = GBRIGV*GBRPIG $ FRML GGBRCFKG GBRCFKG = GBRTCFKG*GBRCG $ FRML GGBRSSRG GBRSSRG = GBRTSSRG*GBRWSSS + JGBRSSRG $ FRML GGBRTY GBRTY = GBRTTY*GBRYP + JGBRTY $ FRML GGBRTI GBRTI = GBRTTI*(GBRCPV*GBRPCP+GBRIHV*GBRPIH)/(1+GBRTTI) +JGBRTI $ FRML GGBRTRRH GBRTRRH = (.154+JGBRTTRH)*GBRUN*(GBRWSSE(-1)/1000) +(.89980*GBRPOPT-27557.7)*(GBRWSSE(-1)/1000) +JGBRTRRH $ FRML GGBRYIO GBRYIO = -((GBRIRL+GBRIRL(-1)+GBRIRL(-2))/300) *(GBRGNFL(-1))*(1-DYIO)+DYIO*ZGBRYIO + JGBRYIO $ FRML IGBRNLG GBRNLG = GBRSSRG + GBRTY + GBRTI + GBRYIO - GBRCG - GBRIG - GBRIENTG - GBRTRRH - GBRTRO - GBRKIG $ FRML IGBRGNFL GBRGNFL = GBRGNFL(-1) -GBRNLG + BGBRGNFL $ () () PRODUCTION AND INCOMES () () FRML IGBRGDP GBRGDP = GBRCPV*GBRPCP + GBRCG + GBRIG + GBRIENTG +GBRIBV*GBRPIB + GBRIHV*GBRPIH + GBRISKV*GBRPISK +GBRXGSV*GBRPXGS - GBRMGSV*GBRPMGS + GBRDGDP $ FRML IGBRGDPV GBRGDPV = GBRCPV+ GBRCGV+ GBRIGV+ GBRIBV+ GBRIHV+ GBRISKV + GBRXGSV- GBRMGSV +GBRDGDPV $ FRML IGBRYF GBRYF = GBRGDP - GBRTI $ FRML IGBRYFB GBRYFB = GBRYF - GBRCGW - GBRCFKG $ FRML IGBRYFBV GBRYFBV = GBRYFB/GBRPYFB $ FRML IGBRWSSS GBRWSSS = (GBREB*GBRWSSE + GBREG*GBRWRG)/1000 $ FRML IGBRYRP GBRYRP = GBRYF - GBRWSSS - GBRCFKG $ FRML GGBRDP GBRDP = GBRTDP*(GBRKBV*GBRPIB) $ FRML IGBRYIP GBRYIP = GBRYIE - GBRYIO $ FRML GGBRYP GBRYP = GBRWSSS - GBRSSRG + GBRYRP - GBRDP + GBRYIP + GBRTRRH + JGBRYP $ FRML IGBRYDH GBRYDH = GBRYP - GBRTY + JGBRYDH $ FRML IGBRYDRH GBRYDRH = GBRYDH/GBRPCP $ () () CURRENT BALANCE () () FRML IGBRX GBRXGS = GBRXGSV*GBRPXGS $ FRML IGBRM GBRMGS = GBRMGSV*GBRPMGS $ FRML _GJ_D GBRYIE = (GBRYIE(-1) +GBRYIE(-1)*(2*((DEUEXCH/GBREXCH) /(DEUEXCH(-1)/GBREXCH(-1))-1) +((USAEXCH/GBREXCH)/(USAEXCH(-1)/GBREXCH(-1))-1))/3 +GBRYIE(-1)*((2*((DEUEXCH/GBREXCH) /(DEUEXCH(-1)/GBREXCH(-1))) *((DEUIRS/DEUIRS(-3))**(1/3)-1) +((USAEXCH/GBREXCH)/(USAEXCH(-1)/GBREXCH(-1))) *((USAIRS/USAIRS(-3))**(1/3)-1))/3) +((2*((DEUEXCH/GBREXCH)/(DEUEXCH(-1)/GBREXCH(-1))) *.01*DEUIRS+((USAEXCH/GBREXCH) /(USAEXCH(-1)/GBREXCH(-1)))*.01*USAIRS)/3) *GBRCB(-1))$ FRML IGBRCB GBRCB = GBRXGS - GBRMGS + GBRYIE +GBRCBR $ () () FINANCIAL SECTOR () () FRML _GJ_D_Z GBRIRS = 150*DLOG(GBRPCPN) + 50*DLOG(GBRGDPV) $ () FRML GGBRIRS GBRIRS = DGBRIRS*GBRIRS(-1)+(GBRD1IRS*(EURIRS-EURIRS(-1)) () +GBRD2IRS*100*LOG(GBRPCPN) () +GBRD3IRS*100*LOG(GBRPCPN(-1)) () +GBRD4IRS*100*LOG(GBRPCPN(-2)) () +GBRD5IRS*100*LOG(GBRGDPV) () +GBRD6IRS*(100*(-GBRNLG/GBRGDP)) () +GBRD7IRS*(100*(-GBRCB/GBRGDP))) + JGBRIRS $ FRML GGBRIRL GBRIRL = (1-DGBRIRL)*100*(-1+EXP(.853*LOG(1+GBRIRL(-1)/100) +.382*LOG(1+GBRIRS/100)-.235*LOG(1+GBRIRS(-1)/100) -.00048)) +GBRD1IRL*(GBRIRL(-1)+GBRIRS-GBRIRS(-1))+JGBRIRL $ () FRML _GJ_D GBREXCH = 1/EXP( () LOG(USAEXCH(-1)/GBREXCH(-1)) () +LOG(GBRPYFB/USAPYFB)-LOG(GBRPYFB(-1)/USAPYFB(-1)) () -2.4152*(LOG((1+GBRIRS/100)/(1+USAIRS/100)) () -LOG((1+GBRIRS(-1)/100)/(1+USAIRS(-1)/100))) () -4.1048*LOG((1+GBRIRL(-1)/100)/(1+USAIRL(-1)/100)) () -.3156*LOG((USAEXCH(-1)/GBREXCH(-1))/ () (GBRPYFB(-1)/USAPYFB(-1))) () - .0057*TID + 11.24)*USAEXCH () + DGBREXC1*GBREXCH(-1)*(DEUEXCH/DEUEXCH(-1)) $ FRML _GJ_D_Z LOG(GBREXCH) = LOG(GBREXP) + (LOG(1+GBRIRS/100)-LOG(1+USAIRS/100)) $ FRML _GJ_D_Z GBREXP = GBREXB $ FRML _GJ_D_Z GBREXB = GBREXB(-1) + 1/3*(GBREXCH-GBREXB(-1)) $ () () MAIN ECONOMIC QVOTAS AND OTHER VARIABLES () () FRML IGBRBNLG GBRBNLG = (GBRNLG/GBRGDP)*100 $ FRML IGBRBCB GBRBCB = (GBRCB/GBRGDP)*100 $ FRML IGBRBCP GBRBCP = (GBRCPV/GBRYDRH)*100 $ FRML IGBRBM GBRBM = (GBRMGSV/GBRGDPV)*100 $ FRML IGBRBIP GBRBIP = (GBRIPV/GBRGDPV)*100 $ FRML IGBRBIB GBRBIB = (GBRIBV/GBRYFBV)*100 $ FRML IGBRBW GBRBW = (GBRWSSS/GBRYF)*100 $ FRML _DJ_ GBRIPV = GBRIBV + GBRIHV $ FRML _DJ_ GBRTDDV = GBRGDPV - GBRNGSV - GBRDGDPV $ FRML IGBRNGSV GBRNGSV = GBRXGSV - GBRMGSV $ () () ********************* () * FRA * () ********************* () () HOUSEHOLD DEMAND () () FRML _GJRD FRACPV = (EXP(LOG(FRACPV(-1)) +.546*(LOG(FRAYDRH-.5*(FRAYIP/FRAPCP)) -LOG(FRAYDRH(-2)-.5*(FRAYIP(-2)/FRAPCP(-2))))/2 -.0599*(LOG(FRACPV(-1)/FRAYDRH(-1))) -.00142*(FRAIRL-FRAIRL(-1)) +.00375))$ FRML _GJRD FRAIHV = (EXP(.897*LOG(FRAIHV(-1)) +1.766*(LOG(FRAYDRH-.5*(FRAYIP/FRAPCP)) -LOG(FRAYDRH(-2)-.5*(FRAYIP(-2)/FRAPCP(-2))))/2 -.02036*(FRAIRL(-1)-FRAIRL(-3))/2 +.50038))$ () () BUSINESS INVESTMENT () () FRML IFRAGAP FRAGAP = LOG(FRAYFBV)-.67*LOG(FRAEB+FRAES)-.33*LOG(FRAKBV) -FRAGAPT*TID-FRAGAPK $ FRML GFRAUC FRAUC = FRAPIB*(FRAIRL+15) $ FRML _GJRD_ DLOG(FRAKBV) = 0.70351*DLOG(FRAKBV(-1)) + 0.18125*DLOG(FRAYFBV) + 0.02588*(LOG(FRAYFBV(-1)/FRAKBV(-1)) -0.67*LOG(FRAUC(-1)/FRAWSSE(-1))) + TFRAKBV + 1.02749 $ FRML GFRAIBV FRAIBV = FRAKBV-FRAKBV(-1)+FRAAKBV*FRAKBV(-1) $ FRML _DJ_ FRAITV = FRAIHV + FRAIBV + FRAIGV $ () () EXPORT VOLUMES () FRML GFRAXGSDU FRAXGSDU = XFRADNK*LOG(DNKMGSD) + XFRASWE*LOG(SWEMGSD) + XFRANOR*LOG(NORMGSD) + XFRAFIN*LOG(FINMGSD) + XFRANLD*LOG(NLDMGSD) + XFRAGBR*LOG(GBRMGSD) + XFRAITA*LOG(ITAMGSD) + XFRADEU*LOG(DEUMGSD) + XFRABEL*LOG(BELMGSD) + XFRAESP*LOG(ESPMGSD) + XFRAYPN*LOG(YPNMGSD) + XFRAUSA*LOG(USAMGSD) + XFRAPOL*LOG(POLMGSD) + XFRACZE*LOG(CZEMGSD) + XFRAAUS*LOG(AUSMGSD) + XFRAAUT*LOG(AUTMGSD) + XFRACAN*LOG(CANMGSD) + XFRACHL*LOG(CHLMGSD) + XFRAEST*LOG(ESTMGSD) + XFRAGRC*LOG(GRCMGSD) + XFRAHUN*LOG(HUNMGSD) + XFRAISL*LOG(ISLMGSD) + XFRAIRL*LOG(IRLMGSD) + XFRAISR*LOG(ISRMGSD) + XFRAKOR*LOG(KORMGSD) + XFRALUX*LOG(LUXMGSD) + XFRAMEX*LOG(MEXMGSD) + XFRANZL*LOG(NZLMGSD) + XFRAPRT*LOG(PRTMGSD) + XFRASVK*LOG(SVKMGSD) + XFRASVN*LOG(SVNMGSD) + XFRACHE*LOG(CHEMGSD) + XFRATUR*LOG(TURMGSD) + XFRADAE*LOG(DAEMGSD) + XFRAOOP*LOG(OOPMGSD) + XFRABRA*LOG(BRAMGSD) + XFRARUS*LOG(RUSMGSD) + XFRAIND*LOG(INDMGSD) + XFRACHN*LOG(CHNMGSD) + XFRAIDN*LOG(IDNMGSD) + XFRAZAF*LOG(ZAFMGSD) + XFRARWD*LOG(RWDMGSD) $ FRML _GJRD DLOG(FRAXGSD) = (FRAXGSDU-FRAXGSDU(-1)) $ FRML IFRAXGSV FRAXGSV = FRAXGSD*USAEXCH/(FRAEXCH*FRAPXGS) $ () () IMPORT () () FRML _GJ_ FRAWMV = .140*FRACPV + .160*FRACGNV + .164*FRAIHV +.164*(FRAIBV+FRAISKV) + .164*FRAIGV +.376*FRAXGSV $ () FRML _GJRD Dlog(FRAMGSV) = 1.7000*Dlog(FRAWMV) + 0.11605*Dlog(FRAPYFB/FRAPMGS) - 0.05*(Log(FRAMGSV(-1)/FRAWMV(-1)) -0.74506*Log(FRAPYFB(-1)/FRAPMGS(-1))-0.06579) - 0.01023 $ FRML IFRAMGSD FRAMGSD = FRAMGSV*FRAPMGS*FRAEXCH/USAEXCH $ () () LABOUR MARKET () () FRML _GJ_D_ FRALF = FRAPOPT*((FRALF(-1)/FRAPOPT(-1)) + (1-FRADLF)*(.123*DLOG(FRAET) - .00061)) $ () FRML _DJ_ FRAEBN = (1/0.67)*LOG(FRAYFBV)-((1-0.67)/0.67)*LOG(FRAKBV) $ FRML _DJ_ FRAEBW = LOG(FRAYFBV)+0.33*LOG(FRAUC/FRAWSSE) $ FRML _GJRD DLOG(FRAEP) = 0.55611*DLOG(FRAYFBV)+0.29816*DLOG(FRAYFBV(-1)) -0.07390*(LOG(FRAEP(-1))-FRAEBW(-1)) +0.21753 $ FRML _D__D FRAEB = FRAEP - FRAES $ FRML GFRAEE FRAEE = FRAEB + FRAEG $ FRML _DJ_ FRAET = FRAEE + FRAES $ FRML IFRAUN FRAUN = FRALF - FRAET $ FRML IFRAUNR FRAUNR = (FRAUN/FRALF)*100 $ () () WAGES () FRML GFRAWU FRAWU = (17.80*LOG(DEUWSSE)+ 9.12*LOG(GBRWSSE)+ 8.54*LOG(ITAWSSE)+ 7.50*LOG(BELWSSE)+ 6.56*LOG(USAWSSE))/49.52 $ FRML IFRAEYFB FRAEYFB = (FRAYFBV/(FRAEB+FRAES))/BFRAEYFB $ FRML _GJRD DLOG(FRAWR) = 1.00*(DLOG(FRAPYFB)) +.21215*(FRAWU-FRAWU(-1)) -.01004*(FRAUNR(-1)-.8*(FRAUNR(-2))) +.30317*DLOG(FRAEYFB) +.46863*(DLOG(FRAPCP/FRAPYFB)) -.07018*LOG(FRAWSSE(-1)/(FRAPYFB(-1)*FRAEYFB(-1))) +.25822 $ FRML GFRAWSSE FRAWSSE = FRAKWSSE*FRAWR + JFRAWSSE $ FRML GFRAWRG FRAWRG = FRAKWRG*FRAWR + JFRAWRG $ () () DOMESTIC PRICES () () FRML GFRAPCPN FRAPCPN = FRAPCPN(-1)*(.15*(FRAPMGS/FRAPMGS(-1))+ .85*(FRAPYFB/FRAPYFB(-1))) + JFRAPCPN $ FRML IFRAPCP FRAPCP = (1+FRATTI)*FRAPCPN $ FRML GFRAPCGN FRAPCGN = FRAPCGN(-1)*(.22*(FRAPMGS/FRAPMGS(-1))+ .78*(FRAPYFB/FRAPYFB(-1))) + JFRAPCGN $ FRML GFRAPIB FRAPIB = FRAPIB(-1)*(.16*(FRAPMGS/FRAPMGS(-1))+ .84*(FRAPYFB/FRAPYFB(-1))) + JFRAPIB $ FRML GFRAPIHN FRAPIHN = FRAPIHN(-1)*(FRAPIB/FRAPIB(-1)) + JFRAPIHN $ FRML IFRAPIH FRAPIH = (1+FRATTI)*FRAPIHN $ FRML GFRAPIG FRAPIG = FRAPIG(-1)*(FRAPIB/FRAPIB(-1)) + JFRAPIG $ FRML GFRAPISK FRAPISK = FRAPIB + JFRAPISK $ FRML GFRAULC FRAULC = ((FRAWSSE*(FRAEB+FRAES))/FRAYFBV)/BFRAULC $ FRML GFRAUCCB FRAUCCB = (FRAPIB*((FRAIRL+FRAIRL(-1)+FRAIRL(-2)+FRAIRL(-3) +FRAIRL(-4)+FRAIRL(-5)+FRAIRL(-6))/7+15) *FRAKBV/FRAYFBV)/BFRAUCCB $ FRML _GJRD DLOG(FRAPYFB) = .600*(LOG(FRAULC)-LOG(FRAULC(-1))) +.04276*(LOG(FRAPMGS)-LOG(FRAPMGS(-1))) +.23351*(FRAGAP-FRAGAP(-1)) -.14057*(LOG(FRAPYFB(-1))-.67*LOG(FRAULC(-1)) -.33*LOG(FRAUCCB(-1))+0.06956) +.02059 $ () () IMPORT PRICES () () FRML GFRAPMGSU FRAPMGSU = MFRADNK*LOG(DNKPXGS/FRAEXCH*DNKEXCH) + MFRASWE*LOG(SWEPXGS/FRAEXCH*SWEEXCH) + MFRANOR*LOG(NORPXGS/FRAEXCH*NOREXCH) + MFRAFIN*LOG(FINPXGS/FRAEXCH*FINEXCH) + MFRANLD*LOG(NLDPXGS/FRAEXCH*NLDEXCH) + MFRAGBR*LOG(GBRPXGS/FRAEXCH*GBREXCH) + MFRAITA*LOG(ITAPXGS/FRAEXCH*ITAEXCH) + MFRADEU*LOG(DEUPXGS/FRAEXCH*DEUEXCH) + MFRABEL*LOG(BELPXGS/FRAEXCH*BELEXCH) + MFRAESP*LOG(ESPPXGS/FRAEXCH*ESPEXCH) + MFRAYPN*LOG(YPNPXGS/FRAEXCH*YPNEXCH) + MFRAUSA*LOG(USAPXGS/FRAEXCH*USAEXCH) + MFRAPOL*LOG(POLPXGS/FRAEXCH*POLEXCH) + MFRACZE*LOG(CZEPXGS/FRAEXCH*CZEEXCH) + MFRAAUS*LOG(AUSPXGS/FRAEXCH*AUSEXCH) + MFRAAUT*LOG(AUTPXGS/FRAEXCH*AUTEXCH) + MFRACAN*LOG(CANPXGS/FRAEXCH*CANEXCH) + MFRACHL*LOG(CHLPXGS/FRAEXCH*CHLEXCH) + MFRAEST*LOG(ESTPXGS/FRAEXCH*ESTEXCH) + MFRAGRC*LOG(GRCPXGS/FRAEXCH*GRCEXCH) + MFRAHUN*LOG(HUNPXGS/FRAEXCH*HUNEXCH) + MFRAISL*LOG(ISLPXGS/FRAEXCH*ISLEXCH) + MFRAIRL*LOG(IRLPXGS/FRAEXCH*IRLEXCH) + MFRAISR*LOG(ISRPXGS/FRAEXCH*ISREXCH) + MFRAKOR*LOG(KORPXGS/FRAEXCH*KOREXCH) + MFRALUX*LOG(LUXPXGS/FRAEXCH*LUXEXCH) + MFRAMEX*LOG(MEXPXGS/FRAEXCH*MEXEXCH) + MFRANZL*LOG(NZLPXGS/FRAEXCH*NZLEXCH) + MFRAPRT*LOG(PRTPXGS/FRAEXCH*PRTEXCH) + MFRASVK*LOG(SVKPXGS/FRAEXCH*SVKEXCH) + MFRASVN*LOG(SVNPXGS/FRAEXCH*SVNEXCH) + MFRACHE*LOG(CHEPXGS/FRAEXCH*CHEEXCH) + MFRATUR*LOG(TURPXGS/FRAEXCH*TUREXCH) + MFRADAE*LOG(DAEPXGS/FRAEXCH*DAEEXCH) + MFRAOOP*LOG(OOPPXGS/FRAEXCH*OOPEXCH) + MFRABRA*LOG(BRAPXGS/FRAEXCH*BRAEXCH) + MFRARUS*LOG(RUSPXGS/FRAEXCH*RUSEXCH) + MFRAIND*LOG(INDPXGS/FRAEXCH*INDEXCH) + MFRACHN*LOG(CHNPXGS/FRAEXCH*CHNEXCH) + MFRAIDN*LOG(IDNPXGS/FRAEXCH*IDNEXCH) + MFRAZAF*LOG(ZAFPXGS/FRAEXCH*ZAFEXCH) + MFRARWD*LOG(RWDPXGS/FRAEXCH*RWDEXCH) $ () FRML _GJRD_ DLOG(FRAPMGS) = (FRAPMGSU-FRAPMGSU(-1)) $ () () EXPORT PRICES () () FRML _GJR DLOG(FRAPXIN) = .22*DLOG(FRAPMGS) + .78*DLOG(FRAPYFB) $ FRML GFRAPXGSU FRAPXGSU = XFRADNK*LOG(DNKPMGS/FRAEXCH*DNKEXCH) + XFRASWE*LOG(SWEPMGS/FRAEXCH*SWEEXCH) + XFRANOR*LOG(NORPMGS/FRAEXCH*NOREXCH) + XFRAFIN*LOG(FINPMGS/FRAEXCH*FINEXCH) + XFRANLD*LOG(NLDPMGS/FRAEXCH*NLDEXCH) + XFRAGBR*LOG(GBRPMGS/FRAEXCH*GBREXCH) + XFRAITA*LOG(ITAPMGS/FRAEXCH*ITAEXCH) + XFRADEU*LOG(DEUPMGS/FRAEXCH*DEUEXCH) + XFRABEL*LOG(BELPMGS/FRAEXCH*BELEXCH) + XFRAESP*LOG(ESPPMGS/FRAEXCH*ESPEXCH) + XFRAYPN*LOG(YPNPMGS/FRAEXCH*YPNEXCH) + XFRAUSA*LOG(USAPMGS/FRAEXCH*USAEXCH) + XFRAPOL*LOG(POLPMGS/FRAEXCH*POLEXCH) + XFRACZE*LOG(CZEPMGS/FRAEXCH*CZEEXCH) + XFRAAUS*LOG(AUSPMGS/FRAEXCH*AUSEXCH) + XFRAAUT*LOG(AUTPMGS/FRAEXCH*AUTEXCH) + XFRACAN*LOG(CANPMGS/FRAEXCH*CANEXCH) + XFRACHL*LOG(CHLPMGS/FRAEXCH*CHLEXCH) + XFRAEST*LOG(ESTPMGS/FRAEXCH*ESTEXCH) + XFRAGRC*LOG(GRCPMGS/FRAEXCH*GRCEXCH) + XFRAHUN*LOG(HUNPMGS/FRAEXCH*HUNEXCH) + XFRAISL*LOG(ISLPMGS/FRAEXCH*ISLEXCH) + XFRAIRL*LOG(IRLPMGS/FRAEXCH*IRLEXCH) + XFRAISR*LOG(ISRPMGS/FRAEXCH*ISREXCH) + XFRAKOR*LOG(KORPMGS/FRAEXCH*KOREXCH) + XFRALUX*LOG(LUXPMGS/FRAEXCH*LUXEXCH) + XFRAMEX*LOG(MEXPMGS/FRAEXCH*MEXEXCH) + XFRANZL*LOG(NZLPMGS/FRAEXCH*NZLEXCH) + XFRAPRT*LOG(PRTPMGS/FRAEXCH*PRTEXCH) + XFRASVK*LOG(SVKPMGS/FRAEXCH*SVKEXCH) + XFRASVN*LOG(SVNPMGS/FRAEXCH*SVNEXCH) + XFRACHE*LOG(CHEPMGS/FRAEXCH*CHEEXCH) + XFRATUR*LOG(TURPMGS/FRAEXCH*TUREXCH) + XFRADAE*LOG(DAEPMGS/FRAEXCH*DAEEXCH) + XFRAOOP*LOG(OOPPMGS/FRAEXCH*OOPEXCH) + XFRABRA*LOG(BRAPMGS/FRAEXCH*BRAEXCH) + XFRARUS*LOG(RUSPMGS/FRAEXCH*RUSEXCH) + XFRAIND*LOG(INDPMGS/FRAEXCH*INDEXCH) + XFRACHN*LOG(CHNPMGS/FRAEXCH*CHNEXCH) + XFRAIDN*LOG(IDNPMGS/FRAEXCH*IDNEXCH) + XFRAZAF*LOG(ZAFPMGS/FRAEXCH*ZAFEXCH) + XFRARWD*LOG(RWDPMGS/FRAEXCH*RWDEXCH) $ () FRML _GJRD_ DLOG(FRAPXGS) = 0.08205 * (FRAPXGSU-FRAPXGSU(-1)) + 0.91795 * DLOG(FRAPXIN) $ () () THE GOVERNMENT SECTOR () () FRML GFRACGWV FRACGWV = FRAEG*BFRACGWV $ FRML GFRACGNV FRACGNV = FRACGNV(-1)*(FRACGWV/FRACGWV(-1))*(1-DFRACGNV) + JFRACGNV $ FRML IFRACGV FRACGV = FRACGWV + FRACGNV $ FRML IFRACGW FRACGW = FRACGWV*FRAWRG/(BFRACGWV*1000) $ FRML IFRACG FRACG = FRACGW + FRACGNV*FRAPCGN $ FRML IFRAIG FRAIG = FRAIGV*FRAPIG $ FRML GFRACFKG FRACFKG = FRATCFKG*FRACG $ FRML GFRASSRG FRASSRG = FRATSSRG*FRAWSSS + JFRASSRG $ FRML GFRATY FRATY = FRATTY*FRAYP + JFRATY $ FRML GFRATI FRATI = FRATTI*(FRACPV*FRAPCP+FRAIHV*FRAPIH)/(1+FRATTI) +JFRATI $ FRML GFRATRRH FRATRRH = (.301+JFRATTRH)*FRAUN*(FRAWSSE(-1)/1000) +(.34871*FRAPOPT-6619.32)*(FRAWSSE(-1)/1000) +JFRATRRH $ FRML GFRAYIO FRAYIO = -((FRAIRL+FRAIRL(-1)+FRAIRL(-2))/300) *(FRAGNFL(-1))*(1-DYIO)+DYIO*ZFRAYIO + JFRAYIO $ FRML IFRANLG FRANLG = FRASSRG + FRATY + FRATI + FRAYIO - FRACG - FRAIG - FRAIENTG - FRATRRH - FRATRO - FRAKIG $ FRML IFRAGNFL FRAGNFL = FRAGNFL(-1) -FRANLG + BFRAGNFL $ () () PRODUCTION AND INCOMES () () FRML IFRAGDP FRAGDP = FRACPV*FRAPCP + FRACG + FRAIG + FRAIBV*FRAPIB+FRAIENTG +FRAIHV*FRAPIH + FRAISKV*FRAPISK +FRAXGSV*FRAPXGS - FRAMGSV*FRAPMGS + FRADGDP $ FRML IFRAGDPV FRAGDPV = FRACPV+ FRACGV+ FRAIGV+ FRAIBV+ FRAIHV+ FRAISKV + FRAXGSV- FRAMGSV + FRADGDPV $ FRML IFRAYF FRAYF = FRAGDP - FRATI $ FRML IFRAYFB FRAYFB = FRAYF - FRACGW - FRACFKG $ FRML IFRAYFBV FRAYFBV = FRAYFB/FRAPYFB $ FRML IFRAWSSS FRAWSSS = (FRAEB*FRAWSSE + FRAEG*FRAWRG)/1000 $ FRML IFRAYRP FRAYRP = FRAYF - FRAWSSS - FRACFKG $ FRML GFRADP FRADP = FRATDP*(FRAKBV*FRAPIB) $ FRML IFRAYIP FRAYIP = FRAYIE - FRAYIO $ FRML GFRAYP FRAYP = FRAWSSS - FRASSRG + FRAYRP - FRADP + FRAYIP + FRATRRH + JFRAYP $ FRML IFRAYDH FRAYDH = FRAYP - FRATY + JFRAYDH $ FRML IFRAYDRH FRAYDRH = FRAYDH/FRAPCP $ () () CURRENT BALANCE () () FRML IFRAX FRAXGS = FRAXGSV*FRAPXGS $ FRML IFRAM FRAMGS = FRAMGSV*FRAPMGS $ FRML _GJ_D FRAYIE = (FRAYIE(-1) +FRAYIE(-1)*(2*((DEUEXCH/FRAEXCH) /(DEUEXCH(-1)/FRAEXCH(-1))-1) +((USAEXCH/FRAEXCH)/(USAEXCH(-1)/FRAEXCH(-1))-1))/3 +FRAYIE(-1)*((2*((DEUEXCH/FRAEXCH) /(DEUEXCH(-1)/FRAEXCH(-1))) *((DEUIRS/DEUIRS(-3))**(1/3)-1) +((USAEXCH/FRAEXCH)/(USAEXCH(-1)/FRAEXCH(-1))) *((USAIRS/USAIRS(-3))**(1/3)-1))/3) +((2*((DEUEXCH/FRAEXCH)/(DEUEXCH(-1)/FRAEXCH(-1))) *.01*DEUIRS+((USAEXCH/FRAEXCH) /(USAEXCH(-1)/FRAEXCH(-1)))*.01*USAIRS)/3) *FRACB(-1))$ FRML IFRACB FRACB = FRAXGS - FRAMGS + FRAYIE +FRACBR $ () () FINANCIAL SECTOR () () FRML GFRAIRS FRAIRS = eurirs + jfrairs$ FRML GFRAIRL FRAIRL = (1-DFRAIRL)*100*(-1+EXP(.653*LOG(1+FRAIRL(-1)/100) +.536*LOG(1+FRAIRS/100)-.189*LOG(1+FRAIRS(-1)/100) +.00323)) +FRADXIRL*(FRAIRL(-1)+DEUIRL-DEUIRL(-1) +(((FRAPCPN/FRAPCPN(-1)) -(FRAPCPN(-2)/FRAPCPN(-3)))/2 -((DEUPCPN/DEUPCPN(-1)) -(DEUPCPN(-2)/DEUPCPN(-3)))/2)*100) +FRAD1IRL*(FRAIRL(-1)+DEUIRL-DEUIRL(-1))+JFRAIRL $ () FRML _GJ_D FRAEXCH = FRAEXCH(-1)*(DEUEXCH/DEUEXCH(-1)) $ FRML _GJ_D FRAEXCH = FRAEXCH(-1)*(EUREXC/EUREXC(-1)) $ () () MAIN ECONOMIC QVOTAS AND OTHER VARIABLES () () FRML IFRABNLG FRABNLG = (FRANLG/FRAGDP)*100 $ FRML IFRABCB FRABCB = (FRACB/FRAGDP)*100 $ FRML IFRABCP FRABCP = (FRACPV/FRAYDRH)*100 $ FRML IFRABM FRABM = (FRAMGSV/FRAGDPV)*100 $ FRML IFRABIP FRABIP = (FRAIPV/FRAGDPV)*100 $ FRML IFRABIB FRABIB = (FRAIBV/FRAYFBV)*100 $ FRML IFRABW FRABW = (FRAWSSS/FRAYF)*100 $ FRML _DJ_ FRAIPV = FRAIBV + FRAIHV $ FRML _DJ_ FRATDDV = FRAGDPV - FRANGSV $ FRML IFRANGSV FRANGSV = FRAXGSV - FRAMGSV $ () () ******************* () * ESP * () ******************* () () HOUSEHOLD DEMAND () () FRML _GJRD ESPCPV = (EXP(LOG(ESPCPV(-1)) +.639*(.9*LOG(ESPYDRH-.5*(ESPYIP/ESPPCP)) -.8*LOG(ESPYDRH(-1)-.5*(ESPYIP(-1)/ESPPCP(-1))) -.1*LOG(ESPYDRH(-2)-.5*(ESPYIP(-2)/ESPPCP(-2)))) -.258*(LOG(ESPCPV(-1)/ESPYDRH(-1))) -.00789*(.5*ESPIRL-.25*ESPIRL(-1)-.25*ESPIRL(-3)) -.02401))$ FRML _GJRD ESPIHV = (EXP(.95596*LOG(ESPIHV(-1)) +1.19516*0.5*(LOG(ESPYFBV)-LOG(ESPYFBV(-2))) -.02624*.33*(ESPIRL-ESPIRL(-3)) +.10700))$ () () () BUSINESS INVESTMENT () () () FRML IESPGAP ESPGAP = LOG(ESPYFBV)-.74*LOG(ESPEB+ESPES)-.26*LOG(ESPKBV) - ESPGAPT*TID-ESPGAPK $ () FRML GESPUC ESPUC = ESPPIB*(ESPIRL+15) $ FRML _GJRD_ DLOG(ESPKBV) = 0.65189*DLOG(ESPKBV(-1)) + 0.20119*DLOG(ESPYFBV) + 0.03000*(LOG(ESPYFBV(-1)/ESPKBV(-1)) -0.74*LOG(ESPUC(-1)/ESPWSSE(-1))) + TESPKBV + 1.15006$ FRML GESPIBV ESPIBV = ESPKBV-ESPKBV(-1)+ESPAKBV*ESPKBV(-1) $ FRML _DJ_ ESPITV = ESPIHV + ESPIBV + ESPIGV $ () () EXPORT VOLUMES () FRML GESPXGSDU ESPXGSDU = XESPDNK*LOG(DNKMGSD) + XESPSWE*LOG(SWEMGSD) + XESPNOR*LOG(NORMGSD) + XESPFIN*LOG(FINMGSD) + XESPNLD*LOG(NLDMGSD) + XESPGBR*LOG(GBRMGSD) + XESPITA*LOG(ITAMGSD) + XESPDEU*LOG(DEUMGSD) + XESPFRA*LOG(FRAMGSD) + XESPBEL*LOG(BELMGSD) + XESPYPN*LOG(YPNMGSD) + XESPUSA*LOG(USAMGSD) + XESPPOL*LOG(POLMGSD) + XESPCZE*LOG(CZEMGSD) + XESPAUS*LOG(AUSMGSD) + XESPAUT*LOG(AUTMGSD) + XESPCAN*LOG(CANMGSD) + XESPCHL*LOG(CHLMGSD) + XESPEST*LOG(ESTMGSD) + XESPGRC*LOG(GRCMGSD) + XESPHUN*LOG(HUNMGSD) + XESPISL*LOG(ISLMGSD) + XESPIRL*LOG(IRLMGSD) + XESPISR*LOG(ISRMGSD) + XESPKOR*LOG(KORMGSD) + XESPLUX*LOG(LUXMGSD) + XESPMEX*LOG(MEXMGSD) + XESPNZL*LOG(NZLMGSD) + XESPPRT*LOG(PRTMGSD) + XESPSVK*LOG(SVKMGSD) + XESPSVN*LOG(SVNMGSD) + XESPCHE*LOG(CHEMGSD) + XESPTUR*LOG(TURMGSD) + XESPDAE*LOG(DAEMGSD) + XESPOOP*LOG(OOPMGSD) + XESPBRA*LOG(BRAMGSD) + XESPRUS*LOG(RUSMGSD) + XESPIND*LOG(INDMGSD) + XESPCHN*LOG(CHNMGSD) + XESPIDN*LOG(IDNMGSD) + XESPZAF*LOG(ZAFMGSD) + XESPRWD*LOG(RWDMGSD) $ FRML _GJRD DLOG(ESPXGSD)= (ESPXGSDU-ESPXGSDU(-1)) $ FRML IESPXGSV ESPXGSV = ESPXGSD*USAEXCH/(ESPEXCH*ESPPXGS) $ () () IMPORT () () FRML _GJ_ ESPWMV = .078*ESPCPV + .041*ESPCGNV + .150*ESPIHV +.150*(ESPIBV+ESPISKV) + .150*ESPIGV +.127*ESPXGSV $ () FRML _GJRD Dlog(ESPMGSV) = 1.5000*Dlog(ESPWMV) + 0.2184*Dlog(ESPPYFB/ESPPMGS) - 0.0769*(Log(ESPMGSV(-1)/ESPWMV(-1))-1.48494*Log(ESPPYFB(-1)/ESPPMGS(-1))-0.73357) + 0.01396 $ () FRML IESPMGSD ESPMGSD = ESPMGSV*ESPPMGS*ESPEXCH/USAEXCH $ () () LABOUR MARKET () () FRML _GJ_D_ ESPLF = ESPPOPT*((ESPLF(-1)/ESPPOPT(-1)) + (1-ESPDLF)*(.2155*DLOG(ESPET) + .00285)) $ () FRML _DJ_ ESPEBN = (1/0.74)*LOG(ESPYFBV)-((1-0.74)/0.74)*LOG(ESPKBV) $ FRML _DJ_ ESPEBW = LOG(ESPYFBV)+0.26*LOG(ESPUC/ESPWSSE) $ FRML _GJRD DLOG(ESPEP) = 0.76448*DLOG(ESPYFBV)+0.23552*DLOG(ESPYFBV(-1)) -0.11759*(LOG(ESPEP(-1))-ESPEBW(-1)) +0.38717 $ FRML _D__D ESPEB = ESPEP - ESPES $ FRML GESPEE ESPEE = ESPEB + ESPEG $ FRML _DJ_ ESPET = ESPEE + ESPES $ FRML IESPUN ESPUN = ESPLF - ESPET + JESPUN $ FRML IESPUNR ESPUNR = (ESPUN/ESPLF)*100 $ () () WAGES () FRML GESPWU ESPWU = (15.38*LOG(DEUWSSE)+ 7.63*LOG(GBRWSSE)+ 20.67*LOG(FRAWSSE)+ 9.13*LOG(ITAWSSE)+ 4.32*LOG(USAWSSE))/57.13 $ FRML IESPEYFB ESPEYFB = (ESPYFBV/(ESPEB+ESPES))/BESPEYFB $ FRML _GJRD DLOG(ESPWR) = .766*(DLOG(ESPPYFB)) -.0018*ESPUNR(-1) +.447*(DLOG(ESPEYFB)) -.050*LOG(ESPWSSE(-1)/(ESPPYFB(-1)*ESPEYFB(-1))) +.194 $ FRML GESPWSSE ESPWSSE = ESPKWSSE*ESPWR + JESPWSSE $ FRML GESPWRG ESPWRG = ESPKWRG*ESPWR + JESPWRG $ () () DOMESTIC PRICES () () FRML GESPPCPN ESPPCPN = ESPPCPN(-1)*(.33*(ESPPMGS/ESPPMGS(-1))+ .67*(ESPPYFB/ESPPYFB(-1))) + JESPPCPN $ FRML IESPPCP ESPPCP = (1+ESPTTI)*ESPPCPN $ FRML GESPPCGN ESPPCGN = ESPPCGN(-1)*(.36*(ESPPMGS/ESPPMGS(-1))+ .64*(ESPPYFB/ESPPYFB(-1))) + JESPPCGN $ FRML GESPPIHN ESPPIHN = ESPPIHN(-1)*(.12*(ESPPMGS/ESPPMGS(-1))+ .88*(ESPPYFB/ESPPYFB(-1))) + JESPPIHN $ FRML IESPPIH ESPPIH = (1+ESPTTI)*ESPPIHN $ FRML GESPPIB ESPPIB = ESPPIB(-1)*(.47*(ESPPMGS/ESPPMGS(-1))+ .53*(ESPPYFB/ESPPYFB(-1))) + JESPPIB $ FRML GESPPIG ESPPIG = ESPPIG(-1)*(.28*(ESPPMGS/ESPPMGS(-1))+ .72*(ESPPYFB/ESPPYFB(-1))) + JESPPIG $ FRML GESPPISK ESPPISK = ESPPIB + JESPPISK $ FRML GESPULC ESPULC = ((ESPWSSE*(ESPEB+ESPES))/ESPYFBV)/BESPULC $ FRML GESPUCCB ESPUCCB = (ESPPIB*((ESPIRL+ESPIRL(-1)+ESPIRL(-2)+ESPIRL(-3) +ESPIRL(-4)+ESPIRL(-5)+ESPIRL(-6))/7+15) *ESPKBV/ESPYFBV)/BESPUCCB $ FRML _GJRD DLOG(ESPPYFB) = .600*(LOG(ESPULC)-LOG(ESPULC(-1))) +.462*(ESPGAP-ESPGAP(-1)) -.010*(LOG(ESPPYFB(-1))-.74*LOG(ESPULC(-1)) -.26*LOG(ESPUCCB(-1))-0.0050) +.0166 $ () () IMPORT PRICES () FRML GESPPMGSU ESPPMGSU = MESPDNK*LOG(DNKPXGS/ESPEXCH*DNKEXCH) + MESPSWE*LOG(SWEPXGS/ESPEXCH*SWEEXCH) + MESPNOR*LOG(NORPXGS/ESPEXCH*NOREXCH) + MESPFIN*LOG(FINPXGS/ESPEXCH*FINEXCH) + MESPNLD*LOG(NLDPXGS/ESPEXCH*NLDEXCH) + MESPGBR*LOG(GBRPXGS/ESPEXCH*GBREXCH) + MESPITA*LOG(ITAPXGS/ESPEXCH*ITAEXCH) + MESPDEU*LOG(DEUPXGS/ESPEXCH*DEUEXCH) + MESPBEL*LOG(BELPXGS/ESPEXCH*BELEXCH) + MESPFRA*LOG(FRAPXGS/ESPEXCH*FRAEXCH) + MESPYPN*LOG(YPNPXGS/ESPEXCH*YPNEXCH) + MESPUSA*LOG(USAPXGS/ESPEXCH*USAEXCH) + MESPPOL*LOG(POLPXGS/ESPEXCH*POLEXCH) + MESPCZE*LOG(CZEPXGS/ESPEXCH*CZEEXCH) + MESPAUS*LOG(AUSPXGS/ESPEXCH*AUSEXCH) + MESPAUT*LOG(AUTPXGS/ESPEXCH*AUTEXCH) + MESPCAN*LOG(CANPXGS/ESPEXCH*CANEXCH) + MESPCHL*LOG(CHLPXGS/ESPEXCH*CHLEXCH) + MESPEST*LOG(ESTPXGS/ESPEXCH*ESTEXCH) + MESPGRC*LOG(GRCPXGS/ESPEXCH*GRCEXCH) + MESPHUN*LOG(HUNPXGS/ESPEXCH*HUNEXCH) + MESPISL*LOG(ISLPXGS/ESPEXCH*ISLEXCH) + MESPIRL*LOG(IRLPXGS/ESPEXCH*IRLEXCH) + MESPISR*LOG(ISRPXGS/ESPEXCH*ISREXCH) + MESPKOR*LOG(KORPXGS/ESPEXCH*KOREXCH) + MESPLUX*LOG(LUXPXGS/ESPEXCH*LUXEXCH) + MESPMEX*LOG(MEXPXGS/ESPEXCH*MEXEXCH) + MESPNZL*LOG(NZLPXGS/ESPEXCH*NZLEXCH) + MESPPRT*LOG(PRTPXGS/ESPEXCH*PRTEXCH) + MESPSVK*LOG(SVKPXGS/ESPEXCH*SVKEXCH) + MESPSVN*LOG(SVNPXGS/ESPEXCH*SVNEXCH) + MESPCHE*LOG(CHEPXGS/ESPEXCH*CHEEXCH) + MESPTUR*LOG(TURPXGS/ESPEXCH*TUREXCH) + MESPDAE*LOG(DAEPXGS/ESPEXCH*DAEEXCH) + MESPOOP*LOG(OOPPXGS/ESPEXCH*OOPEXCH) + MESPBRA*LOG(BRAPXGS/ESPEXCH*BRAEXCH) + MESPRUS*LOG(RUSPXGS/ESPEXCH*RUSEXCH) + MESPIND*LOG(INDPXGS/ESPEXCH*INDEXCH) + MESPCHN*LOG(CHNPXGS/ESPEXCH*CHNEXCH) + MESPIDN*LOG(IDNPXGS/ESPEXCH*IDNEXCH) + MESPZAF*LOG(ZAFPXGS/ESPEXCH*ZAFEXCH) + MESPRWD*LOG(RWDPXGS/ESPEXCH*RWDEXCH) $ FRML _GJRD_ DLOG(ESPPMGS) = (ESPPMGSU-ESPPMGSU(-1)) $ () () () EXPORT PRICES () FRML _GJR DLOG(ESPPXIN) = .13*DLOG(ESPPMGS) + .87*DLOG(ESPPYFB) $ FRML GESPPXGSU ESPPXGSU = XESPDNK*LOG(DNKPMGS/ESPEXCH*DNKEXCH) + XESPSWE*LOG(SWEPMGS/ESPEXCH*SWEEXCH) + XESPNOR*LOG(NORPMGS/ESPEXCH*NOREXCH) + XESPFIN*LOG(FINPMGS/ESPEXCH*FINEXCH) + XESPNLD*LOG(NLDPMGS/ESPEXCH*NLDEXCH) + XESPGBR*LOG(GBRPMGS/ESPEXCH*GBREXCH) + XESPITA*LOG(ITAPMGS/ESPEXCH*ITAEXCH) + XESPDEU*LOG(DEUPMGS/ESPEXCH*DEUEXCH) + XESPBEL*LOG(BELPMGS/ESPEXCH*BELEXCH) + XESPFRA*LOG(FRAPMGS/ESPEXCH*FRAEXCH) + XESPYPN*LOG(YPNPMGS/ESPEXCH*YPNEXCH) + XESPUSA*LOG(USAPMGS/ESPEXCH*USAEXCH) + XESPPOL*LOG(POLPMGS/ESPEXCH*POLEXCH) + XESPCZE*LOG(CZEPMGS/ESPEXCH*CZEEXCH) + XESPAUS*LOG(AUSPMGS/ESPEXCH*AUSEXCH) + XESPAUT*LOG(AUTPMGS/ESPEXCH*AUTEXCH) + XESPCAN*LOG(CANPMGS/ESPEXCH*CANEXCH) + XESPCHL*LOG(CHLPMGS/ESPEXCH*CHLEXCH) + XESPEST*LOG(ESTPMGS/ESPEXCH*ESTEXCH) + XESPGRC*LOG(GRCPMGS/ESPEXCH*GRCEXCH) + XESPHUN*LOG(HUNPMGS/ESPEXCH*HUNEXCH) + XESPISL*LOG(ISLPMGS/ESPEXCH*ISLEXCH) + XESPIRL*LOG(IRLPMGS/ESPEXCH*IRLEXCH) + XESPISR*LOG(ISRPMGS/ESPEXCH*ISREXCH) + XESPKOR*LOG(KORPMGS/ESPEXCH*KOREXCH) + XESPLUX*LOG(LUXPMGS/ESPEXCH*LUXEXCH) + XESPMEX*LOG(MEXPMGS/ESPEXCH*MEXEXCH) + XESPNZL*LOG(NZLPMGS/ESPEXCH*NZLEXCH) + XESPPRT*LOG(PRTPMGS/ESPEXCH*PRTEXCH) + XESPSVK*LOG(SVKPMGS/ESPEXCH*SVKEXCH) + XESPSVN*LOG(SVNPMGS/ESPEXCH*SVNEXCH) + XESPCHE*LOG(CHEPMGS/ESPEXCH*CHEEXCH) + XESPTUR*LOG(TURPMGS/ESPEXCH*TUREXCH) + XESPDAE*LOG(DAEPMGS/ESPEXCH*DAEEXCH) + XESPOOP*LOG(OOPPMGS/ESPEXCH*OOPEXCH) + XESPBRA*LOG(BRAPMGS/ESPEXCH*BRAEXCH) + XESPRUS*LOG(RUSPMGS/ESPEXCH*RUSEXCH) + XESPIND*LOG(INDPMGS/ESPEXCH*INDEXCH) + XESPCHN*LOG(CHNPMGS/ESPEXCH*CHNEXCH) + XESPIDN*LOG(IDNPMGS/ESPEXCH*IDNEXCH) + XESPZAF*LOG(ZAFPMGS/ESPEXCH*ZAFEXCH) + XESPRWD*LOG(RWDPMGS/ESPEXCH*RWDEXCH) $ FRML _GJRD_ DLOG(ESPPXGS) = 0.31242 * (ESPPXGSU-ESPPXGSU(-1)) + 0.68758 * DLOG(ESPPXIN)$ () () THE GOVERNMENT SECTOR () () FRML GESPCGWV ESPCGWV = ESPEG*BESPCGWV $ FRML _GJ_D ESPCGNV = ESPCGNV(-1)*(ESPCGWV/ESPCGWV(-1))$ FRML IESPCGV ESPCGV = ESPCGWV + ESPCGNV $ FRML IESPCGW ESPCGW = ESPCGWV*ESPWRG/(BESPCGWV*1000) $ FRML IESPCG ESPCG = ESPCGW + ESPCGNV*ESPPCGN $ FRML IESPIG ESPIG = ESPIGV*ESPPIG $ FRML GESPCFKG ESPCFKG = ESPTCFKG*ESPCG $ FRML GESPSSRG ESPSSRG = ESPTSSRG*ESPWSSS + JESPSSRG $ FRML GESPTY ESPTY = ESPTTY*ESPYP + JESPTY $ FRML GESPTI ESPTI = ESPTTI*(ESPCPV*ESPPCP+ESPIHV*ESPPIH)/(1+ESPTTI) +JESPTI $ FRML GESPTRRH ESPTRRH = (.304+JESPTTRH)*ESPUN*(ESPWSSE(-1)/1000) +(.23147*ESPPOPT-1492.68)*(ESPWSSE(-1)/1000) +JESPTRRH $ FRML GESPYIO ESPYIO = -((ESPIRL+ESPIRL(-1)+ESPIRL(-2))/300) *(ESPGNFL(-1))*(1-DYIO)+DYIO*ZESPYIO + JESPYIO $ FRML IESPNLG ESPNLG = ESPSSRG + ESPTY + ESPTI + ESPYIO - ESPCG - ESPIG - ESPIENTG - ESPTRRH - ESPTRO - ESPKIG $ FRML IESPGNFL ESPGNFL = ESPGNFL(-1) -ESPNLG + BESPGNFL $ () () PRODUCTION AND INCOMES () () FRML IESPGDP ESPGDP = ESPCPV*ESPPCP + ESPCG + ESPIG + ESPIBV*ESPPIB+ESPIENTG +ESPIHV*ESPPIH + ESPISKV*ESPPISK +ESPXGSV*ESPPXGS - ESPMGSV*ESPPMGS + ESPDGDP $ FRML IESPGDPV ESPGDPV = ESPCPV+ ESPCGV+ ESPIGV+ ESPIBV+ ESPIHV+ ESPISKV + ESPXGSV- ESPMGSV + ESPDGDPV $ FRML IESPYF ESPYF = ESPGDP - ESPTI $ FRML IESPYFB ESPYFB = ESPYF - ESPCGW - ESPCFKG $ FRML IESPYFBV ESPYFBV = ESPYFB/ESPPYFB $ FRML IESPWSSS ESPWSSS = (ESPEB*ESPWSSE + ESPEG*ESPWRG)/1000 $ FRML IESPYRP ESPYRP = ESPYF - ESPWSSS - ESPCFKG $ FRML GESPDP ESPDP = ESPTDP*(ESPKBV*ESPPIB) $ FRML IESPYIP ESPYIP = ESPYIE - ESPYIO $ FRML GESPYP ESPYP = ESPWSSS - ESPSSRG + ESPYRP - ESPDP + ESPYIP + ESPTRRH + JESPYP $ FRML IESPYDH ESPYDH = ESPYP - ESPTY + JESPYDH $ FRML IESPYDRH ESPYDRH = ESPYDH/ESPPCP $ () () CURRENT BALANCE () () FRML IESPX ESPXGS = ESPXGSV*ESPPXGS $ FRML IESPM ESPMGS = ESPMGSV*ESPPMGS $ FRML _GJ_D ESPYIE = (ESPYIE(-1) +ESPYIE(-1)* (2*((DEUEXCH/ESPEXCH)/(DEUEXCH(-1)/ESPEXCH(-1))-1) +((USAEXCH/ESPEXCH)/(USAEXCH(-1)/ESPEXCH(-1))-1))/3 +ESPYIE(-1)* ((2*((DEUEXCH/ESPEXCH) /(DEUEXCH(-1)/ESPEXCH(-1))) *((DEUIRS/DEUIRS(-3))**(1/3)-1) +((USAEXCH/ESPEXCH)/(USAEXCH(-1)/ESPEXCH(-1))) *((USAIRS/USAIRS(-3))**(1/3)-1))/3) +((2*((DEUEXCH/ESPEXCH)/(DEUEXCH(-1)/ESPEXCH(-1))) *.01*DEUIRS +((USAEXCH/ESPEXCH)/(USAEXCH(-1)/ESPEXCH(-1))) *.01*USAIRS)/3) *ESPCB(-1))$ FRML IESPCB ESPCB = ESPXGS - ESPMGS + ESPYIE +ESPCBR $ () () FINANCIAL SECTOR () () FRML GESPIRS ESPIRS = eurirs + jespirs$ FRML GESPIRL ESPIRL = (1-DESPIRL)*100*(-1+EXP(LOG(1+ESPIRL(-1)/100) +.352*(LOG(1+ESPIRL(-1)/100)-LOG(1+ESPIRL(-2)/100)) +.406*(LOG(1+ESPIRS/100)-LOG(1+ESPIRS(-1)/100)) -.192*LOG((1+ESPIRL(-1)/100)/(1+ESPIRS(-1)/100)) +.002)) +ESPDXIRL*(ESPIRL(-1)+DEUIRL-DEUIRL(-1) +(((ESPPCPN/ESPPCPN(-1)) -(ESPPCPN(-2)/ESPPCPN(-3)))/2 -((DEUPCPN/DEUPCPN(-1)) -(DEUPCPN(-2)/DEUPCPN(-3)))/2)*100) +ESPD1IRL*(ESPIRL(-1)+DEUIRL-DEUIRL(-1))+JESPIRL $ () FRML _GJ_D ESPEXCH = ESPEXCH(-1)*(DEUEXCH/DEUEXCH(-1)) $ FRML _GJ_D ESPEXCH = ESPEXCH(-1)*(EUREXC/EUREXC(-1)) $ () () MAIN ECONOMIC QVOTAS AND OTHER VARIABLES () () FRML IESPBNLG ESPBNLG = (ESPNLG/ESPGDP)*100 $ FRML IESPBCB ESPBCB = (ESPCB/ESPGDP)*100 $ FRML IESPBCP ESPBCP = (ESPCPV/ESPYDRH)*100 $ FRML IESPBM ESPBM = (ESPMGSV/ESPGDPV)*100 $ FRML IESPBIP ESPBIP = (ESPIPV/ESPGDPV)*100 $ FRML IESPBIB ESPBIB = (ESPIBV/ESPYFBV)*100 $ FRML IESPBW ESPBW = (ESPWSSS/ESPYF)*100 $ FRML _DJ_ ESPIPV = ESPIBV + ESPIHV $ FRML _DJ_ ESPTDDV = ESPGDPV - ESPNGSV $ FRML IESPNGSV ESPNGSV = ESPXGSV - ESPMGSV $ () () () ********************* () * ITA * () ********************* () () HOUSEHOLD DEMAND () () FRML _GJRD ITACPV = (EXP(LOG(ITACPV(-1)) +.643*(.75*LOG(ITAYDRH-.5*(ITAYIP/ITAPCP)) -.50*LOG(ITAYDRH(-1)-.5*(ITAYIP(-1)/ITAPCP(-1))) -.25*LOG(ITAYDRH(-2)-.5*(ITAYIP(-2)/ITAPCP(-2)))) -.0010*(ITAIRL-(ITAIRL(-1)+ITAIRL(-2))/2) -.0599*(LOG(ITACPV(-1)/ITAYDRH(-1))) +.00242))$ FRML _GJRD ITAIHV = (EXP(.58120*LOG(ITAIHV(-1)) +1.0*((DLOG(ITAYDRH)+DLOG(ITAYDRH(-1)))/2) -.0078*(.75*(ITAIRL-(ITAPCP/ITAPCP(-1)-1)*100) -.50*(ITAIRL(-1)-(ITAPCP(-1)/ITAPCP(-2)-1)*100) -.25*(ITAIRL(-2)-(ITAPCP(-2)/ITAPCP(-3)-1)*100)) -2.51705)) $ () () BUSINESS INVESTMENT () () FRML IITAGAP ITAGAP = LOG(ITAYFBV)-.68*LOG(ITAEB+ITAES)-.32*LOG(ITAKBV) -ITAGAPT*TID-ITAGAPK $ FRML GITAUC ITAUC = ITAPIB*(ITAIRL+15) $ FRML _GJRD_ DLOG(ITAKBV) = 0.6080*DLOG(ITAKBV(-1)) + 0.08009*DLOG(ITAYFBV) + 0.02000*(LOG(ITAYFBV(-1)/ITAKBV(-1)) -0.68*LOG(ITAUC(-1)/ITAWSSE(-1))) + TITAKBV - 0.00705*D1993 + 0.97853 $ FRML GITAIBV ITAIBV = ITAKBV-ITAKBV(-1)+ITAAKBV*ITAKBV(-1) $ FRML _DJ_ ITAITV = ITAIHV + ITAIBV + ITAIGV $ () () EXPORT VOLUMES () FRML GITAXGSDU ITAXGSDU = XITADNK*LOG(DNKMGSD) + XITASWE*LOG(SWEMGSD) + XITANOR*LOG(NORMGSD) + XITAFIN*LOG(FINMGSD) + XITANLD*LOG(NLDMGSD) + XITAGBR*LOG(GBRMGSD) + XITABEL*LOG(BELMGSD) + XITADEU*LOG(DEUMGSD) + XITAFRA*LOG(FRAMGSD) + XITAESP*LOG(ESPMGSD) + XITAYPN*LOG(YPNMGSD) + XITAUSA*LOG(USAMGSD) + XITAPOL*LOG(POLMGSD) + XITACZE*LOG(CZEMGSD) + XITAAUS*LOG(AUSMGSD) + XITAAUT*LOG(AUTMGSD) + XITACAN*LOG(CANMGSD) + XITACHL*LOG(CHLMGSD) + XITAEST*LOG(ESTMGSD) + XITAGRC*LOG(GRCMGSD) + XITAHUN*LOG(HUNMGSD) + XITAISL*LOG(ISLMGSD) + XITAIRL*LOG(IRLMGSD) + XITAISR*LOG(ISRMGSD) + XITAKOR*LOG(KORMGSD) + XITALUX*LOG(LUXMGSD) + XITAMEX*LOG(MEXMGSD) + XITANZL*LOG(NZLMGSD) + XITAPRT*LOG(PRTMGSD) + XITASVK*LOG(SVKMGSD) + XITASVN*LOG(SVNMGSD) + XITACHE*LOG(CHEMGSD) + XITATUR*LOG(TURMGSD) + XITADAE*LOG(DAEMGSD) + XITAOOP*LOG(OOPMGSD) + XITABRA*LOG(BRAMGSD) + XITARUS*LOG(RUSMGSD) + XITAIND*LOG(INDMGSD) + XITACHN*LOG(CHNMGSD) + XITAIDN*LOG(IDNMGSD) + XITAZAF*LOG(ZAFMGSD) + XITARWD*LOG(RWDMGSD) $ FRML _GJRD DLOG(ITAXGSD) = (ITAXGSDU-ITAXGSDU(-1)) $ FRML IITAXGSV ITAXGSV = ITAXGSD*USAEXCH/(ITAEXCH*ITAPXGS) $ () () IMPORT () () FRML _GJ_ ITAWMV = .158*ITACPV + .125*ITACGNV + .158*ITAIHV +.158*(ITAIBV+ITAISKV) + .158*ITAIGV +.197*ITAXGSV $ () FRML _GJRD Dlog(ITAMGSV) = 2.09160*Dlog(ITAWMV) + 0.14378*Dlog(ITAPYFB/ITAPMGS) - 0.05*(Log(ITAMGSV(-1)/ITAWMV(-1))-0.80876*Log(ITAPYFB(-1)/ITAPMGS(-1))-0.11571) - 0.01430 $ () FRML IITAMGSD ITAMGSD = ITAMGSV*ITAPMGS*ITAEXCH/USAEXCH $ () () LABOUR MARKET () () FRML _GJ_D_ ITALF = ITAPOPT*((ITALF(-1)/ITAPOPT(-1)) + (1-ITADLF)*(.390*DLOG(ITAET) + .00025)) $ () FRML _DJ_ ITAEBN = (1/0.68)*LOG(ITAYFBV)-((1-0.68)/0.68)*LOG(ITAKBV) $ FRML _DJ_ ITAEBW = LOG(ITAYFBV)+0.32*LOG(ITAUC/ITAWSSE) $ FRML _GJRD DLOG(ITAEP) = 0.40010*DLOG(ITAYFBV)+0.39990*DLOG(ITAYFBV(-1)) -0.11359*(LOG(ITAEP(-1))-ITAEBW(-1)) +0.35671 $ FRML _D__D ITAEB = ITAEP - ITAES $ FRML GITAEE ITAEE = ITAEB + ITAEG $ FRML _DJ_ ITAET = ITAEE + ITAES $ FRML IITAUN ITAUN = ITALF - ITAET $ FRML IITAUNR ITAUNR = (ITAUN/ITALF)*100 $ () () WAGES () FRML GITAWU ITAWU = (18.50*LOG(DEUWSSE)+ 6.17*LOG(GBRWSSE)+ 13.16*LOG(FRAWSSE)+ 4.93*LOG(ESPWSSE)+ 7.48*LOG(USAWSSE))/50.24 $ FRML IITAEYFB ITAEYFB = (ITAYFBV/(ITAEB+ITAES))/BITAEYFB $ FRML _GJRD DLOG(ITAWR) = .90*(DLOG(ITAPYFB)) +.45115*(ITAWU-ITAWU(-1)) -.00869*(ITAUNR(-1)-.8*ITAUNR(-2)) +.52922*DLOG(ITAEYFB) -.19618*LOG(ITAWSSE(-1)/(ITAPYFB(-1)*ITAEYFB(-1))) + .63798 $ FRML GITAWSSE ITAWSSE = ITAKWSSE*ITAWR + JITAWSSE $ FRML GITAWRG ITAWRG = ITAKWRG*ITAWR + JITAWRG $ () () DOMESTIC PRICES () () FRML GITAPCPN ITAPCPN = ITAPCPN(-1)*(.18*(ITAPMGS/ITAPMGS(-1))+ .82*(ITAPYFB/ITAPYFB(-1))) + JITAPCPN $ FRML IITAPCP ITAPCP = (1+ITATTI)*ITAPCPN $ FRML GITAPCGN ITAPCGN = ITAPCGN(-1)*(.22*(ITAPMGS/ITAPMGS(-1))+ .78*(ITAPYFB/ITAPYFB(-1))) + JITAPCGN $ FRML GITAPIB ITAPIB = ITAPIB(-1)*(.19*(ITAPMGS/ITAPMGS(-1))+ .81*(ITAPYFB/ITAPYFB(-1))) + JITAPIB $ FRML GITAPIHN ITAPIHN = ITAPIHN(-1)*(ITAPIB/ITAPIB(-1)) + JITAPIHN $ FRML IITAPIH ITAPIH = (1+ITATTI)*ITAPIHN $ FRML GITAPIG ITAPIG = ITAPIG(-1)*(ITAPIB/ITAPIB(-1)) + JITAPIG $ FRML GITAPISK ITAPISK = ITAPIB + JITAPISK $ FRML GITAULC ITAULC = ((ITAWSSE*(ITAEB+ITAES))/ITAYFBV)/BITAULC $ FRML GITAUCCB ITAUCCB = (ITAPIB*((ITAIRL+ITAIRL(-1)+ITAIRL(-2)+ITAIRL(-3) +ITAIRL(-4)+ITAIRL(-5)+ITAIRL(-6))/7+15) *ITAKBV/ITAYFBV)/BITAUCCB $ FRML _GJRD DLOG(ITAPYFB) = .778*(LOG(ITAULC)-LOG(ITAULC(-1))) +.070*(LOG(ITAPMGS)-LOG(ITAPMGS(-1))) +.252*(ITAGAP-ITAGAP(-1)) -.100*(LOG(ITAPYFB(-1))-.68*LOG(ITAULC(-1)) -.32*LOG(ITAUCCB(-1))+0.02305) +.0157 $ () () IMPORT PRICES () FRML GITAPMGSU ITAPMGSU = MITADNK*LOG(DNKPXGS/ITAEXCH*DNKEXCH) + MITASWE*LOG(SWEPXGS/ITAEXCH*SWEEXCH) + MITANOR*LOG(NORPXGS/ITAEXCH*NOREXCH) + MITAFIN*LOG(FINPXGS/ITAEXCH*FINEXCH) + MITANLD*LOG(NLDPXGS/ITAEXCH*NLDEXCH) + MITAGBR*LOG(GBRPXGS/ITAEXCH*GBREXCH) + MITAESP*LOG(ESPPXGS/ITAEXCH*ESPEXCH) + MITADEU*LOG(DEUPXGS/ITAEXCH*DEUEXCH) + MITABEL*LOG(BELPXGS/ITAEXCH*BELEXCH) + MITAFRA*LOG(FRAPXGS/ITAEXCH*FRAEXCH) + MITAYPN*LOG(YPNPXGS/ITAEXCH*YPNEXCH) + MITAUSA*LOG(USAPXGS/ITAEXCH*USAEXCH) + MITAPOL*LOG(POLPXGS/ITAEXCH*POLEXCH) + MITACZE*LOG(CZEPXGS/ITAEXCH*CZEEXCH) + MITAAUS*LOG(AUSPXGS/ITAEXCH*AUSEXCH) + MITAAUT*LOG(AUTPXGS/ITAEXCH*AUTEXCH) + MITACAN*LOG(CANPXGS/ITAEXCH*CANEXCH) + MITACHL*LOG(CHLPXGS/ITAEXCH*CHLEXCH) + MITAEST*LOG(ESTPXGS/ITAEXCH*ESTEXCH) + MITAGRC*LOG(GRCPXGS/ITAEXCH*GRCEXCH) + MITAHUN*LOG(HUNPXGS/ITAEXCH*HUNEXCH) + MITAISL*LOG(ISLPXGS/ITAEXCH*ISLEXCH) + MITAIRL*LOG(IRLPXGS/ITAEXCH*IRLEXCH) + MITAISR*LOG(ISRPXGS/ITAEXCH*ISREXCH) + MITAKOR*LOG(KORPXGS/ITAEXCH*KOREXCH) + MITALUX*LOG(LUXPXGS/ITAEXCH*LUXEXCH) + MITAMEX*LOG(MEXPXGS/ITAEXCH*MEXEXCH) + MITANZL*LOG(NZLPXGS/ITAEXCH*NZLEXCH) + MITAPRT*LOG(PRTPXGS/ITAEXCH*PRTEXCH) + MITASVK*LOG(SVKPXGS/ITAEXCH*SVKEXCH) + MITASVN*LOG(SVNPXGS/ITAEXCH*SVNEXCH) + MITACHE*LOG(CHEPXGS/ITAEXCH*CHEEXCH) + MITATUR*LOG(TURPXGS/ITAEXCH*TUREXCH) + MITADAE*LOG(DAEPXGS/ITAEXCH*DAEEXCH) + MITAOOP*LOG(OOPPXGS/ITAEXCH*OOPEXCH) + MITABRA*LOG(BRAPXGS/ITAEXCH*BRAEXCH) + MITARUS*LOG(RUSPXGS/ITAEXCH*RUSEXCH) + MITAIND*LOG(INDPXGS/ITAEXCH*INDEXCH) + MITACHN*LOG(CHNPXGS/ITAEXCH*CHNEXCH) + MITAIDN*LOG(IDNPXGS/ITAEXCH*IDNEXCH) + MITAZAF*LOG(ZAFPXGS/ITAEXCH*ZAFEXCH) + MITARWD*LOG(RWDPXGS/ITAEXCH*RWDEXCH) $ FRML _GJRD_ DLOG(ITAPMGS) = (ITAPMGSU-ITAPMGSU(-1)) $ () () () EXPORT PRICES () () FRML _GJR DLOG(ITAPXIN) = .27*DLOG(ITAPMGS)+.73*DLOG(ITAPYFB) $ FRML GITAPXGSU ITAPXGSU = XITADNK*LOG(DNKPMGS/ITAEXCH*DNKEXCH) + XITASWE*LOG(SWEPMGS/ITAEXCH*SWEEXCH) + XITANOR*LOG(NORPMGS/ITAEXCH*NOREXCH) + XITAFIN*LOG(FINPMGS/ITAEXCH*FINEXCH) + XITANLD*LOG(NLDPMGS/ITAEXCH*NLDEXCH) + XITAGBR*LOG(GBRPMGS/ITAEXCH*GBREXCH) + XITAESP*LOG(ESPPMGS/ITAEXCH*ESPEXCH) + XITADEU*LOG(DEUPMGS/ITAEXCH*DEUEXCH) + XITABEL*LOG(BELPMGS/ITAEXCH*BELEXCH) + XITAFRA*LOG(FRAPMGS/ITAEXCH*FRAEXCH) + XITAYPN*LOG(YPNPMGS/ITAEXCH*YPNEXCH) + XITAUSA*LOG(USAPMGS/ITAEXCH*USAEXCH) + XITAPOL*LOG(POLPMGS/ITAEXCH*POLEXCH) + XITACZE*LOG(CZEPMGS/ITAEXCH*CZEEXCH) + XITAAUS*LOG(AUSPMGS/ITAEXCH*AUSEXCH) + XITAAUT*LOG(AUTPMGS/ITAEXCH*AUTEXCH) + XITACAN*LOG(CANPMGS/ITAEXCH*CANEXCH) + XITACHL*LOG(CHLPMGS/ITAEXCH*CHLEXCH) + XITAEST*LOG(ESTPMGS/ITAEXCH*ESTEXCH) + XITAGRC*LOG(GRCPMGS/ITAEXCH*GRCEXCH) + XITAHUN*LOG(HUNPMGS/ITAEXCH*HUNEXCH) + XITAISL*LOG(ISLPMGS/ITAEXCH*ISLEXCH) + XITAIRL*LOG(IRLPMGS/ITAEXCH*IRLEXCH) + XITAISR*LOG(ISRPMGS/ITAEXCH*ISREXCH) + XITAKOR*LOG(KORPMGS/ITAEXCH*KOREXCH) + XITALUX*LOG(LUXPMGS/ITAEXCH*LUXEXCH) + XITAMEX*LOG(MEXPMGS/ITAEXCH*MEXEXCH) + XITANZL*LOG(NZLPMGS/ITAEXCH*NZLEXCH) + XITAPRT*LOG(PRTPMGS/ITAEXCH*PRTEXCH) + XITASVK*LOG(SVKPMGS/ITAEXCH*SVKEXCH) + XITASVN*LOG(SVNPMGS/ITAEXCH*SVNEXCH) + XITACHE*LOG(CHEPMGS/ITAEXCH*CHEEXCH) + XITATUR*LOG(TURPMGS/ITAEXCH*TUREXCH) + XITADAE*LOG(DAEPMGS/ITAEXCH*DAEEXCH) + XITAOOP*LOG(OOPPMGS/ITAEXCH*OOPEXCH) + XITABRA*LOG(BRAPMGS/ITAEXCH*BRAEXCH) + XITARUS*LOG(RUSPMGS/ITAEXCH*RUSEXCH) + XITAIND*LOG(INDPMGS/ITAEXCH*INDEXCH) + XITACHN*LOG(CHNPMGS/ITAEXCH*CHNEXCH) + XITAIDN*LOG(IDNPMGS/ITAEXCH*IDNEXCH) + XITAZAF*LOG(ZAFPMGS/ITAEXCH*ZAFEXCH) + XITARWD*LOG(RWDPMGS/ITAEXCH*RWDEXCH) $ FRML _GJRD_ DLOG(ITAPXGS) = 0.10564 * (ITAPXGSU-ITAPXGSU(-1)) + 0.89436 * DLOG(ITAPXIN) $ () () THE GOVERNMENT SECTOR () () FRML GITACGWV ITACGWV = ITAEG*BITACGWV $ FRML _GJ_D ITACGNV = ITACGNV(-1)*(ITACGWV/ITACGWV(-1))$ FRML IITACGV ITACGV = ITACGWV + ITACGNV $ FRML IITACGW ITACGW = ITACGWV*ITAWRG/(BITACGWV*1000) $ FRML IITACG ITACG = ITACGW + ITACGNV*ITAPCGN + JITACG $ FRML IITAIG ITAIG = ITAIGV*ITAPIG $ FRML GITACFKG ITACFKG = ITATCFKG*ITACG $ FRML GITASSRG ITASSRG = ITATSSRG*ITAWSSS + JITASSRG $ FRML GITATY ITATY = ITATTY*ITAYP + JITATY $ FRML GITATI ITATI = ITATTI*(ITACPV*ITAPCP+ITAIHV*ITAPIH)/(1+ITATTI) +JITATI $ FRML GITATRRH ITATRRH = (.1+JITATTRH)*ITAUN*(ITAWSSE(-1)/1000) +(.75208*ITAPOPT-20096.96)*(ITAWSSE(-1)/1000)+JITATRRH $ FRML GITAYIO ITAYIO = -((ITAIRL+ITAIRL(-1)+ITAIRL(-2))/300) *(ITAGNFL(-1))*(1-DYIO)+DYIO*ZITAYIO + JITAYIO $ FRML IITANLG ITANLG = ITASSRG + ITATY + ITATI + ITAYIO - ITACG - ITAIG - ITAIENTG - ITATRRH - ITATRO - ITAKIG $ FRML IITAGNFL ITAGNFL = ITAGNFL(-1) -ITANLG + BITAGNFL $ () () PRODUCTION AND INCOMES () () FRML IITAGDP ITAGDP = ITACPV*ITAPCP + ITACG + ITAIG + ITAIBV*ITAPIB+ITAIENTG +ITAIHV*ITAPIH + ITAISKV*ITAPISK +ITAXGSV*ITAPXGS - ITAMGSV*ITAPMGS + ITADGDP $ FRML IITAGDPV ITAGDPV = ITACPV+ ITACGV+ ITAIGV+ ITAIBV+ ITAIHV+ ITAISKV + ITAXGSV- ITAMGSV + ITADGDPV $ FRML IITAYF ITAYF = ITAGDP - ITATI $ FRML IITAYFB ITAYFB = ITAYF - ITACGW -ITACFKG $ FRML IITAYFBV ITAYFBV = ITAYFB/ITAPYFB $ FRML IITAWSSS ITAWSSS = (ITAEB*ITAWSSE + ITAEG*ITAWRG)/1000 $ FRML IITAYRP ITAYRP = ITAYF - ITAWSSS - ITACFKG $ FRML GITADP ITADP = ITATDP*(ITAKBV*ITAPIB) $ FRML IITAYIP ITAYIP = ITAYIE - ITAYIO $ FRML GITAYP ITAYP = ITAWSSS - ITASSRG + ITAYRP - ITADP + ITAYIP + ITATRRH + JITAYP $ FRML IITAYDH ITAYDH = ITAYP - ITATY + JITAYDH $ FRML IITAYDRH ITAYDRH = ITAYDH/ITAPCP $ () () CURRENT BALANCE () () FRML IITAX ITAXGS = ITAXGSV*ITAPXGS $ FRML IITAM ITAMGS = ITAMGSV*ITAPMGS $ FRML _GJ_D ITAYIE = (ITAYIE(-1) +ITAYIE(-1)* (2*((DEUEXCH/ITAEXCH)/(DEUEXCH(-1)/ITAEXCH(-1))-1) +((USAEXCH/ITAEXCH)/(USAEXCH(-1)/ITAEXCH(-1))-1))/3 +ITAYIE(-1)* ((2*((DEUEXCH/ITAEXCH) /(DEUEXCH(-1)/ITAEXCH(-1))) *((DEUIRS/DEUIRS(-3))**(1/3)-1) +((USAEXCH/ITAEXCH)/(USAEXCH(-1)/ITAEXCH(-1))) *((USAIRS/USAIRS(-3))**(1/3)-1))/3) +((2*((DEUEXCH/ITAEXCH)/(DEUEXCH(-1)/ITAEXCH(-1))) *.01*DEUIRS +((USAEXCH/ITAEXCH)/(USAEXCH(-1)/ITAEXCH(-1))) *.01*USAIRS)/3) *ITACB(-1))$ FRML IITACB ITACB = ITAXGS - ITAMGS + ITAYIE +ITACBR $ () () FINANCIAL SECTOR () () FRML GITAIRS ITAIRS = eurirs + jitairs$ FRML GITAIRL ITAIRL = (1-DITAIRL)*100*(-1+EXP(LOG(1+ITAIRL(-1)/100) +.323*(LOG(1+ITAIRL(-1)/100)-LOG(1+ITAIRL(-2)/100)) +.494*(LOG(1+ITAIRS/100)-LOG(1+ITAIRS(-1)/100)) -.300*LOG((1+ITAIRL(-1)/100)/(1+ITAIRS(-1)/100)) +.003)) +ITADXIRL*(ITAIRL(-1)+DEUIRL-DEUIRL(-1) +(((ITAPCPN/ITAPCPN(-1)) -(ITAPCPN(-2)/ITAPCPN(-3)))/2 -((DEUPCPN/DEUPCPN(-1)) -(DEUPCPN(-2)/DEUPCPN(-3)))/2)*100) +ITAD1IRL*(ITAIRL(-1)+DEUIRL-DEUIRL(-1))+JITAIRL $ () FRML _GJ_D ITAEXCH = ITAEXCH(-1)*(DEUEXCH/DEUEXCH(-1)) $ FRML _GJ_D ITAEXCH = ITAEXCH(-1)*(EUREXC/EUREXC(-1)) $ () () MAIN ECONOMIC QVOTAS AND OTHER VARIABLES () () FRML IITABNLG ITABNLG = (ITANLG/ITAGDP)*100 $ FRML IITABCB ITABCB = (ITACB/ITAGDP)*100 $ FRML IITABCP ITABCP = (ITACPV/ITAYDRH)*100 $ FRML IITABM ITABM = (ITAMGSV/ITAGDPV)*100 $ FRML IITABIP ITABIP = (ITAIPV/ITAGDPV)*100 $ FRML IITABIB ITABIB = (ITAIBV/ITAYFBV)*100 $ FRML IITABW ITABW = (ITAWSSS/ITAYF)*100 $ FRML _DJ_ ITAIPV = ITAIBV + ITAIHV $ FRML _DJ_ ITATDDV = ITAGDPV - ITANGSV $ FRML IITANGSV ITANGSV = ITAXGSV - ITAMGSV $ () () () ******************* () * USA * () ******************* () () () HOUSEHOLD DEMAND () () FRML _GJRD USACPV = (EXP(LOG(USACPV(-1)) +.700*(.9*LOG(USAYDRH-.5*USAYIP/USAPCP) -.8*LOG(USAYDRH(-1)-.5*USAYIP(-1)/USAPCP(-1)) -.1*LOG(USAYDRH(-2)-.5*USAYIP(-2)/USAPCP(-2))) -.419*(LOG(USACPV(-1)/USAYDRH(-1))) -.00903*(USAIRL-USAIRL(-3))/3 -.02125))$ FRML _GJRD USAIHV = (EXP(.811*LOG(USAIHV(-1)) +1.701*(LOG(USAYFBV)-LOG(USAYFBV(-2)))/2 -.0300*(USAIRL-USAIRL(-1)) +.9629))$ () () BUSINESS INVESTMENT () () FRML IUSAGAP USAGAP = LOG(USAYFBV)-.68*LOG(USAEB+USAES)-.32*LOG(USAKBV) -USAGAPT*TID-USAGAPK $ FRML GUSAUC USAUC = USAPIB*(USAIRL+15) $ FRML _GJRD_ DLOG(USAKBV) = 1.00000*DLOG(USAKBV(-1)) - 0.39147*DLOG(USAKBV(-2)) + 0.17710*DLOG(USAYFBV) + 0.02000*(LOG(USAYFBV(-1)/USAKBV(-1)) -0.68*LOG(USAUC(-1)/USAWSSE(-1))) + TUSAKBV + 1.42385 $ FRML GUSAIBV USAIBV = USAKBV-USAKBV(-1)+USAAKBV*USAKBV(-1) $ FRML _DJ_ USAITV = USAIHV + USAIBV + USAIGV $ () () EXPORT VOLUMES () () FRML GUSAXGSDU USAXGSDU = XUSADNK*LOG(DNKMGSD) + XUSASWE*LOG(SWEMGSD) + XUSANOR*LOG(NORMGSD) + XUSAFIN*LOG(FINMGSD) + XUSANLD*LOG(NLDMGSD) + XUSAGBR*LOG(GBRMGSD) + XUSABEL*LOG(BELMGSD) + XUSADEU*LOG(DEUMGSD) + XUSAFRA*LOG(FRAMGSD) + XUSAESP*LOG(ESPMGSD) + XUSAYPN*LOG(YPNMGSD) + XUSAITA*LOG(ITAMGSD) + XUSAPOL*LOG(POLMGSD) + XUSACZE*LOG(CZEMGSD) + XUSAAUS*LOG(AUSMGSD) + XUSAAUT*LOG(AUTMGSD) + XUSACAN*LOG(CANMGSD) + XUSACHL*LOG(CHLMGSD) + XUSAEST*LOG(ESTMGSD) + XUSAGRC*LOG(GRCMGSD) + XUSAHUN*LOG(HUNMGSD) + XUSAISL*LOG(ISLMGSD) + XUSAIRL*LOG(IRLMGSD) + XUSAISR*LOG(ISRMGSD) + XUSAKOR*LOG(KORMGSD) + XUSALUX*LOG(LUXMGSD) + XUSAMEX*LOG(MEXMGSD) + XUSANZL*LOG(NZLMGSD) + XUSAPRT*LOG(PRTMGSD) + XUSASVK*LOG(SVKMGSD) + XUSASVN*LOG(SVNMGSD) + XUSACHE*LOG(CHEMGSD) + XUSATUR*LOG(TURMGSD) + XUSADAE*LOG(DAEMGSD) + XUSAOOP*LOG(OOPMGSD) + XUSABRA*LOG(BRAMGSD) + XUSARUS*LOG(RUSMGSD) + XUSAIND*LOG(INDMGSD) + XUSACHN*LOG(CHNMGSD) + XUSAIDN*LOG(IDNMGSD) + XUSAZAF*LOG(ZAFMGSD) + XUSARWD*LOG(RWDMGSD) $ FRML _GJRD DLOG(USAXGSD) = (USAXGSDU-USAXGSDU(-1))$ FRML IUSAXGSV USAXGSV = USAXGSD/USAPXGS $ () () IMPORT () () FRML _GJ_ USAWMV = .079*USACPV + .065*USACGNV +.061*(USAITV+USAISKV) +.072*USAXGSV $ () FRML _GJRD Dlog(USAMGSV) = 2.73007*Dlog(USAWMV) - 0.03*(Log(USAMGSV(-1)/USAWMV(-1))-1.000*Log(USAPYFB(-1)/USAPMGS(-1))-0.37670) + 0.02160 - 0.04340 $ () FRML IUSAMGSD USAMGSD = USAMGSV*USAPMGS $ () () LABOUR MARKET () () FRML _GJ_D USALF = USAPOPT*((USALF(-1)/USAPOPT(-1)) + (1-USADLF)*(.130*DLOG(USAET) - .00095)) $ () FRML _DJ_ USAEBN = (1/0.68)*LOG(USAYFBV)-((1-0.68)/0.68)*LOG(USAKBV) $ FRML _DJ_ USAEBW = LOG(USAYFBV)+0.32*LOG(USAUC/USAWSSE) $ FRML _GJRD DLOG(USAEP) = 0.55440*DLOG(USAYFBV)+0.33979*DLOG(USAYFBV(-1)) -0.05000*(LOG(USAEP(-1))-USAEBW(-1)) +0.13219 $ FRML _D__D USAEB = USAEP - USAES $ FRML GUSAEE USAEE = USAEB + USAEG $ FRML _EJ_ USAET = USAEE + USAES $ FRML IUSAUN USAUN = USALF - USAET $ FRML IUSAUNR USAUNR = (USAUN/USALF)*100 $ () () WAGES () FRML GUSAWU USAWU = (3.86*LOG(DEUWSSE)+ 4.71*LOG(GBRWSSE)+ 2.41*LOG(FRAWSSE)+ 8.39*LOG(YPNWSSE))/19.37 $ FRML IUSAEYFB USAEYFB = (USAYFBV/(USAEB+USAES))/BUSAEYFB $ FRML _GJRD DLOG(USAWR) = .80009*(DLOG(USAPYFB)) +.11396*(USAWU-USAWU(-1)) -.00332*(USAUNR(-1)-.5*(USAUNR(-2))) +.62916*(DLOG(USAEYFB)) +.57512*DLOG(USAPCP/USAPYFB) -.30604*LOG(USAWSSE(-1)/(USAPYFB(-1)*USAEYFB(-1))) +1.11250 $ FRML GUSAWSSE USAWSSE = USAKWSSE*USAWR + JUSAWSSE $ FRML GUSAWRG USAWRG = USAKWRG*USAWR + JUSAWRG $ () () DOMESTIC PRICES () () FRML GUSAPCPN USAPCPN = USAPCPN(-1)*(.08*(USAPMGS/USAPMGS(-1))+ .92*(USAPYFB/USAPYFB(-1))) + JUSAPCPN $ FRML IUSAPCP USAPCP = (1+USATTI)*USAPCPN $ FRML GUSAPCGN USAPCGN = USAPCGN(-1)*(.15*(USAPMGS/USAPMGS(-1))+ .85*(USAPYFB/USAPYFB(-1))) + JUSAPCGN $ FRML GUSAPIB USAPIB = USAPIB(-1)*(.07*(USAPMGS/USAPMGS(-1))+ .93*(USAPYFB/USAPYFB(-1))) + JUSAPIB $ FRML GUSAPIG USAPIG = USAPIG(-1)*(.07*(USAPMGS/USAPMGS(-1))+ .93*(USAPYFB/USAPYFB(-1))) + JUSAPIG $ FRML GUSAPIHN USAPIHN = USAPIHN(-1)*(USAPIB/USAPIB(-1)) + JUSAPIHN $ FRML IUSAPIH USAPIH = (1+USATTI)*USAPIHN $ FRML GUSAPISK USAPISK = USAPIB + JUSAPISK $ FRML GUSAULC USAULC = ((USAWSSE*(USAEB+USAES))/USAYFBV)/BUSAULC $ FRML GUSAUCCB USAUCCB = (USAPIB*((USAIRL+USAIRL(-1)+USAIRL(-2)+USAIRL(-3) +USAIRL(-4)+USAIRL(-5)+USAIRL(-6))/7+15) *USAKBV/USAYFBV)/BUSAUCCB $ FRML _GJRD DLOG(USAPYFB) = .69341*(LOG(USAULC)-LOG(USAULC(-1))) +.05149*(LOG(USAPMGS)-LOG(USAPMGS(-1))) +.25949*(USAGAP-USAGAP(-1)) -.06979*(LOG(USAPYFB(-1))-.68*LOG(USAULC(-1)) -.32*LOG(USAUCCB(-1))+0.10552) +.01055 $ () () IMPORT PRICES () () FRML GUSAPMGSU USAPMGSU = MUSADNK*LOG(DNKPXGS/USAEXCH*DNKEXCH) + MUSASWE*LOG(SWEPXGS/USAEXCH*SWEEXCH) + MUSANOR*LOG(NORPXGS/USAEXCH*NOREXCH) + MUSAFIN*LOG(FINPXGS/USAEXCH*FINEXCH) + MUSANLD*LOG(NLDPXGS/USAEXCH*NLDEXCH) + MUSAGBR*LOG(GBRPXGS/USAEXCH*GBREXCH) + MUSAESP*LOG(ESPPXGS/USAEXCH*ESPEXCH) + MUSADEU*LOG(DEUPXGS/USAEXCH*DEUEXCH) + MUSABEL*LOG(BELPXGS/USAEXCH*BELEXCH) + MUSAFRA*LOG(FRAPXGS/USAEXCH*FRAEXCH) + MUSAYPN*LOG(YPNPXGS/USAEXCH*YPNEXCH) + MUSAITA*LOG(ITAPXGS/USAEXCH*ITAEXCH) + MUSAPOL*LOG(POLPXGS/USAEXCH*POLEXCH) + MUSACZE*LOG(CZEPXGS/USAEXCH*CZEEXCH) + MUSAAUS*LOG(AUSPXGS/USAEXCH*AUSEXCH) + MUSAAUT*LOG(AUTPXGS/USAEXCH*AUTEXCH) + MUSACAN*LOG(CANPXGS/USAEXCH*CANEXCH) + MUSACHL*LOG(CHLPXGS/USAEXCH*CHLEXCH) + MUSAEST*LOG(ESTPXGS/USAEXCH*ESTEXCH) + MUSAGRC*LOG(GRCPXGS/USAEXCH*GRCEXCH) + MUSAHUN*LOG(HUNPXGS/USAEXCH*HUNEXCH) + MUSAISL*LOG(ISLPXGS/USAEXCH*ISLEXCH) + MUSAIRL*LOG(IRLPXGS/USAEXCH*IRLEXCH) + MUSAISR*LOG(ISRPXGS/USAEXCH*ISREXCH) + MUSAKOR*LOG(KORPXGS/USAEXCH*KOREXCH) + MUSALUX*LOG(LUXPXGS/USAEXCH*LUXEXCH) + MUSAMEX*LOG(MEXPXGS/USAEXCH*MEXEXCH) + MUSANZL*LOG(NZLPXGS/USAEXCH*NZLEXCH) + MUSAPRT*LOG(PRTPXGS/USAEXCH*PRTEXCH) + MUSASVK*LOG(SVKPXGS/USAEXCH*SVKEXCH) + MUSASVN*LOG(SVNPXGS/USAEXCH*SVNEXCH) + MUSACHE*LOG(CHEPXGS/USAEXCH*CHEEXCH) + MUSATUR*LOG(TURPXGS/USAEXCH*TUREXCH) + MUSADAE*LOG(DAEPXGS/USAEXCH*DAEEXCH) + MUSAOOP*LOG(OOPPXGS/USAEXCH*OOPEXCH) + MUSABRA*LOG(BRAPXGS/USAEXCH*BRAEXCH) + MUSARUS*LOG(RUSPXGS/USAEXCH*RUSEXCH) + MUSAIND*LOG(INDPXGS/USAEXCH*INDEXCH) + MUSACHN*LOG(CHNPXGS/USAEXCH*CHNEXCH) + MUSAIDN*LOG(IDNPXGS/USAEXCH*IDNEXCH) + MUSAZAF*LOG(ZAFPXGS/USAEXCH*ZAFEXCH) + MUSARWD*LOG(RWDPXGS/USAEXCH*RWDEXCH) $ FRML _GJRD_ DLOG(USAPMGS) = (USAPMGSU-USAPMGSU(-1)) $ () () EXPORT PRICES () () FRML _GJR DLOG(USAPXIN) = .10*DLOG(USAPMGS)+ .90*DLOG(USAPYFB) $ FRML GUSAPXGSU USAPXGSU = XUSADNK*LOG(DNKPMGS/USAEXCH*DNKEXCH) + XUSASWE*LOG(SWEPMGS/USAEXCH*SWEEXCH) + XUSANOR*LOG(NORPMGS/USAEXCH*NOREXCH) + XUSAFIN*LOG(FINPMGS/USAEXCH*FINEXCH) + XUSANLD*LOG(NLDPMGS/USAEXCH*NLDEXCH) + XUSAGBR*LOG(GBRPMGS/USAEXCH*GBREXCH) + XUSAESP*LOG(ESPPMGS/USAEXCH*ESPEXCH) + XUSADEU*LOG(DEUPMGS/USAEXCH*DEUEXCH) + XUSABEL*LOG(BELPMGS/USAEXCH*BELEXCH) + XUSAFRA*LOG(FRAPMGS/USAEXCH*FRAEXCH) + XUSAYPN*LOG(YPNPMGS/USAEXCH*YPNEXCH) + XUSAITA*LOG(ITAPMGS/USAEXCH*ITAEXCH) + XUSAPOL*LOG(POLPMGS/USAEXCH*POLEXCH) + XUSACZE*LOG(CZEPMGS/USAEXCH*CZEEXCH) + XUSAAUS*LOG(AUSPMGS/USAEXCH*AUSEXCH) + XUSAAUT*LOG(AUTPMGS/USAEXCH*AUTEXCH) + XUSACAN*LOG(CANPMGS/USAEXCH*CANEXCH) + XUSACHL*LOG(CHLPMGS/USAEXCH*CHLEXCH) + XUSAEST*LOG(ESTPMGS/USAEXCH*ESTEXCH) + XUSAGRC*LOG(GRCPMGS/USAEXCH*GRCEXCH) + XUSAHUN*LOG(HUNPMGS/USAEXCH*HUNEXCH) + XUSAISL*LOG(ISLPMGS/USAEXCH*ISLEXCH) + XUSAIRL*LOG(IRLPMGS/USAEXCH*IRLEXCH) + XUSAISR*LOG(ISRPMGS/USAEXCH*ISREXCH) + XUSAKOR*LOG(KORPMGS/USAEXCH*KOREXCH) + XUSALUX*LOG(LUXPMGS/USAEXCH*LUXEXCH) + XUSAMEX*LOG(MEXPMGS/USAEXCH*MEXEXCH) + XUSANZL*LOG(NZLPMGS/USAEXCH*NZLEXCH) + XUSAPRT*LOG(PRTPMGS/USAEXCH*PRTEXCH) + XUSASVK*LOG(SVKPMGS/USAEXCH*SVKEXCH) + XUSASVN*LOG(SVNPMGS/USAEXCH*SVNEXCH) + XUSACHE*LOG(CHEPMGS/USAEXCH*CHEEXCH) + XUSATUR*LOG(TURPMGS/USAEXCH*TUREXCH) + XUSADAE*LOG(DAEPMGS/USAEXCH*DAEEXCH) + XUSAOOP*LOG(OOPPMGS/USAEXCH*OOPEXCH) + XUSABRA*LOG(BRAPMGS/USAEXCH*BRAEXCH) + XUSARUS*LOG(RUSPMGS/USAEXCH*RUSEXCH) + XUSAIND*LOG(INDPMGS/USAEXCH*INDEXCH) + XUSACHN*LOG(CHNPMGS/USAEXCH*CHNEXCH) + XUSAIDN*LOG(IDNPMGS/USAEXCH*IDNEXCH) + XUSAZAF*LOG(ZAFPMGS/USAEXCH*ZAFEXCH) + XUSARWD*LOG(RWDPMGS/USAEXCH*RWDEXCH) $ FRML _GJRD_ DLOG(USAPXGS) = 0.61931 *(USAPXGSU-USAPXGSU(-1)) + 0.38069 * DLOG(USAPXIN) $ () () THE GOVERNMENT SECTOR () () FRML GUSACGWV USACGWV = USAEG*BUSACGWV $ FRML GUSACGNV USACGNV = USACGNV(-1)*(USACGWV/USACGWV(-1))*(1-DUSACGNV) + JUSACGNV $ FRML IUSACGV USACGV = USACGWV + USACGNV $ FRML IUSACGW USACGW = USACGWV*USAWRG/(BUSACGWV*1000) $ FRML IUSACG USACG = USACGW + USACGNV*USAPCGN + JUSACG $ FRML IUSAIG USAIG = USAIGV*USAPIG $ FRML GUSACFKG USACFKG = USATCFKG*USACG $ FRML GUSASSRG USASSRG = USATSSRG*USAWSSS + JUSASSRG $ FRML GUSATY USATY = USATTY*USAYP + JUSATY $ FRML GUSATI USATI = USATTI*(USACPV*USAPCP+USAIHV*USAPIH)/(1+USATTI) +JUSATI $ FRML GUSATRRH USATRRH = (.133+JUSATTRH)*USAUN*(USAWSSE(-1)/1000) +(.24191*USAPOPT-24563.1)*(USAWSSE(-1)/1000) +JUSATRRH $ FRML GUSAYIO USAYIO = -((USAIRL+USAIRL(-1)+USAIRL(-2))/300) *(USAGNFL(-1))*(1-DYIO)+DYIO*ZUSAYIO + JUSAYIO $ FRML IUSANLG USANLG = USASSRG + USATY + USATI + USAYIO - USACG - USAIG - USAIENTG - USATRRH - USATRO - USAKIG $ FRML IUSAGNFL USAGNFL = USAGNFL(-1) -USANLG + BUSAGNFL $ () () PRODUCTION AND INCOMES () () FRML IUSAGDP USAGDP = USACPV*USAPCP + USACG + USAIG + USAIBV*USAPIB+USAIENTG +USAIHV*USAPIH + USAISKV*USAPISK +USAXGSV*USAPXGS - USAMGSV*USAPMGS + USADGDP $ FRML GUSAGDPV USAGDPV = USACPV+ USACGV+ USAIGV+ USAIBV+ USAIHV+ USAISKV + USAXGSV- USAMGSV + USADGDPV $ FRML IUSAYF USAYF = USAGDP - USATI $ FRML IUSAYFB USAYFB = USAYF - USACGW - USACFKG $ FRML IUSAYFBV USAYFBV = USAYFB/USAPYFB $ FRML IUSAWSSS USAWSSS = (USAEB*USAWSSE + USAEG*USAWRG)/1000 $ FRML IUSAYRP USAYRP = USAYF - USAWSSS - USACFKG $ FRML GUSADP USADP = USATDP*(USAKBV*USAPIB) $ FRML IUSAYIP USAYIP = USAYIE - USAYIO $ FRML GUSAYP USAYP = USAWSSS - USASSRG + USAYRP - USADP + USAYIP + USATRRH + JUSAYP $ FRML IUSAYDH USAYDH = USAYP - USATY + JUSAYDH $ FRML IUSAYDRH USAYDRH = USAYDH/USAPCP $ () () CURRENT BALANCE () () FRML IUSAX USAXGS = USAXGSV*USAPXGS $ FRML IUSAM USAMGS = USAMGSV*USAPMGS $ FRML _GJ_D USAYIE = (USAYIE(-1) +USAYIE(-1)*((USAIRS/USAIRS(-3))**(1/3)-1) +.01*USAIRS*USACB(-1))$ FRML IUSACB USACB = USAXGS - USAMGS + USAYIE +USACBR $ () () FINANCIAL SECTOR () FRML _GJ_D_Z USAIRS = 150*DLOG(USAPCPN) + 50*DLOG(USAGDPV) $ () FRML GUSAIRS USAIRS = DUSAIRS*USAIRS(-1)+(USAD1IRS*(DEUIRS-DEUIRS(-1)) () +USAD2IRS*100*LOG(USAPCPN) () +USAD3IRS*100*LOG(USAPCPN(-1)) () +USAD4IRS*100*LOG(USAPCPN(-2)) () +USAD5IRS*100*LOG(USAGDPV) () +USAD6IRS*(100*(-USANLG/USAGDP)) () +USAD7IRS*(100*(-USACB/USAGDP))) + JUSAIRS $ FRML GUSAIRL USAIRL = (1-DUSAIRL)*100*(-1+EXP(.7717*LOG(1+USAIRL(-1)/100) +.4720*LOG(1+USAIRS/100)-.2437*LOG(1+USAIRS(-1)/100) +.0018)) +USAD1IRL*(USAIRL(-1)+USAIRS-USAIRS(-1))+JUSAIRL $ () () MAIN ECONOMIC QVOTAS AND OTHER VARIABLES () () FRML IUSABNLG USABNLG = (USANLG/USAGDP)*100 $ FRML IUSABCB USABCB = (USACB/USAGDP)*100 $ FRML IUSABCP USABCP = (USACPV/USAYDRH)*100 $ FRML IUSABM USABM = (USAMGSV/USAGDPV)*100 $ FRML IUSABIP USABIP = (USAIPV/USAGDPV)*100 $ FRML IUSABIB USABIB = (USAIBV/USAYFBV)*100 $ FRML IUSABW USABW = (USAWSSS/USAYF)*100 $ FRML _DJ_ USAIPV = USAIBV + USAIHV $ FRML _DJ_ USATDDV = USAGDPV - USANGSV - USADGDPV $ FRML IUSANGSV USANGSV = USAXGSV - USAMGSV $ () () () ******************* () * YPN * () ******************* () () HOUSEHOLD DEMAND () () FRML _GJRD DLOG(YPNCPV) = .680*(LOG(YPNYDRH-.75*YPNYIP/YPNPCP) -LOG(YPNYDRH(-1)-.75*YPNYIP(-1)/YPNPCP(-1)))/2 -.0074*(YPNIRL-YPNIRL(-2))/2 -.0583*(LOG(YPNCPV(-1)/YPNYDRH(-1))) +.00163 $ FRML _GJRD YPNIHV = (EXP(.899*LOG(YPNIHV(-1)) +1.238*(LOG(YPNYFBV)-LOG(YPNYFBV(-2)))/2 -.0678*(YPNIRL-YPNIRL(-3))/3 +.9605))$ () () BUSINESS INVESTMENT () () FRML IYPNGAP YPNGAP = LOG(YPNYFBV)-.76*LOG(YPNEB+YPNES)-.24*LOG(YPNKBV) -YPNGAPT*TID-YPNGAPK $ FRML GYPNUC YPNUC = YPNPIB*(YPNIRL+15) $ FRML _GJRD_ DLOG(YPNKBV) = 0.32557*DLOG(YPNKBV(-1)) + 0.10003*DLOG(YPNYFBV(-1)) + 0.07745*(LOG(YPNYFBV(-1)/YPNKBV(-1)) -0.76*LOG(YPNUC(-1)/YPNWSSE(-1))) + TYPNKBV + 0.02258*D1975 + 0.02600*D1991 + 3.31737 $ FRML GYPNIBV YPNIBV = YPNKBV-YPNKBV(-1)+YPNAKBV*YPNKBV(-1) $ FRML _DJ_ YPNITV = YPNIHV + YPNIBV + YPNIGV $ () () EXPORT VOLUMES () () FRML GYPNXGSDU YPNXGSDU = XYPNDNK*LOG(DNKMGSD) + XYPNSWE*LOG(SWEMGSD) + XYPNNOR*LOG(NORMGSD) + XYPNFIN*LOG(FINMGSD) + XYPNNLD*LOG(NLDMGSD) + XYPNGBR*LOG(GBRMGSD) + XYPNBEL*LOG(BELMGSD) + XYPNDEU*LOG(DEUMGSD) + XYPNFRA*LOG(FRAMGSD) + XYPNESP*LOG(ESPMGSD) + XYPNUSA*LOG(USAMGSD) + XYPNYPN*LOG(YPNMGSD) + XYPNPOL*LOG(POLMGSD) + XYPNCZE*LOG(CZEMGSD) + XYPNAUS*LOG(AUSMGSD) + XYPNAUT*LOG(AUTMGSD) + XYPNCAN*LOG(CANMGSD) + XYPNCHL*LOG(CHLMGSD) + XYPNEST*LOG(ESTMGSD) + XYPNGRC*LOG(GRCMGSD) + XYPNHUN*LOG(HUNMGSD) + XYPNISL*LOG(ISLMGSD) + XYPNIRL*LOG(IRLMGSD) + XYPNISR*LOG(ISRMGSD) + XYPNKOR*LOG(KORMGSD) + XYPNLUX*LOG(LUXMGSD) + XYPNMEX*LOG(MEXMGSD) + XYPNNZL*LOG(NZLMGSD) + XYPNPRT*LOG(PRTMGSD) + XYPNSVK*LOG(SVKMGSD) + XYPNSVN*LOG(SVNMGSD) + XYPNCHE*LOG(CHEMGSD) + XYPNTUR*LOG(TURMGSD) + XYPNDAE*LOG(DAEMGSD) + XYPNOOP*LOG(OOPMGSD) + XYPNBRA*LOG(BRAMGSD) + XYPNRUS*LOG(RUSMGSD) + XYPNIND*LOG(INDMGSD) + XYPNCHN*LOG(CHNMGSD) + XYPNIDN*LOG(IDNMGSD) + XYPNZAF*LOG(ZAFMGSD) + XYPNRWD*LOG(RWDMGSD) $ FRML _GJRD DLOG(YPNXGSD)= (YPNXGSDU-YPNXGSDU(-1)) $ FRML IYPNXGSV YPNXGSV = YPNXGSD*USAEXCH/(YPNEXCH*YPNPXGS) $ () () IMPORT () () FRML _GJ_ YPNWMV = .063*YPNCPV + .044*YPNCGNV +.056*(YPNITV+YPNISKV) +.072*YPNXGSV $ () FRML _GJRD Dlog(YPNMGSV) = 1.58774*Dlog(YPNWMV) - 0.09204*(Log(YPNMGSV(-1)/YPNWMV(-1))-.43041*Log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klf*POLPOPT $ FRML _GJ_D POLLF = POLPOPT*(POLLF(-1)/POLPOPT(-1)) $ () FRML _DJ_ POLEBN = (1/0.70)*LOG(POLYFBV)-((1-0.70)/0.70)*LOG(POLKBV) $ FRML _DJ_ POLEBW = LOG(POLYFBV)+0.3*LOG(POLUC/POLWSSE) $ FRML _GJRD DLOG(POLEP) = 0.66601*DLOG(POLYFBV)+0.33399*DLOG(POLYFBV(-1)) -0.18479*(LOG(POLEP(-1))-POLEBW(-1)) +0.51272 $ FRML _D__D POLEB = POLEP - POLES $ FRML GPOLEE POLEE = POLEB + POLEG $ FRML _DJ_ POLET = POLEE + POLES $ FRML IPOLUN POLUN = POLLF - POLET + JPOLUN $ FRML IPOLUNR POLUNR = (POLUN/POLLF)*100 $ () () WAGES () FRML GPOLWU POLWU = (25.8683*LOG(DEUWSSE)+5.9358*LOG(GBRWSSE)+12.0233*LOG(FRAWSSE) +6.5941*LOG(ITAWSSE)+5.5363*LOG(CZEWSSE))/54.2418 $ FRML IPOLEYFB POLEYFB = (POLYFBV/(POLEB+POLES))/BPOLEYFB $ FRML _GJRD DLOG(POLWR) = 0.900*(DLOG(POLPYFB)) +0.900*(DLOG(POLEYFB)) -0.10*log(POLwsse(-1)/(POLpyfb(-1)*POLeyfb(-1))) - 0.003*POLunr(-1) +0.36500 $ FRML GPOLWSSE POLWSSE = POLKWSSE*POLWR + JPOLWSSE $ FRML GPOLWRG POLWRG = POLKWRG*POLWR + JPOLWRG $ () () DOMESTIC PRICES () () FRML GPOLPCPN POLPCPN = POLPCPN(-1)*( 0.15429*(POLPMGS/POLPMGS(-1))+ 0.84571*(POLPYFB/POLPYFB(-1))) + JPOLPCPN $ FRML IPOLPCP POLPCP = (1+POLTTI)*POLPCPN $ FRML GPOLPCGN POLPCGN = POLPCGN(-1)*(0.15429*(POLPMGS/POLPMGS(-1))+ 0.84571*(POLPYFB/POLPYFB(-1))) + JPOLPCGN $ FRML GPOLPIB POLPIB = POLPIB(-1)*( 0.15429*(POLPMGS/POLPMGS(-1))+ 0.84571*(POLPYFB/POLPYFB(-1))) + JPOLPIB $ FRML GPOLPIHN POLPIHN = POLPIHN(-1)*(POLPIB/POLPIB(-1)) + JPOLPIHN $ FRML IPOLPIH POLPIH = (1+POLTTI)*POLPIHN $ FRML GPOLPIG POLPIG = POLPIG(-1)*(POLPIB/POLPIB(-1)) + JPOLPIG $ FRML GPOLPISK POLPISK = POLPIB + JPOLPISK $ FRML GPOLULC POLULC = ((POLWSSE*(POLEB+POLES))/POLYFBV)/BPOLULC $ FRML GPOLUCCB POLUCCB = (POLpib*(POLirl+20)*POLkbv/POLyfbv)/BPOLUCCB $ FRML _GJRD DLOG(POLPYFB) = 0.50255*(LOG(POLULC)-LOG(POLULC(-1))) +0.09937*(Log(POLpmgs)-Log(POLpmgs(-1))) -0.10000*(LOG(POLPYFB(-1))-.7*LOG(POLULC(-1)) -.3*LOG(POLUCCB(-1)) - 0.09344)+ 0.02378 $ () () IMPORT PRICES () FRML GPOLPMGSU POLPMGSU = MPOLDNK*LOG(DNKPXGS/POLEXCH*DNKEXCH) + MPOLSWE*LOG(SWEPXGS/POLEXCH*SWEEXCH) + MPOLNOR*LOG(NORPXGS/POLEXCH*NOREXCH) + MPOLFIN*LOG(FINPXGS/POLEXCH*FINEXCH) + MPOLNLD*LOG(NLDPXGS/POLEXCH*NLDEXCH) + MPOLGBR*LOG(GBRPXGS/POLEXCH*GBREXCH) + MPOLESP*LOG(ESPPXGS/POLEXCH*ESPEXCH) + MPOLDEU*LOG(DEUPXGS/POLEXCH*DEUEXCH) + MPOLBEL*LOG(BELPXGS/POLEXCH*BELEXCH) + MPOLFRA*LOG(FRAPXGS/POLEXCH*FRAEXCH) + MPOLYPN*LOG(YPNPXGS/POLEXCH*YPNEXCH) + MPOLITA*LOG(ITAPXGS/POLEXCH*ITAEXCH) + MPOLUSA*LOG(USAPXGS/POLEXCH*USAEXCH) + MPOLCZE*LOG(CZEPXGS/POLEXCH*CZEEXCH) + MPOLAUS*LOG(AUSPXGS/POLEXCH*AUSEXCH) + MPOLAUT*LOG(AUTPXGS/POLEXCH*AUTEXCH) + MPOLCAN*LOG(CANPXGS/POLEXCH*CANEXCH) + MPOLCHL*LOG(CHLPXGS/POLEXCH*CHLEXCH) + MPOLEST*LOG(ESTPXGS/POLEXCH*ESTEXCH) + MPOLGRC*LOG(GRCPXGS/POLEXCH*GRCEXCH) + MPOLHUN*LOG(HUNPXGS/POLEXCH*HUNEXCH) + MPOLISL*LOG(ISLPXGS/POLEXCH*ISLEXCH) + MPOLIRL*LOG(IRLPXGS/POLEXCH*IRLEXCH) + MPOLISR*LOG(ISRPXGS/POLEXCH*ISREXCH) + MPOLKOR*LOG(KORPXGS/POLEXCH*KOREXCH) + MPOLLUX*LOG(LUXPXGS/POLEXCH*LUXEXCH) + MPOLMEX*LOG(MEXPXGS/POLEXCH*MEXEXCH) + MPOLNZL*LOG(NZLPXGS/POLEXCH*NZLEXCH) + MPOLPRT*LOG(PRTPXGS/POLEXCH*PRTEXCH) + MPOLSVK*LOG(SVKPXGS/POLEXCH*SVKEXCH) + MPOLSVN*LOG(SVNPXGS/POLEXCH*SVNEXCH) + MPOLCHE*LOG(CHEPXGS/POLEXCH*CHEEXCH) + MPOLTUR*LOG(TURPXGS/POLEXCH*TUREXCH) + MPOLDAE*LOG(DAEPXGS/POLEXCH*DAEEXCH) + MPOLOOP*LOG(OOPPXGS/POLEXCH*OOPEXCH) + MPOLBRA*LOG(BRAPXGS/POLEXCH*BRAEXCH) + MPOLRUS*LOG(RUSPXGS/POLEXCH*RUSEXCH) + MPOLIND*LOG(INDPXGS/POLEXCH*INDEXCH) + MPOLCHN*LOG(CHNPXGS/POLEXCH*CHNEXCH) + MPOLIDN*LOG(IDNPXGS/POLEXCH*IDNEXCH) + MPOLZAF*LOG(ZAFPXGS/POLEXCH*ZAFEXCH) + MPOLRWD*LOG(RWDPXGS/POLEXCH*RWDEXCH) $ FRML _GJRD DLOG(POLPMGS) = (POLPMGSU-POLPMGSU(-1)) $ () EXPORT PRICES () () FRML _GJR DLOG(POLPXIN) = .43*DLOG(POLPMGS)+ .57*DLOG(POLPYFB) $ FRML GPOLPXGSU POLPXGSU = XPOLDNK*LOG(DNKPMGS/POLEXCH*DNKEXCH) + XPOLSWE*LOG(SWEPMGS/POLEXCH*SWEEXCH) + XPOLNOR*LOG(NORPMGS/POLEXCH*NOREXCH) + XPOLFIN*LOG(FINPMGS/POLEXCH*FINEXCH) + XPOLNLD*LOG(NLDPMGS/POLEXCH*NLDEXCH) + XPOLGBR*LOG(GBRPMGS/POLEXCH*GBREXCH) + XPOLESP*LOG(ESPPMGS/POLEXCH*ESPEXCH) + XPOLDEU*LOG(DEUPMGS/POLEXCH*DEUEXCH) + XPOLBEL*LOG(BELPMGS/POLEXCH*BELEXCH) + XPOLFRA*LOG(FRAPMGS/POLEXCH*FRAEXCH) + XPOLYPN*LOG(YPNPMGS/POLEXCH*YPNEXCH) + XPOLITA*LOG(ITAPMGS/POLEXCH*ITAEXCH) + XPOLUSA*LOG(USAPMGS/POLEXCH*USAEXCH) + XPOLCZE*LOG(CZEPMGS/POLEXCH*CZEEXCH) + XPOLAUS*LOG(AUSPMGS/POLEXCH*AUSEXCH) + XPOLAUT*LOG(AUTPMGS/POLEXCH*AUTEXCH) + XPOLCAN*LOG(CANPMGS/POLEXCH*CANEXCH) + XPOLCHL*LOG(CHLPMGS/POLEXCH*CHLEXCH) + XPOLEST*LOG(ESTPMGS/POLEXCH*ESTEXCH) + XPOLGRC*LOG(GRCPMGS/POLEXCH*GRCEXCH) + XPOLHUN*LOG(HUNPMGS/POLEXCH*HUNEXCH) + XPOLISL*LOG(ISLPMGS/POLEXCH*ISLEXCH) + XPOLIRL*LOG(IRLPMGS/POLEXCH*IRLEXCH) + XPOLISR*LOG(ISRPMGS/POLEXCH*ISREXCH) + XPOLKOR*LOG(KORPMGS/POLEXCH*KOREXCH) + XPOLLUX*LOG(LUXPMGS/POLEXCH*LUXEXCH) + XPOLMEX*LOG(MEXPMGS/POLEXCH*MEXEXCH) + XPOLNZL*LOG(NZLPMGS/POLEXCH*NZLEXCH) + XPOLPRT*LOG(PRTPMGS/POLEXCH*PRTEXCH) + XPOLSVK*LOG(SVKPMGS/POLEXCH*SVKEXCH) + XPOLSVN*LOG(SVNPMGS/POLEXCH*SVNEXCH) + XPOLCHE*LOG(CHEPMGS/POLEXCH*CHEEXCH) + XPOLTUR*LOG(TURPMGS/POLEXCH*TUREXCH) + XPOLDAE*LOG(DAEPMGS/POLEXCH*DAEEXCH) + XPOLOOP*LOG(OOPPMGS/POLEXCH*OOPEXCH) + XPOLBRA*LOG(BRAPMGS/POLEXCH*BRAEXCH) + XPOLRUS*LOG(RUSPMGS/POLEXCH*RUSEXCH) + XPOLIND*LOG(INDPMGS/POLEXCH*INDEXCH) + XPOLCHN*LOG(CHNPMGS/POLEXCH*CHNEXCH) + XPOLIDN*LOG(IDNPMGS/POLEXCH*IDNEXCH) + XPOLZAF*LOG(ZAFPMGS/POLEXCH*ZAFEXCH) + XPOLRWD*LOG(RWDPMGS/POLEXCH*RWDEXCH) $ FRML _GJRD DLOG(POLPXGS) = 0.66314*dlog(POLpyfb)+0.33686*(POLpxgsu-POLpxgsu(-1)) +0.28733*(dlog(POLpmgs)-dlog(POLpyfb)) $ () FRML _GJRD_ DLOG(POLPXGS) = (POLPXGSU-POLPXGSU(-1)) $ () () THE GOVERNMENT SECTOR () () FRML GPOLCGWV POLCGWV = POLEG * BPOLCGWV $ FRML GPOLCGNV POLCGNV = POLCGNV(-1)*(POLCGWV/POLCGWV(-1))*(1-DPOLCGNV) + JPOLCGNV $ FRML IPOLCGV POLCGV = POLCGWV + POLCGNV $ FRML IPOLCGW POLCGW = POLCGWV*POLWRG/(BPOLCGWV*1000) $ FRML IPOLCG POLCG = POLCGW + POLCGNV*POLPCGN $ FRML IPOLIG POLIG = POLIGV*POLPIG $ FRML GPOLCFKG POLCFKG = POLTCFKG*POLCG $ FRML GPOLSSRG POLSSRG = POLTSSRG*POLWSSS + JPOLSSRG $ FRML GPOLTY POLTY = POLTTY*POLYP + JPOLTY $ FRML GPOLTI POLTI = POLTTI*(POLCPV*POLPCP+POLIHV*POLPIH)/(1+POLTTI) +JPOLTI $ FRML GpolTRRH polTRRH = (0.268*polun+polpopt*kpoltrrh)*(polwsse(-1)/1000)+JpolTRRH $ FRML GPOLYIO POLYIO = -((POLIRL+POLIRL(-1)+POLIRL(-2))/300) *POLGNFL(-1)*(1-DYIO)+DYIO*ZPOLYIO + JPOLYIO $ FRML IPOLNLG POLNLG = POLSSRG + POLTY + POLTI + POLYIO - POLCG - POLIG - POLIENTG - POLTRRH - POLTRO - POLKIG $ FRML IPOLGNFL POLGNFL = POLGNFL(-1) -POLNLG + BPOLGNFL $ () () PRODUCTION AND INCOMES () () FRML IPOLGDP POLGDP = POLCPV*POLPCP + POLCG + POLIG + POLIBV*POLPIB+POLIENTG +POLIHV*POLPIH + POLISKV*POLPISK +POLXGSV*POLPXGS - POLMGSV*POLPMGS + POLDGDP $ FRML IPOLGDPV POLGDPV = POLCPV+ POLCGV+ POLIGV+ POLIBV+ POLIHV+ POLISKV + POLXGSV- POLMGSV + POLDGDPV $ FRML IPOLYF POLYF = POLGDP - POLTI $ FRML IPOLYFB POLYFB = POLYF - POLCGW - POLCFKG $ FRML IPOLYFBV POLYFBV = POLYFB/POLPYFB $ FRML IPOLWSSS POLWSSS = (POLEB*POLWSSE + POLEG*POLWRG)/1000 $ FRML IPOLYRP POLYRP = POLYF - POLWSSS - POLCFKG $ FRML GPOLDP POLDP = POLTDP*(POLKBV*POLPIB) $ FRML IPOLYIP POLYIP = POLYIE - POLYIO $ FRML GPOLYP POLYP = POLWSSS - POLSSRG + POLYRP - POLDP + POLYIP + POLTRRH + JPOLYP $ FRML IPOLYDH POLYDH = POLYP - POLTY + JPOLYDH $ FRML IPOLYDRH POLYDRH = POLYDH/POLPCP $ () () CURRENT BALANCE () () FRML IPOLX POLXGS = POLXGSV*POLPXGS $ FRML IPOLM POLMGS = POLMGSV*POLPMGS $ FRML _GJ_D POLYIE = (POLYIE(-1) +POLYIE(-1)*(2*((DEUEXCH/POLEXCH) /(DEUEXCH(-1)/POLEXCH(-1))-1) +((USAEXCH/POLEXCH)/(USAEXCH(-1)/POLEXCH(-1))-1))/3 +POLYIE(-1)*((2*((DEUEXCH/POLEXCH) /(DEUEXCH(-1)/POLEXCH(-1))) *((DEUIRS/DEUIRS(-3))**(1/3)-1) +((USAEXCH/POLEXCH)/(USAEXCH(-1)/POLEXCH(-1))) *((USAIRS/USAIRS(-3))**(1/3)-1))/3) +((2*((DEUEXCH/POLEXCH)/(DEUEXCH(-1)/POLEXCH(-1))) *.01*DEUIRS+((USAEXCH/POLEXCH) /(USAEXCH(-1)/POLEXCH(-1)))*.01*USAIRS)/3) *POLCB(-1))$ FRML IPOLCB POLCB = POLXGS - POLMGS + POLYIE +POLCBR $ () () FINANCIAL SECTOR () () () FRML GPOLIRS POLIRS = EURIRS + jPOLIRS $ FRML _GJ_D_Z POLIRS = 150*DLOG(POLPCPN) + 50*DLOG(POLGDPV) $ FRML GPOLIRL POLIRL = (1-DPOLIRL)*100*(-1+EXP(0.96098*LOG(1+POLIRL(-1)/100) +0.61487*LOG(1+POLIRS/100)- 0.57585*LOG(1+POLIRS(-1)/100) - 0.00136)) +POLD1IRL*(POLIRL(-1)+POLIRS-POLIRS(-1))+JPOLIRL $ () FRML _GJ_D POLEXCH = 1/EXP( () LOG(USAEXCH(-1)*USAPYFB(-1)/(POLEXCH(-1)*POLPYFB(-1))) () -1*(LOG((1+POLIRS/100)/(1+USAIRS/100)) () -LOG((1+POLIRS(-1)/100)/(1+USAIRS(-1)/100))) () -2.9171*LOG((1+POLIRL(-1)/100)/(1+USAIRL(-1)/100)) () -.3024*LOG(USAEXCH(-1)*USAPYFB(-1)/( () POLEXCH(-1)*POLPYFB(-1))) () -.00658*TID+13.1959) () *USAPYFB*USAEXCH/POLPYFB $ FRML _GJ_D_Z LOG(POLEXCH) = LOG(POLEXP) + (LOG(1+POLIRS/100)-LOG(1+USAIRS/100)) $ FRML _GJ_D_Z POLEXP = POLEXB $ FRML _GJ_D_Z POLEXB = POLEXB(-1) + 1/3*(POLEXCH-POLEXB(-1)) $ () FRML _GJ_D POLEXCH = POLEXCH(-1)*(EUREXC/EUREXC(-1)) $ () () MAIN ECONOMIC QVOTAS AND OTHER VARIABLES () () FRML IPOLBNLG POLBNLG = (POLNLG/POLGDP)*100 $ FRML IPOLBCB POLBCB = (POLCB/POLGDP)*100 $ FRML IPOLBCP POLBCP = (POLCPV/POLYDRH)*100 $ FRML IPOLBM POLBM = (POLMGSV/POLGDPV)*100 $ FRML IPOLBIP POLBIP = (POLIPV/POLGDPV)*100 $ FRML IPOLBIB POLBIB = (POLIBV/POLYFBV)*100 $ FRML IPOLBW POLBW = (POLWSSS/POLYF)*100 $ FRML _DJ_ POLIPV = POLIBV + POLIHV $ FRML _DJ_ POLTDDV = POLGDPV - POLNGSV $ FRML IPOLNGSV POLNGSV = POLXGSV - POLMGSV $ () () () () () ********************* () * CZE * () ********************* () () HOUSEHOLD DEMAND () () FRML _GJRD Dlog(CZECPV) = 0.50*DLOG(CZEYDRH) -0.56768*LOG(CZECPV(-1)/CZEYDRH(-1)) + 0.00161 $ () FRML _GJRD CZEIHV = (EXP(0.90231*LOG(CZEIHV(-1)) + 1.89742*(LOG(CZEYFBV)-LOG(CZEYFBV(-2)))/2 -.01844*((CZEirl-CZEirl(-3))/3) + 0.43226))$ () () BUSINESS INVESTMENT () () FRML ICZEGAP CZEGAP = LOG(CZEYFBV)-.7*LOG(CZEEB+CZEES)-.3*LOG(CZEKBV) -CZEGAPT*TID-CZEGAPK $ FRML GCZEUC CZEUC = CZEPIB*(CZEIRL+15) $ FRML _GJRD_ DLOG(CZEKBV) = 0.34424*DLOG(CZEKBV(-1)) + 0.15000*DLOG(CZEYFBV) + 0.03000*(LOG(CZEYFBV(-1)/CZEKBV(-1)) -0.70*LOG(CZEUC(-1)/CZEWSSE(-1))) + TCZEKBV + 6.92650 $ FRML GCZEIBV CZEIBV = CZEKBV-CZEKBV(-1)+CZEAKBV*CZEKBV(-1) $ FRML _DJ_ CZEITV = CZEIHV + CZEIBV + CZEIGV $ () () EXPORT VOLUMES () FRML GCZEXGSDU CZEXGSDU = XCZEDNK*LOG(DNKMGSD) + XCZESWE*LOG(SWEMGSD) + XCZENOR*LOG(NORMGSD) + XCZEFIN*LOG(FINMGSD) + XCZENLD*LOG(NLDMGSD) + XCZEGBR*LOG(GBRMGSD) + XCZEBEL*LOG(BELMGSD) + XCZEDEU*LOG(DEUMGSD) + XCZEFRA*LOG(FRAMGSD) + XCZEESP*LOG(ESPMGSD) + XCZEYPN*LOG(YPNMGSD) + XCZEITA*LOG(ITAMGSD) + XCZEUSA*LOG(USAMGSD) + XCZEPOL*LOG(POLMGSD) + XCZEAUS*LOG(AUSMGSD) + XCZEAUT*LOG(AUTMGSD) + XCZECAN*LOG(CANMGSD) + XCZECHL*LOG(CHLMGSD) + XCZEEST*LOG(ESTMGSD) + XCZEGRC*LOG(GRCMGSD) + XCZEHUN*LOG(HUNMGSD) + XCZEISL*LOG(ISLMGSD) + XCZEIRL*LOG(IRLMGSD) + XCZEISR*LOG(ISRMGSD) + XCZEKOR*LOG(KORMGSD) + XCZELUX*LOG(LUXMGSD) + XCZEMEX*LOG(MEXMGSD) + XCZENZL*LOG(NZLMGSD) + XCZEPRT*LOG(PRTMGSD) + XCZESVK*LOG(SVKMGSD) + XCZESVN*LOG(SVNMGSD) + XCZECHE*LOG(CHEMGSD) + XCZETUR*LOG(TURMGSD) + XCZEDAE*LOG(DAEMGSD) + XCZEOOP*LOG(OOPMGSD) + XCZEBRA*LOG(BRAMGSD) + XCZERUS*LOG(RUSMGSD) + XCZEIND*LOG(INDMGSD) + XCZECHN*LOG(CHNMGSD) + XCZEIDN*LOG(IDNMGSD) + XCZEZAF*LOG(ZAFMGSD) + XCZERWD*LOG(RWDMGSD) $ FRML _GJRD DLOG(CZEXGSD) = (CZEXGSDU-CZEXGSDU(-1)) $ FRML ICZEXGSV CZEXGSV = CZEXGSD/(CZEEXCH*CZEPXGS)*USAEXCH $ () () IMPORT () () FRML _GJ_ CZEWMV = .190*CZECPV+.140*CZECGNV+.184*CZEIHV+.184*(CZEIBV+CZEISKV) +.184*CZEIGV+.186*CZEXGSV $ FRML _GJRD DLOG(CZEMGSV) = 1.2*DLOG(CZEWMV) -0.26711*(LOG(CZEMGSV(-1)/CZEWMV(-1)) -0.8*LOG(CZEPYFB(-1)/CZEPMGS(-1)) -0.78336 ) +0.02285 $ () FRML ICZEMGSD CZEMGSD = CZEMGSV*CZEPMGS*CZEEXCH/USAEXCH $ () () LABOUR MARKET () () () FRML _GJ_D CZELF = CZEklf*CZEPOPT $ FRML _GJ_D CZELF = CZEPOPT*(CZELF(-1)/CZEPOPT(-1)) $ () FRML _DJ_ CZEEBN = (1/0.70)*LOG(CZEYFBV)-((1-0.70)/0.70)*LOG(CZEKBV) $ FRML _DJ_ CZEEBW = LOG(CZEYFBV)+0.3*LOG(CZEUC/CZEWSSE) $ FRML _GJRD DLOG(CZEEP) = 0.09228*DLOG(CZEYFBV)+0.70772*DLOG(CZEYFBV(-1)) -0.05*(LOG(CZEEP(-1))-CZEEBW(-1)) +0.05271 $ FRML _D__D CZEEB = CZEEP - CZEES $ FRML GCZEEE CZEEE = CZEEB + CZEEG $ FRML _DJ_ CZEET = CZEEE + CZEES $ FRML ICZEUN CZEUN = CZELF - CZEET + JCZEUN $ FRML ICZEUNR CZEUNR = (CZEUN/CZELF)*100 $ () () WAGES () FRML GCZEWU CZEWU = (30.7623*LOG(DEUWSSE)+5.0304*LOG(GBRWSSE)+5.3891*LOG(FRAWSSE) +4.8472*LOG(ITAWSSE)+5.9113*LOG(POLWSSE))/51.9403 $ FRML ICZEEYFB CZEEYFB = (CZEYFBV/(CZEEB+CZEES))/BCZEEYFB $ FRML _GJRD DLOG(CZEWR) = 0.46181*(DLOG(CZEPYFB)) +0.49654*(DLOG(CZEEYFB)) -0.36971*LOG(CZEWSSE(-1)/(CZEPYFB(-1)*CZEEYFB(-1))) -0.00300*CZEunr(-1) +2.08657 $ FRML GCZEWSSE CZEWSSE = CZEKWSSE*CZEWR + JCZEWSSE $ FRML GCZEWRG CZEWRG = CZEKWRG*CZEWR + JCZEWRG $ () () DOMESTIC PRICES () () FRML GCZEPCPN CZEPCPN = CZEPCPN(-1)*( 0.18954*(CZEPMGS/CZEPMGS(-1))+ 0.81046*(CZEPYFB/CZEPYFB(-1))) + JCZEPCPN $ FRML ICZEPCP CZEPCP = (1+CZETTI)*CZEPCPN $ FRML GCZEPCGN CZEPCGN = CZEPCGN(-1)*(0.25804*(CZEPMGS/CZEPMGS(-1))+ 0.74196*(CZEPYFB/CZEPYFB(-1))) + JCZEPCGN $ FRML GCZEPIB CZEPIB = CZEPIB(-1)*(0.45276*(CZEPMGS/CZEPMGS(-1))+ 0.54724*(CZEPYFB/CZEPYFB(-1))) + JCZEPIB $ FRML GCZEPIHN CZEPIHN = CZEPIHN(-1)*(CZEPIB/CZEPIB(-1)) + JCZEPIHN $ FRML ICZEPIH CZEPIH = (1+CZETTI)*CZEPIHN $ FRML GCZEPIG CZEPIG = CZEPIG(-1)*(CZEPIB/CZEPIB(-1)) + JCZEPIG $ FRML GCZEPISK CZEPISK = CZEPIB + JCZEPISK $ FRML GCZEULC CZEULC = ((CZEWSSE*(CZEEB+CZEES))/CZEYFBV)/BCZEULC $ FRML GCZEUCCB CZEUCCB = (CZEpib*(CZEirl+15)*CZEkbv/CZEyfbv)/BCZEUCCB $ FRML _GJRD DLOG(CZEPYFB) = 0.62338*(LOG(CZEULC)-LOG(CZEULC(-1))) -0.10000*(LOG(CZEPYFB(-1))-.7*LOG(CZEULC(-1)) -.3*LOG(CZEUCCB(-1))- 0.01789)+0.00546 $ () () IMPORT PRICES () FRML GCZEPMGSU CZEPMGSU = MCZEDNK*LOG(DNKPXGS/CZEEXCH*DNKEXCH) + MCZESWE*LOG(SWEPXGS/CZEEXCH*SWEEXCH) + MCZENOR*LOG(NORPXGS/CZEEXCH*NOREXCH) + MCZEFIN*LOG(FINPXGS/CZEEXCH*FINEXCH) + MCZENLD*LOG(NLDPXGS/CZEEXCH*NLDEXCH) + MCZEGBR*LOG(GBRPXGS/CZEEXCH*GBREXCH) + MCZEESP*LOG(ESPPXGS/CZEEXCH*ESPEXCH) + MCZEDEU*LOG(DEUPXGS/CZEEXCH*DEUEXCH) + MCZEBEL*LOG(BELPXGS/CZEEXCH*BELEXCH) + MCZEFRA*LOG(FRAPXGS/CZEEXCH*FRAEXCH) + MCZEYPN*LOG(YPNPXGS/CZEEXCH*YPNEXCH) + MCZEITA*LOG(ITAPXGS/CZEEXCH*ITAEXCH) + MCZEUSA*LOG(USAPXGS/CZEEXCH*USAEXCH) + MCZEPOL*LOG(POLPXGS/CZEEXCH*POLEXCH) + MCZEAUS*LOG(AUSPXGS/CZEEXCH*AUSEXCH) + MCZEAUT*LOG(AUTPXGS/CZEEXCH*AUTEXCH) + MCZECAN*LOG(CANPXGS/CZEEXCH*CANEXCH) + MCZECHL*LOG(CHLPXGS/CZEEXCH*CHLEXCH) + MCZEEST*LOG(ESTPXGS/CZEEXCH*ESTEXCH) + MCZEGRC*LOG(GRCPXGS/CZEEXCH*GRCEXCH) + MCZEHUN*LOG(HUNPXGS/CZEEXCH*HUNEXCH) + MCZEISL*LOG(ISLPXGS/CZEEXCH*ISLEXCH) + MCZEIRL*LOG(IRLPXGS/CZEEXCH*IRLEXCH) + MCZEISR*LOG(ISRPXGS/CZEEXCH*ISREXCH) + MCZEKOR*LOG(KORPXGS/CZEEXCH*KOREXCH) + MCZELUX*LOG(LUXPXGS/CZEEXCH*LUXEXCH) + MCZEMEX*LOG(MEXPXGS/CZEEXCH*MEXEXCH) + MCZENZL*LOG(NZLPXGS/CZEEXCH*NZLEXCH) + MCZEPRT*LOG(PRTPXGS/CZEEXCH*PRTEXCH) + MCZESVK*LOG(SVKPXGS/CZEEXCH*SVKEXCH) + MCZESVN*LOG(SVNPXGS/CZEEXCH*SVNEXCH) + MCZECHE*LOG(CHEPXGS/CZEEXCH*CHEEXCH) + MCZETUR*LOG(TURPXGS/CZEEXCH*TUREXCH) + MCZEDAE*LOG(DAEPXGS/CZEEXCH*DAEEXCH) + MCZEOOP*LOG(OOPPXGS/CZEEXCH*OOPEXCH) + MCZEBRA*LOG(BRAPXGS/CZEEXCH*BRAEXCH) + MCZERUS*LOG(RUSPXGS/CZEEXCH*RUSEXCH) + MCZEIND*LOG(INDPXGS/CZEEXCH*INDEXCH) + MCZECHN*LOG(CHNPXGS/CZEEXCH*CHNEXCH) + MCZEIDN*LOG(IDNPXGS/CZEEXCH*IDNEXCH) + MCZEZAF*LOG(ZAFPXGS/CZEEXCH*ZAFEXCH) + MCZERWD*LOG(RWDPXGS/CZEEXCH*RWDEXCH) $ FRML _GJRD DLOG(CZEPMGS) = (CZEPMGSU-CZEPMGSU(-1)) $ () EXPORT PRICES () () FRML _GJR DLOG(CZEPXIN) = .43*DLOG(CZEPMGS)+ .57*DLOG(CZEPYFB) $ FRML GCZEPXGSU CZEPXGSU = XCZEDNK*LOG(DNKPMGS/CZEEXCH*DNKEXCH) + XCZESWE*LOG(SWEPMGS/CZEEXCH*SWEEXCH) + XCZENOR*LOG(NORPMGS/CZEEXCH*NOREXCH) + XCZEFIN*LOG(FINPMGS/CZEEXCH*FINEXCH) + XCZENLD*LOG(NLDPMGS/CZEEXCH*NLDEXCH) + XCZEGBR*LOG(GBRPMGS/CZEEXCH*GBREXCH) + XCZEESP*LOG(ESPPMGS/CZEEXCH*ESPEXCH) + XCZEDEU*LOG(DEUPMGS/CZEEXCH*DEUEXCH) + XCZEBEL*LOG(BELPMGS/CZEEXCH*BELEXCH) + XCZEFRA*LOG(FRAPMGS/CZEEXCH*FRAEXCH) + XCZEYPN*LOG(YPNPMGS/CZEEXCH*YPNEXCH) + XCZEITA*LOG(ITAPMGS/CZEEXCH*ITAEXCH) + XCZEUSA*LOG(USAPMGS/CZEEXCH*USAEXCH) + XCZEPOL*LOG(POLPMGS/CZEEXCH*POLEXCH) + XCZEAUS*LOG(AUSPMGS/CZEEXCH*AUSEXCH) + XCZEAUT*LOG(AUTPMGS/CZEEXCH*AUTEXCH) + XCZECAN*LOG(CANPMGS/CZEEXCH*CANEXCH) + XCZECHL*LOG(CHLPMGS/CZEEXCH*CHLEXCH) + XCZEEST*LOG(ESTPMGS/CZEEXCH*ESTEXCH) + XCZEGRC*LOG(GRCPMGS/CZEEXCH*GRCEXCH) + XCZEHUN*LOG(HUNPMGS/CZEEXCH*HUNEXCH) + XCZEISL*LOG(ISLPMGS/CZEEXCH*ISLEXCH) + XCZEIRL*LOG(IRLPMGS/CZEEXCH*IRLEXCH) + XCZEISR*LOG(ISRPMGS/CZEEXCH*ISREXCH) + XCZEKOR*LOG(KORPMGS/CZEEXCH*KOREXCH) + XCZELUX*LOG(LUXPMGS/CZEEXCH*LUXEXCH) + XCZEMEX*LOG(MEXPMGS/CZEEXCH*MEXEXCH) + XCZENZL*LOG(NZLPMGS/CZEEXCH*NZLEXCH) + XCZEPRT*LOG(PRTPMGS/CZEEXCH*PRTEXCH) + XCZESVK*LOG(SVKPMGS/CZEEXCH*SVKEXCH) + XCZESVN*LOG(SVNPMGS/CZEEXCH*SVNEXCH) + XCZECHE*LOG(CHEPMGS/CZEEXCH*CHEEXCH) + XCZETUR*LOG(TURPMGS/CZEEXCH*TUREXCH) + XCZEDAE*LOG(DAEPMGS/CZEEXCH*DAEEXCH) + XCZEOOP*LOG(OOPPMGS/CZEEXCH*OOPEXCH) + XCZEBRA*LOG(BRAPMGS/CZEEXCH*BRAEXCH) + XCZERUS*LOG(RUSPMGS/CZEEXCH*RUSEXCH) + XCZEIND*LOG(INDPMGS/CZEEXCH*INDEXCH) + XCZECHN*LOG(CHNPMGS/CZEEXCH*CHNEXCH) + XCZEIDN*LOG(IDNPMGS/CZEEXCH*IDNEXCH) + XCZEZAF*LOG(ZAFPMGS/CZEEXCH*ZAFEXCH) + XCZERWD*LOG(RWDPMGS/CZEEXCH*RWDEXCH) $ FRML _GJRD DLOG(CZEPXGS) = 0.66314*dlog(CZEpyfb)+0.33686*(CZEpxgsu-CZEpxgsu(-1)) +0.28733*(dlog(CZEpmgs)-dlog(CZEpyfb)) $ () FRML _GJRD_ DLOG(CZEPXGS) = (CZEPXGSU-CZEPXGSU(-1)) $ () () THE GOVERNMENT SECTOR () () FRML GCZECGWV CZECGWV = CZEEG * BCZECGWV $ FRML GCZECGNV CZECGNV = CZECGNV(-1)*(CZECGWV/CZECGWV(-1))*(1-DCZECGNV) + JCZECGNV $ FRML ICZECGV CZECGV = CZECGWV + CZECGNV $ FRML ICZECGW CZECGW = CZECGWV*CZEWRG/(BCZECGWV*1000) $ FRML ICZECG CZECG = CZECGW + CZECGNV*CZEPCGN $ FRML ICZEIG CZEIG = CZEIGV*CZEPIG $ FRML GCZECFKG CZECFKG = CZETCFKG*CZECG $ FRML GCZESSRG CZESSRG = CZETSSRG*CZEWSSS + JCZESSRG $ FRML GCZETY CZETY = CZETTY*CZEYP + JCZETY $ FRML GCZETI CZETI = CZETTI*(CZECPV*CZEPCP+CZEIHV*CZEPIH)/(1+CZETTI) +JCZETI $ FRML GczeTRRH czeTRRH = (0.387*czeun+czepopt*kczetrrh)*(czewsse(-1)/1000)+JczeTRRH $ FRML GCZEYIO CZEYIO = -((CZEIRL+CZEIRL(-1)+CZEIRL(-2))/300) *CZEGNFL(-1)*(1-DYIO)+DYIO*ZCZEYIO + JCZEYIO $ FRML ICZENLG CZENLG = CZESSRG + CZETY + CZETI + CZEYIO - CZECG - CZEIG - CZEIENTG - CZETRRH - CZETRO - CZEKIG $ FRML ICZEGNFL CZEGNFL = CZEGNFL(-1) -CZENLG + BCZEGNFL $ () () PRODUCTION AND INCOMES () () FRML ICZEGDP CZEGDP = CZECPV*CZEPCP + CZECG + CZEIG + CZEIBV*CZEPIB+CZEIENTG +CZEIHV*CZEPIH + CZEISKV*CZEPISK +CZEXGSV*CZEPXGS - CZEMGSV*CZEPMGS + CZEDGDP $ FRML ICZEGDPV CZEGDPV = CZECPV+ CZECGV+ CZEIGV+ CZEIBV+ CZEIHV+ CZEISKV + CZEXGSV- CZEMGSV + CZEDGDPV $ FRML ICZEYF CZEYF = CZEGDP - CZETI $ FRML ICZEYFB CZEYFB = CZEYF - CZECGW - CZECFKG $ FRML ICZEYFBV CZEYFBV = CZEYFB/CZEPYFB $ FRML ICZEWSSS CZEWSSS = (CZEEB*CZEWSSE + CZEEG*CZEWRG)/1000 $ FRML ICZEYRP CZEYRP = CZEYF - CZEWSSS - CZECFKG $ FRML GCZEDP CZEDP = CZETDP*(CZEKBV*CZEPIB) $ FRML ICZEYIP CZEYIP = CZEYIE - CZEYIO $ FRML GCZEYP CZEYP = CZEWSSS - CZESSRG + CZEYRP - CZEDP + CZEYIP + CZETRRH + JCZEYP $ FRML ICZEYDH CZEYDH = CZEYP - CZETY + JCZEYDH $ FRML ICZEYDRH CZEYDRH = CZEYDH/CZEPCP $ () () CURRENT BALANCE () () FRML ICZEX CZEXGS = CZEXGSV*CZEPXGS $ FRML ICZEM CZEMGS = CZEMGSV*CZEPMGS $ FRML _GJ_D CZEYIE = (CZEYIE(-1) +CZEYIE(-1)*(2*((DEUEXCH/CZEEXCH) /(DEUEXCH(-1)/CZEEXCH(-1))-1) +((USAEXCH/CZEEXCH)/(USAEXCH(-1)/CZEEXCH(-1))-1))/3 +CZEYIE(-1)*((2*((DEUEXCH/CZEEXCH) /(DEUEXCH(-1)/CZEEXCH(-1))) *((DEUIRS/DEUIRS(-3))**(1/3)-1) +((USAEXCH/CZEEXCH)/(USAEXCH(-1)/CZEEXCH(-1))) *((USAIRS/USAIRS(-3))**(1/3)-1))/3) +((2*((DEUEXCH/CZEEXCH)/(DEUEXCH(-1)/CZEEXCH(-1))) *.01*DEUIRS+((USAEXCH/CZEEXCH) /(USAEXCH(-1)/CZEEXCH(-1)))*.01*USAIRS)/3) *CZECB(-1))$ FRML ICZECB CZECB = CZEXGS - CZEMGS + CZEYIE +CZECBR $ () () FINANCIAL SECTOR () () () FRML GCZEIRS CZEIRS = eurirs + jCZEirs $ FRML _GJ_D_Z CZEIRS = 150*DLOG(CZEPCPN) + 50*DLOG(CZEGDPV) $ FRML GCZEIRL CZEIRL = (1-DCZEIRL)*100*(-1+EXP(0.89280*LOG(1+CZEIRL(-1)/100) +0.36634*LOG(1+CZEIRS/100)- 0.25914*LOG(1+CZEIRS(-1)/100) - 0.00088)) +CZED1IRL*(CZEIRL(-1)+CZEIRS-CZEIRS(-1))+JCZEIRL $ () FRML _GJ_D CZEEXCH = 1/EXP( () LOG(USAEXCH(-1)*USAPYFB(-1)/(CZEEXCH(-1)*CZEPYFB(-1))) () -1*(LOG((1+CZEIRS/100)/(1+USAIRS/100)) () -LOG((1+CZEIRS(-1)/100)/(1+USAIRS(-1)/100))) () -2.9171*LOG((1+CZEIRL(-1)/100)/(1+USAIRL(-1)/100)) () -.3024*LOG(USAEXCH(-1)*USAPYFB(-1)/( () CZEEXCH(-1)*CZEPYFB(-1))) () -.00658*TID+13.1959) () *USAPYFB*USAEXCH/CZEPYFB $ () FRML _GJ_D CZEEXCH = CZEEXCH(-1)*(EUREXC/EUREXC(-1)) $ FRML _GJ_D_Z LOG(CZEEXCH) = LOG(CZEEXP) + (LOG(1+CZEIRS/100)-LOG(1+USAIRS/100)) $ FRML _GJ_D_Z CZEEXP = CZEEXB $ FRML _GJ_D_Z CZEEXB = CZEEXB(-1) + 1/3*(CZEEXCH-CZEEXB(-1)) $ () () MAIN ECONOMIC QVOTAS AND OTHER VARIABLES () () FRML ICZEBNLG CZEBNLG = (CZENLG/CZEGDP)*100 $ FRML ICZEBCB CZEBCB = (CZECB/CZEGDP)*100 $ FRML ICZEBCP CZEBCP = (CZECPV/CZEYDRH)*100 $ FRML ICZEBM CZEBM = (CZEMGSV/CZEGDPV)*100 $ FRML ICZEBIP CZEBIP = (CZEIPV/CZEGDPV)*100 $ FRML ICZEBIB CZEBIB = (CZEIBV/CZEYFBV)*100 $ FRML ICZEBW CZEBW = (CZEWSSS/CZEYF)*100 $ FRML _DJ_ CZEIPV = CZEIBV + CZEIHV $ FRML _DJ_ CZETDDV = CZEGDPV - CZENGSV $ FRML ICZENGSV CZENGSV = CZEXGSV - CZEMGSV $ () () () () ************************************************************************************* () SEMI-ENDOGENE LANDE - Kun handlen er modelleret * () ************************************************************************************* () () () ******************* () * AUS * () ******************* () () EXPORT VOLUMES () FRML GAUSXGSDU AUSXGSDU = XAUSDNK*LOG(DNKMGSD) + XAUSSWE*LOG(SWEMGSD) + XAUSNOR*LOG(NORMGSD) + XAUSFIN*LOG(FINMGSD) + XAUSNLD*LOG(NLDMGSD) + XAUSGBR*LOG(GBRMGSD) + XAUSBEL*LOG(BELMGSD) + XAUSDEU*LOG(DEUMGSD) + XAUSFRA*LOG(FRAMGSD) + XAUSESP*LOG(ESPMGSD) + XAUSYPN*LOG(YPNMGSD) + XAUSITA*LOG(ITAMGSD) + XAUSUSA*LOG(USAMGSD) + XAUSPOL*LOG(POLMGSD) + XAUSCZE*LOG(CZEMGSD) + XAUSAUT*LOG(AUTMGSD) + XAUSCAN*LOG(CANMGSD) + XAUSCHL*LOG(CHLMGSD) + XAUSEST*LOG(ESTMGSD) + XAUSHUN*LOG(HUNMGSD) + XAUSGRC*LOG(GRCMGSD) + XAUSISL*LOG(ISLMGSD) + XAUSIRL*LOG(IRLMGSD) + XAUSISR*LOG(ISRMGSD) + XAUSKOR*LOG(KORMGSD) + XAUSLUX*LOG(LUXMGSD) + XAUSMEX*LOG(MEXMGSD) + XAUSNZL*LOG(NZLMGSD) + XAUSPRT*LOG(PRTMGSD) + XAUSSVK*LOG(SVKMGSD) + XAUSSVN*LOG(SVNMGSD) + XAUSCHE*LOG(CHEMGSD) + XAUSTUR*LOG(TURMGSD) + XAUSDAE*LOG(DAEMGSD) + XAUSOOP*LOG(OOPMGSD) + XAUSBRA*LOG(BRAMGSD) + XAUSRUS*LOG(RUSMGSD) + XAUSIND*LOG(INDMGSD) + XAUSCHN*LOG(CHNMGSD) + XAUSIDN*LOG(IDNMGSD) + XAUSZAF*LOG(ZAFMGSD) + XAUSRWD*LOG(RWDMGSD) $ FRML _GJRD DLOG(AUSXGSD) = (AUSXGSDU-AUSXGSDU(-1))$ FRML GAUSXGSV AUSXGSV = AUSXGSD*USAEXCH/(AUSEXCH*AUSPXGS) $ () () () IMPORT () FRML _GJRD_ DLOG(AUSMGSV) = 1.00000*DLOG(AUSXGSV)-0.8319*DLOG(AUSPMGS/AUSPXGS) -0.6200*LOG(AUSMGSV(-1)/AUSXGSV(-1)) -0.5853*LOG(AUSPMGS(-1)/AUSPXGS(-1)) +0.0298 - D1972*0.2296 $ () FRML GAUSMGSD AUSMGSD = AUSMGSV*AUSPMGS*AUSEXCH/USAEXCH $ () () () IMPORT PRICES () () FRML GAUSPMGSU AUSPMGSU = MAUSDNK*LOG(DNKPXGS/AUSEXCH*DNKEXCH) + MAUSSWE*LOG(SWEPXGS/AUSEXCH*SWEEXCH) + MAUSNOR*LOG(NORPXGS/AUSEXCH*NOREXCH) + MAUSFIN*LOG(FINPXGS/AUSEXCH*FINEXCH) + MAUSNLD*LOG(NLDPXGS/AUSEXCH*NLDEXCH) + MAUSGBR*LOG(GBRPXGS/AUSEXCH*GBREXCH) + MAUSESP*LOG(ESPPXGS/AUSEXCH*ESPEXCH) + MAUSDEU*LOG(DEUPXGS/AUSEXCH*DEUEXCH) + MAUSBEL*LOG(BELPXGS/AUSEXCH*BELEXCH) + MAUSFRA*LOG(FRAPXGS/AUSEXCH*FRAEXCH) + MAUSYPN*LOG(YPNPXGS/AUSEXCH*YPNEXCH) + MAUSITA*LOG(ITAPXGS/AUSEXCH*ITAEXCH) + MAUSUSA*LOG(USAPXGS/AUSEXCH*USAEXCH) + MAUSPOL*LOG(POLPXGS/AUSEXCH*POLEXCH) + MAUSCZE*LOG(CZEPXGS/AUSEXCH*CZEEXCH) + MAUSAUT*LOG(AUTPXGS/AUSEXCH*AUTEXCH) + MAUSCAN*LOG(CANPXGS/AUSEXCH*CANEXCH) + MAUSCHL*LOG(CHLPXGS/AUSEXCH*CHLEXCH) + MAUSEST*LOG(ESTPXGS/AUSEXCH*ESTEXCH) + MAUSHUN*LOG(HUNPXGS/AUSEXCH*HUNEXCH) + MAUSGRC*LOG(GRCPXGS/AUSEXCH*GRCEXCH) + MAUSISL*LOG(ISLPXGS/AUSEXCH*ISLEXCH) + MAUSIRL*LOG(IRLPXGS/AUSEXCH*IRLEXCH) + MAUSISR*LOG(ISRPXGS/AUSEXCH*ISREXCH) + MAUSKOR*LOG(KORPXGS/AUSEXCH*KOREXCH) + MAUSLUX*LOG(LUXPXGS/AUSEXCH*LUXEXCH) + MAUSMEX*LOG(MEXPXGS/AUSEXCH*MEXEXCH) + MAUSNZL*LOG(NZLPXGS/AUSEXCH*NZLEXCH) + MAUSPRT*LOG(PRTPXGS/AUSEXCH*PRTEXCH) + MAUSSVK*LOG(SVKPXGS/AUSEXCH*SVKEXCH) + MAUSSVN*LOG(SVNPXGS/AUSEXCH*SVNEXCH) + MAUSCHE*LOG(CHEPXGS/AUSEXCH*CHEEXCH) + MAUSTUR*LOG(TURPXGS/AUSEXCH*TUREXCH) + MAUSDAE*LOG(DAEPXGS/AUSEXCH*DAEEXCH) + MAUSOOP*LOG(OOPPXGS/AUSEXCH*OOPEXCH) + MAUSBRA*LOG(BRAPXGS/AUSEXCH*BRAEXCH) + MAUSRUS*LOG(RUSPXGS/AUSEXCH*RUSEXCH) + MAUSIND*LOG(INDPXGS/AUSEXCH*INDEXCH) + MAUSCHN*LOG(CHNPXGS/AUSEXCH*CHNEXCH) + MAUSIDN*LOG(IDNPXGS/AUSEXCH*IDNEXCH) + MAUSZAF*LOG(ZAFPXGS/AUSEXCH*ZAFEXCH) + MAUSRWD*LOG(RWDPXGS/AUSEXCH*RWDEXCH) $ () FRML _GJRD_ DLOG(AUSPMGS) = (AUSPMGSU-AUSPMGSU(-1)) $ () () () EXPORT PRICES () FRML GAUSPXGSU AUSPXGSU = XAUSDNK*LOG(DNKPMGS/AUSEXCH*DNKEXCH) + XAUSSWE*LOG(SWEPMGS/AUSEXCH*SWEEXCH) + XAUSNOR*LOG(NORPMGS/AUSEXCH*NOREXCH) + XAUSFIN*LOG(FINPMGS/AUSEXCH*FINEXCH) + XAUSNLD*LOG(NLDPMGS/AUSEXCH*NLDEXCH) + XAUSGBR*LOG(GBRPMGS/AUSEXCH*GBREXCH) + XAUSESP*LOG(ESPPMGS/AUSEXCH*ESPEXCH) + XAUSDEU*LOG(DEUPMGS/AUSEXCH*DEUEXCH) + XAUSBEL*LOG(BELPMGS/AUSEXCH*BELEXCH) + XAUSFRA*LOG(FRAPMGS/AUSEXCH*FRAEXCH) + XAUSYPN*LOG(YPNPMGS/AUSEXCH*YPNEXCH) + XAUSITA*LOG(ITAPMGS/AUSEXCH*ITAEXCH) + XAUSUSA*LOG(USAPMGS/AUSEXCH*USAEXCH) + XAUSPOL*LOG(POLPMGS/AUSEXCH*POLEXCH) + XAUSCZE*LOG(CZEPMGS/AUSEXCH*CZEEXCH) + XAUSAUT*LOG(AUTPMGS/AUSEXCH*AUTEXCH) + XAUSCAN*LOG(CANPMGS/AUSEXCH*CANEXCH) + XAUSCHL*LOG(CHLPMGS/AUSEXCH*CHLEXCH) + XAUSEST*LOG(ESTPMGS/AUSEXCH*ESTEXCH) + XAUSHUN*LOG(HUNPMGS/AUSEXCH*HUNEXCH) + XAUSGRC*LOG(GRCPMGS/AUSEXCH*GRCEXCH) + XAUSISL*LOG(ISLPMGS/AUSEXCH*ISLEXCH) + XAUSIRL*LOG(IRLPMGS/AUSEXCH*IRLEXCH) + XAUSISR*LOG(ISRPMGS/AUSEXCH*ISREXCH) + XAUSKOR*LOG(KORPMGS/AUSEXCH*KOREXCH) + XAUSLUX*LOG(LUXPMGS/AUSEXCH*LUXEXCH) + XAUSMEX*LOG(MEXPMGS/AUSEXCH*MEXEXCH) + XAUSNZL*LOG(NZLPMGS/AUSEXCH*NZLEXCH) + XAUSPRT*LOG(PRTPMGS/AUSEXCH*PRTEXCH) + XAUSSVK*LOG(SVKPMGS/AUSEXCH*SVKEXCH) + XAUSSVN*LOG(SVNPMGS/AUSEXCH*SVNEXCH) + XAUSCHE*LOG(CHEPMGS/AUSEXCH*CHEEXCH) + XAUSTUR*LOG(TURPMGS/AUSEXCH*TUREXCH) + XAUSDAE*LOG(DAEPMGS/AUSEXCH*DAEEXCH) + XAUSOOP*LOG(OOPPMGS/AUSEXCH*OOPEXCH) + XAUSBRA*LOG(BRAPMGS/AUSEXCH*BRAEXCH) + XAUSRUS*LOG(RUSPMGS/AUSEXCH*RUSEXCH) + XAUSIND*LOG(INDPMGS/AUSEXCH*INDEXCH) + XAUSCHN*LOG(CHNPMGS/AUSEXCH*CHNEXCH) + XAUSIDN*LOG(IDNPMGS/AUSEXCH*IDNEXCH) + XAUSZAF*LOG(ZAFPMGS/AUSEXCH*ZAFEXCH) + XAUSRWD*LOG(RWDPMGS/AUSEXCH*RWDEXCH) $ () FRML _GJRD_ DLOG(AUSPXGS) = (AUSPXGSU-AUSPXGSU(-1)) $ () () () () () () ******************* () * AUT * () ******************* () () EXPORT VOLUMES () FRML GAUTXGSDU AUTXGSDU = XAUTDNK*LOG(DNKMGSD) + XAUTSWE*LOG(SWEMGSD) + XAUTNOR*LOG(NORMGSD) + XAUTFIN*LOG(FINMGSD) + XAUTNLD*LOG(NLDMGSD) + XAUTGBR*LOG(GBRMGSD) + XAUTBEL*LOG(BELMGSD) + XAUTDEU*LOG(DEUMGSD) + XAUTFRA*LOG(FRAMGSD) + XAUTESP*LOG(ESPMGSD) + XAUTYPN*LOG(YPNMGSD) + XAUTITA*LOG(ITAMGSD) + XAUTUSA*LOG(USAMGSD) + XAUTPOL*LOG(POLMGSD) + XAUTCZE*LOG(CZEMGSD) + XAUTAUS*LOG(AUSMGSD) + XAUTCAN*LOG(CANMGSD) + XAUTCHL*LOG(CHLMGSD) + XAUTEST*LOG(ESTMGSD) + XAUTHUN*LOG(HUNMGSD) + XAUTGRC*LOG(GRCMGSD) + XAUTISL*LOG(ISLMGSD) + XAUTIRL*LOG(IRLMGSD) + XAUTISR*LOG(ISRMGSD) + XAUTKOR*LOG(KORMGSD) + XAUTLUX*LOG(LUXMGSD) + XAUTMEX*LOG(MEXMGSD) + XAUTNZL*LOG(NZLMGSD) + XAUTPRT*LOG(PRTMGSD) + XAUTSVK*LOG(SVKMGSD) + XAUTSVN*LOG(SVNMGSD) + XAUTCHE*LOG(CHEMGSD) + XAUTTUR*LOG(TURMGSD) + XAUTDAE*LOG(DAEMGSD) + XAUTOOP*LOG(OOPMGSD) + XAUTBRA*LOG(BRAMGSD) + XAUTRUS*LOG(RUSMGSD) + XAUTIND*LOG(INDMGSD) + XAUTCHN*LOG(CHNMGSD) + XAUTIDN*LOG(IDNMGSD) + XAUTZAF*LOG(ZAFMGSD) + XAUTRWD*LOG(RWDMGSD) $ FRML _GJRD DLOG(AUTXGSD) = (AUTXGSDU-AUTXGSDU(-1)) $ FRML GAUTXGSV AUTXGSV = AUTXGSD*USAEXCH/(AUTEXCH*AUTPXGS) $ () () () IMPORT () FRML _GJRD_ DLOG(AUTMGSV) = 0.95230*DLOG(AUTXGSV) - 0.53434*DLOG(AUTPMGS/AUTPXGS) - 0.24349*LOG(AUTMGSV(-1)/AUTXGSV(-1)) - 0.56440*LOG(AUTPMGS(-1)/AUTPXGS(-1)) - 0.01466 - D1978*0.06151 $ () FRML GAUTMGSD AUTMGSD = AUTMGSV*AUTPMGS*AUTEXCH/USAEXCH $ () () () IMPORT PRICES () () FRML GAUTPMGSU AUTPMGSU = MAUTDNK*LOG(DNKPXGS/AUTEXCH*DNKEXCH) + MAUTSWE*LOG(SWEPXGS/AUTEXCH*SWEEXCH) + MAUTNOR*LOG(NORPXGS/AUTEXCH*NOREXCH) + MAUTFIN*LOG(FINPXGS/AUTEXCH*FINEXCH) + MAUTNLD*LOG(NLDPXGS/AUTEXCH*NLDEXCH) + MAUTGBR*LOG(GBRPXGS/AUTEXCH*GBREXCH) + MAUTESP*LOG(ESPPXGS/AUTEXCH*ESPEXCH) + MAUTDEU*LOG(DEUPXGS/AUTEXCH*DEUEXCH) + MAUTBEL*LOG(BELPXGS/AUTEXCH*BELEXCH) + MAUTFRA*LOG(FRAPXGS/AUTEXCH*FRAEXCH) + MAUTYPN*LOG(YPNPXGS/AUTEXCH*YPNEXCH) + MAUTITA*LOG(ITAPXGS/AUTEXCH*ITAEXCH) + MAUTUSA*LOG(USAPXGS/AUTEXCH*USAEXCH) + MAUTPOL*LOG(POLPXGS/AUTEXCH*POLEXCH) + MAUTCZE*LOG(CZEPXGS/AUTEXCH*CZEEXCH) + MAUTAUS*LOG(AUSPXGS/AUTEXCH*AUSEXCH) + MAUTCAN*LOG(CANPXGS/AUTEXCH*CANEXCH) + MAUTCHL*LOG(CHLPXGS/AUTEXCH*CHLEXCH) + MAUTEST*LOG(ESTPXGS/AUTEXCH*ESTEXCH) + MAUTHUN*LOG(HUNPXGS/AUTEXCH*HUNEXCH) + MAUTGRC*LOG(GRCPXGS/AUTEXCH*GRCEXCH) + MAUTISL*LOG(ISLPXGS/AUTEXCH*ISLEXCH) + MAUTIRL*LOG(IRLPXGS/AUTEXCH*IRLEXCH) + MAUTISR*LOG(ISRPXGS/AUTEXCH*ISREXCH) + MAUTKOR*LOG(KORPXGS/AUTEXCH*KOREXCH) + MAUTLUX*LOG(LUXPXGS/AUTEXCH*LUXEXCH) + MAUTMEX*LOG(MEXPXGS/AUTEXCH*MEXEXCH) + MAUTNZL*LOG(NZLPXGS/AUTEXCH*NZLEXCH) + MAUTPRT*LOG(PRTPXGS/AUTEXCH*PRTEXCH) + MAUTSVK*LOG(SVKPXGS/AUTEXCH*SVKEXCH) + MAUTSVN*LOG(SVNPXGS/AUTEXCH*SVNEXCH) + MAUTCHE*LOG(CHEPXGS/AUTEXCH*CHEEXCH) + MAUTTUR*LOG(TURPXGS/AUTEXCH*TUREXCH) + MAUTDAE*LOG(DAEPXGS/AUTEXCH*DAEEXCH) + MAUTOOP*LOG(OOPPXGS/AUTEXCH*OOPEXCH) + MAUTBRA*LOG(BRAPXGS/AUTEXCH*BRAEXCH) + MAUTRUS*LOG(RUSPXGS/AUTEXCH*RUSEXCH) + MAUTIND*LOG(INDPXGS/AUTEXCH*INDEXCH) + MAUTCHN*LOG(CHNPXGS/AUTEXCH*CHNEXCH) + MAUTIDN*LOG(IDNPXGS/AUTEXCH*IDNEXCH) + MAUTZAF*LOG(ZAFPXGS/AUTEXCH*ZAFEXCH) + MAUTRWD*LOG(RWDPXGS/AUTEXCH*RWDEXCH) $ () FRML _GJRD_ DLOG(AUTPMGS) = (AUTPMGSU-AUTPMGSU(-1)) $ () () () EXPORT PRICES () FRML GAUTPXGSU AUTPXGSU = XAUTDNK*LOG(DNKPMGS/AUTEXCH*DNKEXCH) + XAUTSWE*LOG(SWEPMGS/AUTEXCH*SWEEXCH) + XAUTNOR*LOG(NORPMGS/AUTEXCH*NOREXCH) + XAUTFIN*LOG(FINPMGS/AUTEXCH*FINEXCH) + XAUTNLD*LOG(NLDPMGS/AUTEXCH*NLDEXCH) + XAUTGBR*LOG(GBRPMGS/AUTEXCH*GBREXCH) + XAUTESP*LOG(ESPPMGS/AUTEXCH*ESPEXCH) + XAUTDEU*LOG(DEUPMGS/AUTEXCH*DEUEXCH) + XAUTBEL*LOG(BELPMGS/AUTEXCH*BELEXCH) + XAUTFRA*LOG(FRAPMGS/AUTEXCH*FRAEXCH) + XAUTYPN*LOG(YPNPMGS/AUTEXCH*YPNEXCH) + XAUTITA*LOG(ITAPMGS/AUTEXCH*ITAEXCH) + XAUTUSA*LOG(USAPMGS/AUTEXCH*USAEXCH) + XAUTPOL*LOG(POLPMGS/AUTEXCH*POLEXCH) + XAUTCZE*LOG(CZEPMGS/AUTEXCH*CZEEXCH) + XAUTAUS*LOG(AUSPMGS/AUTEXCH*AUSEXCH) + XAUTCAN*LOG(CANPMGS/AUTEXCH*CANEXCH) + XAUTCHL*LOG(CHLPMGS/AUTEXCH*CHLEXCH) + XAUTEST*LOG(ESTPMGS/AUTEXCH*ESTEXCH) + XAUTHUN*LOG(HUNPMGS/AUTEXCH*HUNEXCH) + XAUTGRC*LOG(GRCPMGS/AUTEXCH*GRCEXCH) + XAUTISL*LOG(ISLPMGS/AUTEXCH*ISLEXCH) + XAUTIRL*LOG(IRLPMGS/AUTEXCH*IRLEXCH) + XAUTISR*LOG(ISRPMGS/AUTEXCH*ISREXCH) + XAUTKOR*LOG(KORPMGS/AUTEXCH*KOREXCH) + XAUTLUX*LOG(LUXPMGS/AUTEXCH*LUXEXCH) + XAUTMEX*LOG(MEXPMGS/AUTEXCH*MEXEXCH) + XAUTNZL*LOG(NZLPMGS/AUTEXCH*NZLEXCH) + XAUTPRT*LOG(PRTPMGS/AUTEXCH*PRTEXCH) + XAUTSVK*LOG(SVKPMGS/AUTEXCH*SVKEXCH) + XAUTSVN*LOG(SVNPMGS/AUTEXCH*SVNEXCH) + XAUTCHE*LOG(CHEPMGS/AUTEXCH*CHEEXCH) + XAUTTUR*LOG(TURPMGS/AUTEXCH*TUREXCH) + XAUTDAE*LOG(DAEPMGS/AUTEXCH*DAEEXCH) + XAUTOOP*LOG(OOPPMGS/AUTEXCH*OOPEXCH) + XAUTBRA*LOG(BRAPMGS/AUTEXCH*BRAEXCH) + XAUTRUS*LOG(RUSPMGS/AUTEXCH*RUSEXCH) + XAUTIND*LOG(INDPMGS/AUTEXCH*INDEXCH) + XAUTCHN*LOG(CHNPMGS/AUTEXCH*CHNEXCH) + XAUTIDN*LOG(IDNPMGS/AUTEXCH*IDNEXCH) + XAUTZAF*LOG(ZAFPMGS/AUTEXCH*ZAFEXCH) + XAUTRWD*LOG(RWDPMGS/AUTEXCH*RWDEXCH) $ () FRML _GJRD_ DLOG(AUTPXGS) = (AUTPXGSU-AUTPXGSU(-1)) $ () () () () () ******************* () * BRA * () ******************* () () EXPORT VOLUMES () FRML GBRAXGSDU BRAXGSDU = XBRADNK*LOG(DNKMGSD) + XBRASWE*LOG(SWEMGSD) + XBRANOR*LOG(NORMGSD) + XBRAFIN*LOG(FINMGSD) + XBRANLD*LOG(NLDMGSD) + XBRAGBR*LOG(GBRMGSD) + XBRABEL*LOG(BELMGSD) + XBRADEU*LOG(DEUMGSD) + XBRAFRA*LOG(FRAMGSD) + XBRAESP*LOG(ESPMGSD) + XBRAYPN*LOG(YPNMGSD) + XBRAITA*LOG(ITAMGSD) + XBRAUSA*LOG(USAMGSD) + XBRAPOL*LOG(POLMGSD) + XBRAAUS*LOG(AUSMGSD) + XBRAAUT*LOG(AUTMGSD) + XBRACAN*LOG(CANMGSD) + XBRACHL*LOG(CHLMGSD) + XBRAEST*LOG(ESTMGSD) + XBRAGRC*LOG(GRCMGSD) + XBRACZE*LOG(CZEMGSD) + XBRAHUN*LOG(HUNMGSD) + XBRAISL*LOG(ISLMGSD) + XBRAIRL*LOG(IRLMGSD) + XBRAISR*LOG(ISRMGSD) + XBRAKOR*LOG(KORMGSD) + XBRALUX*LOG(LUXMGSD) + XBRAMEX*LOG(MEXMGSD) + XBRANZL*LOG(NZLMGSD) + XBRAPRT*LOG(PRTMGSD) + XBRASVK*LOG(SVKMGSD) + XBRASVN*LOG(SVNMGSD) + XBRACHE*LOG(CHEMGSD) + XBRATUR*LOG(TURMGSD) + XBRADAE*LOG(DAEMGSD) + XBRAOOP*LOG(OOPMGSD) + XBRARUS*LOG(RUSMGSD) + XBRAIND*LOG(INDMGSD) + XBRACHN*LOG(CHNMGSD) + XBRAIDN*LOG(IDNMGSD) + XBRAZAF*LOG(ZAFMGSD) + XBRARWD*LOG(RWDMGSD) $ FRML _GJRD DLOG(BRAXGSD) = (BRAXGSDU-BRAXGSDU(-1)) $ FRML GBRAXGSV BRAXGSV = BRAXGSD*USAEXCH/(BRAEXCH*BRAPXGS) $ () () () IMPORT () FRML _GJRD_ DLOG(BRAMGSV) = 1.16387*DLOG(BRAXGSV) - 1.95636*DLOG(BRAPMGS/BRAPXGS) - 0.25809*LOG(BRAMGSV(-1)/BRAXGSV(-1)) - 1.43349*LOG(BRAPMGS(-1)/BRAPXGS(-1)) - 0.09740 + D2000*0.14139 $ () FRML GBRAMGSD BRAMGSD = BRAMGSV*BRAPMGS*BRAEXCH/USAEXCH $ () () () IMPORT PRICES () () FRML GBRAPMGSU BRAPMGSU = MBRADNK*LOG(DNKPXGS/BRAEXCH*DNKEXCH) + MBRASWE*LOG(SWEPXGS/BRAEXCH*SWEEXCH) + MBRANOR*LOG(NORPXGS/BRAEXCH*NOREXCH) + MBRAFIN*LOG(FINPXGS/BRAEXCH*FINEXCH) + MBRANLD*LOG(NLDPXGS/BRAEXCH*NLDEXCH) + MBRAGBR*LOG(GBRPXGS/BRAEXCH*GBREXCH) + MBRAESP*LOG(ESPPXGS/BRAEXCH*ESPEXCH) + MBRADEU*LOG(DEUPXGS/BRAEXCH*DEUEXCH) + MBRABEL*LOG(BELPXGS/BRAEXCH*BELEXCH) + MBRAFRA*LOG(FRAPXGS/BRAEXCH*FRAEXCH) + MBRAYPN*LOG(YPNPXGS/BRAEXCH*YPNEXCH) + MBRAITA*LOG(ITAPXGS/BRAEXCH*ITAEXCH) + MBRAUSA*LOG(USAPXGS/BRAEXCH*USAEXCH) + MBRAPOL*LOG(POLPXGS/BRAEXCH*POLEXCH) + MBRAAUS*LOG(AUSPXGS/BRAEXCH*AUSEXCH) + MBRAAUT*LOG(AUTPXGS/BRAEXCH*AUTEXCH) + MBRACAN*LOG(CANPXGS/BRAEXCH*CANEXCH) + MBRACHL*LOG(CHLPXGS/BRAEXCH*CHLEXCH) + MBRAEST*LOG(ESTPXGS/BRAEXCH*ESTEXCH) + MBRAGRC*LOG(GRCPXGS/BRAEXCH*GRCEXCH) + MBRACZE*LOG(CZEPXGS/BRAEXCH*CZEEXCH) + MBRAHUN*LOG(HUNPXGS/BRAEXCH*HUNEXCH) + MBRAISL*LOG(ISLPXGS/BRAEXCH*ISLEXCH) + MBRAIRL*LOG(IRLPXGS/BRAEXCH*IRLEXCH) + MBRAISR*LOG(ISRPXGS/BRAEXCH*ISREXCH) + MBRAKOR*LOG(KORPXGS/BRAEXCH*KOREXCH) + MBRALUX*LOG(LUXPXGS/BRAEXCH*LUXEXCH) + MBRAMEX*LOG(MEXPXGS/BRAEXCH*MEXEXCH) + MBRANZL*LOG(NZLPXGS/BRAEXCH*NZLEXCH) + MBRAPRT*LOG(PRTPXGS/BRAEXCH*PRTEXCH) + MBRASVK*LOG(SVKPXGS/BRAEXCH*SVKEXCH) + MBRASVN*LOG(SVNPXGS/BRAEXCH*SVNEXCH) + MBRACHE*LOG(CHEPXGS/BRAEXCH*CHEEXCH) + MBRATUR*LOG(TURPXGS/BRAEXCH*TUREXCH) + MBRADAE*LOG(DAEPXGS/BRAEXCH*DAEEXCH) + MBRAOOP*LOG(OOPPXGS/BRAEXCH*OOPEXCH) + MBRARUS*LOG(RUSPXGS/BRAEXCH*RUSEXCH) + MBRAIND*LOG(INDPXGS/BRAEXCH*INDEXCH) + MBRACHN*LOG(CHNPXGS/BRAEXCH*CHNEXCH) + MBRAIDN*LOG(IDNPXGS/BRAEXCH*IDNEXCH) + MBRAZAF*LOG(ZAFPXGS/BRAEXCH*ZAFEXCH) + MBRARWD*LOG(RWDPXGS/BRAEXCH*RWDEXCH) $ () FRML _GJRD_ DLOG(BRAPMGS) = (BRAPMGSU-BRAPMGSU(-1)) $ () () () EXPORT PRICES () FRML GBRAPXGSU BRAPXGSU = XBRADNK*LOG(DNKPMGS/BRAEXCH*DNKEXCH) + XBRASWE*LOG(SWEPMGS/BRAEXCH*SWEEXCH) + XBRANOR*LOG(NORPMGS/BRAEXCH*NOREXCH) + XBRAFIN*LOG(FINPMGS/BRAEXCH*FINEXCH) + XBRANLD*LOG(NLDPMGS/BRAEXCH*NLDEXCH) + XBRAGBR*LOG(GBRPMGS/BRAEXCH*GBREXCH) + XBRAESP*LOG(ESPPMGS/BRAEXCH*ESPEXCH) + XBRADEU*LOG(DEUPMGS/BRAEXCH*DEUEXCH) + XBRABEL*LOG(BELPMGS/BRAEXCH*BELEXCH) + XBRAFRA*LOG(FRAPMGS/BRAEXCH*FRAEXCH) + XBRAYPN*LOG(YPNPMGS/BRAEXCH*YPNEXCH) + XBRAITA*LOG(ITAPMGS/BRAEXCH*ITAEXCH) + XBRAUSA*LOG(USAPMGS/BRAEXCH*USAEXCH) + XBRAPOL*LOG(POLPMGS/BRAEXCH*POLEXCH) + XBRAAUS*LOG(AUSPMGS/BRAEXCH*AUSEXCH) + XBRAAUT*LOG(AUTPMGS/BRAEXCH*AUTEXCH) + XBRACAN*LOG(CANPMGS/BRAEXCH*CANEXCH) + XBRACHL*LOG(CHLPMGS/BRAEXCH*CHLEXCH) + XBRAEST*LOG(ESTPMGS/BRAEXCH*ESTEXCH) + XBRAGRC*LOG(GRCPMGS/BRAEXCH*GRCEXCH) + XBRACZE*LOG(CZEPMGS/BRAEXCH*CZEEXCH) + XBRAHUN*LOG(HUNPMGS/BRAEXCH*HUNEXCH) + XBRAISL*LOG(ISLPMGS/BRAEXCH*ISLEXCH) + XBRAIRL*LOG(IRLPMGS/BRAEXCH*IRLEXCH) + XBRAISR*LOG(ISRPMGS/BRAEXCH*ISREXCH) + XBRAKOR*LOG(KORPMGS/BRAEXCH*KOREXCH) + XBRALUX*LOG(LUXPMGS/BRAEXCH*LUXEXCH) + XBRAMEX*LOG(MEXPMGS/BRAEXCH*MEXEXCH) + XBRANZL*LOG(NZLPMGS/BRAEXCH*NZLEXCH) + XBRAPRT*LOG(PRTPMGS/BRAEXCH*PRTEXCH) + XBRASVK*LOG(SVKPMGS/BRAEXCH*SVKEXCH) + XBRASVN*LOG(SVNPMGS/BRAEXCH*SVNEXCH) + XBRACHE*LOG(CHEPMGS/BRAEXCH*CHEEXCH) + XBRATUR*LOG(TURPMGS/BRAEXCH*TUREXCH) + XBRADAE*LOG(DAEPMGS/BRAEXCH*DAEEXCH) + XBRAOOP*LOG(OOPPMGS/BRAEXCH*OOPEXCH) + XBRARUS*LOG(RUSPMGS/BRAEXCH*RUSEXCH) + XBRAIND*LOG(INDPMGS/BRAEXCH*INDEXCH) + XBRACHN*LOG(CHNPMGS/BRAEXCH*CHNEXCH) + XBRAIDN*LOG(IDNPMGS/BRAEXCH*IDNEXCH) + XBRAZAF*LOG(ZAFPMGS/BRAEXCH*ZAFEXCH) + XBRARWD*LOG(RWDPMGS/BRAEXCH*RWDEXCH) $ () FRML _GJRD_ DLOG(BRAPXGS) = (BRAPXGSU-BRAPXGSU(-1)) $ () () () () () ******************* () * CAN * () ******************* () () EXPORT VOLUMES () FRML GCANXGSDU CANXGSDU = XCANDNK*LOG(DNKMGSD) + XCANSWE*LOG(SWEMGSD) + XCANNOR*LOG(NORMGSD) + XCANFIN*LOG(FINMGSD) + XCANNLD*LOG(NLDMGSD) + XCANGBR*LOG(GBRMGSD) + XCANBEL*LOG(BELMGSD) + XCANDEU*LOG(DEUMGSD) + XCANFRA*LOG(FRAMGSD) + XCANESP*LOG(ESPMGSD) + XCANYPN*LOG(YPNMGSD) + XCANITA*LOG(ITAMGSD) + XCANUSA*LOG(USAMGSD) + XCANPOL*LOG(POLMGSD) + XCANCZE*LOG(CZEMGSD) + XCANAUS*LOG(AUSMGSD) + XCANAUT*LOG(AUTMGSD) + XCANCHL*LOG(CHLMGSD) + XCANEST*LOG(ESTMGSD) + XCANHUN*LOG(HUNMGSD) + XCANGRC*LOG(GRCMGSD) + XCANISL*LOG(ISLMGSD) + XCANIRL*LOG(IRLMGSD) + XCANISR*LOG(ISRMGSD) + XCANKOR*LOG(KORMGSD) + XCANLUX*LOG(LUXMGSD) + XCANMEX*LOG(MEXMGSD) + XCANNZL*LOG(NZLMGSD) + XCANPRT*LOG(PRTMGSD) + XCANSVK*LOG(SVKMGSD) + XCANSVN*LOG(SVNMGSD) + XCANCHE*LOG(CHEMGSD) + XCANTUR*LOG(TURMGSD) + XCANDAE*LOG(DAEMGSD) + XCANOOP*LOG(OOPMGSD) + XCANBRA*LOG(BRAMGSD) + XCANRUS*LOG(RUSMGSD) + XCANIND*LOG(INDMGSD) + XCANCHN*LOG(CHNMGSD) + XCANIDN*LOG(IDNMGSD) + XCANZAF*LOG(ZAFMGSD) + XCANRWD*LOG(RWDMGSD) $ FRML _GJRD DLOG(CANXGSD) = (CANXGSDU-CANXGSDU(-1))$ FRML GCANXGSV CANXGSV = CANXGSD*USAEXCH/(CANEXCH*CANPXGS) $ () () () IMPORT () FRML _GJRD_ DLOG(CANMGSV) = 0.66708*DLOG(CANXGSV) - 0.67991*DLOG(CANPMGS/CANPXGS) -0.22656*LOG(CANMGSV(-1)/CANXGSV(-1)) -0.21132*LOG(CANPMGS(-1)/CANPXGS(-1)) +0.01052 - D1982*0.16542 $ () FRML GCANMGSD CANMGSD = CANMGSV*CANPMGS*CANEXCH/USAEXCH $ () () () IMPORT PRICES () () FRML GCANPMGSU CANPMGSU = MCANDNK*LOG(DNKPXGS/CANEXCH*DNKEXCH) + MCANSWE*LOG(SWEPXGS/CANEXCH*SWEEXCH) + MCANNOR*LOG(NORPXGS/CANEXCH*NOREXCH) + MCANFIN*LOG(FINPXGS/CANEXCH*FINEXCH) + MCANNLD*LOG(NLDPXGS/CANEXCH*NLDEXCH) + MCANGBR*LOG(GBRPXGS/CANEXCH*GBREXCH) + MCANESP*LOG(ESPPXGS/CANEXCH*ESPEXCH) + MCANDEU*LOG(DEUPXGS/CANEXCH*DEUEXCH) + MCANBEL*LOG(BELPXGS/CANEXCH*BELEXCH) + MCANFRA*LOG(FRAPXGS/CANEXCH*FRAEXCH) + MCANYPN*LOG(YPNPXGS/CANEXCH*YPNEXCH) + MCANITA*LOG(ITAPXGS/CANEXCH*ITAEXCH) + MCANUSA*LOG(USAPXGS/CANEXCH*USAEXCH) + MCANPOL*LOG(POLPXGS/CANEXCH*POLEXCH) + MCANCZE*LOG(CZEPXGS/CANEXCH*CZEEXCH) + MCANAUS*LOG(AUSPXGS/CANEXCH*AUSEXCH) + MCANAUT*LOG(AUTPXGS/CANEXCH*AUTEXCH) + MCANCHL*LOG(CHLPXGS/CANEXCH*CHLEXCH) + MCANEST*LOG(ESTPXGS/CANEXCH*ESTEXCH) + MCANHUN*LOG(HUNPXGS/CANEXCH*HUNEXCH) + MCANGRC*LOG(GRCPXGS/CANEXCH*GRCEXCH) + MCANISL*LOG(ISLPXGS/CANEXCH*ISLEXCH) + MCANIRL*LOG(IRLPXGS/CANEXCH*IRLEXCH) + MCANISR*LOG(ISRPXGS/CANEXCH*ISREXCH) + MCANKOR*LOG(KORPXGS/CANEXCH*KOREXCH) + MCANLUX*LOG(LUXPXGS/CANEXCH*LUXEXCH) + MCANMEX*LOG(MEXPXGS/CANEXCH*MEXEXCH) + MCANNZL*LOG(NZLPXGS/CANEXCH*NZLEXCH) + MCANPRT*LOG(PRTPXGS/CANEXCH*PRTEXCH) + MCANSVK*LOG(SVKPXGS/CANEXCH*SVKEXCH) + MCANSVN*LOG(SVNPXGS/CANEXCH*SVNEXCH) + MCANCHE*LOG(CHEPXGS/CANEXCH*CHEEXCH) + MCANTUR*LOG(TURPXGS/CANEXCH*TUREXCH) + MCANDAE*LOG(DAEPXGS/CANEXCH*DAEEXCH) + MCANOOP*LOG(OOPPXGS/CANEXCH*OOPEXCH) + MCANBRA*LOG(BRAPXGS/CANEXCH*BRAEXCH) + MCANRUS*LOG(RUSPXGS/CANEXCH*RUSEXCH) + MCANIND*LOG(INDPXGS/CANEXCH*INDEXCH) + MCANCHN*LOG(CHNPXGS/CANEXCH*CHNEXCH) + MCANIDN*LOG(IDNPXGS/CANEXCH*IDNEXCH) + MCANZAF*LOG(ZAFPXGS/CANEXCH*ZAFEXCH) + MCANRWD*LOG(RWDPXGS/CANEXCH*RWDEXCH) $ () FRML _GJRD_ DLOG(CANPMGS) = (CANPMGSU-CANPMGSU(-1)) $ () () () EXPORT PRICES () FRML GCANPXGSU CANPXGSU = XCANDNK*LOG(DNKPMGS/CANEXCH*DNKEXCH) + XCANSWE*LOG(SWEPMGS/CANEXCH*SWEEXCH) + XCANNOR*LOG(NORPMGS/CANEXCH*NOREXCH) + XCANFIN*LOG(FINPMGS/CANEXCH*FINEXCH) + XCANNLD*LOG(NLDPMGS/CANEXCH*NLDEXCH) + XCANGBR*LOG(GBRPMGS/CANEXCH*GBREXCH) + XCANESP*LOG(ESPPMGS/CANEXCH*ESPEXCH) + XCANDEU*LOG(DEUPMGS/CANEXCH*DEUEXCH) + XCANBEL*LOG(BELPMGS/CANEXCH*BELEXCH) + XCANFRA*LOG(FRAPMGS/CANEXCH*FRAEXCH) + XCANYPN*LOG(YPNPMGS/CANEXCH*YPNEXCH) + XCANITA*LOG(ITAPMGS/CANEXCH*ITAEXCH) + XCANUSA*LOG(USAPMGS/CANEXCH*USAEXCH) + XCANPOL*LOG(POLPMGS/CANEXCH*POLEXCH) + XCANCZE*LOG(CZEPMGS/CANEXCH*CZEEXCH) + XCANAUS*LOG(AUSPMGS/CANEXCH*AUSEXCH) + XCANAUT*LOG(AUTPMGS/CANEXCH*AUTEXCH) + XCANCHL*LOG(CHLPMGS/CANEXCH*CHLEXCH) + XCANEST*LOG(ESTPMGS/CANEXCH*ESTEXCH) + XCANHUN*LOG(HUNPMGS/CANEXCH*HUNEXCH) + XCANGRC*LOG(GRCPMGS/CANEXCH*GRCEXCH) + XCANISL*LOG(ISLPMGS/CANEXCH*ISLEXCH) + XCANIRL*LOG(IRLPMGS/CANEXCH*IRLEXCH) + XCANISR*LOG(ISRPMGS/CANEXCH*ISREXCH) + XCANKOR*LOG(KORPMGS/CANEXCH*KOREXCH) + XCANLUX*LOG(LUXPMGS/CANEXCH*LUXEXCH) + XCANMEX*LOG(MEXPMGS/CANEXCH*MEXEXCH) + XCANNZL*LOG(NZLPMGS/CANEXCH*NZLEXCH) + XCANPRT*LOG(PRTPMGS/CANEXCH*PRTEXCH) + XCANSVK*LOG(SVKPMGS/CANEXCH*SVKEXCH) + XCANSVN*LOG(SVNPMGS/CANEXCH*SVNEXCH) + XCANCHE*LOG(CHEPMGS/CANEXCH*CHEEXCH) + XCANTUR*LOG(TURPMGS/CANEXCH*TUREXCH) + XCANDAE*LOG(DAEPMGS/CANEXCH*DAEEXCH) + XCANOOP*LOG(OOPPMGS/CANEXCH*OOPEXCH) + XCANBRA*LOG(BRAPMGS/CANEXCH*BRAEXCH) + XCANRUS*LOG(RUSPMGS/CANEXCH*RUSEXCH) + XCANIND*LOG(INDPMGS/CANEXCH*INDEXCH) + XCANCHN*LOG(CHNPMGS/CANEXCH*CHNEXCH) + XCANIDN*LOG(IDNPMGS/CANEXCH*IDNEXCH) + XCANZAF*LOG(ZAFPMGS/CANEXCH*ZAFEXCH) + XCANRWD*LOG(RWDPMGS/CANEXCH*RWDEXCH) $ () FRML _GJRD_ DLOG(CANPXGS) = (CANPXGSU-CANPXGSU(-1)) $ () () () () () ******************* () * CHE * () ******************* () () EXPORT VOLUMES () FRML GCHEXGSDU CHEXGSDU = XCHEDNK*LOG(DNKMGSD) + XCHESWE*LOG(SWEMGSD) + XCHENOR*LOG(NORMGSD) + XCHEFIN*LOG(FINMGSD) + XCHENLD*LOG(NLDMGSD) + XCHEGBR*LOG(GBRMGSD) + XCHEBEL*LOG(BELMGSD) + XCHEDEU*LOG(DEUMGSD) + XCHEFRA*LOG(FRAMGSD) + XCHEESP*LOG(ESPMGSD) + XCHEYPN*LOG(YPNMGSD) + XCHEITA*LOG(ITAMGSD) + XCHEUSA*LOG(USAMGSD) + XCHEPOL*LOG(POLMGSD) + XCHEAUS*LOG(AUSMGSD) + XCHEAUT*LOG(AUTMGSD) + XCHECAN*LOG(CANMGSD) + XCHECHL*LOG(CHLMGSD) + XCHEEST*LOG(ESTMGSD) + XCHEGRC*LOG(GRCMGSD) + XCHECZE*LOG(CZEMGSD) + XCHEHUN*LOG(HUNMGSD) + XCHEISL*LOG(ISLMGSD) + XCHEIRL*LOG(IRLMGSD) + XCHEISR*LOG(ISRMGSD) + XCHEKOR*LOG(KORMGSD) + XCHELUX*LOG(LUXMGSD) + XCHEMEX*LOG(MEXMGSD) + XCHENZL*LOG(NZLMGSD) + XCHEPRT*LOG(PRTMGSD) + XCHESVK*LOG(SVKMGSD) + XCHESVN*LOG(SVNMGSD) + XCHETUR*LOG(TURMGSD) + XCHEDAE*LOG(DAEMGSD) + XCHEOOP*LOG(OOPMGSD) + XCHEBRA*LOG(BRAMGSD) + XCHERUS*LOG(RUSMGSD) + XCHEIND*LOG(INDMGSD) + XCHECHN*LOG(CHNMGSD) + XCHEIDN*LOG(IDNMGSD) + XCHEZAF*LOG(ZAFMGSD) + XCHERWD*LOG(RWDMGSD) $ FRML _GJRD DLOG(CHEXGSD) = (CHEXGSDU-CHEXGSDU(-1)) $ FRML GCHEXGSV CHEXGSV = CHEXGSD*USAEXCH/(CHEEXCH*CHEPXGS) $ () () () IMPORT () FRML _GJRD_ DLOG(CHEMGSV) = 0.82162*DLOG(CHEXGSV) - 0.42431*DLOG(CHEPMGS/CHEPXGS) -0.33027*LOG(CHEMGSV(-1)/CHEXGSV(-1)) -0.39648*LOG(CHEPMGS(-1)/CHEPXGS(-1)) +0.00617 - D1975*0.12187 - S1992*0.05665 $ () FRML GCHEMGSD CHEMGSD = CHEMGSV*CHEPMGS*CHEEXCH/USAEXCH $ () () () IMPORT PRICES () () FRML GCHEPMGSU CHEPMGSU = MCHEDNK*LOG(DNKPXGS/CHEEXCH*DNKEXCH) + MCHESWE*LOG(SWEPXGS/CHEEXCH*SWEEXCH) + MCHENOR*LOG(NORPXGS/CHEEXCH*NOREXCH) + MCHEFIN*LOG(FINPXGS/CHEEXCH*FINEXCH) + MCHENLD*LOG(NLDPXGS/CHEEXCH*NLDEXCH) + MCHEGBR*LOG(GBRPXGS/CHEEXCH*GBREXCH) + MCHEESP*LOG(ESPPXGS/CHEEXCH*ESPEXCH) + MCHEDEU*LOG(DEUPXGS/CHEEXCH*DEUEXCH) + MCHEBEL*LOG(BELPXGS/CHEEXCH*BELEXCH) + MCHEFRA*LOG(FRAPXGS/CHEEXCH*FRAEXCH) + MCHEYPN*LOG(YPNPXGS/CHEEXCH*YPNEXCH) + MCHEITA*LOG(ITAPXGS/CHEEXCH*ITAEXCH) + MCHEUSA*LOG(USAPXGS/CHEEXCH*USAEXCH) + MCHEPOL*LOG(POLPXGS/CHEEXCH*POLEXCH) + MCHEAUS*LOG(AUSPXGS/CHEEXCH*AUSEXCH) + MCHEAUT*LOG(AUTPXGS/CHEEXCH*AUTEXCH) + MCHECAN*LOG(CANPXGS/CHEEXCH*CANEXCH) + MCHECHL*LOG(CHLPXGS/CHEEXCH*CHLEXCH) + MCHEEST*LOG(ESTPXGS/CHEEXCH*ESTEXCH) + MCHEGRC*LOG(GRCPXGS/CHEEXCH*GRCEXCH) + MCHECZE*LOG(CZEPXGS/CHEEXCH*CZEEXCH) + MCHEHUN*LOG(HUNPXGS/CHEEXCH*HUNEXCH) + MCHEISL*LOG(ISLPXGS/CHEEXCH*ISLEXCH) + MCHEIRL*LOG(IRLPXGS/CHEEXCH*IRLEXCH) + MCHEISR*LOG(ISRPXGS/CHEEXCH*ISREXCH) + MCHEKOR*LOG(KORPXGS/CHEEXCH*KOREXCH) + MCHELUX*LOG(LUXPXGS/CHEEXCH*LUXEXCH) + MCHEMEX*LOG(MEXPXGS/CHEEXCH*MEXEXCH) + MCHENZL*LOG(NZLPXGS/CHEEXCH*NZLEXCH) + MCHEPRT*LOG(PRTPXGS/CHEEXCH*PRTEXCH) + MCHESVK*LOG(SVKPXGS/CHEEXCH*SVKEXCH) + MCHESVN*LOG(SVNPXGS/CHEEXCH*SVNEXCH) + MCHETUR*LOG(TURPXGS/CHEEXCH*TUREXCH) + MCHEDAE*LOG(DAEPXGS/CHEEXCH*DAEEXCH) + MCHEOOP*LOG(OOPPXGS/CHEEXCH*OOPEXCH) + MCHEBRA*LOG(BRAPXGS/CHEEXCH*BRAEXCH) + MCHERUS*LOG(RUSPXGS/CHEEXCH*RUSEXCH) + MCHEIND*LOG(INDPXGS/CHEEXCH*INDEXCH) + MCHECHN*LOG(CHNPXGS/CHEEXCH*CHNEXCH) + MCHEIDN*LOG(IDNPXGS/CHEEXCH*IDNEXCH) + MCHEZAF*LOG(ZAFPXGS/CHEEXCH*ZAFEXCH) + MCHERWD*LOG(RWDPXGS/CHEEXCH*RWDEXCH) $ () FRML _GJRD_ DLOG(CHEPMGS) = (CHEPMGSU-CHEPMGSU(-1)) $ () () () EXPORT PRICES () FRML GCHEPXGSU CHEPXGSU = XCHEDNK*LOG(DNKPMGS/CHEEXCH*DNKEXCH) + XCHESWE*LOG(SWEPMGS/CHEEXCH*SWEEXCH) + XCHENOR*LOG(NORPMGS/CHEEXCH*NOREXCH) + XCHEFIN*LOG(FINPMGS/CHEEXCH*FINEXCH) + XCHENLD*LOG(NLDPMGS/CHEEXCH*NLDEXCH) + XCHEGBR*LOG(GBRPMGS/CHEEXCH*GBREXCH) + XCHEESP*LOG(ESPPMGS/CHEEXCH*ESPEXCH) + XCHEDEU*LOG(DEUPMGS/CHEEXCH*DEUEXCH) + XCHEBEL*LOG(BELPMGS/CHEEXCH*BELEXCH) + XCHEFRA*LOG(FRAPMGS/CHEEXCH*FRAEXCH) + XCHEYPN*LOG(YPNPMGS/CHEEXCH*YPNEXCH) + XCHEITA*LOG(ITAPMGS/CHEEXCH*ITAEXCH) + XCHEUSA*LOG(USAPMGS/CHEEXCH*USAEXCH) + XCHEPOL*LOG(POLPMGS/CHEEXCH*POLEXCH) + XCHEAUS*LOG(AUSPMGS/CHEEXCH*AUSEXCH) + XCHEAUT*LOG(AUTPMGS/CHEEXCH*AUTEXCH) + XCHECAN*LOG(CANPMGS/CHEEXCH*CANEXCH) + XCHECHL*LOG(CHLPMGS/CHEEXCH*CHLEXCH) + XCHEEST*LOG(ESTPMGS/CHEEXCH*ESTEXCH) + XCHEGRC*LOG(GRCPMGS/CHEEXCH*GRCEXCH) + XCHECZE*LOG(CZEPMGS/CHEEXCH*CZEEXCH) + XCHEHUN*LOG(HUNPMGS/CHEEXCH*HUNEXCH) + XCHEISL*LOG(ISLPMGS/CHEEXCH*ISLEXCH) + XCHEIRL*LOG(IRLPMGS/CHEEXCH*IRLEXCH) + XCHEISR*LOG(ISRPMGS/CHEEXCH*ISREXCH) + XCHEKOR*LOG(KORPMGS/CHEEXCH*KOREXCH) + XCHELUX*LOG(LUXPMGS/CHEEXCH*LUXEXCH) + XCHEMEX*LOG(MEXPMGS/CHEEXCH*MEXEXCH) + XCHENZL*LOG(NZLPMGS/CHEEXCH*NZLEXCH) + XCHEPRT*LOG(PRTPMGS/CHEEXCH*PRTEXCH) + XCHESVK*LOG(SVKPMGS/CHEEXCH*SVKEXCH) + XCHESVN*LOG(SVNPMGS/CHEEXCH*SVNEXCH) + XCHETUR*LOG(TURPMGS/CHEEXCH*TUREXCH) + XCHEDAE*LOG(DAEPMGS/CHEEXCH*DAEEXCH) + XCHEOOP*LOG(OOPPMGS/CHEEXCH*OOPEXCH) + XCHEBRA*LOG(BRAPMGS/CHEEXCH*BRAEXCH) + XCHERUS*LOG(RUSPMGS/CHEEXCH*RUSEXCH) + XCHEIND*LOG(INDPMGS/CHEEXCH*INDEXCH) + XCHECHN*LOG(CHNPMGS/CHEEXCH*CHNEXCH) + XCHEIDN*LOG(IDNPMGS/CHEEXCH*IDNEXCH) + XCHEZAF*LOG(ZAFPMGS/CHEEXCH*ZAFEXCH) + XCHERWD*LOG(RWDPMGS/CHEEXCH*RWDEXCH) $ () FRML _GJRD_ DLOG(CHEPXGS) = (CHEPXGSU-CHEPXGSU(-1)) $ () () () () () ******************* () * CHL * () ******************* () () EXPORT VOLUMES () FRML GCHLXGSDU CHLXGSDU = XCHLDNK*LOG(DNKMGSD) + XCHLSWE*LOG(SWEMGSD) + XCHLNOR*LOG(NORMGSD) + XCHLFIN*LOG(FINMGSD) + XCHLNLD*LOG(NLDMGSD) + XCHLGBR*LOG(GBRMGSD) + XCHLBEL*LOG(BELMGSD) + XCHLDEU*LOG(DEUMGSD) + XCHLFRA*LOG(FRAMGSD) + XCHLESP*LOG(ESPMGSD) + XCHLYPN*LOG(YPNMGSD) + XCHLITA*LOG(ITAMGSD) + XCHLUSA*LOG(USAMGSD) + XCHLPOL*LOG(POLMGSD) + XCHLCZE*LOG(CZEMGSD) + XCHLAUS*LOG(AUSMGSD) + XCHLAUT*LOG(AUTMGSD) + XCHLCAN*LOG(CANMGSD) + XCHLEST*LOG(ESTMGSD) + XCHLHUN*LOG(HUNMGSD) + XCHLGRC*LOG(GRCMGSD) + XCHLISL*LOG(ISLMGSD) + XCHLIRL*LOG(IRLMGSD) + XCHLISR*LOG(ISRMGSD) + XCHLKOR*LOG(KORMGSD) + XCHLLUX*LOG(LUXMGSD) + XCHLMEX*LOG(MEXMGSD) + XCHLNZL*LOG(NZLMGSD) + XCHLPRT*LOG(PRTMGSD) + XCHLSVK*LOG(SVKMGSD) + XCHLSVN*LOG(SVNMGSD) + XCHLCHE*LOG(CHEMGSD) + XCHLTUR*LOG(TURMGSD) + XCHLDAE*LOG(DAEMGSD) + XCHLOOP*LOG(OOPMGSD) + XCHLBRA*LOG(BRAMGSD) + XCHLRUS*LOG(RUSMGSD) + XCHLIND*LOG(INDMGSD) + XCHLCHN*LOG(CHNMGSD) + XCHLIDN*LOG(IDNMGSD) + XCHLZAF*LOG(ZAFMGSD) + XCHLRWD*LOG(RWDMGSD) $ FRML _GJRD DLOG(CHLXGSD) = (CHLXGSDU-CHLXGSDU(-1)) $ FRML GCHLXGSV CHLXGSV = CHLXGSD*USAEXCH/(CHLEXCH*CHLPXGS) $ () () () IMPORT () FRML _GJRD_ DLOG(CHLMGSV) = 1.19889*DLOG(CHLXGSV) - 2.73853*DLOG(CHLPMGS/CHLPXGS) -0.18737*LOG(CHLMGSV(-1)/CHLXGSV(-1)) -2.07379*LOG(CHLPMGS(-1)/CHLPXGS(-1)) -0.09719 + D2000*0.14942 $ () FRML GCHLMGSD CHLMGSD = CHLMGSV*CHLPMGS*CHLEXCH/USAEXCH $ () () () IMPORT PRICES () () FRML GCHLPMGSU CHLPMGSU = MCHLDNK*LOG(DNKPXGS/CHLEXCH*DNKEXCH) + MCHLSWE*LOG(SWEPXGS/CHLEXCH*SWEEXCH) + MCHLNOR*LOG(NORPXGS/CHLEXCH*NOREXCH) + MCHLFIN*LOG(FINPXGS/CHLEXCH*FINEXCH) + MCHLNLD*LOG(NLDPXGS/CHLEXCH*NLDEXCH) + MCHLGBR*LOG(GBRPXGS/CHLEXCH*GBREXCH) + MCHLESP*LOG(ESPPXGS/CHLEXCH*ESPEXCH) + MCHLDEU*LOG(DEUPXGS/CHLEXCH*DEUEXCH) + MCHLBEL*LOG(BELPXGS/CHLEXCH*BELEXCH) + MCHLFRA*LOG(FRAPXGS/CHLEXCH*FRAEXCH) + MCHLYPN*LOG(YPNPXGS/CHLEXCH*YPNEXCH) + MCHLITA*LOG(ITAPXGS/CHLEXCH*ITAEXCH) + MCHLUSA*LOG(USAPXGS/CHLEXCH*USAEXCH) + MCHLPOL*LOG(POLPXGS/CHLEXCH*POLEXCH) + MCHLCZE*LOG(CZEPXGS/CHLEXCH*CZEEXCH) + MCHLAUS*LOG(AUSPXGS/CHLEXCH*AUSEXCH) + MCHLAUT*LOG(AUTPXGS/CHLEXCH*AUTEXCH) + MCHLCAN*LOG(CANPXGS/CHLEXCH*CANEXCH) + MCHLEST*LOG(ESTPXGS/CHLEXCH*ESTEXCH) + MCHLHUN*LOG(HUNPXGS/CHLEXCH*HUNEXCH) + MCHLGRC*LOG(GRCPXGS/CHLEXCH*GRCEXCH) + MCHLISL*LOG(ISLPXGS/CHLEXCH*ISLEXCH) + MCHLIRL*LOG(IRLPXGS/CHLEXCH*IRLEXCH) + MCHLISR*LOG(ISRPXGS/CHLEXCH*ISREXCH) + MCHLKOR*LOG(KORPXGS/CHLEXCH*KOREXCH) + MCHLLUX*LOG(LUXPXGS/CHLEXCH*LUXEXCH) + MCHLMEX*LOG(MEXPXGS/CHLEXCH*MEXEXCH) + MCHLNZL*LOG(NZLPXGS/CHLEXCH*NZLEXCH) + MCHLPRT*LOG(PRTPXGS/CHLEXCH*PRTEXCH) + MCHLSVK*LOG(SVKPXGS/CHLEXCH*SVKEXCH) + MCHLSVN*LOG(SVNPXGS/CHLEXCH*SVNEXCH) + MCHLCHE*LOG(CHEPXGS/CHLEXCH*CHEEXCH) + MCHLTUR*LOG(TURPXGS/CHLEXCH*TUREXCH) + MCHLDAE*LOG(DAEPXGS/CHLEXCH*DAEEXCH) + MCHLOOP*LOG(OOPPXGS/CHLEXCH*OOPEXCH) + MCHLBRA*LOG(BRAPXGS/CHLEXCH*BRAEXCH) + MCHLRUS*LOG(RUSPXGS/CHLEXCH*RUSEXCH) + MCHLIND*LOG(INDPXGS/CHLEXCH*INDEXCH) + MCHLCHN*LOG(CHNPXGS/CHLEXCH*CHNEXCH) + MCHLIDN*LOG(IDNPXGS/CHLEXCH*IDNEXCH) + MCHLZAF*LOG(ZAFPXGS/CHLEXCH*ZAFEXCH) + MCHLRWD*LOG(RWDPXGS/CHLEXCH*RWDEXCH) $ () FRML _GJRD_ DLOG(CHLPMGS) = (CHLPMGSU-CHLPMGSU(-1)) $ () () () EXPORT PRICES () FRML GCHLPXGSU CHLPXGSU = XCHLDNK*LOG(DNKPMGS/CHLEXCH*DNKEXCH) + XCHLSWE*LOG(SWEPMGS/CHLEXCH*SWEEXCH) + XCHLNOR*LOG(NORPMGS/CHLEXCH*NOREXCH) + XCHLFIN*LOG(FINPMGS/CHLEXCH*FINEXCH) + XCHLNLD*LOG(NLDPMGS/CHLEXCH*NLDEXCH) + XCHLGBR*LOG(GBRPMGS/CHLEXCH*GBREXCH) + XCHLESP*LOG(ESPPMGS/CHLEXCH*ESPEXCH) + XCHLDEU*LOG(DEUPMGS/CHLEXCH*DEUEXCH) + XCHLBEL*LOG(BELPMGS/CHLEXCH*BELEXCH) + XCHLFRA*LOG(FRAPMGS/CHLEXCH*FRAEXCH) + XCHLYPN*LOG(YPNPMGS/CHLEXCH*YPNEXCH) + XCHLITA*LOG(ITAPMGS/CHLEXCH*ITAEXCH) + XCHLUSA*LOG(USAPMGS/CHLEXCH*USAEXCH) + XCHLPOL*LOG(POLPMGS/CHLEXCH*POLEXCH) + XCHLCZE*LOG(CZEPMGS/CHLEXCH*CZEEXCH) + XCHLAUS*LOG(AUSPMGS/CHLEXCH*AUSEXCH) + XCHLAUT*LOG(AUTPMGS/CHLEXCH*AUTEXCH) + XCHLCAN*LOG(CANPMGS/CHLEXCH*CANEXCH) + XCHLEST*LOG(ESTPMGS/CHLEXCH*ESTEXCH) + XCHLHUN*LOG(HUNPMGS/CHLEXCH*HUNEXCH) + XCHLGRC*LOG(GRCPMGS/CHLEXCH*GRCEXCH) + XCHLISL*LOG(ISLPMGS/CHLEXCH*ISLEXCH) + XCHLIRL*LOG(IRLPMGS/CHLEXCH*IRLEXCH) + XCHLISR*LOG(ISRPMGS/CHLEXCH*ISREXCH) + XCHLKOR*LOG(KORPMGS/CHLEXCH*KOREXCH) + XCHLLUX*LOG(LUXPMGS/CHLEXCH*LUXEXCH) + XCHLMEX*LOG(MEXPMGS/CHLEXCH*MEXEXCH) + XCHLNZL*LOG(NZLPMGS/CHLEXCH*NZLEXCH) + XCHLPRT*LOG(PRTPMGS/CHLEXCH*PRTEXCH) + XCHLSVK*LOG(SVKPMGS/CHLEXCH*SVKEXCH) + XCHLSVN*LOG(SVNPMGS/CHLEXCH*SVNEXCH) + XCHLCHE*LOG(CHEPMGS/CHLEXCH*CHEEXCH) + XCHLTUR*LOG(TURPMGS/CHLEXCH*TUREXCH) + XCHLDAE*LOG(DAEPMGS/CHLEXCH*DAEEXCH) + XCHLOOP*LOG(OOPPMGS/CHLEXCH*OOPEXCH) + XCHLBRA*LOG(BRAPMGS/CHLEXCH*BRAEXCH) + XCHLRUS*LOG(RUSPMGS/CHLEXCH*RUSEXCH) + XCHLIND*LOG(INDPMGS/CHLEXCH*INDEXCH) + XCHLCHN*LOG(CHNPMGS/CHLEXCH*CHNEXCH) + XCHLIDN*LOG(IDNPMGS/CHLEXCH*IDNEXCH) + XCHLZAF*LOG(ZAFPMGS/CHLEXCH*ZAFEXCH) + XCHLRWD*LOG(RWDPMGS/CHLEXCH*RWDEXCH) $ () FRML _GJRD_ DLOG(CHLPXGS) = (CHLPXGSU-CHLPXGSU(-1)) $ () () () () () ******************* () * CHN * () ******************* () () EXPORT VOLUMES () FRML GCHNXGSDU CHNXGSDU = XCHNDNK*LOG(DNKMGSD) + XCHNSWE*LOG(SWEMGSD) + XCHNNOR*LOG(NORMGSD) + XCHNFIN*LOG(FINMGSD) + XCHNNLD*LOG(NLDMGSD) + XCHNGBR*LOG(GBRMGSD) + XCHNBEL*LOG(BELMGSD) + XCHNDEU*LOG(DEUMGSD) + XCHNFRA*LOG(FRAMGSD) + XCHNESP*LOG(ESPMGSD) + XCHNYPN*LOG(YPNMGSD) + XCHNITA*LOG(ITAMGSD) + XCHNUSA*LOG(USAMGSD) + XCHNPOL*LOG(POLMGSD) + XCHNAUS*LOG(AUSMGSD) + XCHNAUT*LOG(AUTMGSD) + XCHNCAN*LOG(CANMGSD) + XCHNCHL*LOG(CHLMGSD) + XCHNEST*LOG(ESTMGSD) + XCHNGRC*LOG(GRCMGSD) + XCHNCZE*LOG(CZEMGSD) + XCHNHUN*LOG(HUNMGSD) + XCHNISL*LOG(ISLMGSD) + XCHNIRL*LOG(IRLMGSD) + XCHNISR*LOG(ISRMGSD) + XCHNKOR*LOG(KORMGSD) + XCHNLUX*LOG(LUXMGSD) + XCHNMEX*LOG(MEXMGSD) + XCHNNZL*LOG(NZLMGSD) + XCHNPRT*LOG(PRTMGSD) + XCHNSVK*LOG(SVKMGSD) + XCHNSVN*LOG(SVNMGSD) + XCHNCHE*LOG(CHEMGSD) + XCHNTUR*LOG(TURMGSD) + XCHNDAE*LOG(DAEMGSD) + XCHNOOP*LOG(OOPMGSD) + XCHNBRA*LOG(BRAMGSD) + XCHNRUS*LOG(RUSMGSD) + XCHNIND*LOG(INDMGSD) + XCHNIDN*LOG(IDNMGSD) + XCHNZAF*LOG(ZAFMGSD) + XCHNRWD*LOG(RWDMGSD) $ FRML _GJRD DLOG(CHNXGSD) = (CHNXGSDU-CHNXGSDU(-1)) $ FRML GCHNXGSV CHNXGSV = CHNXGSD*USAEXCH/(CHNEXCH*CHNPXGS) $ () () () IMPORT () FRML _GJRD_ DLOG(CHNMGSV) = 0.78000*DLOG(CHNXGSV) - 0.91892*DLOG(CHNPMGS/CHNPXGS) -0.57932*LOG(CHNMGSV(-1)/CHNXGSV(-1)) -0.50000*LOG(CHNPMGS(-1)/CHNPXGS(-1)) -0.03903 + D1985*0.36804 - D1990*0.24340 $ () FRML GCHNMGSD CHNMGSD = CHNMGSV*CHNPMGS*CHNEXCH/USAEXCH $ () () () IMPORT PRICES () () FRML GCHNPMGSU CHNPMGSU = MCHNDNK*LOG(DNKPXGS/CHNEXCH*DNKEXCH) + MCHNSWE*LOG(SWEPXGS/CHNEXCH*SWEEXCH) + MCHNNOR*LOG(NORPXGS/CHNEXCH*NOREXCH) + MCHNFIN*LOG(FINPXGS/CHNEXCH*FINEXCH) + MCHNNLD*LOG(NLDPXGS/CHNEXCH*NLDEXCH) + MCHNGBR*LOG(GBRPXGS/CHNEXCH*GBREXCH) + MCHNESP*LOG(ESPPXGS/CHNEXCH*ESPEXCH) + MCHNDEU*LOG(DEUPXGS/CHNEXCH*DEUEXCH) + MCHNBEL*LOG(BELPXGS/CHNEXCH*BELEXCH) + MCHNFRA*LOG(FRAPXGS/CHNEXCH*FRAEXCH) + MCHNYPN*LOG(YPNPXGS/CHNEXCH*YPNEXCH) + MCHNITA*LOG(ITAPXGS/CHNEXCH*ITAEXCH) + MCHNUSA*LOG(USAPXGS/CHNEXCH*USAEXCH) + MCHNPOL*LOG(POLPXGS/CHNEXCH*POLEXCH) + MCHNAUS*LOG(AUSPXGS/CHNEXCH*AUSEXCH) + MCHNAUT*LOG(AUTPXGS/CHNEXCH*AUTEXCH) + MCHNCAN*LOG(CANPXGS/CHNEXCH*CANEXCH) + MCHNCHL*LOG(CHLPXGS/CHNEXCH*CHLEXCH) + MCHNEST*LOG(ESTPXGS/CHNEXCH*ESTEXCH) + MCHNGRC*LOG(GRCPXGS/CHNEXCH*GRCEXCH) + MCHNCZE*LOG(CZEPXGS/CHNEXCH*CZEEXCH) + MCHNHUN*LOG(HUNPXGS/CHNEXCH*HUNEXCH) + MCHNISL*LOG(ISLPXGS/CHNEXCH*ISLEXCH) + MCHNIRL*LOG(IRLPXGS/CHNEXCH*IRLEXCH) + MCHNISR*LOG(ISRPXGS/CHNEXCH*ISREXCH) + MCHNKOR*LOG(KORPXGS/CHNEXCH*KOREXCH) + MCHNLUX*LOG(LUXPXGS/CHNEXCH*LUXEXCH) + MCHNMEX*LOG(MEXPXGS/CHNEXCH*MEXEXCH) + MCHNNZL*LOG(NZLPXGS/CHNEXCH*NZLEXCH) + MCHNPRT*LOG(PRTPXGS/CHNEXCH*PRTEXCH) + MCHNSVK*LOG(SVKPXGS/CHNEXCH*SVKEXCH) + MCHNSVN*LOG(SVNPXGS/CHNEXCH*SVNEXCH) + MCHNCHE*LOG(CHEPXGS/CHNEXCH*CHEEXCH) + MCHNTUR*LOG(TURPXGS/CHNEXCH*TUREXCH) + MCHNDAE*LOG(DAEPXGS/CHNEXCH*DAEEXCH) + MCHNOOP*LOG(OOPPXGS/CHNEXCH*OOPEXCH) + MCHNBRA*LOG(BRAPXGS/CHNEXCH*BRAEXCH) + MCHNRUS*LOG(RUSPXGS/CHNEXCH*RUSEXCH) + MCHNIND*LOG(INDPXGS/CHNEXCH*INDEXCH) + MCHNIDN*LOG(IDNPXGS/CHNEXCH*IDNEXCH) + MCHNZAF*LOG(ZAFPXGS/CHNEXCH*ZAFEXCH) + MCHNRWD*LOG(RWDPXGS/CHNEXCH*RWDEXCH) $ () FRML _GJRD_ DLOG(CHNPMGS) = (CHNPMGSU-CHNPMGSU(-1)) $ () () () EXPORT PRICES () FRML GCHNPXGSU CHNPXGSU = XCHNDNK*LOG(DNKPMGS/CHNEXCH*DNKEXCH) + XCHNSWE*LOG(SWEPMGS/CHNEXCH*SWEEXCH) + XCHNNOR*LOG(NORPMGS/CHNEXCH*NOREXCH) + XCHNFIN*LOG(FINPMGS/CHNEXCH*FINEXCH) + XCHNNLD*LOG(NLDPMGS/CHNEXCH*NLDEXCH) + XCHNGBR*LOG(GBRPMGS/CHNEXCH*GBREXCH) + XCHNESP*LOG(ESPPMGS/CHNEXCH*ESPEXCH) + XCHNDEU*LOG(DEUPMGS/CHNEXCH*DEUEXCH) + XCHNBEL*LOG(BELPMGS/CHNEXCH*BELEXCH) + XCHNFRA*LOG(FRAPMGS/CHNEXCH*FRAEXCH) + XCHNYPN*LOG(YPNPMGS/CHNEXCH*YPNEXCH) + XCHNITA*LOG(ITAPMGS/CHNEXCH*ITAEXCH) + XCHNUSA*LOG(USAPMGS/CHNEXCH*USAEXCH) + XCHNPOL*LOG(POLPMGS/CHNEXCH*POLEXCH) + XCHNAUS*LOG(AUSPMGS/CHNEXCH*AUSEXCH) + XCHNAUT*LOG(AUTPMGS/CHNEXCH*AUTEXCH) + XCHNCAN*LOG(CANPMGS/CHNEXCH*CANEXCH) + XCHNCHL*LOG(CHLPMGS/CHNEXCH*CHLEXCH) + XCHNEST*LOG(ESTPMGS/CHNEXCH*ESTEXCH) + XCHNGRC*LOG(GRCPMGS/CHNEXCH*GRCEXCH) + XCHNCZE*LOG(CZEPMGS/CHNEXCH*CZEEXCH) + XCHNHUN*LOG(HUNPMGS/CHNEXCH*HUNEXCH) + XCHNISL*LOG(ISLPMGS/CHNEXCH*ISLEXCH) + XCHNIRL*LOG(IRLPMGS/CHNEXCH*IRLEXCH) + XCHNISR*LOG(ISRPMGS/CHNEXCH*ISREXCH) + XCHNKOR*LOG(KORPMGS/CHNEXCH*KOREXCH) + XCHNLUX*LOG(LUXPMGS/CHNEXCH*LUXEXCH) + XCHNMEX*LOG(MEXPMGS/CHNEXCH*MEXEXCH) + XCHNNZL*LOG(NZLPMGS/CHNEXCH*NZLEXCH) + XCHNPRT*LOG(PRTPMGS/CHNEXCH*PRTEXCH) + XCHNSVK*LOG(SVKPMGS/CHNEXCH*SVKEXCH) + XCHNSVN*LOG(SVNPMGS/CHNEXCH*SVNEXCH) + XCHNCHE*LOG(CHEPMGS/CHNEXCH*CHEEXCH) + XCHNTUR*LOG(TURPMGS/CHNEXCH*TUREXCH) + XCHNDAE*LOG(DAEPMGS/CHNEXCH*DAEEXCH) + XCHNOOP*LOG(OOPPMGS/CHNEXCH*OOPEXCH) + XCHNBRA*LOG(BRAPMGS/CHNEXCH*BRAEXCH) + XCHNRUS*LOG(RUSPMGS/CHNEXCH*RUSEXCH) + XCHNIND*LOG(INDPMGS/CHNEXCH*INDEXCH) + XCHNIDN*LOG(IDNPMGS/CHNEXCH*IDNEXCH) + XCHNZAF*LOG(ZAFPMGS/CHNEXCH*ZAFEXCH) + XCHNRWD*LOG(RWDPMGS/CHNEXCH*RWDEXCH) $ () FRML _GJRD_ DLOG(CHNPXGS) = (CHNPXGSU-CHNPXGSU(-1)) $ () () () () () ******************* () * DAE * () ******************* () () EXPORT VOLUMES () FRML GDAEXGSDU DAEXGSDU = XDAEDNK*LOG(DNKMGSD) + XDAESWE*LOG(SWEMGSD) + XDAENOR*LOG(NORMGSD) + XDAEFIN*LOG(FINMGSD) + XDAENLD*LOG(NLDMGSD) + XDAEGBR*LOG(GBRMGSD) + XDAEBEL*LOG(BELMGSD) + XDAEDEU*LOG(DEUMGSD) + XDAEFRA*LOG(FRAMGSD) + XDAEESP*LOG(ESPMGSD) + XDAEYPN*LOG(YPNMGSD) + XDAEITA*LOG(ITAMGSD) + XDAEUSA*LOG(USAMGSD) + XDAEPOL*LOG(POLMGSD) + XDAEAUS*LOG(AUSMGSD) + XDAEAUT*LOG(AUTMGSD) + XDAECAN*LOG(CANMGSD) + XDAECHL*LOG(CHLMGSD) + XDAEEST*LOG(ESTMGSD) + XDAEGRC*LOG(GRCMGSD) + XDAECZE*LOG(CZEMGSD) + XDAEHUN*LOG(HUNMGSD) + XDAEISL*LOG(ISLMGSD) + XDAEIRL*LOG(IRLMGSD) + XDAEISR*LOG(ISRMGSD) + XDAEKOR*LOG(KORMGSD) + XDAELUX*LOG(LUXMGSD) + XDAEMEX*LOG(MEXMGSD) + XDAENZL*LOG(NZLMGSD) + XDAEPRT*LOG(PRTMGSD) + XDAESVK*LOG(SVKMGSD) + XDAESVN*LOG(SVNMGSD) + XDAECHE*LOG(CHEMGSD) + XDAETUR*LOG(TURMGSD) + XDAEOOP*LOG(OOPMGSD) + XDAEBRA*LOG(BRAMGSD) + XDAERUS*LOG(RUSMGSD) + XDAEIND*LOG(INDMGSD) + XDAECHN*LOG(CHNMGSD) + XDAEIDN*LOG(IDNMGSD) + XDAEZAF*LOG(ZAFMGSD) + XDAERWD*LOG(RWDMGSD) $ FRML _GJRD DLOG(DAEXGSD) = (DAEXGSDU-DAEXGSDU(-1)) $ FRML GDAEXGSV DAEXGSV = DAEXGSD*USAEXCH/(DAEEXCH*DAEPXGS) $ () () () IMPORT () FRML _GJRD_ DLOG(DAEMGSV) = 1.20413*DLOG(DAEXGSV)- 1.00000*DLOG(DAEPMGS/DAEPXGS) -0.50000*LOG(DAEMGSV(-1)/DAEXGSV(-1)) -0.50000*LOG(DAEPMGS(-1)/DAEPXGS(-1)) -0.04513 $ () FRML GDAEMGSD DAEMGSD = DAEMGSV*DAEPMGS*DAEEXCH/USAEXCH $ () () () IMPORT PRICES () () FRML GDAEPMGSU DAEPMGSU = MDAEDNK*LOG(DNKPXGS/DAEEXCH*DNKEXCH) + MDAESWE*LOG(SWEPXGS/DAEEXCH*SWEEXCH) + MDAENOR*LOG(NORPXGS/DAEEXCH*NOREXCH) + MDAEFIN*LOG(FINPXGS/DAEEXCH*FINEXCH) + MDAENLD*LOG(NLDPXGS/DAEEXCH*NLDEXCH) + MDAEGBR*LOG(GBRPXGS/DAEEXCH*GBREXCH) + MDAEESP*LOG(ESPPXGS/DAEEXCH*ESPEXCH) + MDAEDEU*LOG(DEUPXGS/DAEEXCH*DEUEXCH) + MDAEBEL*LOG(BELPXGS/DAEEXCH*BELEXCH) + MDAEFRA*LOG(FRAPXGS/DAEEXCH*FRAEXCH) + MDAEYPN*LOG(YPNPXGS/DAEEXCH*YPNEXCH) + MDAEITA*LOG(ITAPXGS/DAEEXCH*ITAEXCH) + MDAEUSA*LOG(USAPXGS/DAEEXCH*USAEXCH) + MDAEPOL*LOG(POLPXGS/DAEEXCH*POLEXCH) + MDAEAUS*LOG(AUSPXGS/DAEEXCH*AUSEXCH) + MDAEAUT*LOG(AUTPXGS/DAEEXCH*AUTEXCH) + MDAECAN*LOG(CANPXGS/DAEEXCH*CANEXCH) + MDAECHL*LOG(CHLPXGS/DAEEXCH*CHLEXCH) + MDAEEST*LOG(ESTPXGS/DAEEXCH*ESTEXCH) + MDAEGRC*LOG(GRCPXGS/DAEEXCH*GRCEXCH) + MDAECZE*LOG(CZEPXGS/DAEEXCH*CZEEXCH) + MDAEHUN*LOG(HUNPXGS/DAEEXCH*HUNEXCH) + MDAEISL*LOG(ISLPXGS/DAEEXCH*ISLEXCH) + MDAEIRL*LOG(IRLPXGS/DAEEXCH*IRLEXCH) + MDAEISR*LOG(ISRPXGS/DAEEXCH*ISREXCH) + MDAEKOR*LOG(KORPXGS/DAEEXCH*KOREXCH) + MDAELUX*LOG(LUXPXGS/DAEEXCH*LUXEXCH) + MDAEMEX*LOG(MEXPXGS/DAEEXCH*MEXEXCH) + MDAENZL*LOG(NZLPXGS/DAEEXCH*NZLEXCH) + MDAEPRT*LOG(PRTPXGS/DAEEXCH*PRTEXCH) + MDAESVK*LOG(SVKPXGS/DAEEXCH*SVKEXCH) + MDAESVN*LOG(SVNPXGS/DAEEXCH*SVNEXCH) + MDAECHE*LOG(CHEPXGS/DAEEXCH*CHEEXCH) + MDAETUR*LOG(TURPXGS/DAEEXCH*TUREXCH) + MDAEOOP*LOG(OOPPXGS/DAEEXCH*OOPEXCH) + MDAEBRA*LOG(BRAPXGS/DAEEXCH*BRAEXCH) + MDAERUS*LOG(RUSPXGS/DAEEXCH*RUSEXCH) + MDAEIND*LOG(INDPXGS/DAEEXCH*INDEXCH) + MDAECHN*LOG(CHNPXGS/DAEEXCH*CHNEXCH) + MDAEIDN*LOG(IDNPXGS/DAEEXCH*IDNEXCH) + MDAEZAF*LOG(ZAFPXGS/DAEEXCH*ZAFEXCH) + MDAERWD*LOG(RWDPXGS/DAEEXCH*RWDEXCH) $ () FRML _GJRD_ DLOG(DAEPMGS) = (DAEPMGSU-DAEPMGSU(-1)) $ () () () EXPORT PRICES () FRML GDAEPXGSU DAEPXGSU = XDAEDNK*LOG(DNKPMGS/DAEEXCH*DNKEXCH) + XDAESWE*LOG(SWEPMGS/DAEEXCH*SWEEXCH) + XDAENOR*LOG(NORPMGS/DAEEXCH*NOREXCH) + XDAEFIN*LOG(FINPMGS/DAEEXCH*FINEXCH) + XDAENLD*LOG(NLDPMGS/DAEEXCH*NLDEXCH) + XDAEGBR*LOG(GBRPMGS/DAEEXCH*GBREXCH) + XDAEESP*LOG(ESPPMGS/DAEEXCH*ESPEXCH) + XDAEDEU*LOG(DEUPMGS/DAEEXCH*DEUEXCH) + XDAEBEL*LOG(BELPMGS/DAEEXCH*BELEXCH) + XDAEFRA*LOG(FRAPMGS/DAEEXCH*FRAEXCH) + XDAEYPN*LOG(YPNPMGS/DAEEXCH*YPNEXCH) + XDAEITA*LOG(ITAPMGS/DAEEXCH*ITAEXCH) + XDAEUSA*LOG(USAPMGS/DAEEXCH*USAEXCH) + XDAEPOL*LOG(POLPMGS/DAEEXCH*POLEXCH) + XDAEAUS*LOG(AUSPMGS/DAEEXCH*AUSEXCH) + XDAEAUT*LOG(AUTPMGS/DAEEXCH*AUTEXCH) + XDAECAN*LOG(CANPMGS/DAEEXCH*CANEXCH) + XDAECHL*LOG(CHLPMGS/DAEEXCH*CHLEXCH) + XDAEEST*LOG(ESTPMGS/DAEEXCH*ESTEXCH) + XDAEGRC*LOG(GRCPMGS/DAEEXCH*GRCEXCH) + XDAECZE*LOG(CZEPMGS/DAEEXCH*CZEEXCH) + XDAEHUN*LOG(HUNPMGS/DAEEXCH*HUNEXCH) + XDAEISL*LOG(ISLPMGS/DAEEXCH*ISLEXCH) + XDAEIRL*LOG(IRLPMGS/DAEEXCH*IRLEXCH) + XDAEISR*LOG(ISRPMGS/DAEEXCH*ISREXCH) + XDAEKOR*LOG(KORPMGS/DAEEXCH*KOREXCH) + XDAELUX*LOG(LUXPMGS/DAEEXCH*LUXEXCH) + XDAEMEX*LOG(MEXPMGS/DAEEXCH*MEXEXCH) + XDAENZL*LOG(NZLPMGS/DAEEXCH*NZLEXCH) + XDAEPRT*LOG(PRTPMGS/DAEEXCH*PRTEXCH) + XDAESVK*LOG(SVKPMGS/DAEEXCH*SVKEXCH) + XDAESVN*LOG(SVNPMGS/DAEEXCH*SVNEXCH) + XDAECHE*LOG(CHEPMGS/DAEEXCH*CHEEXCH) + XDAETUR*LOG(TURPMGS/DAEEXCH*TUREXCH) + XDAEOOP*LOG(OOPPMGS/DAEEXCH*OOPEXCH) + XDAEBRA*LOG(BRAPMGS/DAEEXCH*BRAEXCH) + XDAERUS*LOG(RUSPMGS/DAEEXCH*RUSEXCH) + XDAEIND*LOG(INDPMGS/DAEEXCH*INDEXCH) + XDAECHN*LOG(CHNPMGS/DAEEXCH*CHNEXCH) + XDAEIDN*LOG(IDNPMGS/DAEEXCH*IDNEXCH) + XDAEZAF*LOG(ZAFPMGS/DAEEXCH*ZAFEXCH) + XDAERWD*LOG(RWDPMGS/DAEEXCH*RWDEXCH) $ () FRML _GJRD_ DLOG(DAEPXGS) = (DAEPXGSU-DAEPXGSU(-1)) $ () () () () () ******************* () * EST * () ******************* () () EXPORT VOLUMES () FRML GESTXGSDU ESTXGSDU = XESTDNK*LOG(DNKMGSD) + XESTSWE*LOG(SWEMGSD) + XESTNOR*LOG(NORMGSD) + XESTFIN*LOG(FINMGSD) + XESTNLD*LOG(NLDMGSD) + XESTGBR*LOG(GBRMGSD) + XESTBEL*LOG(BELMGSD) + XESTDEU*LOG(DEUMGSD) + XESTFRA*LOG(FRAMGSD) + XESTESP*LOG(ESPMGSD) + XESTYPN*LOG(YPNMGSD) + XESTITA*LOG(ITAMGSD) + XESTUSA*LOG(USAMGSD) + XESTPOL*LOG(POLMGSD) + XESTCZE*LOG(CZEMGSD) + XESTAUS*LOG(AUSMGSD) + XESTAUT*LOG(AUTMGSD) + XESTCAN*LOG(CANMGSD) + XESTCHL*LOG(CHLMGSD) + XESTHUN*LOG(HUNMGSD) + XESTGRC*LOG(GRCMGSD) + XESTISL*LOG(ISLMGSD) + XESTIRL*LOG(IRLMGSD) + XESTISR*LOG(ISRMGSD) + XESTKOR*LOG(KORMGSD) + XESTLUX*LOG(LUXMGSD) + XESTMEX*LOG(MEXMGSD) + XESTNZL*LOG(NZLMGSD) + XESTPRT*LOG(PRTMGSD) + XESTSVK*LOG(SVKMGSD) + XESTSVN*LOG(SVNMGSD) + XESTCHE*LOG(CHEMGSD) + XESTTUR*LOG(TURMGSD) + XESTDAE*LOG(DAEMGSD) + XESTOOP*LOG(OOPMGSD) + XESTBRA*LOG(BRAMGSD) + XESTRUS*LOG(RUSMGSD) + XESTIND*LOG(INDMGSD) + XESTCHN*LOG(CHNMGSD) + XESTIDN*LOG(IDNMGSD) + XESTZAF*LOG(ZAFMGSD) + XESTRWD*LOG(RWDMGSD) $ FRML _GJRD DLOG(ESTXGSD) = (ESTXGSDU-ESTXGSDU(-1)) $ FRML GESTXGSV ESTXGSV = ESTXGSD*USAEXCH/(ESTEXCH*ESTPXGS) $ () () () IMPORT () FRML _GJRD_ DLOG(ESTMGSV) = 0.99526*DLOG(ESTXGSV) - 2.31918*DLOG(ESTPMGS/ESTPXGS) -0.59976*LOG(ESTMGSV(-1)/ESTXGSV(-1)) -0.50000*LOG(ESTPMGS(-1)/ESTPXGS(-1)) +0.03447 $ () FRML GESTMGSD ESTMGSD = ESTMGSV*ESTPMGS*ESTEXCH/USAEXCH $ () () () IMPORT PRICES () () FRML GESTPMGSU ESTPMGSU = MESTDNK*LOG(DNKPXGS/ESTEXCH*DNKEXCH) + MESTSWE*LOG(SWEPXGS/ESTEXCH*SWEEXCH) + MESTNOR*LOG(NORPXGS/ESTEXCH*NOREXCH) + MESTFIN*LOG(FINPXGS/ESTEXCH*FINEXCH) + MESTNLD*LOG(NLDPXGS/ESTEXCH*NLDEXCH) + MESTGBR*LOG(GBRPXGS/ESTEXCH*GBREXCH) + MESTESP*LOG(ESPPXGS/ESTEXCH*ESPEXCH) + MESTDEU*LOG(DEUPXGS/ESTEXCH*DEUEXCH) + MESTBEL*LOG(BELPXGS/ESTEXCH*BELEXCH) + MESTFRA*LOG(FRAPXGS/ESTEXCH*FRAEXCH) + MESTYPN*LOG(YPNPXGS/ESTEXCH*YPNEXCH) + MESTITA*LOG(ITAPXGS/ESTEXCH*ITAEXCH) + MESTUSA*LOG(USAPXGS/ESTEXCH*USAEXCH) + MESTPOL*LOG(POLPXGS/ESTEXCH*POLEXCH) + MESTCZE*LOG(CZEPXGS/ESTEXCH*CZEEXCH) + MESTAUS*LOG(AUSPXGS/ESTEXCH*AUSEXCH) + MESTAUT*LOG(AUTPXGS/ESTEXCH*AUTEXCH) + MESTCAN*LOG(CANPXGS/ESTEXCH*CANEXCH) + MESTCHL*LOG(CHLPXGS/ESTEXCH*CHLEXCH) + MESTHUN*LOG(HUNPXGS/ESTEXCH*HUNEXCH) + MESTGRC*LOG(GRCPXGS/ESTEXCH*GRCEXCH) + MESTISL*LOG(ISLPXGS/ESTEXCH*ISLEXCH) + MESTIRL*LOG(IRLPXGS/ESTEXCH*IRLEXCH) + MESTISR*LOG(ISRPXGS/ESTEXCH*ISREXCH) + MESTKOR*LOG(KORPXGS/ESTEXCH*KOREXCH) + MESTLUX*LOG(LUXPXGS/ESTEXCH*LUXEXCH) + MESTMEX*LOG(MEXPXGS/ESTEXCH*MEXEXCH) + MESTNZL*LOG(NZLPXGS/ESTEXCH*NZLEXCH) + MESTPRT*LOG(PRTPXGS/ESTEXCH*PRTEXCH) + MESTSVK*LOG(SVKPXGS/ESTEXCH*SVKEXCH) + MESTSVN*LOG(SVNPXGS/ESTEXCH*SVNEXCH) + MESTCHE*LOG(CHEPXGS/ESTEXCH*CHEEXCH) + MESTTUR*LOG(TURPXGS/ESTEXCH*TUREXCH) + MESTDAE*LOG(DAEPXGS/ESTEXCH*DAEEXCH) + MESTOOP*LOG(OOPPXGS/ESTEXCH*OOPEXCH) + MESTBRA*LOG(BRAPXGS/ESTEXCH*BRAEXCH) + MESTRUS*LOG(RUSPXGS/ESTEXCH*RUSEXCH) + MESTIND*LOG(INDPXGS/ESTEXCH*INDEXCH) + MESTCHN*LOG(CHNPXGS/ESTEXCH*CHNEXCH) + MESTIDN*LOG(IDNPXGS/ESTEXCH*IDNEXCH) + MESTZAF*LOG(ZAFPXGS/ESTEXCH*ZAFEXCH) + MESTRWD*LOG(RWDPXGS/ESTEXCH*RWDEXCH) $ () FRML _GJRD_ DLOG(ESTPMGS) = (ESTPMGSU-ESTPMGSU(-1)) $ () () () EXPORT PRICES () FRML GESTPXGSU ESTPXGSU = XESTDNK*LOG(DNKPMGS/ESTEXCH*DNKEXCH) + XESTSWE*LOG(SWEPMGS/ESTEXCH*SWEEXCH) + XESTNOR*LOG(NORPMGS/ESTEXCH*NOREXCH) + XESTFIN*LOG(FINPMGS/ESTEXCH*FINEXCH) + XESTNLD*LOG(NLDPMGS/ESTEXCH*NLDEXCH) + XESTGBR*LOG(GBRPMGS/ESTEXCH*GBREXCH) + XESTESP*LOG(ESPPMGS/ESTEXCH*ESPEXCH) + XESTDEU*LOG(DEUPMGS/ESTEXCH*DEUEXCH) + XESTBEL*LOG(BELPMGS/ESTEXCH*BELEXCH) + XESTFRA*LOG(FRAPMGS/ESTEXCH*FRAEXCH) + XESTYPN*LOG(YPNPMGS/ESTEXCH*YPNEXCH) + XESTITA*LOG(ITAPMGS/ESTEXCH*ITAEXCH) + XESTUSA*LOG(USAPMGS/ESTEXCH*USAEXCH) + XESTPOL*LOG(POLPMGS/ESTEXCH*POLEXCH) + XESTCZE*LOG(CZEPMGS/ESTEXCH*CZEEXCH) + XESTAUS*LOG(AUSPMGS/ESTEXCH*AUSEXCH) + XESTAUT*LOG(AUTPMGS/ESTEXCH*AUTEXCH) + XESTCAN*LOG(CANPMGS/ESTEXCH*CANEXCH) + XESTCHL*LOG(CHLPMGS/ESTEXCH*CHLEXCH) + XESTHUN*LOG(HUNPMGS/ESTEXCH*HUNEXCH) + XESTGRC*LOG(GRCPMGS/ESTEXCH*GRCEXCH) + XESTISL*LOG(ISLPMGS/ESTEXCH*ISLEXCH) + XESTIRL*LOG(IRLPMGS/ESTEXCH*IRLEXCH) + XESTISR*LOG(ISRPMGS/ESTEXCH*ISREXCH) + XESTKOR*LOG(KORPMGS/ESTEXCH*KOREXCH) + XESTLUX*LOG(LUXPMGS/ESTEXCH*LUXEXCH) + XESTMEX*LOG(MEXPMGS/ESTEXCH*MEXEXCH) + XESTNZL*LOG(NZLPMGS/ESTEXCH*NZLEXCH) + XESTPRT*LOG(PRTPMGS/ESTEXCH*PRTEXCH) + XESTSVK*LOG(SVKPMGS/ESTEXCH*SVKEXCH) + XESTSVN*LOG(SVNPMGS/ESTEXCH*SVNEXCH) + XESTCHE*LOG(CHEPMGS/ESTEXCH*CHEEXCH) + XESTTUR*LOG(TURPMGS/ESTEXCH*TUREXCH) + XESTDAE*LOG(DAEPMGS/ESTEXCH*DAEEXCH) + XESTOOP*LOG(OOPPMGS/ESTEXCH*OOPEXCH) + XESTBRA*LOG(BRAPMGS/ESTEXCH*BRAEXCH) + XESTRUS*LOG(RUSPMGS/ESTEXCH*RUSEXCH) + XESTIND*LOG(INDPMGS/ESTEXCH*INDEXCH) + XESTCHN*LOG(CHNPMGS/ESTEXCH*CHNEXCH) + XESTIDN*LOG(IDNPMGS/ESTEXCH*IDNEXCH) + XESTZAF*LOG(ZAFPMGS/ESTEXCH*ZAFEXCH) + XESTRWD*LOG(RWDPMGS/ESTEXCH*RWDEXCH) $ () FRML _GJRD_ DLOG(ESTPXGS) = (ESTPXGSU-ESTPXGSU(-1)) $ () () () () ******************* () * GRC * () ******************* () () EXPORT VOLUMES () FRML GGRCXGSDU GRCXGSDU = XGRCDNK*LOG(DNKMGSD) + XGRCSWE*LOG(SWEMGSD) + XGRCNOR*LOG(NORMGSD) + XGRCFIN*LOG(FINMGSD) + XGRCNLD*LOG(NLDMGSD) + XGRCGBR*LOG(GBRMGSD) + XGRCBEL*LOG(BELMGSD) + XGRCDEU*LOG(DEUMGSD) + XGRCFRA*LOG(FRAMGSD) + XGRCESP*LOG(ESPMGSD) + XGRCYPN*LOG(YPNMGSD) + XGRCITA*LOG(ITAMGSD) + XGRCUSA*LOG(USAMGSD) + XGRCPOL*LOG(POLMGSD) + XGRCAUS*LOG(AUSMGSD) + XGRCAUT*LOG(AUTMGSD) + XGRCCAN*LOG(CANMGSD) + XGRCCHL*LOG(CHLMGSD) + XGRCEST*LOG(ESTMGSD) + XGRCHUN*LOG(HUNMGSD) + XGRCCZE*LOG(CZEMGSD) + XGRCISL*LOG(ISLMGSD) + XGRCIRL*LOG(IRLMGSD) + XGRCISR*LOG(ISRMGSD) + XGRCKOR*LOG(KORMGSD) + XGRCLUX*LOG(LUXMGSD) + XGRCMEX*LOG(MEXMGSD) + XGRCNZL*LOG(NZLMGSD) + XGRCPRT*LOG(PRTMGSD) + XGRCSVK*LOG(SVKMGSD) + XGRCSVN*LOG(SVNMGSD) + XGRCCHE*LOG(CHEMGSD) + XGRCTUR*LOG(TURMGSD) + XGRCDAE*LOG(DAEMGSD) + XGRCOOP*LOG(OOPMGSD) + XGRCBRA*LOG(BRAMGSD) + XGRCRUS*LOG(RUSMGSD) + XGRCIND*LOG(INDMGSD) + XGRCCHN*LOG(CHNMGSD) + XGRCIDN*LOG(IDNMGSD) + XGRCZAF*LOG(ZAFMGSD) + XGRCRWD*LOG(RWDMGSD) $ FRML _GJRD DLOG(GRCXGSD) = (GRCXGSDU-GRCXGSDU(-1)) $ FRML GGRCXGSV GRCXGSV = GRCXGSD*USAEXCH/(GRCEXCH*GRCPXGS) $ () () () IMPORT () FRML _GJRD_ DLOG(GRCMGSV) = 0.67897*DLOG(GRCXGSV) - 0.91276*DLOG(GRCPMGS/GRCPXGS) -0.23200*LOG(GRCMGSV(-1)/GRCXGSV(-1)) -0.50000*LOG(GRCPMGS(-1)/GRCPXGS(-1)) +0.12291 -D1974*0.14638 $ () FRML GGRCMGSD GRCMGSD = GRCMGSV*GRCPMGS*GRCEXCH/USAEXCH $ () () () IMPORT PRICES () () FRML GGRCPMGSU GRCPMGSU = MGRCDNK*LOG(DNKPXGS/GRCEXCH*DNKEXCH) + MGRCSWE*LOG(SWEPXGS/GRCEXCH*SWEEXCH) + MGRCNOR*LOG(NORPXGS/GRCEXCH*NOREXCH) + MGRCFIN*LOG(FINPXGS/GRCEXCH*FINEXCH) + MGRCNLD*LOG(NLDPXGS/GRCEXCH*NLDEXCH) + MGRCGBR*LOG(GBRPXGS/GRCEXCH*GBREXCH) + MGRCESP*LOG(ESPPXGS/GRCEXCH*ESPEXCH) + MGRCDEU*LOG(DEUPXGS/GRCEXCH*DEUEXCH) + MGRCBEL*LOG(BELPXGS/GRCEXCH*BELEXCH) + MGRCFRA*LOG(FRAPXGS/GRCEXCH*FRAEXCH) + MGRCYPN*LOG(YPNPXGS/GRCEXCH*YPNEXCH) + MGRCITA*LOG(ITAPXGS/GRCEXCH*ITAEXCH) + MGRCUSA*LOG(USAPXGS/GRCEXCH*USAEXCH) + MGRCPOL*LOG(POLPXGS/GRCEXCH*POLEXCH) + MGRCAUS*LOG(AUSPXGS/GRCEXCH*AUSEXCH) + MGRCAUT*LOG(AUTPXGS/GRCEXCH*AUTEXCH) + MGRCCAN*LOG(CANPXGS/GRCEXCH*CANEXCH) + MGRCCHL*LOG(CHLPXGS/GRCEXCH*CHLEXCH) + MGRCEST*LOG(ESTPXGS/GRCEXCH*ESTEXCH) + MGRCHUN*LOG(HUNPXGS/GRCEXCH*HUNEXCH) + MGRCCZE*LOG(CZEPXGS/GRCEXCH*CZEEXCH) + MGRCISL*LOG(ISLPXGS/GRCEXCH*ISLEXCH) + MGRCIRL*LOG(IRLPXGS/GRCEXCH*IRLEXCH) + MGRCISR*LOG(ISRPXGS/GRCEXCH*ISREXCH) + MGRCKOR*LOG(KORPXGS/GRCEXCH*KOREXCH) + MGRCLUX*LOG(LUXPXGS/GRCEXCH*LUXEXCH) + MGRCMEX*LOG(MEXPXGS/GRCEXCH*MEXEXCH) + MGRCNZL*LOG(NZLPXGS/GRCEXCH*NZLEXCH) + MGRCPRT*LOG(PRTPXGS/GRCEXCH*PRTEXCH) + MGRCSVK*LOG(SVKPXGS/GRCEXCH*SVKEXCH) + MGRCSVN*LOG(SVNPXGS/GRCEXCH*SVNEXCH) + MGRCCHE*LOG(CHEPXGS/GRCEXCH*CHEEXCH) + MGRCTUR*LOG(TURPXGS/GRCEXCH*TUREXCH) + MGRCDAE*LOG(DAEPXGS/GRCEXCH*DAEEXCH) + MGRCOOP*LOG(OOPPXGS/GRCEXCH*OOPEXCH) + MGRCBRA*LOG(BRAPXGS/GRCEXCH*BRAEXCH) + MGRCRUS*LOG(RUSPXGS/GRCEXCH*RUSEXCH) + MGRCIND*LOG(INDPXGS/GRCEXCH*INDEXCH) + MGRCCHN*LOG(CHNPXGS/GRCEXCH*CHNEXCH) + MGRCIDN*LOG(IDNPXGS/GRCEXCH*IDNEXCH) + MGRCZAF*LOG(ZAFPXGS/GRCEXCH*ZAFEXCH) + MGRCRWD*LOG(RWDPXGS/GRCEXCH*RWDEXCH) $ () FRML _GJRD_ DLOG(GRCPMGS) = (GRCPMGSU-GRCPMGSU(-1)) $ () () () EXPORT PRICES () FRML GGRCPXGSU GRCPXGSU = XGRCDNK*LOG(DNKPMGS/GRCEXCH*DNKEXCH) + XGRCSWE*LOG(SWEPMGS/GRCEXCH*SWEEXCH) + XGRCNOR*LOG(NORPMGS/GRCEXCH*NOREXCH) + XGRCFIN*LOG(FINPMGS/GRCEXCH*FINEXCH) + XGRCNLD*LOG(NLDPMGS/GRCEXCH*NLDEXCH) + XGRCGBR*LOG(GBRPMGS/GRCEXCH*GBREXCH) + XGRCESP*LOG(ESPPMGS/GRCEXCH*ESPEXCH) + XGRCDEU*LOG(DEUPMGS/GRCEXCH*DEUEXCH) + XGRCBEL*LOG(BELPMGS/GRCEXCH*BELEXCH) + XGRCFRA*LOG(FRAPMGS/GRCEXCH*FRAEXCH) + XGRCYPN*LOG(YPNPMGS/GRCEXCH*YPNEXCH) + XGRCITA*LOG(ITAPMGS/GRCEXCH*ITAEXCH) + XGRCUSA*LOG(USAPMGS/GRCEXCH*USAEXCH) + XGRCPOL*LOG(POLPMGS/GRCEXCH*POLEXCH) + XGRCAUS*LOG(AUSPMGS/GRCEXCH*AUSEXCH) + XGRCAUT*LOG(AUTPMGS/GRCEXCH*AUTEXCH) + XGRCCAN*LOG(CANPMGS/GRCEXCH*CANEXCH) + XGRCCHL*LOG(CHLPMGS/GRCEXCH*CHLEXCH) + XGRCEST*LOG(ESTPMGS/GRCEXCH*ESTEXCH) + XGRCHUN*LOG(HUNPMGS/GRCEXCH*HUNEXCH) + XGRCCZE*LOG(CZEPMGS/GRCEXCH*CZEEXCH) + XGRCISL*LOG(ISLPMGS/GRCEXCH*ISLEXCH) + XGRCIRL*LOG(IRLPMGS/GRCEXCH*IRLEXCH) + XGRCISR*LOG(ISRPMGS/GRCEXCH*ISREXCH) + XGRCKOR*LOG(KORPMGS/GRCEXCH*KOREXCH) + XGRCLUX*LOG(LUXPMGS/GRCEXCH*LUXEXCH) + XGRCMEX*LOG(MEXPMGS/GRCEXCH*MEXEXCH) + XGRCNZL*LOG(NZLPMGS/GRCEXCH*NZLEXCH) + XGRCPRT*LOG(PRTPMGS/GRCEXCH*PRTEXCH) + XGRCSVK*LOG(SVKPMGS/GRCEXCH*SVKEXCH) + XGRCSVN*LOG(SVNPMGS/GRCEXCH*SVNEXCH) + XGRCCHE*LOG(CHEPMGS/GRCEXCH*CHEEXCH) + XGRCTUR*LOG(TURPMGS/GRCEXCH*TUREXCH) + XGRCDAE*LOG(DAEPMGS/GRCEXCH*DAEEXCH) + XGRCOOP*LOG(OOPPMGS/GRCEXCH*OOPEXCH) + XGRCBRA*LOG(BRAPMGS/GRCEXCH*BRAEXCH) + XGRCRUS*LOG(RUSPMGS/GRCEXCH*RUSEXCH) + XGRCIND*LOG(INDPMGS/GRCEXCH*INDEXCH) + XGRCCHN*LOG(CHNPMGS/GRCEXCH*CHNEXCH) + XGRCIDN*LOG(IDNPMGS/GRCEXCH*IDNEXCH) + XGRCZAF*LOG(ZAFPMGS/GRCEXCH*ZAFEXCH) + XGRCRWD*LOG(RWDPMGS/GRCEXCH*RWDEXCH) $ () FRML _GJRD_ DLOG(GRCPXGS) = (GRCPXGSU-GRCPXGSU(-1)) $ () () () () ******************* () * HUN * () ******************* () () EXPORT VOLUMES () FRML GHUNXGSDU HUNXGSDU = XHUNDNK*LOG(DNKMGSD) + XHUNSWE*LOG(SWEMGSD) + XHUNNOR*LOG(NORMGSD) + XHUNFIN*LOG(FINMGSD) + XHUNNLD*LOG(NLDMGSD) + XHUNGBR*LOG(GBRMGSD) + XHUNBEL*LOG(BELMGSD) + XHUNDEU*LOG(DEUMGSD) + XHUNFRA*LOG(FRAMGSD) + XHUNESP*LOG(ESPMGSD) + XHUNYPN*LOG(YPNMGSD) + XHUNITA*LOG(ITAMGSD) + XHUNUSA*LOG(USAMGSD) + XHUNPOL*LOG(POLMGSD) + XHUNAUS*LOG(AUSMGSD) + XHUNAUT*LOG(AUTMGSD) + XHUNCAN*LOG(CANMGSD) + XHUNCHL*LOG(CHLMGSD) + XHUNEST*LOG(ESTMGSD) + XHUNGRC*LOG(GRCMGSD) + XHUNCZE*LOG(CZEMGSD) + XHUNISL*LOG(ISLMGSD) + XHUNIRL*LOG(IRLMGSD) + XHUNISR*LOG(ISRMGSD) + XHUNKOR*LOG(KORMGSD) + XHUNLUX*LOG(LUXMGSD) + XHUNMEX*LOG(MEXMGSD) + XHUNNZL*LOG(NZLMGSD) + XHUNPRT*LOG(PRTMGSD) + XHUNSVK*LOG(SVKMGSD) + XHUNSVN*LOG(SVNMGSD) + XHUNCHE*LOG(CHEMGSD) + XHUNTUR*LOG(TURMGSD) + XHUNDAE*LOG(DAEMGSD) + XHUNOOP*LOG(OOPMGSD) + XHUNBRA*LOG(BRAMGSD) + XHUNRUS*LOG(RUSMGSD) + XHUNIND*LOG(INDMGSD) + XHUNCHN*LOG(CHNMGSD) + XHUNIDN*LOG(IDNMGSD) + XHUNZAF*LOG(ZAFMGSD) + XHUNRWD*LOG(RWDMGSD) $ FRML _GJRD DLOG(HUNXGSD) = (HUNXGSDU-HUNXGSDU(-1)) $ FRML GHUNXGSV HUNXGSV = HUNXGSD*USAEXCH/(HUNEXCH*HUNPXGS) $ () () () IMPORT () FRML _GJRD_ DLOG(HUNMGSV) = 0.66855*DLOG(HUNXGSV) - 1.43284*DLOG(HUNPMGS/HUNPXGS) -0.46771*LOG(HUNMGSV(-1)/HUNXGSV(-1)) -0.27158*LOG(HUNPMGS(-1)/HUNPXGS(-1)) +0.04359 $ () FRML GHUNMGSD HUNMGSD = HUNMGSV*HUNPMGS*HUNEXCH/USAEXCH $ () () () IMPORT PRICES () () FRML GHUNPMGSU HUNPMGSU = MHUNDNK*LOG(DNKPXGS/HUNEXCH*DNKEXCH) + MHUNSWE*LOG(SWEPXGS/HUNEXCH*SWEEXCH) + MHUNNOR*LOG(NORPXGS/HUNEXCH*NOREXCH) + MHUNFIN*LOG(FINPXGS/HUNEXCH*FINEXCH) + MHUNNLD*LOG(NLDPXGS/HUNEXCH*NLDEXCH) + MHUNGBR*LOG(GBRPXGS/HUNEXCH*GBREXCH) + MHUNESP*LOG(ESPPXGS/HUNEXCH*ESPEXCH) + MHUNDEU*LOG(DEUPXGS/HUNEXCH*DEUEXCH) + MHUNBEL*LOG(BELPXGS/HUNEXCH*BELEXCH) + MHUNFRA*LOG(FRAPXGS/HUNEXCH*FRAEXCH) + MHUNYPN*LOG(YPNPXGS/HUNEXCH*YPNEXCH) + MHUNITA*LOG(ITAPXGS/HUNEXCH*ITAEXCH) + MHUNUSA*LOG(USAPXGS/HUNEXCH*USAEXCH) + MHUNPOL*LOG(POLPXGS/HUNEXCH*POLEXCH) + MHUNAUS*LOG(AUSPXGS/HUNEXCH*AUSEXCH) + MHUNAUT*LOG(AUTPXGS/HUNEXCH*AUTEXCH) + MHUNCAN*LOG(CANPXGS/HUNEXCH*CANEXCH) + MHUNCHL*LOG(CHLPXGS/HUNEXCH*CHLEXCH) + MHUNEST*LOG(ESTPXGS/HUNEXCH*ESTEXCH) + MHUNGRC*LOG(GRCPXGS/HUNEXCH*GRCEXCH) + MHUNCZE*LOG(CZEPXGS/HUNEXCH*CZEEXCH) + MHUNISL*LOG(ISLPXGS/HUNEXCH*ISLEXCH) + MHUNIRL*LOG(IRLPXGS/HUNEXCH*IRLEXCH) + MHUNISR*LOG(ISRPXGS/HUNEXCH*ISREXCH) + MHUNKOR*LOG(KORPXGS/HUNEXCH*KOREXCH) + MHUNLUX*LOG(LUXPXGS/HUNEXCH*LUXEXCH) + MHUNMEX*LOG(MEXPXGS/HUNEXCH*MEXEXCH) + MHUNNZL*LOG(NZLPXGS/HUNEXCH*NZLEXCH) + MHUNPRT*LOG(PRTPXGS/HUNEXCH*PRTEXCH) + MHUNSVK*LOG(SVKPXGS/HUNEXCH*SVKEXCH) + MHUNSVN*LOG(SVNPXGS/HUNEXCH*SVNEXCH) + MHUNCHE*LOG(CHEPXGS/HUNEXCH*CHEEXCH) + MHUNTUR*LOG(TURPXGS/HUNEXCH*TUREXCH) + MHUNDAE*LOG(DAEPXGS/HUNEXCH*DAEEXCH) + MHUNOOP*LOG(OOPPXGS/HUNEXCH*OOPEXCH) + MHUNBRA*LOG(BRAPXGS/HUNEXCH*BRAEXCH) + MHUNRUS*LOG(RUSPXGS/HUNEXCH*RUSEXCH) + MHUNIND*LOG(INDPXGS/HUNEXCH*INDEXCH) + MHUNCHN*LOG(CHNPXGS/HUNEXCH*CHNEXCH) + MHUNIDN*LOG(IDNPXGS/HUNEXCH*IDNEXCH) + MHUNZAF*LOG(ZAFPXGS/HUNEXCH*ZAFEXCH) + MHUNRWD*LOG(RWDPXGS/HUNEXCH*RWDEXCH) $ () FRML _GJRD_ DLOG(HUNPMGS) = (HUNPMGSU-HUNPMGSU(-1)) $ () () () EXPORT PRICES () FRML GHUNPXGSU HUNPXGSU = XHUNDNK*LOG(DNKPMGS/HUNEXCH*DNKEXCH) + XHUNSWE*LOG(SWEPMGS/HUNEXCH*SWEEXCH) + XHUNNOR*LOG(NORPMGS/HUNEXCH*NOREXCH) + XHUNFIN*LOG(FINPMGS/HUNEXCH*FINEXCH) + XHUNNLD*LOG(NLDPMGS/HUNEXCH*NLDEXCH) + XHUNGBR*LOG(GBRPMGS/HUNEXCH*GBREXCH) + XHUNESP*LOG(ESPPMGS/HUNEXCH*ESPEXCH) + XHUNDEU*LOG(DEUPMGS/HUNEXCH*DEUEXCH) + XHUNBEL*LOG(BELPMGS/HUNEXCH*BELEXCH) + XHUNFRA*LOG(FRAPMGS/HUNEXCH*FRAEXCH) + XHUNYPN*LOG(YPNPMGS/HUNEXCH*YPNEXCH) + XHUNITA*LOG(ITAPMGS/HUNEXCH*ITAEXCH) + XHUNUSA*LOG(USAPMGS/HUNEXCH*USAEXCH) + XHUNPOL*LOG(POLPMGS/HUNEXCH*POLEXCH) + XHUNAUS*LOG(AUSPMGS/HUNEXCH*AUSEXCH) + XHUNAUT*LOG(AUTPMGS/HUNEXCH*AUTEXCH) + XHUNCAN*LOG(CANPMGS/HUNEXCH*CANEXCH) + XHUNCHL*LOG(CHLPMGS/HUNEXCH*CHLEXCH) + XHUNEST*LOG(ESTPMGS/HUNEXCH*ESTEXCH) + XHUNGRC*LOG(GRCPMGS/HUNEXCH*GRCEXCH) + XHUNCZE*LOG(CZEPMGS/HUNEXCH*CZEEXCH) + XHUNISL*LOG(ISLPMGS/HUNEXCH*ISLEXCH) + XHUNIRL*LOG(IRLPMGS/HUNEXCH*IRLEXCH) + XHUNISR*LOG(ISRPMGS/HUNEXCH*ISREXCH) + XHUNKOR*LOG(KORPMGS/HUNEXCH*KOREXCH) + XHUNLUX*LOG(LUXPMGS/HUNEXCH*LUXEXCH) + XHUNMEX*LOG(MEXPMGS/HUNEXCH*MEXEXCH) + XHUNNZL*LOG(NZLPMGS/HUNEXCH*NZLEXCH) + XHUNPRT*LOG(PRTPMGS/HUNEXCH*PRTEXCH) + XHUNSVK*LOG(SVKPMGS/HUNEXCH*SVKEXCH) + XHUNSVN*LOG(SVNPMGS/HUNEXCH*SVNEXCH) + XHUNCHE*LOG(CHEPMGS/HUNEXCH*CHEEXCH) + XHUNTUR*LOG(TURPMGS/HUNEXCH*TUREXCH) + XHUNDAE*LOG(DAEPMGS/HUNEXCH*DAEEXCH) + XHUNOOP*LOG(OOPPMGS/HUNEXCH*OOPEXCH) + XHUNBRA*LOG(BRAPMGS/HUNEXCH*BRAEXCH) + XHUNRUS*LOG(RUSPMGS/HUNEXCH*RUSEXCH) + XHUNIND*LOG(INDPMGS/HUNEXCH*INDEXCH) + XHUNCHN*LOG(CHNPMGS/HUNEXCH*CHNEXCH) + XHUNIDN*LOG(IDNPMGS/HUNEXCH*IDNEXCH) + XHUNZAF*LOG(ZAFPMGS/HUNEXCH*ZAFEXCH) + XHUNRWD*LOG(RWDPMGS/HUNEXCH*RWDEXCH) $ () FRML _GJRD_ DLOG(HUNPXGS) = (HUNPXGSU-HUNPXGSU(-1)) $ () () () () ******************* () * IDN * () ******************* () () EXPORT VOLUMES () FRML GIDNXGSDU IDNXGSDU = XIDNDNK*LOG(DNKMGSD) + XIDNSWE*LOG(SWEMGSD) + XIDNNOR*LOG(NORMGSD) + XIDNFIN*LOG(FINMGSD) + XIDNNLD*LOG(NLDMGSD) + XIDNGBR*LOG(GBRMGSD) + XIDNBEL*LOG(BELMGSD) + XIDNDEU*LOG(DEUMGSD) + XIDNFRA*LOG(FRAMGSD) + XIDNESP*LOG(ESPMGSD) + XIDNYPN*LOG(YPNMGSD) + XIDNITA*LOG(ITAMGSD) + XIDNUSA*LOG(USAMGSD) + XIDNPOL*LOG(POLMGSD) + XIDNAUS*LOG(AUSMGSD) + XIDNAUT*LOG(AUTMGSD) + XIDNCAN*LOG(CANMGSD) + XIDNCHL*LOG(CHLMGSD) + XIDNEST*LOG(ESTMGSD) + XIDNGRC*LOG(GRCMGSD) + XIDNCZE*LOG(CZEMGSD) + XIDNHUN*LOG(HUNMGSD) + XIDNISL*LOG(ISLMGSD) + XIDNIRL*LOG(IRLMGSD) + XIDNISR*LOG(ISRMGSD) + XIDNKOR*LOG(KORMGSD) + XIDNLUX*LOG(LUXMGSD) + XIDNMEX*LOG(MEXMGSD) + XIDNNZL*LOG(NZLMGSD) + XIDNPRT*LOG(PRTMGSD) + XIDNSVK*LOG(SVKMGSD) + XIDNSVN*LOG(SVNMGSD) + XIDNCHE*LOG(CHEMGSD) + XIDNTUR*LOG(TURMGSD) + XIDNDAE*LOG(DAEMGSD) + XIDNOOP*LOG(OOPMGSD) + XIDNBRA*LOG(BRAMGSD) + XIDNRUS*LOG(RUSMGSD) + XIDNIND*LOG(INDMGSD) + XIDNCHN*LOG(CHNMGSD) + XIDNZAF*LOG(ZAFMGSD) + XIDNRWD*LOG(RWDMGSD) $ FRML _GJRD DLOG(IDNXGSD) = (IDNXGSDU-IDNXGSDU(-1)) $ FRML GIDNXGSV IDNXGSV = IDNXGSD*USAEXCH/(IDNEXCH*IDNPXGS) $ () () () IMPORT () FRML _GJRD_ DLOG(IDNMGSV) = 0.98270*DLOG(IDNXGSV) - 0.55315*DLOG(IDNPMGS/IDNPXGS) -0.38440*LOG(IDNMGSV(-1)/IDNXGSV(-1)) -0.50000*LOG(IDNPMGS(-1)/IDNPXGS(-1)) -0.07196 $ () FRML GIDNMGSD IDNMGSD = IDNMGSV*IDNPMGS*IDNEXCH/USAEXCH $ () () () IMPORT PRICES () () FRML GIDNPMGSU IDNPMGSU = MIDNDNK*LOG(DNKPXGS/IDNEXCH*DNKEXCH) + MIDNSWE*LOG(SWEPXGS/IDNEXCH*SWEEXCH) + MIDNNOR*LOG(NORPXGS/IDNEXCH*NOREXCH) + MIDNFIN*LOG(FINPXGS/IDNEXCH*FINEXCH) + MIDNNLD*LOG(NLDPXGS/IDNEXCH*NLDEXCH) + MIDNGBR*LOG(GBRPXGS/IDNEXCH*GBREXCH) + MIDNESP*LOG(ESPPXGS/IDNEXCH*ESPEXCH) + MIDNDEU*LOG(DEUPXGS/IDNEXCH*DEUEXCH) + MIDNBEL*LOG(BELPXGS/IDNEXCH*BELEXCH) + MIDNFRA*LOG(FRAPXGS/IDNEXCH*FRAEXCH) + MIDNYPN*LOG(YPNPXGS/IDNEXCH*YPNEXCH) + MIDNITA*LOG(ITAPXGS/IDNEXCH*ITAEXCH) + MIDNUSA*LOG(USAPXGS/IDNEXCH*USAEXCH) + MIDNPOL*LOG(POLPXGS/IDNEXCH*POLEXCH) + MIDNAUS*LOG(AUSPXGS/IDNEXCH*AUSEXCH) + MIDNAUT*LOG(AUTPXGS/IDNEXCH*AUTEXCH) + MIDNCAN*LOG(CANPXGS/IDNEXCH*CANEXCH) + MIDNCHL*LOG(CHLPXGS/IDNEXCH*CHLEXCH) + MIDNEST*LOG(ESTPXGS/IDNEXCH*ESTEXCH) + MIDNGRC*LOG(GRCPXGS/IDNEXCH*GRCEXCH) + MIDNCZE*LOG(CZEPXGS/IDNEXCH*CZEEXCH) + MIDNHUN*LOG(HUNPXGS/IDNEXCH*HUNEXCH) + MIDNISL*LOG(ISLPXGS/IDNEXCH*ISLEXCH) + MIDNIRL*LOG(IRLPXGS/IDNEXCH*IRLEXCH) + MIDNISR*LOG(ISRPXGS/IDNEXCH*ISREXCH) + MIDNKOR*LOG(KORPXGS/IDNEXCH*KOREXCH) + MIDNLUX*LOG(LUXPXGS/IDNEXCH*LUXEXCH) + MIDNMEX*LOG(MEXPXGS/IDNEXCH*MEXEXCH) + MIDNNZL*LOG(NZLPXGS/IDNEXCH*NZLEXCH) + MIDNPRT*LOG(PRTPXGS/IDNEXCH*PRTEXCH) + MIDNSVK*LOG(SVKPXGS/IDNEXCH*SVKEXCH) + MIDNSVN*LOG(SVNPXGS/IDNEXCH*SVNEXCH) + MIDNCHE*LOG(CHEPXGS/IDNEXCH*CHEEXCH) + MIDNTUR*LOG(TURPXGS/IDNEXCH*TUREXCH) + MIDNDAE*LOG(DAEPXGS/IDNEXCH*DAEEXCH) + MIDNOOP*LOG(OOPPXGS/IDNEXCH*OOPEXCH) + MIDNBRA*LOG(BRAPXGS/IDNEXCH*BRAEXCH) + MIDNRUS*LOG(RUSPXGS/IDNEXCH*RUSEXCH) + MIDNIND*LOG(INDPXGS/IDNEXCH*INDEXCH) + MIDNCHN*LOG(CHNPXGS/IDNEXCH*CHNEXCH) + MIDNZAF*LOG(ZAFPXGS/IDNEXCH*ZAFEXCH) + MIDNRWD*LOG(RWDPXGS/IDNEXCH*RWDEXCH) $ () FRML _GJRD_ DLOG(IDNPMGS) = (IDNPMGSU-IDNPMGSU(-1)) $ () () () EXPORT PRICES () FRML GIDNPXGSU IDNPXGSU = XIDNDNK*LOG(DNKPMGS/IDNEXCH*DNKEXCH) + XIDNSWE*LOG(SWEPMGS/IDNEXCH*SWEEXCH) + XIDNNOR*LOG(NORPMGS/IDNEXCH*NOREXCH) + XIDNFIN*LOG(FINPMGS/IDNEXCH*FINEXCH) + XIDNNLD*LOG(NLDPMGS/IDNEXCH*NLDEXCH) + XIDNGBR*LOG(GBRPMGS/IDNEXCH*GBREXCH) + XIDNESP*LOG(ESPPMGS/IDNEXCH*ESPEXCH) + XIDNDEU*LOG(DEUPMGS/IDNEXCH*DEUEXCH) + XIDNBEL*LOG(BELPMGS/IDNEXCH*BELEXCH) + XIDNFRA*LOG(FRAPMGS/IDNEXCH*FRAEXCH) + XIDNYPN*LOG(YPNPMGS/IDNEXCH*YPNEXCH) + XIDNITA*LOG(ITAPMGS/IDNEXCH*ITAEXCH) + XIDNUSA*LOG(USAPMGS/IDNEXCH*USAEXCH) + XIDNPOL*LOG(POLPMGS/IDNEXCH*POLEXCH) + XIDNAUS*LOG(AUSPMGS/IDNEXCH*AUSEXCH) + XIDNAUT*LOG(AUTPMGS/IDNEXCH*AUTEXCH) + XIDNCAN*LOG(CANPMGS/IDNEXCH*CANEXCH) + XIDNCHL*LOG(CHLPMGS/IDNEXCH*CHLEXCH) + XIDNEST*LOG(ESTPMGS/IDNEXCH*ESTEXCH) + XIDNGRC*LOG(GRCPMGS/IDNEXCH*GRCEXCH) + XIDNCZE*LOG(CZEPMGS/IDNEXCH*CZEEXCH) + XIDNHUN*LOG(HUNPMGS/IDNEXCH*HUNEXCH) + XIDNISL*LOG(ISLPMGS/IDNEXCH*ISLEXCH) + XIDNIRL*LOG(IRLPMGS/IDNEXCH*IRLEXCH) + XIDNISR*LOG(ISRPMGS/IDNEXCH*ISREXCH) + XIDNKOR*LOG(KORPMGS/IDNEXCH*KOREXCH) + XIDNLUX*LOG(LUXPMGS/IDNEXCH*LUXEXCH) + XIDNMEX*LOG(MEXPMGS/IDNEXCH*MEXEXCH) + XIDNNZL*LOG(NZLPMGS/IDNEXCH*NZLEXCH) + XIDNPRT*LOG(PRTPMGS/IDNEXCH*PRTEXCH) + XIDNSVK*LOG(SVKPMGS/IDNEXCH*SVKEXCH) + XIDNSVN*LOG(SVNPMGS/IDNEXCH*SVNEXCH) + XIDNCHE*LOG(CHEPMGS/IDNEXCH*CHEEXCH) + XIDNTUR*LOG(TURPMGS/IDNEXCH*TUREXCH) + XIDNDAE*LOG(DAEPMGS/IDNEXCH*DAEEXCH) + XIDNOOP*LOG(OOPPMGS/IDNEXCH*OOPEXCH) + XIDNBRA*LOG(BRAPMGS/IDNEXCH*BRAEXCH) + XIDNRUS*LOG(RUSPMGS/IDNEXCH*RUSEXCH) + XIDNIND*LOG(INDPMGS/IDNEXCH*INDEXCH) + XIDNCHN*LOG(CHNPMGS/IDNEXCH*CHNEXCH) + XIDNZAF*LOG(ZAFPMGS/IDNEXCH*ZAFEXCH) + XIDNRWD*LOG(RWDPMGS/IDNEXCH*RWDEXCH) $ () FRML _GJRD_ DLOG(IDNPXGS) = (IDNPXGSU-IDNPXGSU(-1)) $ () () () ******************* () * IND * () ******************* () () EXPORT VOLUMES () FRML GINDXGSDU INDXGSDU = XINDDNK*LOG(DNKMGSD) + XINDSWE*LOG(SWEMGSD) + XINDNOR*LOG(NORMGSD) + XINDFIN*LOG(FINMGSD) + XINDNLD*LOG(NLDMGSD) + XINDGBR*LOG(GBRMGSD) + XINDBEL*LOG(BELMGSD) + XINDDEU*LOG(DEUMGSD) + XINDFRA*LOG(FRAMGSD) + XINDESP*LOG(ESPMGSD) + XINDYPN*LOG(YPNMGSD) + XINDITA*LOG(ITAMGSD) + XINDUSA*LOG(USAMGSD) + XINDPOL*LOG(POLMGSD) + XINDAUS*LOG(AUSMGSD) + XINDAUT*LOG(AUTMGSD) + XINDCAN*LOG(CANMGSD) + XINDCHL*LOG(CHLMGSD) + XINDEST*LOG(ESTMGSD) + XINDGRC*LOG(GRCMGSD) + XINDCZE*LOG(CZEMGSD) + XINDHUN*LOG(HUNMGSD) + XINDISL*LOG(ISLMGSD) + XINDIRL*LOG(IRLMGSD) + XINDISR*LOG(ISRMGSD) + XINDKOR*LOG(KORMGSD) + XINDLUX*LOG(LUXMGSD) + XINDMEX*LOG(MEXMGSD) + XINDNZL*LOG(NZLMGSD) + XINDPRT*LOG(PRTMGSD) + XINDSVK*LOG(SVKMGSD) + XINDSVN*LOG(SVNMGSD) + XINDCHE*LOG(CHEMGSD) + XINDTUR*LOG(TURMGSD) + XINDDAE*LOG(DAEMGSD) + XINDOOP*LOG(OOPMGSD) + XINDBRA*LOG(BRAMGSD) + XINDRUS*LOG(RUSMGSD) + XINDCHN*LOG(CHNMGSD) + XINDIDN*LOG(IDNMGSD) + XINDZAF*LOG(ZAFMGSD) + XINDRWD*LOG(RWDMGSD) $ FRML _GJRD DLOG(INDXGSD) = (INDXGSDU-INDXGSDU(-1)) $ FRML GINDXGSV INDXGSV = INDXGSD*USAEXCH/(INDEXCH*INDPXGS) $ () () () IMPORT () FRML _GJRD_ DLOG(INDMGSV) = 0.99093*DLOG(INDXGSV) - 1.19220*DLOG(INDPMGS/INDPXGS) -0.61521*LOG(INDMGSV(-1)/INDXGSV(-1)) -0.50000*LOG(INDPMGS(-1)/INDPXGS(-1)) +0.08672 $ () FRML GINDMGSD INDMGSD = INDMGSV*INDPMGS*INDEXCH/USAEXCH $ () () () IMPORT PRICES () () FRML GINDPMGSU INDPMGSU = MINDDNK*LOG(DNKPXGS/INDEXCH*DNKEXCH) + MINDSWE*LOG(SWEPXGS/INDEXCH*SWEEXCH) + MINDNOR*LOG(NORPXGS/INDEXCH*NOREXCH) + MINDFIN*LOG(FINPXGS/INDEXCH*FINEXCH) + MINDNLD*LOG(NLDPXGS/INDEXCH*NLDEXCH) + MINDGBR*LOG(GBRPXGS/INDEXCH*GBREXCH) + MINDESP*LOG(ESPPXGS/INDEXCH*ESPEXCH) + MINDDEU*LOG(DEUPXGS/INDEXCH*DEUEXCH) + MINDBEL*LOG(BELPXGS/INDEXCH*BELEXCH) + MINDFRA*LOG(FRAPXGS/INDEXCH*FRAEXCH) + MINDYPN*LOG(YPNPXGS/INDEXCH*YPNEXCH) + MINDITA*LOG(ITAPXGS/INDEXCH*ITAEXCH) + MINDUSA*LOG(USAPXGS/INDEXCH*USAEXCH) + MINDPOL*LOG(POLPXGS/INDEXCH*POLEXCH) + MINDAUS*LOG(AUSPXGS/INDEXCH*AUSEXCH) + MINDAUT*LOG(AUTPXGS/INDEXCH*AUTEXCH) + MINDCAN*LOG(CANPXGS/INDEXCH*CANEXCH) + MINDCHL*LOG(CHLPXGS/INDEXCH*CHLEXCH) + MINDEST*LOG(ESTPXGS/INDEXCH*ESTEXCH) + MINDGRC*LOG(GRCPXGS/INDEXCH*GRCEXCH) + MINDCZE*LOG(CZEPXGS/INDEXCH*CZEEXCH) + MINDHUN*LOG(HUNPXGS/INDEXCH*HUNEXCH) + MINDISL*LOG(ISLPXGS/INDEXCH*ISLEXCH) + MINDIRL*LOG(IRLPXGS/INDEXCH*IRLEXCH) + MINDISR*LOG(ISRPXGS/INDEXCH*ISREXCH) + MINDKOR*LOG(KORPXGS/INDEXCH*KOREXCH) + MINDLUX*LOG(LUXPXGS/INDEXCH*LUXEXCH) + MINDMEX*LOG(MEXPXGS/INDEXCH*MEXEXCH) + MINDNZL*LOG(NZLPXGS/INDEXCH*NZLEXCH) + MINDPRT*LOG(PRTPXGS/INDEXCH*PRTEXCH) + MINDSVK*LOG(SVKPXGS/INDEXCH*SVKEXCH) + MINDSVN*LOG(SVNPXGS/INDEXCH*SVNEXCH) + MINDCHE*LOG(CHEPXGS/INDEXCH*CHEEXCH) + MINDTUR*LOG(TURPXGS/INDEXCH*TUREXCH) + MINDDAE*LOG(DAEPXGS/INDEXCH*DAEEXCH) + MINDOOP*LOG(OOPPXGS/INDEXCH*OOPEXCH) + MINDBRA*LOG(BRAPXGS/INDEXCH*BRAEXCH) + MINDRUS*LOG(RUSPXGS/INDEXCH*RUSEXCH) + MINDCHN*LOG(CHNPXGS/INDEXCH*CHNEXCH) + MINDIDN*LOG(IDNPXGS/INDEXCH*IDNEXCH) + MINDZAF*LOG(ZAFPXGS/INDEXCH*ZAFEXCH) + MINDRWD*LOG(RWDPXGS/INDEXCH*RWDEXCH) $ () FRML _GJRD_ DLOG(INDPMGS) = (INDPMGSU-INDPMGSU(-1)) $ () () () EXPORT PRICES () FRML GINDPXGSU INDPXGSU = XINDDNK*LOG(DNKPMGS/INDEXCH*DNKEXCH) + XINDSWE*LOG(SWEPMGS/INDEXCH*SWEEXCH) + XINDNOR*LOG(NORPMGS/INDEXCH*NOREXCH) + XINDFIN*LOG(FINPMGS/INDEXCH*FINEXCH) + XINDNLD*LOG(NLDPMGS/INDEXCH*NLDEXCH) + XINDGBR*LOG(GBRPMGS/INDEXCH*GBREXCH) + XINDESP*LOG(ESPPMGS/INDEXCH*ESPEXCH) + XINDDEU*LOG(DEUPMGS/INDEXCH*DEUEXCH) + XINDBEL*LOG(BELPMGS/INDEXCH*BELEXCH) + XINDFRA*LOG(FRAPMGS/INDEXCH*FRAEXCH) + XINDYPN*LOG(YPNPMGS/INDEXCH*YPNEXCH) + XINDITA*LOG(ITAPMGS/INDEXCH*ITAEXCH) + XINDUSA*LOG(USAPMGS/INDEXCH*USAEXCH) + XINDPOL*LOG(POLPMGS/INDEXCH*POLEXCH) + XINDAUS*LOG(AUSPMGS/INDEXCH*AUSEXCH) + XINDAUT*LOG(AUTPMGS/INDEXCH*AUTEXCH) + XINDCAN*LOG(CANPMGS/INDEXCH*CANEXCH) + XINDCHL*LOG(CHLPMGS/INDEXCH*CHLEXCH) + XINDEST*LOG(ESTPMGS/INDEXCH*ESTEXCH) + XINDGRC*LOG(GRCPMGS/INDEXCH*GRCEXCH) + XINDCZE*LOG(CZEPMGS/INDEXCH*CZEEXCH) + XINDHUN*LOG(HUNPMGS/INDEXCH*HUNEXCH) + XINDISL*LOG(ISLPMGS/INDEXCH*ISLEXCH) + XINDIRL*LOG(IRLPMGS/INDEXCH*IRLEXCH) + XINDISR*LOG(ISRPMGS/INDEXCH*ISREXCH) + XINDKOR*LOG(KORPMGS/INDEXCH*KOREXCH) + XINDLUX*LOG(LUXPMGS/INDEXCH*LUXEXCH) + XINDMEX*LOG(MEXPMGS/INDEXCH*MEXEXCH) + XINDNZL*LOG(NZLPMGS/INDEXCH*NZLEXCH) + XINDPRT*LOG(PRTPMGS/INDEXCH*PRTEXCH) + XINDSVK*LOG(SVKPMGS/INDEXCH*SVKEXCH) + XINDSVN*LOG(SVNPMGS/INDEXCH*SVNEXCH) + XINDCHE*LOG(CHEPMGS/INDEXCH*CHEEXCH) + XINDTUR*LOG(TURPMGS/INDEXCH*TUREXCH) + XINDDAE*LOG(DAEPMGS/INDEXCH*DAEEXCH) + XINDOOP*LOG(OOPPMGS/INDEXCH*OOPEXCH) + XINDBRA*LOG(BRAPMGS/INDEXCH*BRAEXCH) + XINDRUS*LOG(RUSPMGS/INDEXCH*RUSEXCH) + XINDCHN*LOG(CHNPMGS/INDEXCH*CHNEXCH) + XINDIDN*LOG(IDNPMGS/INDEXCH*IDNEXCH) + XINDZAF*LOG(ZAFPMGS/INDEXCH*ZAFEXCH) + XINDRWD*LOG(RWDPMGS/INDEXCH*RWDEXCH) $ () FRML _GJRD_ DLOG(INDPXGS) = (INDPXGSU-INDPXGSU(-1)) $ () () () ******************* () * IRL * () ******************* () () EXPORT VOLUMES () FRML GIRLXGSDU IRLXGSDU = XIRLDNK*LOG(DNKMGSD) + XIRLSWE*LOG(SWEMGSD) + XIRLNOR*LOG(NORMGSD) + XIRLFIN*LOG(FINMGSD) + XIRLNLD*LOG(NLDMGSD) + XIRLGBR*LOG(GBRMGSD) + XIRLBEL*LOG(BELMGSD) + XIRLDEU*LOG(DEUMGSD) + XIRLFRA*LOG(FRAMGSD) + XIRLESP*LOG(ESPMGSD) + XIRLYPN*LOG(YPNMGSD) + XIRLITA*LOG(ITAMGSD) + XIRLUSA*LOG(USAMGSD) + XIRLPOL*LOG(POLMGSD) + XIRLAUS*LOG(AUSMGSD) + XIRLAUT*LOG(AUTMGSD) + XIRLCAN*LOG(CANMGSD) + XIRLCHL*LOG(CHLMGSD) + XIRLEST*LOG(ESTMGSD) + XIRLGRC*LOG(GRCMGSD) + XIRLCZE*LOG(CZEMGSD) + XIRLHUN*LOG(HUNMGSD) + XIRLISL*LOG(ISLMGSD) + XIRLISR*LOG(ISRMGSD) + XIRLKOR*LOG(KORMGSD) + XIRLLUX*LOG(LUXMGSD) + XIRLMEX*LOG(MEXMGSD) + XIRLNZL*LOG(NZLMGSD) + XIRLPRT*LOG(PRTMGSD) + XIRLSVK*LOG(SVKMGSD) + XIRLSVN*LOG(SVNMGSD) + XIRLCHE*LOG(CHEMGSD) + XIRLTUR*LOG(TURMGSD) + XIRLDAE*LOG(DAEMGSD) + XIRLOOP*LOG(OOPMGSD) + XIRLBRA*LOG(BRAMGSD) + XIRLRUS*LOG(RUSMGSD) + XIRLIND*LOG(INDMGSD) + XIRLCHN*LOG(CHNMGSD) + XIRLIDN*LOG(IDNMGSD) + XIRLZAF*LOG(ZAFMGSD) + XIRLRWD*LOG(RWDMGSD) $ FRML _GJRD DLOG(IRLXGSD) = (IRLXGSDU-IRLXGSDU(-1)) $ FRML GIRLXGSV IRLXGSV = IRLXGSD*USAEXCH/(IRLEXCH*IRLPXGS) $ () () () IMPORT () FRML _GJRD_ DLOG(IRLMGSV) = 0.96387*DLOG(IRLXGSV) - 0.50415*DLOG(IRLPMGS/IRLPXGS) -0.11724*LOG(IRLMGSV(-1)/IRLXGSV(-1)) -0.41315*LOG(IRLPMGS(-1)/IRLPXGS(-1)) -0.04103 - D1975*0.13831 + D1979*0.10047 $ () FRML GIRLMGSD IRLMGSD = IRLMGSV*IRLPMGS*IRLEXCH/USAEXCH $ () () () IMPORT PRICES () () FRML GIRLPMGSU IRLPMGSU = MIRLDNK*LOG(DNKPXGS/IRLEXCH*DNKEXCH) + MIRLSWE*LOG(SWEPXGS/IRLEXCH*SWEEXCH) + MIRLNOR*LOG(NORPXGS/IRLEXCH*NOREXCH) + MIRLFIN*LOG(FINPXGS/IRLEXCH*FINEXCH) + MIRLNLD*LOG(NLDPXGS/IRLEXCH*NLDEXCH) + MIRLGBR*LOG(GBRPXGS/IRLEXCH*GBREXCH) + MIRLESP*LOG(ESPPXGS/IRLEXCH*ESPEXCH) + MIRLDEU*LOG(DEUPXGS/IRLEXCH*DEUEXCH) + MIRLBEL*LOG(BELPXGS/IRLEXCH*BELEXCH) + MIRLFRA*LOG(FRAPXGS/IRLEXCH*FRAEXCH) + MIRLYPN*LOG(YPNPXGS/IRLEXCH*YPNEXCH) + MIRLITA*LOG(ITAPXGS/IRLEXCH*ITAEXCH) + MIRLUSA*LOG(USAPXGS/IRLEXCH*USAEXCH) + MIRLPOL*LOG(POLPXGS/IRLEXCH*POLEXCH) + MIRLAUS*LOG(AUSPXGS/IRLEXCH*AUSEXCH) + MIRLAUT*LOG(AUTPXGS/IRLEXCH*AUTEXCH) + MIRLCAN*LOG(CANPXGS/IRLEXCH*CANEXCH) + MIRLCHL*LOG(CHLPXGS/IRLEXCH*CHLEXCH) + MIRLEST*LOG(ESTPXGS/IRLEXCH*ESTEXCH) + MIRLGRC*LOG(GRCPXGS/IRLEXCH*GRCEXCH) + MIRLCZE*LOG(CZEPXGS/IRLEXCH*CZEEXCH) + MIRLHUN*LOG(HUNPXGS/IRLEXCH*HUNEXCH) + MIRLISL*LOG(ISLPXGS/IRLEXCH*ISLEXCH) + MIRLISR*LOG(ISRPXGS/IRLEXCH*ISREXCH) + MIRLKOR*LOG(KORPXGS/IRLEXCH*KOREXCH) + MIRLLUX*LOG(LUXPXGS/IRLEXCH*LUXEXCH) + MIRLMEX*LOG(MEXPXGS/IRLEXCH*MEXEXCH) + MIRLNZL*LOG(NZLPXGS/IRLEXCH*NZLEXCH) + MIRLPRT*LOG(PRTPXGS/IRLEXCH*PRTEXCH) + MIRLSVK*LOG(SVKPXGS/IRLEXCH*SVKEXCH) + MIRLSVN*LOG(SVNPXGS/IRLEXCH*SVNEXCH) + MIRLCHE*LOG(CHEPXGS/IRLEXCH*CHEEXCH) + MIRLTUR*LOG(TURPXGS/IRLEXCH*TUREXCH) + MIRLDAE*LOG(DAEPXGS/IRLEXCH*DAEEXCH) + MIRLOOP*LOG(OOPPXGS/IRLEXCH*OOPEXCH) + MIRLBRA*LOG(BRAPXGS/IRLEXCH*BRAEXCH) + MIRLRUS*LOG(RUSPXGS/IRLEXCH*RUSEXCH) + MIRLIND*LOG(INDPXGS/IRLEXCH*INDEXCH) + MIRLCHN*LOG(CHNPXGS/IRLEXCH*CHNEXCH) + MIRLIDN*LOG(IDNPXGS/IRLEXCH*IDNEXCH) + MIRLZAF*LOG(ZAFPXGS/IRLEXCH*ZAFEXCH) + MIRLRWD*LOG(RWDPXGS/IRLEXCH*RWDEXCH) $ () FRML _GJRD_ DLOG(IRLPMGS) = (IRLPMGSU-IRLPMGSU(-1)) $ () () () EXPORT PRICES () FRML GIRLPXGSU IRLPXGSU = XIRLDNK*LOG(DNKPMGS/IRLEXCH*DNKEXCH) + XIRLSWE*LOG(SWEPMGS/IRLEXCH*SWEEXCH) + XIRLNOR*LOG(NORPMGS/IRLEXCH*NOREXCH) + XIRLFIN*LOG(FINPMGS/IRLEXCH*FINEXCH) + XIRLNLD*LOG(NLDPMGS/IRLEXCH*NLDEXCH) + XIRLGBR*LOG(GBRPMGS/IRLEXCH*GBREXCH) + XIRLESP*LOG(ESPPMGS/IRLEXCH*ESPEXCH) + XIRLDEU*LOG(DEUPMGS/IRLEXCH*DEUEXCH) + XIRLBEL*LOG(BELPMGS/IRLEXCH*BELEXCH) + XIRLFRA*LOG(FRAPMGS/IRLEXCH*FRAEXCH) + XIRLYPN*LOG(YPNPMGS/IRLEXCH*YPNEXCH) + XIRLITA*LOG(ITAPMGS/IRLEXCH*ITAEXCH) + XIRLUSA*LOG(USAPMGS/IRLEXCH*USAEXCH) + XIRLPOL*LOG(POLPMGS/IRLEXCH*POLEXCH) + XIRLAUS*LOG(AUSPMGS/IRLEXCH*AUSEXCH) + XIRLAUT*LOG(AUTPMGS/IRLEXCH*AUTEXCH) + XIRLCAN*LOG(CANPMGS/IRLEXCH*CANEXCH) + XIRLCHL*LOG(CHLPMGS/IRLEXCH*CHLEXCH) + XIRLEST*LOG(ESTPMGS/IRLEXCH*ESTEXCH) + XIRLGRC*LOG(GRCPMGS/IRLEXCH*GRCEXCH) + XIRLCZE*LOG(CZEPMGS/IRLEXCH*CZEEXCH) + XIRLHUN*LOG(HUNPMGS/IRLEXCH*HUNEXCH) + XIRLISL*LOG(ISLPMGS/IRLEXCH*ISLEXCH) + XIRLISR*LOG(ISRPMGS/IRLEXCH*ISREXCH) + XIRLKOR*LOG(KORPMGS/IRLEXCH*KOREXCH) + XIRLLUX*LOG(LUXPMGS/IRLEXCH*LUXEXCH) + XIRLMEX*LOG(MEXPMGS/IRLEXCH*MEXEXCH) + XIRLNZL*LOG(NZLPMGS/IRLEXCH*NZLEXCH) + XIRLPRT*LOG(PRTPMGS/IRLEXCH*PRTEXCH) + XIRLSVK*LOG(SVKPMGS/IRLEXCH*SVKEXCH) + XIRLSVN*LOG(SVNPMGS/IRLEXCH*SVNEXCH) + XIRLCHE*LOG(CHEPMGS/IRLEXCH*CHEEXCH) + XIRLTUR*LOG(TURPMGS/IRLEXCH*TUREXCH) + XIRLDAE*LOG(DAEPMGS/IRLEXCH*DAEEXCH) + XIRLOOP*LOG(OOPPMGS/IRLEXCH*OOPEXCH) + XIRLBRA*LOG(BRAPMGS/IRLEXCH*BRAEXCH) + XIRLRUS*LOG(RUSPMGS/IRLEXCH*RUSEXCH) + XIRLIND*LOG(INDPMGS/IRLEXCH*INDEXCH) + XIRLCHN*LOG(CHNPMGS/IRLEXCH*CHNEXCH) + XIRLIDN*LOG(IDNPMGS/IRLEXCH*IDNEXCH) + XIRLZAF*LOG(ZAFPMGS/IRLEXCH*ZAFEXCH) + XIRLRWD*LOG(RWDPMGS/IRLEXCH*RWDEXCH) $ () FRML _GJRD_ DLOG(IRLPXGS) = (IRLPXGSU-IRLPXGSU(-1)) $ () () () ******************* () * ISL * () ******************* () () EXPORT VOLUMES () FRML GISLXGSDU ISLXGSDU = XISLDNK*LOG(DNKMGSD) + XISLSWE*LOG(SWEMGSD) + XISLNOR*LOG(NORMGSD) + XISLFIN*LOG(FINMGSD) + XISLNLD*LOG(NLDMGSD) + XISLGBR*LOG(GBRMGSD) + XISLBEL*LOG(BELMGSD) + XISLDEU*LOG(DEUMGSD) + XISLFRA*LOG(FRAMGSD) + XISLESP*LOG(ESPMGSD) + XISLYPN*LOG(YPNMGSD) + XISLITA*LOG(ITAMGSD) + XISLUSA*LOG(USAMGSD) + XISLPOL*LOG(POLMGSD) + XISLCZE*LOG(CZEMGSD) + XISLAUS*LOG(AUSMGSD) + XISLAUT*LOG(AUTMGSD) + XISLCAN*LOG(CANMGSD) + XISLCHL*LOG(CHLMGSD) + XISLEST*LOG(ESTMGSD) + XISLGRC*LOG(GRCMGSD) + XISLHUN*LOG(HUNMGSD) + XISLIRL*LOG(IRLMGSD) + XISLISR*LOG(ISRMGSD) + XISLKOR*LOG(KORMGSD) + XISLLUX*LOG(LUXMGSD) + XISLMEX*LOG(MEXMGSD) + XISLNZL*LOG(NZLMGSD) + XISLPRT*LOG(PRTMGSD) + XISLSVK*LOG(SVKMGSD) + XISLSVN*LOG(SVNMGSD) + XISLCHE*LOG(CHEMGSD) + XISLTUR*LOG(TURMGSD) + XISLDAE*LOG(DAEMGSD) + XISLOOP*LOG(OOPMGSD) + XISLBRA*LOG(BRAMGSD) + XISLRUS*LOG(RUSMGSD) + XISLIND*LOG(INDMGSD) + XISLCHN*LOG(CHNMGSD) + XISLIDN*LOG(IDNMGSD) + XISLZAF*LOG(ZAFMGSD) + XISLRWD*LOG(RWDMGSD) $ FRML _GJRD DLOG(ISLXGSD) = (ISLXGSDU-ISLXGSDU(-1)) $ FRML GISLXGSV ISLXGSV = ISLXGSD*USAEXCH/(ISLEXCH*ISLPXGS) $ () () () IMPORT () FRML _GJRD_ DLOG(ISLMGSV) = 1.00000*DLOG(ISLXGSV) - 1.40257*DLOG(ISLPMGS/ISLPXGS) -0.55068*LOG(ISLMGSV(-1)/ISLXGSV(-1)) -1.26559*LOG(ISLPMGS(-1)/ISLPXGS(-1)) +0.00494 + D2005*0.28169 + D2006*0.29953 $ () FRML GISLMGSD ISLMGSD = ISLMGSV*ISLPMGS*ISLEXCH/USAEXCH $ () () () IMPORT PRICES () () FRML GISLPMGSU ISLPMGSU = MISLDNK*LOG(DNKPXGS/ISLEXCH*DNKEXCH) + MISLSWE*LOG(SWEPXGS/ISLEXCH*SWEEXCH) + MISLNOR*LOG(NORPXGS/ISLEXCH*NOREXCH) + MISLFIN*LOG(FINPXGS/ISLEXCH*FINEXCH) + MISLNLD*LOG(NLDPXGS/ISLEXCH*NLDEXCH) + MISLGBR*LOG(GBRPXGS/ISLEXCH*GBREXCH) + MISLESP*LOG(ESPPXGS/ISLEXCH*ESPEXCH) + MISLDEU*LOG(DEUPXGS/ISLEXCH*DEUEXCH) + MISLBEL*LOG(BELPXGS/ISLEXCH*BELEXCH) + MISLFRA*LOG(FRAPXGS/ISLEXCH*FRAEXCH) + MISLYPN*LOG(YPNPXGS/ISLEXCH*YPNEXCH) + MISLITA*LOG(ITAPXGS/ISLEXCH*ITAEXCH) + MISLUSA*LOG(USAPXGS/ISLEXCH*USAEXCH) + MISLPOL*LOG(POLPXGS/ISLEXCH*POLEXCH) + MISLCZE*LOG(CZEPXGS/ISLEXCH*CZEEXCH) + MISLAUS*LOG(AUSPXGS/ISLEXCH*AUSEXCH) + MISLAUT*LOG(AUTPXGS/ISLEXCH*AUTEXCH) + MISLCAN*LOG(CANPXGS/ISLEXCH*CANEXCH) + MISLCHL*LOG(CHLPXGS/ISLEXCH*CHLEXCH) + MISLEST*LOG(ESTPXGS/ISLEXCH*ESTEXCH) + MISLGRC*LOG(GRCPXGS/ISLEXCH*GRCEXCH) + MISLHUN*LOG(HUNPXGS/ISLEXCH*HUNEXCH) + MISLIRL*LOG(IRLPXGS/ISLEXCH*IRLEXCH) + MISLISR*LOG(ISRPXGS/ISLEXCH*ISREXCH) + MISLKOR*LOG(KORPXGS/ISLEXCH*KOREXCH) + MISLLUX*LOG(LUXPXGS/ISLEXCH*LUXEXCH) + MISLMEX*LOG(MEXPXGS/ISLEXCH*MEXEXCH) + MISLNZL*LOG(NZLPXGS/ISLEXCH*NZLEXCH) + MISLPRT*LOG(PRTPXGS/ISLEXCH*PRTEXCH) + MISLSVK*LOG(SVKPXGS/ISLEXCH*SVKEXCH) + MISLSVN*LOG(SVNPXGS/ISLEXCH*SVNEXCH) + MISLCHE*LOG(CHEPXGS/ISLEXCH*CHEEXCH) + MISLTUR*LOG(TURPXGS/ISLEXCH*TUREXCH) + MISLDAE*LOG(DAEPXGS/ISLEXCH*DAEEXCH) + MISLOOP*LOG(OOPPXGS/ISLEXCH*OOPEXCH) + MISLBRA*LOG(BRAPXGS/ISLEXCH*BRAEXCH) + MISLRUS*LOG(RUSPXGS/ISLEXCH*RUSEXCH) + MISLIND*LOG(INDPXGS/ISLEXCH*INDEXCH) + MISLCHN*LOG(CHNPXGS/ISLEXCH*CHNEXCH) + MISLIDN*LOG(IDNPXGS/ISLEXCH*IDNEXCH) + MISLZAF*LOG(ZAFPXGS/ISLEXCH*ZAFEXCH) + MISLRWD*LOG(RWDPXGS/ISLEXCH*RWDEXCH) $ () FRML _GJRD_ DLOG(ISLPMGS) = (ISLPMGSU-ISLPMGSU(-1)) $ () () () EXPORT PRICES () FRML GISLPXGSU ISLPXGSU = XISLDNK*LOG(DNKPMGS/ISLEXCH*DNKEXCH) + XISLSWE*LOG(SWEPMGS/ISLEXCH*SWEEXCH) + XISLNOR*LOG(NORPMGS/ISLEXCH*NOREXCH) + XISLFIN*LOG(FINPMGS/ISLEXCH*FINEXCH) + XISLNLD*LOG(NLDPMGS/ISLEXCH*NLDEXCH) + XISLGBR*LOG(GBRPMGS/ISLEXCH*GBREXCH) + XISLESP*LOG(ESPPMGS/ISLEXCH*ESPEXCH) + XISLDEU*LOG(DEUPMGS/ISLEXCH*DEUEXCH) + XISLBEL*LOG(BELPMGS/ISLEXCH*BELEXCH) + XISLFRA*LOG(FRAPMGS/ISLEXCH*FRAEXCH) + XISLYPN*LOG(YPNPMGS/ISLEXCH*YPNEXCH) + XISLITA*LOG(ITAPMGS/ISLEXCH*ITAEXCH) + XISLUSA*LOG(USAPMGS/ISLEXCH*USAEXCH) + XISLPOL*LOG(POLPMGS/ISLEXCH*POLEXCH) + XISLCZE*LOG(CZEPMGS/ISLEXCH*CZEEXCH) + XISLAUS*LOG(AUSPMGS/ISLEXCH*AUSEXCH) + XISLAUT*LOG(AUTPMGS/ISLEXCH*AUTEXCH) + XISLCAN*LOG(CANPMGS/ISLEXCH*CANEXCH) + XISLCHL*LOG(CHLPMGS/ISLEXCH*CHLEXCH) + XISLEST*LOG(ESTPMGS/ISLEXCH*ESTEXCH) + XISLGRC*LOG(GRCPMGS/ISLEXCH*GRCEXCH) + XISLHUN*LOG(HUNPMGS/ISLEXCH*HUNEXCH) + XISLIRL*LOG(IRLPMGS/ISLEXCH*IRLEXCH) + XISLISR*LOG(ISRPMGS/ISLEXCH*ISREXCH) + XISLKOR*LOG(KORPMGS/ISLEXCH*KOREXCH) + XISLLUX*LOG(LUXPMGS/ISLEXCH*LUXEXCH) + XISLMEX*LOG(MEXPMGS/ISLEXCH*MEXEXCH) + XISLNZL*LOG(NZLPMGS/ISLEXCH*NZLEXCH) + XISLPRT*LOG(PRTPMGS/ISLEXCH*PRTEXCH) + XISLSVK*LOG(SVKPMGS/ISLEXCH*SVKEXCH) + XISLSVN*LOG(SVNPMGS/ISLEXCH*SVNEXCH) + XISLCHE*LOG(CHEPMGS/ISLEXCH*CHEEXCH) + XISLTUR*LOG(TURPMGS/ISLEXCH*TUREXCH) + XISLDAE*LOG(DAEPMGS/ISLEXCH*DAEEXCH) + XISLOOP*LOG(OOPPMGS/ISLEXCH*OOPEXCH) + XISLBRA*LOG(BRAPMGS/ISLEXCH*BRAEXCH) + XISLRUS*LOG(RUSPMGS/ISLEXCH*RUSEXCH) + XISLIND*LOG(INDPMGS/ISLEXCH*INDEXCH) + XISLCHN*LOG(CHNPMGS/ISLEXCH*CHNEXCH) + XISLIDN*LOG(IDNPMGS/ISLEXCH*IDNEXCH) + XISLZAF*LOG(ZAFPMGS/ISLEXCH*ZAFEXCH) + XISLRWD*LOG(RWDPMGS/ISLEXCH*RWDEXCH) $ () FRML _GJRD_ DLOG(ISLPXGS) = (ISLPXGSU-ISLPXGSU(-1)) $ () () () ******************* () * ISR * () ******************* () () EXPORT VOLUMES () FRML GISRXGSDU ISRXGSDU = XISRDNK*LOG(DNKMGSD) + XISRSWE*LOG(SWEMGSD) + XISRNOR*LOG(NORMGSD) + XISRFIN*LOG(FINMGSD) + XISRNLD*LOG(NLDMGSD) + XISRGBR*LOG(GBRMGSD) + XISRBEL*LOG(BELMGSD) + XISRDEU*LOG(DEUMGSD) + XISRFRA*LOG(FRAMGSD) + XISRESP*LOG(ESPMGSD) + XISRYPN*LOG(YPNMGSD) + XISRITA*LOG(ITAMGSD) + XISRUSA*LOG(USAMGSD) + XISRPOL*LOG(POLMGSD) + XISRAUS*LOG(AUSMGSD) + XISRAUT*LOG(AUTMGSD) + XISRCAN*LOG(CANMGSD) + XISRCHL*LOG(CHLMGSD) + XISREST*LOG(ESTMGSD) + XISRGRC*LOG(GRCMGSD) + XISRCZE*LOG(CZEMGSD) + XISRHUN*LOG(HUNMGSD) + XISRISL*LOG(ISLMGSD) + XISRIRL*LOG(IRLMGSD) + XISRKOR*LOG(KORMGSD) + XISRLUX*LOG(LUXMGSD) + XISRMEX*LOG(MEXMGSD) + XISRNZL*LOG(NZLMGSD) + XISRPRT*LOG(PRTMGSD) + XISRSVK*LOG(SVKMGSD) + XISRSVN*LOG(SVNMGSD) + XISRCHE*LOG(CHEMGSD) + XISRTUR*LOG(TURMGSD) + XISRDAE*LOG(DAEMGSD) + XISROOP*LOG(OOPMGSD) + XISRBRA*LOG(BRAMGSD) + XISRRUS*LOG(RUSMGSD) + XISRIND*LOG(INDMGSD) + XISRCHN*LOG(CHNMGSD) + XISRIDN*LOG(IDNMGSD) + XISRZAF*LOG(ZAFMGSD) + XISRRWD*LOG(RWDMGSD) $ FRML _GJRD DLOG(ISRXGSD) = (ISRXGSDU-ISRXGSDU(-1)) $ FRML GISRXGSV ISRXGSV = ISRXGSD*USAEXCH/(ISREXCH*ISRPXGS) $ () () () IMPORT () FRML _GJRD_ DLOG(ISRMGSV) = 0.82709*DLOG(ISRXGSV) - 0.50000*DLOG(ISRPMGS/ISRPXGS) -0.13824*LOG(ISRMGSV(-1)/ISRXGSV(-1)) -0.24600*LOG(ISRPMGS(-1)/ISRPXGS(-1)) -0.00650 $ () FRML GISRMGSD ISRMGSD = ISRMGSV*ISRPMGS*ISREXCH/USAEXCH $ () () () IMPORT PRICES () () FRML GISRPMGSU ISRPMGSU = MISRDNK*LOG(DNKPXGS/ISREXCH*DNKEXCH) + MISRSWE*LOG(SWEPXGS/ISREXCH*SWEEXCH) + MISRNOR*LOG(NORPXGS/ISREXCH*NOREXCH) + MISRFIN*LOG(FINPXGS/ISREXCH*FINEXCH) + MISRNLD*LOG(NLDPXGS/ISREXCH*NLDEXCH) + MISRGBR*LOG(GBRPXGS/ISREXCH*GBREXCH) + MISRESP*LOG(ESPPXGS/ISREXCH*ESPEXCH) + MISRDEU*LOG(DEUPXGS/ISREXCH*DEUEXCH) + MISRBEL*LOG(BELPXGS/ISREXCH*BELEXCH) + MISRFRA*LOG(FRAPXGS/ISREXCH*FRAEXCH) + MISRYPN*LOG(YPNPXGS/ISREXCH*YPNEXCH) + MISRITA*LOG(ITAPXGS/ISREXCH*ITAEXCH) + MISRUSA*LOG(USAPXGS/ISREXCH*USAEXCH) + MISRPOL*LOG(POLPXGS/ISREXCH*POLEXCH) + MISRAUS*LOG(AUSPXGS/ISREXCH*AUSEXCH) + MISRAUT*LOG(AUTPXGS/ISREXCH*AUTEXCH) + MISRCAN*LOG(CANPXGS/ISREXCH*CANEXCH) + MISRCHL*LOG(CHLPXGS/ISREXCH*CHLEXCH) + MISREST*LOG(ESTPXGS/ISREXCH*ESTEXCH) + MISRGRC*LOG(GRCPXGS/ISREXCH*GRCEXCH) + MISRCZE*LOG(CZEPXGS/ISREXCH*CZEEXCH) + MISRHUN*LOG(HUNPXGS/ISREXCH*HUNEXCH) + MISRISL*LOG(ISLPXGS/ISREXCH*ISLEXCH) + MISRIRL*LOG(IRLPXGS/ISREXCH*IRLEXCH) + MISRKOR*LOG(KORPXGS/ISREXCH*KOREXCH) + MISRLUX*LOG(LUXPXGS/ISREXCH*LUXEXCH) + MISRMEX*LOG(MEXPXGS/ISREXCH*MEXEXCH) + MISRNZL*LOG(NZLPXGS/ISREXCH*NZLEXCH) + MISRPRT*LOG(PRTPXGS/ISREXCH*PRTEXCH) + MISRSVK*LOG(SVKPXGS/ISREXCH*SVKEXCH) + MISRSVN*LOG(SVNPXGS/ISREXCH*SVNEXCH) + MISRCHE*LOG(CHEPXGS/ISREXCH*CHEEXCH) + MISRTUR*LOG(TURPXGS/ISREXCH*TUREXCH) + MISRDAE*LOG(DAEPXGS/ISREXCH*DAEEXCH) + MISROOP*LOG(OOPPXGS/ISREXCH*OOPEXCH) + MISRBRA*LOG(BRAPXGS/ISREXCH*BRAEXCH) + MISRRUS*LOG(RUSPXGS/ISREXCH*RUSEXCH) + MISRIND*LOG(INDPXGS/ISREXCH*INDEXCH) + MISRCHN*LOG(CHNPXGS/ISREXCH*CHNEXCH) + MISRIDN*LOG(IDNPXGS/ISREXCH*IDNEXCH) + MISRZAF*LOG(ZAFPXGS/ISREXCH*ZAFEXCH) + MISRRWD*LOG(RWDPXGS/ISREXCH*RWDEXCH) $ () FRML _GJRD_ DLOG(ISRPMGS) = (ISRPMGSU-ISRPMGSU(-1)) $ () () () EXPORT PRICES () FRML GISRPXGSU ISRPXGSU = XISRDNK*LOG(DNKPMGS/ISREXCH*DNKEXCH) + XISRSWE*LOG(SWEPMGS/ISREXCH*SWEEXCH) + XISRNOR*LOG(NORPMGS/ISREXCH*NOREXCH) + XISRFIN*LOG(FINPMGS/ISREXCH*FINEXCH) + XISRNLD*LOG(NLDPMGS/ISREXCH*NLDEXCH) + XISRGBR*LOG(GBRPMGS/ISREXCH*GBREXCH) + XISRESP*LOG(ESPPMGS/ISREXCH*ESPEXCH) + XISRDEU*LOG(DEUPMGS/ISREXCH*DEUEXCH) + XISRBEL*LOG(BELPMGS/ISREXCH*BELEXCH) + XISRFRA*LOG(FRAPMGS/ISREXCH*FRAEXCH) + XISRYPN*LOG(YPNPMGS/ISREXCH*YPNEXCH) + XISRITA*LOG(ITAPMGS/ISREXCH*ITAEXCH) + XISRUSA*LOG(USAPMGS/ISREXCH*USAEXCH) + XISRPOL*LOG(POLPMGS/ISREXCH*POLEXCH) + XISRAUS*LOG(AUSPMGS/ISREXCH*AUSEXCH) + XISRAUT*LOG(AUTPMGS/ISREXCH*AUTEXCH) + XISRCAN*LOG(CANPMGS/ISREXCH*CANEXCH) + XISRCHL*LOG(CHLPMGS/ISREXCH*CHLEXCH) + XISREST*LOG(ESTPMGS/ISREXCH*ESTEXCH) + XISRGRC*LOG(GRCPMGS/ISREXCH*GRCEXCH) + XISRCZE*LOG(CZEPMGS/ISREXCH*CZEEXCH) + XISRHUN*LOG(HUNPMGS/ISREXCH*HUNEXCH) + XISRISL*LOG(ISLPMGS/ISREXCH*ISLEXCH) + XISRIRL*LOG(IRLPMGS/ISREXCH*IRLEXCH) + XISRKOR*LOG(KORPMGS/ISREXCH*KOREXCH) + XISRLUX*LOG(LUXPMGS/ISREXCH*LUXEXCH) + XISRMEX*LOG(MEXPMGS/ISREXCH*MEXEXCH) + XISRNZL*LOG(NZLPMGS/ISREXCH*NZLEXCH) + XISRPRT*LOG(PRTPMGS/ISREXCH*PRTEXCH) + XISRSVK*LOG(SVKPMGS/ISREXCH*SVKEXCH) + XISRSVN*LOG(SVNPMGS/ISREXCH*SVNEXCH) + XISRCHE*LOG(CHEPMGS/ISREXCH*CHEEXCH) + XISRTUR*LOG(TURPMGS/ISREXCH*TUREXCH) + XISRDAE*LOG(DAEPMGS/ISREXCH*DAEEXCH) + XISROOP*LOG(OOPPMGS/ISREXCH*OOPEXCH) + XISRBRA*LOG(BRAPMGS/ISREXCH*BRAEXCH) + XISRRUS*LOG(RUSPMGS/ISREXCH*RUSEXCH) + XISRIND*LOG(INDPMGS/ISREXCH*INDEXCH) + XISRCHN*LOG(CHNPMGS/ISREXCH*CHNEXCH) + XISRIDN*LOG(IDNPMGS/ISREXCH*IDNEXCH) + XISRZAF*LOG(ZAFPMGS/ISREXCH*ZAFEXCH) + XISRRWD*LOG(RWDPMGS/ISREXCH*RWDEXCH) $ () FRML _GJRD_ DLOG(ISRPXGS) = (ISRPXGSU-ISRPXGSU(-1)) $ () () () ******************* () * KOR * () ******************* () () EXPORT VOLUMES () FRML GKORXGSDU KORXGSDU = XKORDNK*LOG(DNKMGSD) + XKORSWE*LOG(SWEMGSD) + XKORNOR*LOG(NORMGSD) + XKORFIN*LOG(FINMGSD) + XKORNLD*LOG(NLDMGSD) + XKORGBR*LOG(GBRMGSD) + XKORBEL*LOG(BELMGSD) + XKORDEU*LOG(DEUMGSD) + XKORFRA*LOG(FRAMGSD) + XKORESP*LOG(ESPMGSD) + XKORYPN*LOG(YPNMGSD) + XKORITA*LOG(ITAMGSD) + XKORUSA*LOG(USAMGSD) + XKORPOL*LOG(POLMGSD) + XKORAUS*LOG(AUSMGSD) + XKORAUT*LOG(AUTMGSD) + XKORCAN*LOG(CANMGSD) + XKORCHL*LOG(CHLMGSD) + XKOREST*LOG(ESTMGSD) + XKORGRC*LOG(GRCMGSD) + XKORCZE*LOG(CZEMGSD) + XKORHUN*LOG(HUNMGSD) + XKORISL*LOG(ISLMGSD) + XKORIRL*LOG(IRLMGSD) + XKORISR*LOG(ISRMGSD) + XKORLUX*LOG(LUXMGSD) + XKORMEX*LOG(MEXMGSD) + XKORNZL*LOG(NZLMGSD) + XKORPRT*LOG(PRTMGSD) + XKORSVK*LOG(SVKMGSD) + XKORSVN*LOG(SVNMGSD) + XKORCHE*LOG(CHEMGSD) + XKORTUR*LOG(TURMGSD) + XKORDAE*LOG(DAEMGSD) + XKOROOP*LOG(OOPMGSD) + XKORBRA*LOG(BRAMGSD) + XKORRUS*LOG(RUSMGSD) + XKORIND*LOG(INDMGSD) + XKORCHN*LOG(CHNMGSD) + XKORIDN*LOG(IDNMGSD) + XKORZAF*LOG(ZAFMGSD) + XKORRWD*LOG(RWDMGSD) $ FRML _GJRD DLOG(KORXGSD) = (KORXGSDU-KORXGSDU(-1)) $ FRML GKORXGSV KORXGSV = KORXGSD*USAEXCH/(KOREXCH*KORPXGS) $ () () () IMPORT () FRML _GJRD_ DLOG(KORMGSV) = 0.48663*DLOG(KORXGSV) - 1.00000*DLOG(KORPMGS/KORPXGS) -0.20109*LOG(KORMGSV(-1)/KORXGSV(-1)) -0.42419*LOG(KORPMGS(-1)/KORPXGS(-1)) +0.02195 - D1998*0.34755 $ () FRML GKORMGSD KORMGSD = KORMGSV*KORPMGS*KOREXCH/USAEXCH $ () () () IMPORT PRICES () () FRML GKORPMGSU KORPMGSU = MKORDNK*LOG(DNKPXGS/KOREXCH*DNKEXCH) + MKORSWE*LOG(SWEPXGS/KOREXCH*SWEEXCH) + MKORNOR*LOG(NORPXGS/KOREXCH*NOREXCH) + MKORFIN*LOG(FINPXGS/KOREXCH*FINEXCH) + MKORNLD*LOG(NLDPXGS/KOREXCH*NLDEXCH) + MKORGBR*LOG(GBRPXGS/KOREXCH*GBREXCH) + MKORESP*LOG(ESPPXGS/KOREXCH*ESPEXCH) + MKORDEU*LOG(DEUPXGS/KOREXCH*DEUEXCH) + MKORBEL*LOG(BELPXGS/KOREXCH*BELEXCH) + MKORFRA*LOG(FRAPXGS/KOREXCH*FRAEXCH) + MKORYPN*LOG(YPNPXGS/KOREXCH*YPNEXCH) + MKORITA*LOG(ITAPXGS/KOREXCH*ITAEXCH) + MKORUSA*LOG(USAPXGS/KOREXCH*USAEXCH) + MKORPOL*LOG(POLPXGS/KOREXCH*POLEXCH) + MKORAUS*LOG(AUSPXGS/KOREXCH*AUSEXCH) + MKORAUT*LOG(AUTPXGS/KOREXCH*AUTEXCH) + MKORCAN*LOG(CANPXGS/KOREXCH*CANEXCH) + MKORCHL*LOG(CHLPXGS/KOREXCH*CHLEXCH) + MKOREST*LOG(ESTPXGS/KOREXCH*ESTEXCH) + MKORGRC*LOG(GRCPXGS/KOREXCH*GRCEXCH) + MKORCZE*LOG(CZEPXGS/KOREXCH*CZEEXCH) + MKORHUN*LOG(HUNPXGS/KOREXCH*HUNEXCH) + MKORISL*LOG(ISLPXGS/KOREXCH*ISLEXCH) + MKORIRL*LOG(IRLPXGS/KOREXCH*IRLEXCH) + MKORISR*LOG(ISRPXGS/KOREXCH*ISREXCH) + MKORLUX*LOG(LUXPXGS/KOREXCH*LUXEXCH) + MKORMEX*LOG(MEXPXGS/KOREXCH*MEXEXCH) + MKORNZL*LOG(NZLPXGS/KOREXCH*NZLEXCH) + MKORPRT*LOG(PRTPXGS/KOREXCH*PRTEXCH) + MKORSVK*LOG(SVKPXGS/KOREXCH*SVKEXCH) + MKORSVN*LOG(SVNPXGS/KOREXCH*SVNEXCH) + MKORCHE*LOG(CHEPXGS/KOREXCH*CHEEXCH) + MKORTUR*LOG(TURPXGS/KOREXCH*TUREXCH) + MKORDAE*LOG(DAEPXGS/KOREXCH*DAEEXCH) + MKOROOP*LOG(OOPPXGS/KOREXCH*OOPEXCH) + MKORBRA*LOG(BRAPXGS/KOREXCH*BRAEXCH) + MKORRUS*LOG(RUSPXGS/KOREXCH*RUSEXCH) + MKORIND*LOG(INDPXGS/KOREXCH*INDEXCH) + MKORCHN*LOG(CHNPXGS/KOREXCH*CHNEXCH) + MKORIDN*LOG(IDNPXGS/KOREXCH*IDNEXCH) + MKORZAF*LOG(ZAFPXGS/KOREXCH*ZAFEXCH) + MKORRWD*LOG(RWDPXGS/KOREXCH*RWDEXCH) $ () FRML _GJRD_ DLOG(KORPMGS) = (KORPMGSU-KORPMGSU(-1)) $ () () () EXPORT PRICES () FRML GKORPXGSU KORPXGSU = XKORDNK*LOG(DNKPMGS/KOREXCH*DNKEXCH) + XKORSWE*LOG(SWEPMGS/KOREXCH*SWEEXCH) + XKORNOR*LOG(NORPMGS/KOREXCH*NOREXCH) + XKORFIN*LOG(FINPMGS/KOREXCH*FINEXCH) + XKORNLD*LOG(NLDPMGS/KOREXCH*NLDEXCH) + XKORGBR*LOG(GBRPMGS/KOREXCH*GBREXCH) + XKORESP*LOG(ESPPMGS/KOREXCH*ESPEXCH) + XKORDEU*LOG(DEUPMGS/KOREXCH*DEUEXCH) + XKORBEL*LOG(BELPMGS/KOREXCH*BELEXCH) + XKORFRA*LOG(FRAPMGS/KOREXCH*FRAEXCH) + XKORYPN*LOG(YPNPMGS/KOREXCH*YPNEXCH) + XKORITA*LOG(ITAPMGS/KOREXCH*ITAEXCH) + XKORUSA*LOG(USAPMGS/KOREXCH*USAEXCH) + XKORPOL*LOG(POLPMGS/KOREXCH*POLEXCH) + XKORAUS*LOG(AUSPMGS/KOREXCH*AUSEXCH) + XKORAUT*LOG(AUTPMGS/KOREXCH*AUTEXCH) + XKORCAN*LOG(CANPMGS/KOREXCH*CANEXCH) + XKORCHL*LOG(CHLPMGS/KOREXCH*CHLEXCH) + XKOREST*LOG(ESTPMGS/KOREXCH*ESTEXCH) + XKORGRC*LOG(GRCPMGS/KOREXCH*GRCEXCH) + XKORCZE*LOG(CZEPMGS/KOREXCH*CZEEXCH) + XKORHUN*LOG(HUNPMGS/KOREXCH*HUNEXCH) + XKORISL*LOG(ISLPMGS/KOREXCH*ISLEXCH) + XKORIRL*LOG(IRLPMGS/KOREXCH*IRLEXCH) + XKORISR*LOG(ISRPMGS/KOREXCH*ISREXCH) + XKORLUX*LOG(LUXPMGS/KOREXCH*LUXEXCH) + XKORMEX*LOG(MEXPMGS/KOREXCH*MEXEXCH) + XKORNZL*LOG(NZLPMGS/KOREXCH*NZLEXCH) + XKORPRT*LOG(PRTPMGS/KOREXCH*PRTEXCH) + XKORSVK*LOG(SVKPMGS/KOREXCH*SVKEXCH) + XKORSVN*LOG(SVNPMGS/KOREXCH*SVNEXCH) + XKORCHE*LOG(CHEPMGS/KOREXCH*CHEEXCH) + XKORTUR*LOG(TURPMGS/KOREXCH*TUREXCH) + XKORDAE*LOG(DAEPMGS/KOREXCH*DAEEXCH) + XKOROOP*LOG(OOPPMGS/KOREXCH*OOPEXCH) + XKORBRA*LOG(BRAPMGS/KOREXCH*BRAEXCH) + XKORRUS*LOG(RUSPMGS/KOREXCH*RUSEXCH) + XKORIND*LOG(INDPMGS/KOREXCH*INDEXCH) + XKORCHN*LOG(CHNPMGS/KOREXCH*CHNEXCH) + XKORIDN*LOG(IDNPMGS/KOREXCH*IDNEXCH) + XKORZAF*LOG(ZAFPMGS/KOREXCH*ZAFEXCH) + XKORRWD*LOG(RWDPMGS/KOREXCH*RWDEXCH) $ () FRML _GJRD_ DLOG(KORPXGS) = (KORPXGSU-KORPXGSU(-1)) $ () () () ******************* () * LUX * () ******************* () () EXPORT VOLUMES () FRML GLUXXGSDU LUXXGSDU = XLUXDNK*LOG(DNKMGSD) + XLUXSWE*LOG(SWEMGSD) + XLUXNOR*LOG(NORMGSD) + XLUXFIN*LOG(FINMGSD) + XLUXNLD*LOG(NLDMGSD) + XLUXGBR*LOG(GBRMGSD) + XLUXBEL*LOG(BELMGSD) + XLUXDEU*LOG(DEUMGSD) + XLUXFRA*LOG(FRAMGSD) + XLUXESP*LOG(ESPMGSD) + XLUXYPN*LOG(YPNMGSD) + XLUXITA*LOG(ITAMGSD) + XLUXUSA*LOG(USAMGSD) + XLUXPOL*LOG(POLMGSD) + XLUXAUS*LOG(AUSMGSD) + XLUXAUT*LOG(AUTMGSD) + XLUXCAN*LOG(CANMGSD) + XLUXCHL*LOG(CHLMGSD) + XLUXEST*LOG(ESTMGSD) + XLUXGRC*LOG(GRCMGSD) + XLUXCZE*LOG(CZEMGSD) + XLUXHUN*LOG(HUNMGSD) + XLUXISL*LOG(ISLMGSD) + XLUXIRL*LOG(IRLMGSD) + XLUXISR*LOG(ISRMGSD) + XLUXKOR*LOG(KORMGSD) + XLUXMEX*LOG(MEXMGSD) + XLUXNZL*LOG(NZLMGSD) + XLUXPRT*LOG(PRTMGSD) + XLUXSVK*LOG(SVKMGSD) + XLUXSVN*LOG(SVNMGSD) + XLUXCHE*LOG(CHEMGSD) + XLUXTUR*LOG(TURMGSD) + XLUXDAE*LOG(DAEMGSD) + XLUXOOP*LOG(OOPMGSD) + XLUXBRA*LOG(BRAMGSD) + XLUXRUS*LOG(RUSMGSD) + XLUXIND*LOG(INDMGSD) + XLUXCHN*LOG(CHNMGSD) + XLUXIDN*LOG(IDNMGSD) + XLUXZAF*LOG(ZAFMGSD) + XLUXRWD*LOG(RWDMGSD) $ FRML _GJRD DLOG(LUXXGSD) = (LUXXGSDU-LUXXGSDU(-1)) $ FRML GLUXXGSV LUXXGSV = LUXXGSD*USAEXCH/(LUXEXCH*LUXPXGS) $ () () () IMPORT () FRML _GJRD_ DLOG(LUXMGSV) = 0.77236*DLOG(LUXXGSV) - 1.00000*DLOG(LUXPMGS/LUXPXGS) -0.30070*LOG(LUXMGSV(-1)/LUXXGSV(-1)) -0.50000*LOG(LUXPMGS(-1)/LUXPXGS(-1)) -0.04219 - D1974*0.11945 $ () FRML GLUXMGSD LUXMGSD = LUXMGSV*LUXPMGS*LUXEXCH/USAEXCH $ () () () IMPORT PRICES () () FRML GLUXPMGSU LUXPMGSU = MLUXDNK*LOG(DNKPXGS/LUXEXCH*DNKEXCH) + MLUXSWE*LOG(SWEPXGS/LUXEXCH*SWEEXCH) + MLUXNOR*LOG(NORPXGS/LUXEXCH*NOREXCH) + MLUXFIN*LOG(FINPXGS/LUXEXCH*FINEXCH) + MLUXNLD*LOG(NLDPXGS/LUXEXCH*NLDEXCH) + MLUXGBR*LOG(GBRPXGS/LUXEXCH*GBREXCH) + MLUXESP*LOG(ESPPXGS/LUXEXCH*ESPEXCH) + MLUXDEU*LOG(DEUPXGS/LUXEXCH*DEUEXCH) + MLUXBEL*LOG(BELPXGS/LUXEXCH*BELEXCH) + MLUXFRA*LOG(FRAPXGS/LUXEXCH*FRAEXCH) + MLUXYPN*LOG(YPNPXGS/LUXEXCH*YPNEXCH) + MLUXITA*LOG(ITAPXGS/LUXEXCH*ITAEXCH) + MLUXUSA*LOG(USAPXGS/LUXEXCH*USAEXCH) + MLUXPOL*LOG(POLPXGS/LUXEXCH*POLEXCH) + MLUXAUS*LOG(AUSPXGS/LUXEXCH*AUSEXCH) + MLUXAUT*LOG(AUTPXGS/LUXEXCH*AUTEXCH) + MLUXCAN*LOG(CANPXGS/LUXEXCH*CANEXCH) + MLUXCHL*LOG(CHLPXGS/LUXEXCH*CHLEXCH) + MLUXEST*LOG(ESTPXGS/LUXEXCH*ESTEXCH) + MLUXGRC*LOG(GRCPXGS/LUXEXCH*GRCEXCH) + MLUXCZE*LOG(CZEPXGS/LUXEXCH*CZEEXCH) + MLUXHUN*LOG(HUNPXGS/LUXEXCH*HUNEXCH) + MLUXISL*LOG(ISLPXGS/LUXEXCH*ISLEXCH) + MLUXIRL*LOG(IRLPXGS/LUXEXCH*IRLEXCH) + MLUXISR*LOG(ISRPXGS/LUXEXCH*ISREXCH) + MLUXKOR*LOG(KORPXGS/LUXEXCH*KOREXCH) + MLUXMEX*LOG(MEXPXGS/LUXEXCH*MEXEXCH) + MLUXNZL*LOG(NZLPXGS/LUXEXCH*NZLEXCH) + MLUXPRT*LOG(PRTPXGS/LUXEXCH*PRTEXCH) + MLUXSVK*LOG(SVKPXGS/LUXEXCH*SVKEXCH) + MLUXSVN*LOG(SVNPXGS/LUXEXCH*SVNEXCH) + MLUXCHE*LOG(CHEPXGS/LUXEXCH*CHEEXCH) + MLUXTUR*LOG(TURPXGS/LUXEXCH*TUREXCH) + MLUXDAE*LOG(DAEPXGS/LUXEXCH*DAEEXCH) + MLUXOOP*LOG(OOPPXGS/LUXEXCH*OOPEXCH) + MLUXBRA*LOG(BRAPXGS/LUXEXCH*BRAEXCH) + MLUXRUS*LOG(RUSPXGS/LUXEXCH*RUSEXCH) + MLUXIND*LOG(INDPXGS/LUXEXCH*INDEXCH) + MLUXCHN*LOG(CHNPXGS/LUXEXCH*CHNEXCH) + MLUXIDN*LOG(IDNPXGS/LUXEXCH*IDNEXCH) + MLUXZAF*LOG(ZAFPXGS/LUXEXCH*ZAFEXCH) + MLUXRWD*LOG(RWDPXGS/LUXEXCH*RWDEXCH) $ () FRML _GJRD_ DLOG(LUXPMGS) = (LUXPMGSU-LUXPMGSU(-1)) $ () () () EXPORT PRICES () FRML GLUXPXGSU LUXPXGSU = XLUXDNK*LOG(DNKPMGS/LUXEXCH*DNKEXCH) + XLUXSWE*LOG(SWEPMGS/LUXEXCH*SWEEXCH) + XLUXNOR*LOG(NORPMGS/LUXEXCH*NOREXCH) + XLUXFIN*LOG(FINPMGS/LUXEXCH*FINEXCH) + XLUXNLD*LOG(NLDPMGS/LUXEXCH*NLDEXCH) + XLUXGBR*LOG(GBRPMGS/LUXEXCH*GBREXCH) + XLUXESP*LOG(ESPPMGS/LUXEXCH*ESPEXCH) + XLUXDEU*LOG(DEUPMGS/LUXEXCH*DEUEXCH) + XLUXBEL*LOG(BELPMGS/LUXEXCH*BELEXCH) + XLUXFRA*LOG(FRAPMGS/LUXEXCH*FRAEXCH) + XLUXYPN*LOG(YPNPMGS/LUXEXCH*YPNEXCH) + XLUXITA*LOG(ITAPMGS/LUXEXCH*ITAEXCH) + XLUXUSA*LOG(USAPMGS/LUXEXCH*USAEXCH) + XLUXPOL*LOG(POLPMGS/LUXEXCH*POLEXCH) + XLUXAUS*LOG(AUSPMGS/LUXEXCH*AUSEXCH) + XLUXAUT*LOG(AUTPMGS/LUXEXCH*AUTEXCH) + XLUXCAN*LOG(CANPMGS/LUXEXCH*CANEXCH) + XLUXCHL*LOG(CHLPMGS/LUXEXCH*CHLEXCH) + XLUXEST*LOG(ESTPMGS/LUXEXCH*ESTEXCH) + XLUXGRC*LOG(GRCPMGS/LUXEXCH*GRCEXCH) + XLUXCZE*LOG(CZEPMGS/LUXEXCH*CZEEXCH) + XLUXHUN*LOG(HUNPMGS/LUXEXCH*HUNEXCH) + XLUXISL*LOG(ISLPMGS/LUXEXCH*ISLEXCH) + XLUXIRL*LOG(IRLPMGS/LUXEXCH*IRLEXCH) + XLUXISR*LOG(ISRPMGS/LUXEXCH*ISREXCH) + XLUXKOR*LOG(KORPMGS/LUXEXCH*KOREXCH) + XLUXMEX*LOG(MEXPMGS/LUXEXCH*MEXEXCH) + XLUXNZL*LOG(NZLPMGS/LUXEXCH*NZLEXCH) + XLUXPRT*LOG(PRTPMGS/LUXEXCH*PRTEXCH) + XLUXSVK*LOG(SVKPMGS/LUXEXCH*SVKEXCH) + XLUXSVN*LOG(SVNPMGS/LUXEXCH*SVNEXCH) + XLUXCHE*LOG(CHEPMGS/LUXEXCH*CHEEXCH) + XLUXTUR*LOG(TURPMGS/LUXEXCH*TUREXCH) + XLUXDAE*LOG(DAEPMGS/LUXEXCH*DAEEXCH) + XLUXOOP*LOG(OOPPMGS/LUXEXCH*OOPEXCH) + XLUXBRA*LOG(BRAPMGS/LUXEXCH*BRAEXCH) + XLUXRUS*LOG(RUSPMGS/LUXEXCH*RUSEXCH) + XLUXIND*LOG(INDPMGS/LUXEXCH*INDEXCH) + XLUXCHN*LOG(CHNPMGS/LUXEXCH*CHNEXCH) + XLUXIDN*LOG(IDNPMGS/LUXEXCH*IDNEXCH) + XLUXZAF*LOG(ZAFPMGS/LUXEXCH*ZAFEXCH) + XLUXRWD*LOG(RWDPMGS/LUXEXCH*RWDEXCH) $ () FRML _GJRD_ DLOG(LUXPXGS) = (LUXPXGSU-LUXPXGSU(-1)) $ () () () ******************* () * MEX * () ******************* () () EXPORT VOLUMES () FRML GMEXXGSDU MEXXGSDU = XMEXDNK*LOG(DNKMGSD) + XMEXSWE*LOG(SWEMGSD) + XMEXNOR*LOG(NORMGSD) + XMEXFIN*LOG(FINMGSD) + XMEXNLD*LOG(NLDMGSD) + XMEXGBR*LOG(GBRMGSD) + XMEXBEL*LOG(BELMGSD) + XMEXDEU*LOG(DEUMGSD) + XMEXFRA*LOG(FRAMGSD) + XMEXESP*LOG(ESPMGSD) + XMEXYPN*LOG(YPNMGSD) + XMEXITA*LOG(ITAMGSD) + XMEXUSA*LOG(USAMGSD) + XMEXPOL*LOG(POLMGSD) + XMEXAUS*LOG(AUSMGSD) + XMEXAUT*LOG(AUTMGSD) + XMEXCAN*LOG(CANMGSD) + XMEXCHL*LOG(CHLMGSD) + XMEXEST*LOG(ESTMGSD) + XMEXGRC*LOG(GRCMGSD) + XMEXCZE*LOG(CZEMGSD) + XMEXHUN*LOG(HUNMGSD) + XMEXISL*LOG(ISLMGSD) + XMEXIRL*LOG(IRLMGSD) + XMEXISR*LOG(ISRMGSD) + XMEXKOR*LOG(KORMGSD) + XMEXLUX*LOG(LUXMGSD) + XMEXNZL*LOG(NZLMGSD) + XMEXPRT*LOG(PRTMGSD) + XMEXSVK*LOG(SVKMGSD) + XMEXSVN*LOG(SVNMGSD) + XMEXCHE*LOG(CHEMGSD) + XMEXTUR*LOG(TURMGSD) + XMEXDAE*LOG(DAEMGSD) + XMEXOOP*LOG(OOPMGSD) + XMEXBRA*LOG(BRAMGSD) + XMEXRUS*LOG(RUSMGSD) + XMEXIND*LOG(INDMGSD) + XMEXCHN*LOG(CHNMGSD) + XMEXIDN*LOG(IDNMGSD) + XMEXZAF*LOG(ZAFMGSD) + XMEXRWD*LOG(RWDMGSD) $ FRML _GJRD DLOG(MEXXGSD) = (MEXXGSDU-MEXXGSDU(-1)) $ FRML GMEXXGSV MEXXGSV = MEXXGSD*USAEXCH/(MEXEXCH*MEXPXGS) $ () () () IMPORT () FRML _GJRD_ DLOG(MEXMGSV) = 0.50312*DLOG(MEXXGSV) - 1.66380*DLOG(MEXPMGS/MEXPXGS) -0.28831*LOG(MEXMGSV(-1)/MEXXGSV(-1)) -0.50000*LOG(MEXPMGS(-1)/MEXPXGS(-1)) +0.05134 - D1982*0.56922 $ () FRML GMEXMGSD MEXMGSD = MEXMGSV*MEXPMGS*MEXEXCH/USAEXCH $ () () () IMPORT PRICES () () FRML GMEXPMGSU MEXPMGSU = MMEXDNK*LOG(DNKPXGS/MEXEXCH*DNKEXCH) + MMEXSWE*LOG(SWEPXGS/MEXEXCH*SWEEXCH) + MMEXNOR*LOG(NORPXGS/MEXEXCH*NOREXCH) + MMEXFIN*LOG(FINPXGS/MEXEXCH*FINEXCH) + MMEXNLD*LOG(NLDPXGS/MEXEXCH*NLDEXCH) + MMEXGBR*LOG(GBRPXGS/MEXEXCH*GBREXCH) + MMEXESP*LOG(ESPPXGS/MEXEXCH*ESPEXCH) + MMEXDEU*LOG(DEUPXGS/MEXEXCH*DEUEXCH) + MMEXBEL*LOG(BELPXGS/MEXEXCH*BELEXCH) + MMEXFRA*LOG(FRAPXGS/MEXEXCH*FRAEXCH) + MMEXYPN*LOG(YPNPXGS/MEXEXCH*YPNEXCH) + MMEXITA*LOG(ITAPXGS/MEXEXCH*ITAEXCH) + MMEXUSA*LOG(USAPXGS/MEXEXCH*USAEXCH) + MMEXPOL*LOG(POLPXGS/MEXEXCH*POLEXCH) + MMEXAUS*LOG(AUSPXGS/MEXEXCH*AUSEXCH) + MMEXAUT*LOG(AUTPXGS/MEXEXCH*AUTEXCH) + MMEXCAN*LOG(CANPXGS/MEXEXCH*CANEXCH) + MMEXCHL*LOG(CHLPXGS/MEXEXCH*CHLEXCH) + MMEXEST*LOG(ESTPXGS/MEXEXCH*ESTEXCH) + MMEXGRC*LOG(GRCPXGS/MEXEXCH*GRCEXCH) + MMEXCZE*LOG(CZEPXGS/MEXEXCH*CZEEXCH) + MMEXHUN*LOG(HUNPXGS/MEXEXCH*HUNEXCH) + MMEXISL*LOG(ISLPXGS/MEXEXCH*ISLEXCH) + MMEXIRL*LOG(IRLPXGS/MEXEXCH*IRLEXCH) + MMEXISR*LOG(ISRPXGS/MEXEXCH*ISREXCH) + MMEXKOR*LOG(KORPXGS/MEXEXCH*KOREXCH) + MMEXLUX*LOG(LUXPXGS/MEXEXCH*LUXEXCH) + MMEXNZL*LOG(NZLPXGS/MEXEXCH*NZLEXCH) + MMEXPRT*LOG(PRTPXGS/MEXEXCH*PRTEXCH) + MMEXSVK*LOG(SVKPXGS/MEXEXCH*SVKEXCH) + MMEXSVN*LOG(SVNPXGS/MEXEXCH*SVNEXCH) + MMEXCHE*LOG(CHEPXGS/MEXEXCH*CHEEXCH) + MMEXTUR*LOG(TURPXGS/MEXEXCH*TUREXCH) + MMEXDAE*LOG(DAEPXGS/MEXEXCH*DAEEXCH) + MMEXOOP*LOG(OOPPXGS/MEXEXCH*OOPEXCH) + MMEXBRA*LOG(BRAPXGS/MEXEXCH*BRAEXCH) + MMEXRUS*LOG(RUSPXGS/MEXEXCH*RUSEXCH) + MMEXIND*LOG(INDPXGS/MEXEXCH*INDEXCH) + MMEXCHN*LOG(CHNPXGS/MEXEXCH*CHNEXCH) + MMEXIDN*LOG(IDNPXGS/MEXEXCH*IDNEXCH) + MMEXZAF*LOG(ZAFPXGS/MEXEXCH*ZAFEXCH) + MMEXRWD*LOG(RWDPXGS/MEXEXCH*RWDEXCH) $ () FRML _GJRD_ DLOG(MEXPMGS) = (MEXPMGSU-MEXPMGSU(-1)) $ () () () EXPORT PRICES () FRML GMEXPXGSU MEXPXGSU = XMEXDNK*LOG(DNKPMGS/MEXEXCH*DNKEXCH) + XMEXSWE*LOG(SWEPMGS/MEXEXCH*SWEEXCH) + XMEXNOR*LOG(NORPMGS/MEXEXCH*NOREXCH) + XMEXFIN*LOG(FINPMGS/MEXEXCH*FINEXCH) + XMEXNLD*LOG(NLDPMGS/MEXEXCH*NLDEXCH) + XMEXGBR*LOG(GBRPMGS/MEXEXCH*GBREXCH) + XMEXESP*LOG(ESPPMGS/MEXEXCH*ESPEXCH) + XMEXDEU*LOG(DEUPMGS/MEXEXCH*DEUEXCH) + XMEXBEL*LOG(BELPMGS/MEXEXCH*BELEXCH) + XMEXFRA*LOG(FRAPMGS/MEXEXCH*FRAEXCH) + XMEXYPN*LOG(YPNPMGS/MEXEXCH*YPNEXCH) + XMEXITA*LOG(ITAPMGS/MEXEXCH*ITAEXCH) + XMEXUSA*LOG(USAPMGS/MEXEXCH*USAEXCH) + XMEXPOL*LOG(POLPMGS/MEXEXCH*POLEXCH) + XMEXAUS*LOG(AUSPMGS/MEXEXCH*AUSEXCH) + XMEXAUT*LOG(AUTPMGS/MEXEXCH*AUTEXCH) + XMEXCAN*LOG(CANPMGS/MEXEXCH*CANEXCH) + XMEXCHL*LOG(CHLPMGS/MEXEXCH*CHLEXCH) + XMEXEST*LOG(ESTPMGS/MEXEXCH*ESTEXCH) + XMEXGRC*LOG(GRCPMGS/MEXEXCH*GRCEXCH) + XMEXCZE*LOG(CZEPMGS/MEXEXCH*CZEEXCH) + XMEXHUN*LOG(HUNPMGS/MEXEXCH*HUNEXCH) + XMEXISL*LOG(ISLPMGS/MEXEXCH*ISLEXCH) + XMEXIRL*LOG(IRLPMGS/MEXEXCH*IRLEXCH) + XMEXISR*LOG(ISRPMGS/MEXEXCH*ISREXCH) + XMEXKOR*LOG(KORPMGS/MEXEXCH*KOREXCH) + XMEXLUX*LOG(LUXPMGS/MEXEXCH*LUXEXCH) + XMEXNZL*LOG(NZLPMGS/MEXEXCH*NZLEXCH) + XMEXPRT*LOG(PRTPMGS/MEXEXCH*PRTEXCH) + XMEXSVK*LOG(SVKPMGS/MEXEXCH*SVKEXCH) + XMEXSVN*LOG(SVNPMGS/MEXEXCH*SVNEXCH) + XMEXCHE*LOG(CHEPMGS/MEXEXCH*CHEEXCH) + XMEXTUR*LOG(TURPMGS/MEXEXCH*TUREXCH) + XMEXDAE*LOG(DAEPMGS/MEXEXCH*DAEEXCH) + XMEXOOP*LOG(OOPPMGS/MEXEXCH*OOPEXCH) + XMEXBRA*LOG(BRAPMGS/MEXEXCH*BRAEXCH) + XMEXRUS*LOG(RUSPMGS/MEXEXCH*RUSEXCH) + XMEXIND*LOG(INDPMGS/MEXEXCH*INDEXCH) + XMEXCHN*LOG(CHNPMGS/MEXEXCH*CHNEXCH) + XMEXIDN*LOG(IDNPMGS/MEXEXCH*IDNEXCH) + XMEXZAF*LOG(ZAFPMGS/MEXEXCH*ZAFEXCH) + XMEXRWD*LOG(RWDPMGS/MEXEXCH*RWDEXCH) $ () FRML _GJRD_ DLOG(MEXPXGS) = (MEXPXGSU-MEXPXGSU(-1)) $ () () () ******************* () * NZL * () ******************* () () EXPORT VOLUMES () FRML GNZLXGSDU NZLXGSDU = XNZLDNK*LOG(DNKMGSD) + XNZLSWE*LOG(SWEMGSD) + XNZLNOR*LOG(NORMGSD) + XNZLFIN*LOG(FINMGSD) + XNZLNLD*LOG(NLDMGSD) + XNZLGBR*LOG(GBRMGSD) + XNZLBEL*LOG(BELMGSD) + XNZLDEU*LOG(DEUMGSD) + XNZLFRA*LOG(FRAMGSD) + XNZLESP*LOG(ESPMGSD) + XNZLYPN*LOG(YPNMGSD) + XNZLITA*LOG(ITAMGSD) + XNZLUSA*LOG(USAMGSD) + XNZLPOL*LOG(POLMGSD) + XNZLAUS*LOG(AUSMGSD) + XNZLAUT*LOG(AUTMGSD) + XNZLCAN*LOG(CANMGSD) + XNZLCHL*LOG(CHLMGSD) + XNZLEST*LOG(ESTMGSD) + XNZLGRC*LOG(GRCMGSD) + XNZLCZE*LOG(CZEMGSD) + XNZLHUN*LOG(HUNMGSD) + XNZLISL*LOG(ISLMGSD) + XNZLIRL*LOG(IRLMGSD) + XNZLISR*LOG(ISRMGSD) + XNZLKOR*LOG(KORMGSD) + XNZLLUX*LOG(LUXMGSD) + XNZLMEX*LOG(MEXMGSD) + XNZLPRT*LOG(PRTMGSD) + XNZLSVK*LOG(SVKMGSD) + XNZLSVN*LOG(SVNMGSD) + XNZLCHE*LOG(CHEMGSD) + XNZLTUR*LOG(TURMGSD) + XNZLDAE*LOG(DAEMGSD) + XNZLOOP*LOG(OOPMGSD) + XNZLBRA*LOG(BRAMGSD) + XNZLRUS*LOG(RUSMGSD) + XNZLIND*LOG(INDMGSD) + XNZLCHN*LOG(CHNMGSD) + XNZLIDN*LOG(IDNMGSD) + XNZLZAF*LOG(ZAFMGSD) + XNZLRWD*LOG(RWDMGSD) $ FRML _GJRD DLOG(NZLXGSD) = (NZLXGSDU-NZLXGSDU(-1)) $ FRML GNZLXGSV NZLXGSV = NZLXGSD*USAEXCH/(NZLEXCH*NZLPXGS) $ () () () IMPORT () FRML _GJRD_ DLOG(NZLMGSV) = 0.49469*DLOG(NZLXGSV) - 0.55950*DLOG(NZLPMGS/NZLPXGS) -0.47601*LOG(NZLMGSV(-1)/NZLXGSV(-1)) -0.37283*LOG(NZLPMGS(-1)/NZLPXGS(-1)) +0.01822 + D1974*0.31945 $ () FRML GNZLMGSD NZLMGSD = NZLMGSV*NZLPMGS*NZLEXCH/USAEXCH $ () () () IMPORT PRICES () () FRML GNZLPMGSU NZLPMGSU = MNZLDNK*LOG(DNKPXGS/NZLEXCH*DNKEXCH) + MNZLSWE*LOG(SWEPXGS/NZLEXCH*SWEEXCH) + MNZLNOR*LOG(NORPXGS/NZLEXCH*NOREXCH) + MNZLFIN*LOG(FINPXGS/NZLEXCH*FINEXCH) + MNZLNLD*LOG(NLDPXGS/NZLEXCH*NLDEXCH) + MNZLGBR*LOG(GBRPXGS/NZLEXCH*GBREXCH) + MNZLESP*LOG(ESPPXGS/NZLEXCH*ESPEXCH) + MNZLDEU*LOG(DEUPXGS/NZLEXCH*DEUEXCH) + MNZLBEL*LOG(BELPXGS/NZLEXCH*BELEXCH) + MNZLFRA*LOG(FRAPXGS/NZLEXCH*FRAEXCH) + MNZLYPN*LOG(YPNPXGS/NZLEXCH*YPNEXCH) + MNZLITA*LOG(ITAPXGS/NZLEXCH*ITAEXCH) + MNZLUSA*LOG(USAPXGS/NZLEXCH*USAEXCH) + MNZLPOL*LOG(POLPXGS/NZLEXCH*POLEXCH) + MNZLAUS*LOG(AUSPXGS/NZLEXCH*AUSEXCH) + MNZLAUT*LOG(AUTPXGS/NZLEXCH*AUTEXCH) + MNZLCAN*LOG(CANPXGS/NZLEXCH*CANEXCH) + MNZLCHL*LOG(CHLPXGS/NZLEXCH*CHLEXCH) + MNZLEST*LOG(ESTPXGS/NZLEXCH*ESTEXCH) + MNZLGRC*LOG(GRCPXGS/NZLEXCH*GRCEXCH) + MNZLCZE*LOG(CZEPXGS/NZLEXCH*CZEEXCH) + MNZLHUN*LOG(HUNPXGS/NZLEXCH*HUNEXCH) + MNZLISL*LOG(ISLPXGS/NZLEXCH*ISLEXCH) + MNZLIRL*LOG(IRLPXGS/NZLEXCH*IRLEXCH) + MNZLISR*LOG(ISRPXGS/NZLEXCH*ISREXCH) + MNZLKOR*LOG(KORPXGS/NZLEXCH*KOREXCH) + MNZLLUX*LOG(LUXPXGS/NZLEXCH*LUXEXCH) + MNZLMEX*LOG(MEXPXGS/NZLEXCH*MEXEXCH) + MNZLPRT*LOG(PRTPXGS/NZLEXCH*PRTEXCH) + MNZLSVK*LOG(SVKPXGS/NZLEXCH*SVKEXCH) + MNZLSVN*LOG(SVNPXGS/NZLEXCH*SVNEXCH) + MNZLCHE*LOG(CHEPXGS/NZLEXCH*CHEEXCH) + MNZLTUR*LOG(TURPXGS/NZLEXCH*TUREXCH) + MNZLDAE*LOG(DAEPXGS/NZLEXCH*DAEEXCH) + MNZLOOP*LOG(OOPPXGS/NZLEXCH*OOPEXCH) + MNZLBRA*LOG(BRAPXGS/NZLEXCH*BRAEXCH) + MNZLRUS*LOG(RUSPXGS/NZLEXCH*RUSEXCH) + MNZLIND*LOG(INDPXGS/NZLEXCH*INDEXCH) + MNZLCHN*LOG(CHNPXGS/NZLEXCH*CHNEXCH) + MNZLIDN*LOG(IDNPXGS/NZLEXCH*IDNEXCH) + MNZLZAF*LOG(ZAFPXGS/NZLEXCH*ZAFEXCH) + MNZLRWD*LOG(RWDPXGS/NZLEXCH*RWDEXCH) $ () FRML _GJRD_ DLOG(NZLPMGS) = (NZLPMGSU-NZLPMGSU(-1)) $ () () () EXPORT PRICES () FRML GNZLPXGSU NZLPXGSU = XNZLDNK*LOG(DNKPMGS/NZLEXCH*DNKEXCH) + XNZLSWE*LOG(SWEPMGS/NZLEXCH*SWEEXCH) + XNZLNOR*LOG(NORPMGS/NZLEXCH*NOREXCH) + XNZLFIN*LOG(FINPMGS/NZLEXCH*FINEXCH) + XNZLNLD*LOG(NLDPMGS/NZLEXCH*NLDEXCH) + XNZLGBR*LOG(GBRPMGS/NZLEXCH*GBREXCH) + XNZLESP*LOG(ESPPMGS/NZLEXCH*ESPEXCH) + XNZLDEU*LOG(DEUPMGS/NZLEXCH*DEUEXCH) + XNZLBEL*LOG(BELPMGS/NZLEXCH*BELEXCH) + XNZLFRA*LOG(FRAPMGS/NZLEXCH*FRAEXCH) + XNZLYPN*LOG(YPNPMGS/NZLEXCH*YPNEXCH) + XNZLITA*LOG(ITAPMGS/NZLEXCH*ITAEXCH) + XNZLUSA*LOG(USAPMGS/NZLEXCH*USAEXCH) + XNZLPOL*LOG(POLPMGS/NZLEXCH*POLEXCH) + XNZLAUS*LOG(AUSPMGS/NZLEXCH*AUSEXCH) + XNZLAUT*LOG(AUTPMGS/NZLEXCH*AUTEXCH) + XNZLCAN*LOG(CANPMGS/NZLEXCH*CANEXCH) + XNZLCHL*LOG(CHLPMGS/NZLEXCH*CHLEXCH) + XNZLEST*LOG(ESTPMGS/NZLEXCH*ESTEXCH) + XNZLGRC*LOG(GRCPMGS/NZLEXCH*GRCEXCH) + XNZLCZE*LOG(CZEPMGS/NZLEXCH*CZEEXCH) + XNZLHUN*LOG(HUNPMGS/NZLEXCH*HUNEXCH) + XNZLISL*LOG(ISLPMGS/NZLEXCH*ISLEXCH) + XNZLIRL*LOG(IRLPMGS/NZLEXCH*IRLEXCH) + XNZLISR*LOG(ISRPMGS/NZLEXCH*ISREXCH) + XNZLKOR*LOG(KORPMGS/NZLEXCH*KOREXCH) + XNZLLUX*LOG(LUXPMGS/NZLEXCH*LUXEXCH) + XNZLMEX*LOG(MEXPMGS/NZLEXCH*MEXEXCH) + XNZLPRT*LOG(PRTPMGS/NZLEXCH*PRTEXCH) + XNZLSVK*LOG(SVKPMGS/NZLEXCH*SVKEXCH) + XNZLSVN*LOG(SVNPMGS/NZLEXCH*SVNEXCH) + XNZLCHE*LOG(CHEPMGS/NZLEXCH*CHEEXCH) + XNZLTUR*LOG(TURPMGS/NZLEXCH*TUREXCH) + XNZLDAE*LOG(DAEPMGS/NZLEXCH*DAEEXCH) + XNZLOOP*LOG(OOPPMGS/NZLEXCH*OOPEXCH) + XNZLBRA*LOG(BRAPMGS/NZLEXCH*BRAEXCH) + XNZLRUS*LOG(RUSPMGS/NZLEXCH*RUSEXCH) + XNZLIND*LOG(INDPMGS/NZLEXCH*INDEXCH) + XNZLCHN*LOG(CHNPMGS/NZLEXCH*CHNEXCH) + XNZLIDN*LOG(IDNPMGS/NZLEXCH*IDNEXCH) + XNZLZAF*LOG(ZAFPMGS/NZLEXCH*ZAFEXCH) + XNZLRWD*LOG(RWDPMGS/NZLEXCH*RWDEXCH) $ () FRML _GJRD_ DLOG(NZLPXGS) = (NZLPXGSU-NZLPXGSU(-1)) $ () () () ******************* () * OOP * () ******************* () () EXPORT VOLUMES () FRML GOOPXGSDU OOPXGSDU = XOOPDNK*LOG(DNKMGSD) + XOOPSWE*LOG(SWEMGSD) + XOOPNOR*LOG(NORMGSD) + XOOPFIN*LOG(FINMGSD) + XOOPNLD*LOG(NLDMGSD) + XOOPGBR*LOG(GBRMGSD) + XOOPBEL*LOG(BELMGSD) + XOOPDEU*LOG(DEUMGSD) + XOOPFRA*LOG(FRAMGSD) + XOOPESP*LOG(ESPMGSD) + XOOPYPN*LOG(YPNMGSD) + XOOPITA*LOG(ITAMGSD) + XOOPUSA*LOG(USAMGSD) + XOOPPOL*LOG(POLMGSD) + XOOPAUS*LOG(AUSMGSD) + XOOPAUT*LOG(AUTMGSD) + XOOPCAN*LOG(CANMGSD) + XOOPCHL*LOG(CHLMGSD) + XOOPEST*LOG(ESTMGSD) + XOOPGRC*LOG(GRCMGSD) + XOOPCZE*LOG(CZEMGSD) + XOOPHUN*LOG(HUNMGSD) + XOOPISL*LOG(ISLMGSD) + XOOPIRL*LOG(IRLMGSD) + XOOPISR*LOG(ISRMGSD) + XOOPKOR*LOG(KORMGSD) + XOOPLUX*LOG(LUXMGSD) + XOOPMEX*LOG(MEXMGSD) + XOOPNZL*LOG(NZLMGSD) + XOOPPRT*LOG(PRTMGSD) + XOOPSVK*LOG(SVKMGSD) + XOOPSVN*LOG(SVNMGSD) + XOOPCHE*LOG(CHEMGSD) + XOOPTUR*LOG(TURMGSD) + XOOPDAE*LOG(DAEMGSD) + XOOPBRA*LOG(BRAMGSD) + XOOPRUS*LOG(RUSMGSD) + XOOPIND*LOG(INDMGSD) + XOOPCHN*LOG(CHNMGSD) + XOOPIDN*LOG(IDNMGSD) + XOOPZAF*LOG(ZAFMGSD) + XOOPRWD*LOG(RWDMGSD) $ FRML _GJRD DLOG(OOPXGSD) = (OOPXGSDU-OOPXGSDU(-1))$ FRML GOOPXGSV OOPXGSV = OOPXGSD*USAEXCH/(OOPEXCH*OOPPXGS) $ () () () IMPORT () FRML _GJRD_ DLOG(OOPMGSV) = 0.55593*DLOG(OOPXGSV)-0.18284*DLOG(OOPPMGS/OOPPXGS) -0.45513*LOG(OOPMGSV(-1)/OOPXGSV(-1)) -0.36515*LOG(OOPPMGS(-1)/OOPPXGS(-1)) -0.11089 $ () FRML GOOPMGSD OOPMGSD = OOPMGSV*OOPPMGS*OOPEXCH/USAEXCH $ () () () IMPORT PRICES () () FRML GOOPPMGSU OOPPMGSU = MOOPDNK*LOG(DNKPXGS/OOPEXCH*DNKEXCH) + MOOPSWE*LOG(SWEPXGS/OOPEXCH*SWEEXCH) + MOOPNOR*LOG(NORPXGS/OOPEXCH*NOREXCH) + MOOPFIN*LOG(FINPXGS/OOPEXCH*FINEXCH) + MOOPNLD*LOG(NLDPXGS/OOPEXCH*NLDEXCH) + MOOPGBR*LOG(GBRPXGS/OOPEXCH*GBREXCH) + MOOPESP*LOG(ESPPXGS/OOPEXCH*ESPEXCH) + MOOPDEU*LOG(DEUPXGS/OOPEXCH*DEUEXCH) + MOOPBEL*LOG(BELPXGS/OOPEXCH*BELEXCH) + MOOPFRA*LOG(FRAPXGS/OOPEXCH*FRAEXCH) + MOOPYPN*LOG(YPNPXGS/OOPEXCH*YPNEXCH) + MOOPITA*LOG(ITAPXGS/OOPEXCH*ITAEXCH) + MOOPUSA*LOG(USAPXGS/OOPEXCH*USAEXCH) + MOOPPOL*LOG(POLPXGS/OOPEXCH*POLEXCH) + MOOPAUS*LOG(AUSPXGS/OOPEXCH*AUSEXCH) + MOOPAUT*LOG(AUTPXGS/OOPEXCH*AUTEXCH) + MOOPCAN*LOG(CANPXGS/OOPEXCH*CANEXCH) + MOOPCHL*LOG(CHLPXGS/OOPEXCH*CHLEXCH) + MOOPEST*LOG(ESTPXGS/OOPEXCH*ESTEXCH) + MOOPGRC*LOG(GRCPXGS/OOPEXCH*GRCEXCH) + MOOPCZE*LOG(CZEPXGS/OOPEXCH*CZEEXCH) + MOOPHUN*LOG(HUNPXGS/OOPEXCH*HUNEXCH) + MOOPISL*LOG(ISLPXGS/OOPEXCH*ISLEXCH) + MOOPIRL*LOG(IRLPXGS/OOPEXCH*IRLEXCH) + MOOPISR*LOG(ISRPXGS/OOPEXCH*ISREXCH) + MOOPKOR*LOG(KORPXGS/OOPEXCH*KOREXCH) + MOOPLUX*LOG(LUXPXGS/OOPEXCH*LUXEXCH) + MOOPMEX*LOG(MEXPXGS/OOPEXCH*MEXEXCH) + MOOPNZL*LOG(NZLPXGS/OOPEXCH*NZLEXCH) + MOOPPRT*LOG(PRTPXGS/OOPEXCH*PRTEXCH) + MOOPSVK*LOG(SVKPXGS/OOPEXCH*SVKEXCH) + MOOPSVN*LOG(SVNPXGS/OOPEXCH*SVNEXCH) + MOOPCHE*LOG(CHEPXGS/OOPEXCH*CHEEXCH) + MOOPTUR*LOG(TURPXGS/OOPEXCH*TUREXCH) + MOOPDAE*LOG(DAEPXGS/OOPEXCH*DAEEXCH) + MOOPBRA*LOG(BRAPXGS/OOPEXCH*BRAEXCH) + MOOPRUS*LOG(RUSPXGS/OOPEXCH*RUSEXCH) + MOOPIND*LOG(INDPXGS/OOPEXCH*INDEXCH) + MOOPCHN*LOG(CHNPXGS/OOPEXCH*CHNEXCH) + MOOPIDN*LOG(IDNPXGS/OOPEXCH*IDNEXCH) + MOOPZAF*LOG(ZAFPXGS/OOPEXCH*ZAFEXCH) + MOOPRWD*LOG(RWDPXGS/OOPEXCH*RWDEXCH) $ () FRML _GJRD_ DLOG(OOPPMGS) = (OOPPMGSU-OOPPMGSU(-1)) $ () () () EXPORT PRICES () FRML GOOPPXGSU OOPPXGSU = XOOPDNK*LOG(DNKPMGS/OOPEXCH*DNKEXCH) + XOOPSWE*LOG(SWEPMGS/OOPEXCH*SWEEXCH) + XOOPNOR*LOG(NORPMGS/OOPEXCH*NOREXCH) + XOOPFIN*LOG(FINPMGS/OOPEXCH*FINEXCH) + XOOPNLD*LOG(NLDPMGS/OOPEXCH*NLDEXCH) + XOOPGBR*LOG(GBRPMGS/OOPEXCH*GBREXCH) + XOOPESP*LOG(ESPPMGS/OOPEXCH*ESPEXCH) + XOOPDEU*LOG(DEUPMGS/OOPEXCH*DEUEXCH) + XOOPBEL*LOG(BELPMGS/OOPEXCH*BELEXCH) + XOOPFRA*LOG(FRAPMGS/OOPEXCH*FRAEXCH) + XOOPYPN*LOG(YPNPMGS/OOPEXCH*YPNEXCH) + XOOPITA*LOG(ITAPMGS/OOPEXCH*ITAEXCH) + XOOPUSA*LOG(USAPMGS/OOPEXCH*USAEXCH) + XOOPPOL*LOG(POLPMGS/OOPEXCH*POLEXCH) + XOOPAUS*LOG(AUSPMGS/OOPEXCH*AUSEXCH) + XOOPAUT*LOG(AUTPMGS/OOPEXCH*AUTEXCH) + XOOPCAN*LOG(CANPMGS/OOPEXCH*CANEXCH) + XOOPCHL*LOG(CHLPMGS/OOPEXCH*CHLEXCH) + XOOPEST*LOG(ESTPMGS/OOPEXCH*ESTEXCH) + XOOPGRC*LOG(GRCPMGS/OOPEXCH*GRCEXCH) + XOOPCZE*LOG(CZEPMGS/OOPEXCH*CZEEXCH) + XOOPHUN*LOG(HUNPMGS/OOPEXCH*HUNEXCH) + XOOPISL*LOG(ISLPMGS/OOPEXCH*ISLEXCH) + XOOPIRL*LOG(IRLPMGS/OOPEXCH*IRLEXCH) + XOOPISR*LOG(ISRPMGS/OOPEXCH*ISREXCH) + XOOPKOR*LOG(KORPMGS/OOPEXCH*KOREXCH) + XOOPLUX*LOG(LUXPMGS/OOPEXCH*LUXEXCH) + XOOPMEX*LOG(MEXPMGS/OOPEXCH*MEXEXCH) + XOOPNZL*LOG(NZLPMGS/OOPEXCH*NZLEXCH) + XOOPPRT*LOG(PRTPMGS/OOPEXCH*PRTEXCH) + XOOPSVK*LOG(SVKPMGS/OOPEXCH*SVKEXCH) + XOOPSVN*LOG(SVNPMGS/OOPEXCH*SVNEXCH) + XOOPCHE*LOG(CHEPMGS/OOPEXCH*CHEEXCH) + XOOPTUR*LOG(TURPMGS/OOPEXCH*TUREXCH) + XOOPDAE*LOG(DAEPMGS/OOPEXCH*DAEEXCH) + XOOPBRA*LOG(BRAPMGS/OOPEXCH*BRAEXCH) + XOOPRUS*LOG(RUSPMGS/OOPEXCH*RUSEXCH) + XOOPIND*LOG(INDPMGS/OOPEXCH*INDEXCH) + XOOPCHN*LOG(CHNPMGS/OOPEXCH*CHNEXCH) + XOOPIDN*LOG(IDNPMGS/OOPEXCH*IDNEXCH) + XOOPZAF*LOG(ZAFPMGS/OOPEXCH*ZAFEXCH) + XOOPRWD*LOG(RWDPMGS/OOPEXCH*RWDEXCH) $ () FRML _GJRD_ DLOG(OOPPXGS) = (OOPPXGSU-OOPPXGSU(-1)) $ () () () ******************* () * PRT * () ******************* () () EXPORT VOLUMES () FRML GPRTXGSDU PRTXGSDU = XPRTDNK*LOG(DNKMGSD) + XPRTSWE*LOG(SWEMGSD) + XPRTNOR*LOG(NORMGSD) + XPRTFIN*LOG(FINMGSD) + XPRTNLD*LOG(NLDMGSD) + XPRTGBR*LOG(GBRMGSD) + XPRTBEL*LOG(BELMGSD) + XPRTDEU*LOG(DEUMGSD) + XPRTFRA*LOG(FRAMGSD) + XPRTESP*LOG(ESPMGSD) + XPRTYPN*LOG(YPNMGSD) + XPRTITA*LOG(ITAMGSD) + XPRTUSA*LOG(USAMGSD) + XPRTPOL*LOG(POLMGSD) + XPRTAUS*LOG(AUSMGSD) + XPRTAUT*LOG(AUTMGSD) + XPRTCAN*LOG(CANMGSD) + XPRTCHL*LOG(CHLMGSD) + XPRTEST*LOG(ESTMGSD) + XPRTGRC*LOG(GRCMGSD) + XPRTCZE*LOG(CZEMGSD) + XPRTHUN*LOG(HUNMGSD) + XPRTISL*LOG(ISLMGSD) + XPRTIRL*LOG(IRLMGSD) + XPRTISR*LOG(ISRMGSD) + XPRTKOR*LOG(KORMGSD) + XPRTLUX*LOG(LUXMGSD) + XPRTMEX*LOG(MEXMGSD) + XPRTNZL*LOG(NZLMGSD) + XPRTSVK*LOG(SVKMGSD) + XPRTSVN*LOG(SVNMGSD) + XPRTCHE*LOG(CHEMGSD) + XPRTTUR*LOG(TURMGSD) + XPRTDAE*LOG(DAEMGSD) + XPRTOOP*LOG(OOPMGSD) + XPRTBRA*LOG(BRAMGSD) + XPRTRUS*LOG(RUSMGSD) + XPRTIND*LOG(INDMGSD) + XPRTCHN*LOG(CHNMGSD) + XPRTIDN*LOG(IDNMGSD) + XPRTZAF*LOG(ZAFMGSD) + XPRTRWD*LOG(RWDMGSD) $ FRML _GJRD DLOG(PRTXGSD) = (PRTXGSDU-PRTXGSDU(-1))$ FRML GPRTXGSV PRTXGSV = PRTXGSD*USAEXCH/(PRTEXCH*PRTPXGS) $ () () () IMPORT () FRML _GJRD_ DLOG(PRTMGSV) = 0.53233*DLOG(PRTXGSV) - 0.50000*DLOG(PRTPMGS/PRTPXGS) -0.26324*LOG(PRTMGSV(-1)/PRTXGSV(-1)) -0.22670*LOG(PRTPMGS(-1)/PRTPXGS(-1)) +0.09572 $ () FRML GPRTMGSD PRTMGSD = PRTMGSV*PRTPMGS*PRTEXCH/USAEXCH $ () () () IMPORT PRICES () () FRML GPRTPMGSU PRTPMGSU = MPRTDNK*LOG(DNKPXGS/PRTEXCH*DNKEXCH) + MPRTSWE*LOG(SWEPXGS/PRTEXCH*SWEEXCH) + MPRTNOR*LOG(NORPXGS/PRTEXCH*NOREXCH) + MPRTFIN*LOG(FINPXGS/PRTEXCH*FINEXCH) + MPRTNLD*LOG(NLDPXGS/PRTEXCH*NLDEXCH) + MPRTGBR*LOG(GBRPXGS/PRTEXCH*GBREXCH) + MPRTESP*LOG(ESPPXGS/PRTEXCH*ESPEXCH) + MPRTDEU*LOG(DEUPXGS/PRTEXCH*DEUEXCH) + MPRTBEL*LOG(BELPXGS/PRTEXCH*BELEXCH) + MPRTFRA*LOG(FRAPXGS/PRTEXCH*FRAEXCH) + MPRTYPN*LOG(YPNPXGS/PRTEXCH*YPNEXCH) + MPRTITA*LOG(ITAPXGS/PRTEXCH*ITAEXCH) + MPRTUSA*LOG(USAPXGS/PRTEXCH*USAEXCH) + MPRTPOL*LOG(POLPXGS/PRTEXCH*POLEXCH) + MPRTAUS*LOG(AUSPXGS/PRTEXCH*AUSEXCH) + MPRTAUT*LOG(AUTPXGS/PRTEXCH*AUTEXCH) + MPRTCAN*LOG(CANPXGS/PRTEXCH*CANEXCH) + MPRTCHL*LOG(CHLPXGS/PRTEXCH*CHLEXCH) + MPRTEST*LOG(ESTPXGS/PRTEXCH*ESTEXCH) + MPRTGRC*LOG(GRCPXGS/PRTEXCH*GRCEXCH) + MPRTCZE*LOG(CZEPXGS/PRTEXCH*CZEEXCH) + MPRTHUN*LOG(HUNPXGS/PRTEXCH*HUNEXCH) + MPRTISL*LOG(ISLPXGS/PRTEXCH*ISLEXCH) + MPRTIRL*LOG(IRLPXGS/PRTEXCH*IRLEXCH) + MPRTISR*LOG(ISRPXGS/PRTEXCH*ISREXCH) + MPRTKOR*LOG(KORPXGS/PRTEXCH*KOREXCH) + MPRTLUX*LOG(LUXPXGS/PRTEXCH*LUXEXCH) + MPRTMEX*LOG(MEXPXGS/PRTEXCH*MEXEXCH) + MPRTNZL*LOG(NZLPXGS/PRTEXCH*NZLEXCH) + MPRTSVK*LOG(SVKPXGS/PRTEXCH*SVKEXCH) + MPRTSVN*LOG(SVNPXGS/PRTEXCH*SVNEXCH) + MPRTCHE*LOG(CHEPXGS/PRTEXCH*CHEEXCH) + MPRTTUR*LOG(TURPXGS/PRTEXCH*TUREXCH) + MPRTDAE*LOG(DAEPXGS/PRTEXCH*DAEEXCH) + MPRTOOP*LOG(OOPPXGS/PRTEXCH*OOPEXCH) + MPRTBRA*LOG(BRAPXGS/PRTEXCH*BRAEXCH) + MPRTRUS*LOG(RUSPXGS/PRTEXCH*RUSEXCH) + MPRTIND*LOG(INDPXGS/PRTEXCH*INDEXCH) + MPRTCHN*LOG(CHNPXGS/PRTEXCH*CHNEXCH) + MPRTIDN*LOG(IDNPXGS/PRTEXCH*IDNEXCH) + MPRTZAF*LOG(ZAFPXGS/PRTEXCH*ZAFEXCH) + MPRTRWD*LOG(RWDPXGS/PRTEXCH*RWDEXCH) $ () FRML _GJRD_ DLOG(PRTPMGS) = (PRTPMGSU-PRTPMGSU(-1)) $ () () () EXPORT PRICES () FRML GPRTPXGSU PRTPXGSU = XPRTDNK*LOG(DNKPMGS/PRTEXCH*DNKEXCH) + XPRTSWE*LOG(SWEPMGS/PRTEXCH*SWEEXCH) + XPRTNOR*LOG(NORPMGS/PRTEXCH*NOREXCH) + XPRTFIN*LOG(FINPMGS/PRTEXCH*FINEXCH) + XPRTNLD*LOG(NLDPMGS/PRTEXCH*NLDEXCH) + XPRTGBR*LOG(GBRPMGS/PRTEXCH*GBREXCH) + XPRTESP*LOG(ESPPMGS/PRTEXCH*ESPEXCH) + XPRTDEU*LOG(DEUPMGS/PRTEXCH*DEUEXCH) + XPRTBEL*LOG(BELPMGS/PRTEXCH*BELEXCH) + XPRTFRA*LOG(FRAPMGS/PRTEXCH*FRAEXCH) + XPRTYPN*LOG(YPNPMGS/PRTEXCH*YPNEXCH) + XPRTITA*LOG(ITAPMGS/PRTEXCH*ITAEXCH) + XPRTUSA*LOG(USAPMGS/PRTEXCH*USAEXCH) + XPRTPOL*LOG(POLPMGS/PRTEXCH*POLEXCH) + XPRTAUS*LOG(AUSPMGS/PRTEXCH*AUSEXCH) + XPRTAUT*LOG(AUTPMGS/PRTEXCH*AUTEXCH) + XPRTCAN*LOG(CANPMGS/PRTEXCH*CANEXCH) + XPRTCHL*LOG(CHLPMGS/PRTEXCH*CHLEXCH) + XPRTEST*LOG(ESTPMGS/PRTEXCH*ESTEXCH) + XPRTGRC*LOG(GRCPMGS/PRTEXCH*GRCEXCH) + XPRTCZE*LOG(CZEPMGS/PRTEXCH*CZEEXCH) + XPRTHUN*LOG(HUNPMGS/PRTEXCH*HUNEXCH) + XPRTISL*LOG(ISLPMGS/PRTEXCH*ISLEXCH) + XPRTIRL*LOG(IRLPMGS/PRTEXCH*IRLEXCH) + XPRTISR*LOG(ISRPMGS/PRTEXCH*ISREXCH) + XPRTKOR*LOG(KORPMGS/PRTEXCH*KOREXCH) + XPRTLUX*LOG(LUXPMGS/PRTEXCH*LUXEXCH) + XPRTMEX*LOG(MEXPMGS/PRTEXCH*MEXEXCH) + XPRTNZL*LOG(NZLPMGS/PRTEXCH*NZLEXCH) + XPRTSVK*LOG(SVKPMGS/PRTEXCH*SVKEXCH) + XPRTSVN*LOG(SVNPMGS/PRTEXCH*SVNEXCH) + XPRTCHE*LOG(CHEPMGS/PRTEXCH*CHEEXCH) + XPRTTUR*LOG(TURPMGS/PRTEXCH*TUREXCH) + XPRTDAE*LOG(DAEPMGS/PRTEXCH*DAEEXCH) + XPRTOOP*LOG(OOPPMGS/PRTEXCH*OOPEXCH) + XPRTBRA*LOG(BRAPMGS/PRTEXCH*BRAEXCH) + XPRTRUS*LOG(RUSPMGS/PRTEXCH*RUSEXCH) + XPRTIND*LOG(INDPMGS/PRTEXCH*INDEXCH) + XPRTCHN*LOG(CHNPMGS/PRTEXCH*CHNEXCH) + XPRTIDN*LOG(IDNPMGS/PRTEXCH*IDNEXCH) + XPRTZAF*LOG(ZAFPMGS/PRTEXCH*ZAFEXCH) + XPRTRWD*LOG(RWDPMGS/PRTEXCH*RWDEXCH) $ () FRML _GJRD_ DLOG(PRTPXGS) = (PRTPXGSU-PRTPXGSU(-1)) $ () () () ******************* () * RUS * () ******************* () () EXPORT VOLUMES () FRML GRUSXGSDU RUSXGSDU = XRUSDNK*LOG(DNKMGSD) + XRUSSWE*LOG(SWEMGSD) + XRUSNOR*LOG(NORMGSD) + XRUSFIN*LOG(FINMGSD) + XRUSNLD*LOG(NLDMGSD) + XRUSGBR*LOG(GBRMGSD) + XRUSBEL*LOG(BELMGSD) + XRUSDEU*LOG(DEUMGSD) + XRUSFRA*LOG(FRAMGSD) + XRUSESP*LOG(ESPMGSD) + XRUSYPN*LOG(YPNMGSD) + XRUSITA*LOG(ITAMGSD) + XRUSUSA*LOG(USAMGSD) + XRUSPOL*LOG(POLMGSD) + XRUSAUS*LOG(AUSMGSD) + XRUSAUT*LOG(AUTMGSD) + XRUSCAN*LOG(CANMGSD) + XRUSCHL*LOG(CHLMGSD) + XRUSEST*LOG(ESTMGSD) + XRUSGRC*LOG(GRCMGSD) + XRUSCZE*LOG(CZEMGSD) + XRUSHUN*LOG(HUNMGSD) + XRUSISL*LOG(ISLMGSD) + XRUSIRL*LOG(IRLMGSD) + XRUSISR*LOG(ISRMGSD) + XRUSKOR*LOG(KORMGSD) + XRUSLUX*LOG(LUXMGSD) + XRUSMEX*LOG(MEXMGSD) + XRUSNZL*LOG(NZLMGSD) + XRUSPRT*LOG(PRTMGSD) + XRUSSVK*LOG(SVKMGSD) + XRUSSVN*LOG(SVNMGSD) + XRUSCHE*LOG(CHEMGSD) + XRUSTUR*LOG(TURMGSD) + XRUSDAE*LOG(DAEMGSD) + XRUSOOP*LOG(OOPMGSD) + XRUSBRA*LOG(BRAMGSD) + XRUSIND*LOG(INDMGSD) + XRUSCHN*LOG(CHNMGSD) + XRUSIDN*LOG(IDNMGSD) + XRUSZAF*LOG(ZAFMGSD) + XRUSRWD*LOG(RWDMGSD) $ FRML _GJRD DLOG(RUSXGSD) = (RUSXGSDU-RUSXGSDU(-1)) $ FRML GRUSXGSV RUSXGSV = RUSXGSD*USAEXCH/(RUSEXCH*RUSPXGS) $ () () () IMPORT () FRML _GJRD_ DLOG(RUSMGSV) = 1.00000*DLOG(RUSXGSV) - 0.63981*DLOG(RUSPMGS/RUSPXGS) -0.45910*LOG(RUSMGSV(-1)/RUSXGSV(-1)) -0.53092*LOG(RUSPMGS(-1)/RUSPXGS(-1)) -0.16806 $ () FRML GRUSMGSD RUSMGSD = RUSMGSV*RUSPMGS*RUSEXCH/USAEXCH $ () () () IMPORT PRICES () () FRML GRUSPMGSU RUSPMGSU = MRUSDNK*LOG(DNKPXGS/RUSEXCH*DNKEXCH) + MRUSSWE*LOG(SWEPXGS/RUSEXCH*SWEEXCH) + MRUSNOR*LOG(NORPXGS/RUSEXCH*NOREXCH) + MRUSFIN*LOG(FINPXGS/RUSEXCH*FINEXCH) + MRUSNLD*LOG(NLDPXGS/RUSEXCH*NLDEXCH) + MRUSGBR*LOG(GBRPXGS/RUSEXCH*GBREXCH) + MRUSESP*LOG(ESPPXGS/RUSEXCH*ESPEXCH) + MRUSDEU*LOG(DEUPXGS/RUSEXCH*DEUEXCH) + MRUSBEL*LOG(BELPXGS/RUSEXCH*BELEXCH) + MRUSFRA*LOG(FRAPXGS/RUSEXCH*FRAEXCH) + MRUSYPN*LOG(YPNPXGS/RUSEXCH*YPNEXCH) + MRUSITA*LOG(ITAPXGS/RUSEXCH*ITAEXCH) + MRUSUSA*LOG(USAPXGS/RUSEXCH*USAEXCH) + MRUSPOL*LOG(POLPXGS/RUSEXCH*POLEXCH) + MRUSAUS*LOG(AUSPXGS/RUSEXCH*AUSEXCH) + MRUSAUT*LOG(AUTPXGS/RUSEXCH*AUTEXCH) + MRUSCAN*LOG(CANPXGS/RUSEXCH*CANEXCH) + MRUSCHL*LOG(CHLPXGS/RUSEXCH*CHLEXCH) + MRUSEST*LOG(ESTPXGS/RUSEXCH*ESTEXCH) + MRUSGRC*LOG(GRCPXGS/RUSEXCH*GRCEXCH) + MRUSCZE*LOG(CZEPXGS/RUSEXCH*CZEEXCH) + MRUSHUN*LOG(HUNPXGS/RUSEXCH*HUNEXCH) + MRUSISL*LOG(ISLPXGS/RUSEXCH*ISLEXCH) + MRUSIRL*LOG(IRLPXGS/RUSEXCH*IRLEXCH) + MRUSISR*LOG(ISRPXGS/RUSEXCH*ISREXCH) + MRUSKOR*LOG(KORPXGS/RUSEXCH*KOREXCH) + MRUSLUX*LOG(LUXPXGS/RUSEXCH*LUXEXCH) + MRUSMEX*LOG(MEXPXGS/RUSEXCH*MEXEXCH) + MRUSNZL*LOG(NZLPXGS/RUSEXCH*NZLEXCH) + MRUSPRT*LOG(PRTPXGS/RUSEXCH*PRTEXCH) + MRUSSVK*LOG(SVKPXGS/RUSEXCH*SVKEXCH) + MRUSSVN*LOG(SVNPXGS/RUSEXCH*SVNEXCH) + MRUSCHE*LOG(CHEPXGS/RUSEXCH*CHEEXCH) + MRUSTUR*LOG(TURPXGS/RUSEXCH*TUREXCH) + MRUSDAE*LOG(DAEPXGS/RUSEXCH*DAEEXCH) + MRUSOOP*LOG(OOPPXGS/RUSEXCH*OOPEXCH) + MRUSBRA*LOG(BRAPXGS/RUSEXCH*BRAEXCH) + MRUSIND*LOG(INDPXGS/RUSEXCH*INDEXCH) + MRUSCHN*LOG(CHNPXGS/RUSEXCH*CHNEXCH) + MRUSIDN*LOG(IDNPXGS/RUSEXCH*IDNEXCH) + MRUSZAF*LOG(ZAFPXGS/RUSEXCH*ZAFEXCH) + MRUSRWD*LOG(RWDPXGS/RUSEXCH*RWDEXCH) $ () FRML _GJRD_ DLOG(RUSPMGS) = (RUSPMGSU-RUSPMGSU(-1)) $ () () () EXPORT PRICES () FRML GRUSPXGSU RUSPXGSU = XRUSDNK*LOG(DNKPMGS/RUSEXCH*DNKEXCH) + XRUSSWE*LOG(SWEPMGS/RUSEXCH*SWEEXCH) + XRUSNOR*LOG(NORPMGS/RUSEXCH*NOREXCH) + XRUSFIN*LOG(FINPMGS/RUSEXCH*FINEXCH) + XRUSNLD*LOG(NLDPMGS/RUSEXCH*NLDEXCH) + XRUSGBR*LOG(GBRPMGS/RUSEXCH*GBREXCH) + XRUSESP*LOG(ESPPMGS/RUSEXCH*ESPEXCH) + XRUSDEU*LOG(DEUPMGS/RUSEXCH*DEUEXCH) + XRUSBEL*LOG(BELPMGS/RUSEXCH*BELEXCH) + XRUSFRA*LOG(FRAPMGS/RUSEXCH*FRAEXCH) + XRUSYPN*LOG(YPNPMGS/RUSEXCH*YPNEXCH) + XRUSITA*LOG(ITAPMGS/RUSEXCH*ITAEXCH) + XRUSUSA*LOG(USAPMGS/RUSEXCH*USAEXCH) + XRUSPOL*LOG(POLPMGS/RUSEXCH*POLEXCH) + XRUSAUS*LOG(AUSPMGS/RUSEXCH*AUSEXCH) + XRUSAUT*LOG(AUTPMGS/RUSEXCH*AUTEXCH) + XRUSCAN*LOG(CANPMGS/RUSEXCH*CANEXCH) + XRUSCHL*LOG(CHLPMGS/RUSEXCH*CHLEXCH) + XRUSEST*LOG(ESTPMGS/RUSEXCH*ESTEXCH) + XRUSGRC*LOG(GRCPMGS/RUSEXCH*GRCEXCH) + XRUSCZE*LOG(CZEPMGS/RUSEXCH*CZEEXCH) + XRUSHUN*LOG(HUNPMGS/RUSEXCH*HUNEXCH) + XRUSISL*LOG(ISLPMGS/RUSEXCH*ISLEXCH) + XRUSIRL*LOG(IRLPMGS/RUSEXCH*IRLEXCH) + XRUSISR*LOG(ISRPMGS/RUSEXCH*ISREXCH) + XRUSKOR*LOG(KORPMGS/RUSEXCH*KOREXCH) + XRUSLUX*LOG(LUXPMGS/RUSEXCH*LUXEXCH) + XRUSMEX*LOG(MEXPMGS/RUSEXCH*MEXEXCH) + XRUSNZL*LOG(NZLPMGS/RUSEXCH*NZLEXCH) + XRUSPRT*LOG(PRTPMGS/RUSEXCH*PRTEXCH) + XRUSSVK*LOG(SVKPMGS/RUSEXCH*SVKEXCH) + XRUSSVN*LOG(SVNPMGS/RUSEXCH*SVNEXCH) + XRUSCHE*LOG(CHEPMGS/RUSEXCH*CHEEXCH) + XRUSTUR*LOG(TURPMGS/RUSEXCH*TUREXCH) + XRUSDAE*LOG(DAEPMGS/RUSEXCH*DAEEXCH) + XRUSOOP*LOG(OOPPMGS/RUSEXCH*OOPEXCH) + XRUSBRA*LOG(BRAPMGS/RUSEXCH*BRAEXCH) + XRUSIND*LOG(INDPMGS/RUSEXCH*INDEXCH) + XRUSCHN*LOG(CHNPMGS/RUSEXCH*CHNEXCH) + XRUSIDN*LOG(IDNPMGS/RUSEXCH*IDNEXCH) + XRUSZAF*LOG(ZAFPMGS/RUSEXCH*ZAFEXCH) + XRUSRWD*LOG(RWDPMGS/RUSEXCH*RWDEXCH) $ () FRML _GJRD_ DLOG(RUSPXGS) = (RUSPXGSU-RUSPXGSU(-1)) $ () () () ******************* () * RWD * () ******************* () () EXPORT VOLUMES () FRML GRWDXGSDU RWDXGSDU = XRWDDNK*LOG(DNKMGSD) + XRWDSWE*LOG(SWEMGSD) + XRWDNOR*LOG(NORMGSD) + XRWDFIN*LOG(FINMGSD) + XRWDNLD*LOG(NLDMGSD) + XRWDGBR*LOG(GBRMGSD) + XRWDBEL*LOG(BELMGSD) + XRWDDEU*LOG(DEUMGSD) + XRWDFRA*LOG(FRAMGSD) + XRWDESP*LOG(ESPMGSD) + XRWDYPN*LOG(YPNMGSD) + XRWDITA*LOG(ITAMGSD) + XRWDUSA*LOG(USAMGSD) + XRWDPOL*LOG(POLMGSD) + XRWDAUS*LOG(AUSMGSD) + XRWDAUT*LOG(AUTMGSD) + XRWDCAN*LOG(CANMGSD) + XRWDCHL*LOG(CHLMGSD) + XRWDEST*LOG(ESTMGSD) + XRWDGRC*LOG(GRCMGSD) + XRWDCZE*LOG(CZEMGSD) + XRWDHUN*LOG(HUNMGSD) + XRWDISL*LOG(ISLMGSD) + XRWDIRL*LOG(IRLMGSD) + XRWDISR*LOG(ISRMGSD) + XRWDKOR*LOG(KORMGSD) + XRWDLUX*LOG(LUXMGSD) + XRWDMEX*LOG(MEXMGSD) + XRWDNZL*LOG(NZLMGSD) + XRWDPRT*LOG(PRTMGSD) + XRWDSVK*LOG(SVKMGSD) + XRWDSVN*LOG(SVNMGSD) + XRWDCHE*LOG(CHEMGSD) + XRWDTUR*LOG(TURMGSD) + XRWDDAE*LOG(DAEMGSD) + XRWDOOP*LOG(OOPMGSD) + XRWDBRA*LOG(BRAMGSD) + XRWDRUS*LOG(RUSMGSD) + XRWDIND*LOG(INDMGSD) + XRWDCHN*LOG(CHNMGSD) + XRWDIDN*LOG(IDNMGSD) + XRWDZAF*LOG(ZAFMGSD) $ FRML _GJRD DLOG(RWDXGSD) = (RWDXGSDU-RWDXGSDU(-1))$ FRML GRWDXGSV RWDXGSV = RWDXGSD*USAEXCH/(RWDEXCH*RWDPXGS) $ () () () IMPORT () FRML _GJRD_ DLOG(RWDMGSV) = 1.23991*DLOG(RWDXGSV) - 1.66525*DLOG(RWDPMGS/RWDPXGS) -0.50000*LOG(RWDMGSV(-1)/RWDXGSV(-1)) -1.22794*LOG(RWDPMGS(-1)/RWDPXGS(-1)) +0.06027 $ () FRML GRWDMGSD RWDMGSD = RWDMGSV*RWDPMGS*RWDEXCH/USAEXCH $ () () () IMPORT PRICES () () FRML GRWDPMGSU RWDPMGSU = MRWDDNK*LOG(DNKPXGS/RWDEXCH*DNKEXCH) + MRWDSWE*LOG(SWEPXGS/RWDEXCH*SWEEXCH) + MRWDNOR*LOG(NORPXGS/RWDEXCH*NOREXCH) + MRWDFIN*LOG(FINPXGS/RWDEXCH*FINEXCH) + MRWDNLD*LOG(NLDPXGS/RWDEXCH*NLDEXCH) + MRWDGBR*LOG(GBRPXGS/RWDEXCH*GBREXCH) + MRWDESP*LOG(ESPPXGS/RWDEXCH*ESPEXCH) + MRWDDEU*LOG(DEUPXGS/RWDEXCH*DEUEXCH) + MRWDBEL*LOG(BELPXGS/RWDEXCH*BELEXCH) + MRWDFRA*LOG(FRAPXGS/RWDEXCH*FRAEXCH) + MRWDYPN*LOG(YPNPXGS/RWDEXCH*YPNEXCH) + MRWDITA*LOG(ITAPXGS/RWDEXCH*ITAEXCH) + MRWDUSA*LOG(USAPXGS/RWDEXCH*USAEXCH) + MRWDPOL*LOG(POLPXGS/RWDEXCH*POLEXCH) + MRWDAUS*LOG(AUSPXGS/RWDEXCH*AUSEXCH) + MRWDAUT*LOG(AUTPXGS/RWDEXCH*AUTEXCH) + MRWDCAN*LOG(CANPXGS/RWDEXCH*CANEXCH) + MRWDCHL*LOG(CHLPXGS/RWDEXCH*CHLEXCH) + MRWDEST*LOG(ESTPXGS/RWDEXCH*ESTEXCH) + MRWDGRC*LOG(GRCPXGS/RWDEXCH*GRCEXCH) + MRWDCZE*LOG(CZEPXGS/RWDEXCH*CZEEXCH) + MRWDHUN*LOG(HUNPXGS/RWDEXCH*HUNEXCH) + MRWDISL*LOG(ISLPXGS/RWDEXCH*ISLEXCH) + MRWDIRL*LOG(IRLPXGS/RWDEXCH*IRLEXCH) + MRWDISR*LOG(ISRPXGS/RWDEXCH*ISREXCH) + MRWDKOR*LOG(KORPXGS/RWDEXCH*KOREXCH) + MRWDLUX*LOG(LUXPXGS/RWDEXCH*LUXEXCH) + MRWDMEX*LOG(MEXPXGS/RWDEXCH*MEXEXCH) + MRWDNZL*LOG(NZLPXGS/RWDEXCH*NZLEXCH) + MRWDPRT*LOG(PRTPXGS/RWDEXCH*PRTEXCH) + MRWDSVK*LOG(SVKPXGS/RWDEXCH*SVKEXCH) + MRWDSVN*LOG(SVNPXGS/RWDEXCH*SVNEXCH) + MRWDCHE*LOG(CHEPXGS/RWDEXCH*CHEEXCH) + MRWDTUR*LOG(TURPXGS/RWDEXCH*TUREXCH) + MRWDDAE*LOG(DAEPXGS/RWDEXCH*DAEEXCH) + MRWDOOP*LOG(OOPPXGS/RWDEXCH*OOPEXCH) + MRWDBRA*LOG(BRAPXGS/RWDEXCH*BRAEXCH) + MRWDRUS*LOG(RUSPXGS/RWDEXCH*RUSEXCH) + MRWDIND*LOG(INDPXGS/RWDEXCH*INDEXCH) + MRWDCHN*LOG(CHNPXGS/RWDEXCH*CHNEXCH) + MRWDIDN*LOG(IDNPXGS/RWDEXCH*IDNEXCH) + MRWDZAF*LOG(ZAFPXGS/RWDEXCH*ZAFEXCH) $ () FRML _GJRD_ DLOG(RWDPMGS) = (RWDPMGSU-RWDPMGSU(-1)) $ () () () EXPORT PRICES () FRML GRWDPXGSU RWDPXGSU = XRWDDNK*LOG(DNKPMGS/RWDEXCH*DNKEXCH) + XRWDSWE*LOG(SWEPMGS/RWDEXCH*SWEEXCH) + XRWDNOR*LOG(NORPMGS/RWDEXCH*NOREXCH) + XRWDFIN*LOG(FINPMGS/RWDEXCH*FINEXCH) + XRWDNLD*LOG(NLDPMGS/RWDEXCH*NLDEXCH) + XRWDGBR*LOG(GBRPMGS/RWDEXCH*GBREXCH) + XRWDESP*LOG(ESPPMGS/RWDEXCH*ESPEXCH) + XRWDDEU*LOG(DEUPMGS/RWDEXCH*DEUEXCH) + XRWDBEL*LOG(BELPMGS/RWDEXCH*BELEXCH) + XRWDFRA*LOG(FRAPMGS/RWDEXCH*FRAEXCH) + XRWDYPN*LOG(YPNPMGS/RWDEXCH*YPNEXCH) + XRWDITA*LOG(ITAPMGS/RWDEXCH*ITAEXCH) + XRWDUSA*LOG(USAPMGS/RWDEXCH*USAEXCH) + XRWDPOL*LOG(POLPMGS/RWDEXCH*POLEXCH) + XRWDAUS*LOG(AUSPMGS/RWDEXCH*AUSEXCH) + XRWDAUT*LOG(AUTPMGS/RWDEXCH*AUTEXCH) + XRWDCAN*LOG(CANPMGS/RWDEXCH*CANEXCH) + XRWDCHL*LOG(CHLPMGS/RWDEXCH*CHLEXCH) + XRWDEST*LOG(ESTPMGS/RWDEXCH*ESTEXCH) + XRWDGRC*LOG(GRCPMGS/RWDEXCH*GRCEXCH) + XRWDCZE*LOG(CZEPMGS/RWDEXCH*CZEEXCH) + XRWDHUN*LOG(HUNPMGS/RWDEXCH*HUNEXCH) + XRWDISL*LOG(ISLPMGS/RWDEXCH*ISLEXCH) + XRWDIRL*LOG(IRLPMGS/RWDEXCH*IRLEXCH) + XRWDISR*LOG(ISRPMGS/RWDEXCH*ISREXCH) + XRWDKOR*LOG(KORPMGS/RWDEXCH*KOREXCH) + XRWDLUX*LOG(LUXPMGS/RWDEXCH*LUXEXCH) + XRWDMEX*LOG(MEXPMGS/RWDEXCH*MEXEXCH) + XRWDNZL*LOG(NZLPMGS/RWDEXCH*NZLEXCH) + XRWDPRT*LOG(PRTPMGS/RWDEXCH*PRTEXCH) + XRWDSVK*LOG(SVKPMGS/RWDEXCH*SVKEXCH) + XRWDSVN*LOG(SVNPMGS/RWDEXCH*SVNEXCH) + XRWDCHE*LOG(CHEPMGS/RWDEXCH*CHEEXCH) + XRWDTUR*LOG(TURPMGS/RWDEXCH*TUREXCH) + XRWDDAE*LOG(DAEPMGS/RWDEXCH*DAEEXCH) + XRWDOOP*LOG(OOPPMGS/RWDEXCH*OOPEXCH) + XRWDBRA*LOG(BRAPMGS/RWDEXCH*BRAEXCH) + XRWDRUS*LOG(RUSPMGS/RWDEXCH*RUSEXCH) + XRWDIND*LOG(INDPMGS/RWDEXCH*INDEXCH) + XRWDCHN*LOG(CHNPMGS/RWDEXCH*CHNEXCH) + XRWDIDN*LOG(IDNPMGS/RWDEXCH*IDNEXCH) + XRWDZAF*LOG(ZAFPMGS/RWDEXCH*ZAFEXCH) $ () FRML _GJRD_ DLOG(RWDPXGS) = (RWDPXGSU-RWDPXGSU(-1)) $ () () () ******************* () * SVK * () ******************* () () EXPORT VOLUMES () FRML GSVKXGSDU SVKXGSDU = XSVKDNK*LOG(DNKMGSD) + XSVKSWE*LOG(SWEMGSD) + XSVKNOR*LOG(NORMGSD) + XSVKFIN*LOG(FINMGSD) + XSVKNLD*LOG(NLDMGSD) + XSVKGBR*LOG(GBRMGSD) + XSVKBEL*LOG(BELMGSD) + XSVKDEU*LOG(DEUMGSD) + XSVKFRA*LOG(FRAMGSD) + XSVKESP*LOG(ESPMGSD) + XSVKYPN*LOG(YPNMGSD) + XSVKITA*LOG(ITAMGSD) + XSVKUSA*LOG(USAMGSD) + XSVKPOL*LOG(POLMGSD) + XSVKAUS*LOG(AUSMGSD) + XSVKAUT*LOG(AUTMGSD) + XSVKCAN*LOG(CANMGSD) + XSVKCHL*LOG(CHLMGSD) + XSVKEST*LOG(ESTMGSD) + XSVKGRC*LOG(GRCMGSD) + XSVKCZE*LOG(CZEMGSD) + XSVKHUN*LOG(HUNMGSD) + XSVKISL*LOG(ISLMGSD) + XSVKIRL*LOG(IRLMGSD) + XSVKISR*LOG(ISRMGSD) + XSVKKOR*LOG(KORMGSD) + XSVKLUX*LOG(LUXMGSD) + XSVKMEX*LOG(MEXMGSD) + XSVKNZL*LOG(NZLMGSD) + XSVKPRT*LOG(PRTMGSD) + XSVKSVN*LOG(SVNMGSD) + XSVKCHE*LOG(CHEMGSD) + XSVKTUR*LOG(TURMGSD) + XSVKDAE*LOG(DAEMGSD) + XSVKOOP*LOG(OOPMGSD) + XSVKBRA*LOG(BRAMGSD) + XSVKRUS*LOG(RUSMGSD) + XSVKIND*LOG(INDMGSD) + XSVKCHN*LOG(CHNMGSD) + XSVKIDN*LOG(IDNMGSD) + XSVKZAF*LOG(ZAFMGSD) + XSVKRWD*LOG(RWDMGSD) $ FRML _GJRD DLOG(SVKXGSD) = (SVKXGSDU-SVKXGSDU(-1))$ FRML GSVKXGSV SVKXGSV = SVKXGSD*USAEXCH/(SVKEXCH*SVKPXGS) $ () () () IMPORT () FRML _GJRD_ DLOG(SVKMGSV) = 0.71324*DLOG(SVKXGSV) - 0.50000*DLOG(SVKPMGS/SVKPXGS) -0.31484*LOG(SVKMGSV(-1)/SVKXGSV(-1)) -2.18823*LOG(SVKPMGS(-1)/SVKPXGS(-1)) +0.06916 $ () FRML GSVKMGSD SVKMGSD = SVKMGSV*SVKPMGS*SVKEXCH/USAEXCH $ () () () IMPORT PRICES () () FRML GSVKPMGSU SVKPMGSU = MSVKDNK*LOG(DNKPXGS/SVKEXCH*DNKEXCH) + MSVKSWE*LOG(SWEPXGS/SVKEXCH*SWEEXCH) + MSVKNOR*LOG(NORPXGS/SVKEXCH*NOREXCH) + MSVKFIN*LOG(FINPXGS/SVKEXCH*FINEXCH) + MSVKNLD*LOG(NLDPXGS/SVKEXCH*NLDEXCH) + MSVKGBR*LOG(GBRPXGS/SVKEXCH*GBREXCH) + MSVKESP*LOG(ESPPXGS/SVKEXCH*ESPEXCH) + MSVKDEU*LOG(DEUPXGS/SVKEXCH*DEUEXCH) + MSVKBEL*LOG(BELPXGS/SVKEXCH*BELEXCH) + MSVKFRA*LOG(FRAPXGS/SVKEXCH*FRAEXCH) + MSVKYPN*LOG(YPNPXGS/SVKEXCH*YPNEXCH) + MSVKITA*LOG(ITAPXGS/SVKEXCH*ITAEXCH) + MSVKUSA*LOG(USAPXGS/SVKEXCH*USAEXCH) + MSVKPOL*LOG(POLPXGS/SVKEXCH*POLEXCH) + MSVKAUS*LOG(AUSPXGS/SVKEXCH*AUSEXCH) + MSVKAUT*LOG(AUTPXGS/SVKEXCH*AUTEXCH) + MSVKCAN*LOG(CANPXGS/SVKEXCH*CANEXCH) + MSVKCHL*LOG(CHLPXGS/SVKEXCH*CHLEXCH) + MSVKEST*LOG(ESTPXGS/SVKEXCH*ESTEXCH) + MSVKGRC*LOG(GRCPXGS/SVKEXCH*GRCEXCH) + MSVKCZE*LOG(CZEPXGS/SVKEXCH*CZEEXCH) + MSVKHUN*LOG(HUNPXGS/SVKEXCH*HUNEXCH) + MSVKISL*LOG(ISLPXGS/SVKEXCH*ISLEXCH) + MSVKIRL*LOG(IRLPXGS/SVKEXCH*IRLEXCH) + MSVKISR*LOG(ISRPXGS/SVKEXCH*ISREXCH) + MSVKKOR*LOG(KORPXGS/SVKEXCH*KOREXCH) + MSVKLUX*LOG(LUXPXGS/SVKEXCH*LUXEXCH) + MSVKMEX*LOG(MEXPXGS/SVKEXCH*MEXEXCH) + MSVKNZL*LOG(NZLPXGS/SVKEXCH*NZLEXCH) + MSVKPRT*LOG(PRTPXGS/SVKEXCH*PRTEXCH) + MSVKSVN*LOG(SVNPXGS/SVKEXCH*SVNEXCH) + MSVKCHE*LOG(CHEPXGS/SVKEXCH*CHEEXCH) + MSVKTUR*LOG(TURPXGS/SVKEXCH*TUREXCH) + MSVKDAE*LOG(DAEPXGS/SVKEXCH*DAEEXCH) + MSVKOOP*LOG(OOPPXGS/SVKEXCH*OOPEXCH) + MSVKBRA*LOG(BRAPXGS/SVKEXCH*BRAEXCH) + MSVKRUS*LOG(RUSPXGS/SVKEXCH*RUSEXCH) + MSVKIND*LOG(INDPXGS/SVKEXCH*INDEXCH) + MSVKCHN*LOG(CHNPXGS/SVKEXCH*CHNEXCH) + MSVKIDN*LOG(IDNPXGS/SVKEXCH*IDNEXCH) + MSVKZAF*LOG(ZAFPXGS/SVKEXCH*ZAFEXCH) + MSVKRWD*LOG(RWDPXGS/SVKEXCH*RWDEXCH) $ () FRML _GJRD_ DLOG(SVKPMGS) = (SVKPMGSU-SVKPMGSU(-1)) $ () () () EXPORT PRICES () FRML GSVKPXGSU SVKPXGSU = XSVKDNK*LOG(DNKPMGS/SVKEXCH*DNKEXCH) + XSVKSWE*LOG(SWEPMGS/SVKEXCH*SWEEXCH) + XSVKNOR*LOG(NORPMGS/SVKEXCH*NOREXCH) + XSVKFIN*LOG(FINPMGS/SVKEXCH*FINEXCH) + XSVKNLD*LOG(NLDPMGS/SVKEXCH*NLDEXCH) + XSVKGBR*LOG(GBRPMGS/SVKEXCH*GBREXCH) + XSVKESP*LOG(ESPPMGS/SVKEXCH*ESPEXCH) + XSVKDEU*LOG(DEUPMGS/SVKEXCH*DEUEXCH) + XSVKBEL*LOG(BELPMGS/SVKEXCH*BELEXCH) + XSVKFRA*LOG(FRAPMGS/SVKEXCH*FRAEXCH) + XSVKYPN*LOG(YPNPMGS/SVKEXCH*YPNEXCH) + XSVKITA*LOG(ITAPMGS/SVKEXCH*ITAEXCH) + XSVKUSA*LOG(USAPMGS/SVKEXCH*USAEXCH) + XSVKPOL*LOG(POLPMGS/SVKEXCH*POLEXCH) + XSVKAUS*LOG(AUSPMGS/SVKEXCH*AUSEXCH) + XSVKAUT*LOG(AUTPMGS/SVKEXCH*AUTEXCH) + XSVKCAN*LOG(CANPMGS/SVKEXCH*CANEXCH) + XSVKCHL*LOG(CHLPMGS/SVKEXCH*CHLEXCH) + XSVKEST*LOG(ESTPMGS/SVKEXCH*ESTEXCH) + XSVKGRC*LOG(GRCPMGS/SVKEXCH*GRCEXCH) + XSVKCZE*LOG(CZEPMGS/SVKEXCH*CZEEXCH) + XSVKHUN*LOG(HUNPMGS/SVKEXCH*HUNEXCH) + XSVKISL*LOG(ISLPMGS/SVKEXCH*ISLEXCH) + XSVKIRL*LOG(IRLPMGS/SVKEXCH*IRLEXCH) + XSVKISR*LOG(ISRPMGS/SVKEXCH*ISREXCH) + XSVKKOR*LOG(KORPMGS/SVKEXCH*KOREXCH) + XSVKLUX*LOG(LUXPMGS/SVKEXCH*LUXEXCH) + XSVKMEX*LOG(MEXPMGS/SVKEXCH*MEXEXCH) + XSVKNZL*LOG(NZLPMGS/SVKEXCH*NZLEXCH) + XSVKPRT*LOG(PRTPMGS/SVKEXCH*PRTEXCH) + XSVKSVN*LOG(SVNPMGS/SVKEXCH*SVNEXCH) + XSVKCHE*LOG(CHEPMGS/SVKEXCH*CHEEXCH) + XSVKTUR*LOG(TURPMGS/SVKEXCH*TUREXCH) + XSVKDAE*LOG(DAEPMGS/SVKEXCH*DAEEXCH) + XSVKOOP*LOG(OOPPMGS/SVKEXCH*OOPEXCH) + XSVKBRA*LOG(BRAPMGS/SVKEXCH*BRAEXCH) + XSVKRUS*LOG(RUSPMGS/SVKEXCH*RUSEXCH) + XSVKIND*LOG(INDPMGS/SVKEXCH*INDEXCH) + XSVKCHN*LOG(CHNPMGS/SVKEXCH*CHNEXCH) + XSVKIDN*LOG(IDNPMGS/SVKEXCH*IDNEXCH) + XSVKZAF*LOG(ZAFPMGS/SVKEXCH*ZAFEXCH) + XSVKRWD*LOG(RWDPMGS/SVKEXCH*RWDEXCH) $ () FRML _GJRD_ DLOG(SVKPXGS) = (SVKPXGSU-SVKPXGSU(-1)) $ () () () ******************* () * SVN * () ******************* () () EXPORT VOLUMES () FRML GSVNXGSDU SVNXGSDU = XSVNDNK*LOG(DNKMGSD) + XSVNSWE*LOG(SWEMGSD) + XSVNNOR*LOG(NORMGSD) + XSVNFIN*LOG(FINMGSD) + XSVNNLD*LOG(NLDMGSD) + XSVNGBR*LOG(GBRMGSD) + XSVNBEL*LOG(BELMGSD) + XSVNDEU*LOG(DEUMGSD) + XSVNFRA*LOG(FRAMGSD) + XSVNESP*LOG(ESPMGSD) + XSVNYPN*LOG(YPNMGSD) + XSVNITA*LOG(ITAMGSD) + XSVNUSA*LOG(USAMGSD) + XSVNPOL*LOG(POLMGSD) + XSVNAUS*LOG(AUSMGSD) + XSVNAUT*LOG(AUTMGSD) + XSVNCAN*LOG(CANMGSD) + XSVNCHL*LOG(CHLMGSD) + XSVNEST*LOG(ESTMGSD) + XSVNGRC*LOG(GRCMGSD) + XSVNCZE*LOG(CZEMGSD) + XSVNHUN*LOG(HUNMGSD) + XSVNISL*LOG(ISLMGSD) + XSVNIRL*LOG(IRLMGSD) + XSVNISR*LOG(ISRMGSD) + XSVNKOR*LOG(KORMGSD) + XSVNLUX*LOG(LUXMGSD) + XSVNMEX*LOG(MEXMGSD) + XSVNNZL*LOG(NZLMGSD) + XSVNPRT*LOG(PRTMGSD) + XSVNSVK*LOG(SVKMGSD) + XSVNCHE*LOG(CHEMGSD) + XSVNTUR*LOG(TURMGSD) + XSVNDAE*LOG(DAEMGSD) + XSVNOOP*LOG(OOPMGSD) + XSVNBRA*LOG(BRAMGSD) + XSVNRUS*LOG(RUSMGSD) + XSVNIND*LOG(INDMGSD) + XSVNCHN*LOG(CHNMGSD) + XSVNIDN*LOG(IDNMGSD) + XSVNZAF*LOG(ZAFMGSD) + XSVNRWD*LOG(RWDMGSD) $ FRML _GJRD DLOG(SVNXGSD) = (SVNXGSDU-SVNXGSDU(-1)) $ FRML GSVNXGSV SVNXGSV = SVNXGSD*USAEXCH/(SVNEXCH*SVNPXGS) $ () () () IMPORT () FRML _GJRD_ DLOG(SVNMGSV) = 1.02176*DLOG(SVNXGSV) - 0.50000*DLOG(SVNPMGS/SVNPXGS) -0.64841*LOG(SVNMGSV(-1)/SVNXGSV(-1)) -1.06992*LOG(SVNPMGS(-1)/SVNPXGS(-1)) -0.00083 + D1999*0.07419 $ () FRML GSVNMGSD SVNMGSD = SVNMGSV*SVNPMGS*SVNEXCH/USAEXCH $ () () () IMPORT PRICES () () FRML GSVNPMGSU SVNPMGSU = MSVNDNK*LOG(DNKPXGS/SVNEXCH*DNKEXCH) + MSVNSWE*LOG(SWEPXGS/SVNEXCH*SWEEXCH) + MSVNNOR*LOG(NORPXGS/SVNEXCH*NOREXCH) + MSVNFIN*LOG(FINPXGS/SVNEXCH*FINEXCH) + MSVNNLD*LOG(NLDPXGS/SVNEXCH*NLDEXCH) + MSVNGBR*LOG(GBRPXGS/SVNEXCH*GBREXCH) + MSVNESP*LOG(ESPPXGS/SVNEXCH*ESPEXCH) + MSVNDEU*LOG(DEUPXGS/SVNEXCH*DEUEXCH) + MSVNBEL*LOG(BELPXGS/SVNEXCH*BELEXCH) + MSVNFRA*LOG(FRAPXGS/SVNEXCH*FRAEXCH) + MSVNYPN*LOG(YPNPXGS/SVNEXCH*YPNEXCH) + MSVNITA*LOG(ITAPXGS/SVNEXCH*ITAEXCH) + MSVNUSA*LOG(USAPXGS/SVNEXCH*USAEXCH) + MSVNPOL*LOG(POLPXGS/SVNEXCH*POLEXCH) + MSVNAUS*LOG(AUSPXGS/SVNEXCH*AUSEXCH) + MSVNAUT*LOG(AUTPXGS/SVNEXCH*AUTEXCH) + MSVNCAN*LOG(CANPXGS/SVNEXCH*CANEXCH) + MSVNCHL*LOG(CHLPXGS/SVNEXCH*CHLEXCH) + MSVNEST*LOG(ESTPXGS/SVNEXCH*ESTEXCH) + MSVNGRC*LOG(GRCPXGS/SVNEXCH*GRCEXCH) + MSVNCZE*LOG(CZEPXGS/SVNEXCH*CZEEXCH) + MSVNHUN*LOG(HUNPXGS/SVNEXCH*HUNEXCH) + MSVNISL*LOG(ISLPXGS/SVNEXCH*ISLEXCH) + MSVNIRL*LOG(IRLPXGS/SVNEXCH*IRLEXCH) + MSVNISR*LOG(ISRPXGS/SVNEXCH*ISREXCH) + MSVNKOR*LOG(KORPXGS/SVNEXCH*KOREXCH) + MSVNLUX*LOG(LUXPXGS/SVNEXCH*LUXEXCH) + MSVNMEX*LOG(MEXPXGS/SVNEXCH*MEXEXCH) + MSVNNZL*LOG(NZLPXGS/SVNEXCH*NZLEXCH) + MSVNPRT*LOG(PRTPXGS/SVNEXCH*PRTEXCH) + MSVNSVK*LOG(SVKPXGS/SVNEXCH*SVKEXCH) + MSVNCHE*LOG(CHEPXGS/SVNEXCH*CHEEXCH) + MSVNTUR*LOG(TURPXGS/SVNEXCH*TUREXCH) + MSVNDAE*LOG(DAEPXGS/SVNEXCH*DAEEXCH) + MSVNOOP*LOG(OOPPXGS/SVNEXCH*OOPEXCH) + MSVNBRA*LOG(BRAPXGS/SVNEXCH*BRAEXCH) + MSVNRUS*LOG(RUSPXGS/SVNEXCH*RUSEXCH) + MSVNIND*LOG(INDPXGS/SVNEXCH*INDEXCH) + MSVNCHN*LOG(CHNPXGS/SVNEXCH*CHNEXCH) + MSVNIDN*LOG(IDNPXGS/SVNEXCH*IDNEXCH) + MSVNZAF*LOG(ZAFPXGS/SVNEXCH*ZAFEXCH) + MSVNRWD*LOG(RWDPXGS/SVNEXCH*RWDEXCH) $ () FRML _GJRD_ DLOG(SVNPMGS) = (SVNPMGSU-SVNPMGSU(-1)) $ () () () EXPORT PRICES () FRML GSVNPXGSU SVNPXGSU = XSVNDNK*LOG(DNKPMGS/SVNEXCH*DNKEXCH) + XSVNSWE*LOG(SWEPMGS/SVNEXCH*SWEEXCH) + XSVNNOR*LOG(NORPMGS/SVNEXCH*NOREXCH) + XSVNFIN*LOG(FINPMGS/SVNEXCH*FINEXCH) + XSVNNLD*LOG(NLDPMGS/SVNEXCH*NLDEXCH) + XSVNGBR*LOG(GBRPMGS/SVNEXCH*GBREXCH) + XSVNESP*LOG(ESPPMGS/SVNEXCH*ESPEXCH) + XSVNDEU*LOG(DEUPMGS/SVNEXCH*DEUEXCH) + XSVNBEL*LOG(BELPMGS/SVNEXCH*BELEXCH) + XSVNFRA*LOG(FRAPMGS/SVNEXCH*FRAEXCH) + XSVNYPN*LOG(YPNPMGS/SVNEXCH*YPNEXCH) + XSVNITA*LOG(ITAPMGS/SVNEXCH*ITAEXCH) + XSVNUSA*LOG(USAPMGS/SVNEXCH*USAEXCH) + XSVNPOL*LOG(POLPMGS/SVNEXCH*POLEXCH) + XSVNAUS*LOG(AUSPMGS/SVNEXCH*AUSEXCH) + XSVNAUT*LOG(AUTPMGS/SVNEXCH*AUTEXCH) + XSVNCAN*LOG(CANPMGS/SVNEXCH*CANEXCH) + XSVNCHL*LOG(CHLPMGS/SVNEXCH*CHLEXCH) + XSVNEST*LOG(ESTPMGS/SVNEXCH*ESTEXCH) + XSVNGRC*LOG(GRCPMGS/SVNEXCH*GRCEXCH) + XSVNCZE*LOG(CZEPMGS/SVNEXCH*CZEEXCH) + XSVNHUN*LOG(HUNPMGS/SVNEXCH*HUNEXCH) + XSVNISL*LOG(ISLPMGS/SVNEXCH*ISLEXCH) + XSVNIRL*LOG(IRLPMGS/SVNEXCH*IRLEXCH) + XSVNISR*LOG(ISRPMGS/SVNEXCH*ISREXCH) + XSVNKOR*LOG(KORPMGS/SVNEXCH*KOREXCH) + XSVNLUX*LOG(LUXPMGS/SVNEXCH*LUXEXCH) + XSVNMEX*LOG(MEXPMGS/SVNEXCH*MEXEXCH) + XSVNNZL*LOG(NZLPMGS/SVNEXCH*NZLEXCH) + XSVNPRT*LOG(PRTPMGS/SVNEXCH*PRTEXCH) + XSVNSVK*LOG(SVKPMGS/SVNEXCH*SVKEXCH) + XSVNCHE*LOG(CHEPMGS/SVNEXCH*CHEEXCH) + XSVNTUR*LOG(TURPMGS/SVNEXCH*TUREXCH) + XSVNDAE*LOG(DAEPMGS/SVNEXCH*DAEEXCH) + XSVNOOP*LOG(OOPPMGS/SVNEXCH*OOPEXCH) + XSVNBRA*LOG(BRAPMGS/SVNEXCH*BRAEXCH) + XSVNRUS*LOG(RUSPMGS/SVNEXCH*RUSEXCH) + XSVNIND*LOG(INDPMGS/SVNEXCH*INDEXCH) + XSVNCHN*LOG(CHNPMGS/SVNEXCH*CHNEXCH) + XSVNIDN*LOG(IDNPMGS/SVNEXCH*IDNEXCH) + XSVNZAF*LOG(ZAFPMGS/SVNEXCH*ZAFEXCH) + XSVNRWD*LOG(RWDPMGS/SVNEXCH*RWDEXCH) $ () FRML _GJRD_ DLOG(SVNPXGS) = (SVNPXGSU-SVNPXGSU(-1)) $ () () () ******************* () * TUR * () ******************* () () EXPORT VOLUMES () FRML GTURXGSDU TURXGSDU = XTURDNK*LOG(DNKMGSD) + XTURSWE*LOG(SWEMGSD) + XTURNOR*LOG(NORMGSD) + XTURFIN*LOG(FINMGSD) + XTURNLD*LOG(NLDMGSD) + XTURGBR*LOG(GBRMGSD) + XTURBEL*LOG(BELMGSD) + XTURDEU*LOG(DEUMGSD) + XTURFRA*LOG(FRAMGSD) + XTURESP*LOG(ESPMGSD) + XTURYPN*LOG(YPNMGSD) + XTURITA*LOG(ITAMGSD) + XTURUSA*LOG(USAMGSD) + XTURPOL*LOG(POLMGSD) + XTURAUS*LOG(AUSMGSD) + XTURAUT*LOG(AUTMGSD) + XTURCAN*LOG(CANMGSD) + XTURCHL*LOG(CHLMGSD) + XTUREST*LOG(ESTMGSD) + XTURGRC*LOG(GRCMGSD) + XTURCZE*LOG(CZEMGSD) + XTURHUN*LOG(HUNMGSD) + XTURISL*LOG(ISLMGSD) + XTURIRL*LOG(IRLMGSD) + XTURISR*LOG(ISRMGSD) + XTURKOR*LOG(KORMGSD) + XTURLUX*LOG(LUXMGSD) + XTURMEX*LOG(MEXMGSD) + XTURNZL*LOG(NZLMGSD) + XTURPRT*LOG(PRTMGSD) + XTURSVK*LOG(SVKMGSD) + XTURSVN*LOG(SVNMGSD) + XTURCHE*LOG(CHEMGSD) + XTURDAE*LOG(DAEMGSD) + XTUROOP*LOG(OOPMGSD) + XTURBRA*LOG(BRAMGSD) + XTURRUS*LOG(RUSMGSD) + XTURIND*LOG(INDMGSD) + XTURCHN*LOG(CHNMGSD) + XTURIDN*LOG(IDNMGSD) + XTURZAF*LOG(ZAFMGSD) + XTURRWD*LOG(RWDMGSD) $ FRML _GJRD DLOG(TURXGSD) = (TURXGSDU-TURXGSDU(-1))$ FRML GTURXGSV TURXGSV = TURXGSD*USAEXCH/(TUREXCH*TURPXGS) $ () () () IMPORT () FRML _GJRD_ DLOG(TURMGSV) = 0.27017*DLOG(TURXGSV) - 1.06023*DLOG(TURPMGS/TURPXGS) -0.21714*LOG(TURMGSV(-1)/TURXGSV(-1)) -0.50000*LOG(TURPMGS(-1)/TURPXGS(-1)) +0.11607 - D1994*0.39329 - D2001*0.33823 $ () FRML GTURMGSD TURMGSD = TURMGSV*TURPMGS*TUREXCH/USAEXCH $ () () () IMPORT PRICES () () FRML GTURPMGSU TURPMGSU = MTURDNK*LOG(DNKPXGS/TUREXCH*DNKEXCH) + MTURSWE*LOG(SWEPXGS/TUREXCH*SWEEXCH) + MTURNOR*LOG(NORPXGS/TUREXCH*NOREXCH) + MTURFIN*LOG(FINPXGS/TUREXCH*FINEXCH) + MTURNLD*LOG(NLDPXGS/TUREXCH*NLDEXCH) + MTURGBR*LOG(GBRPXGS/TUREXCH*GBREXCH) + MTURESP*LOG(ESPPXGS/TUREXCH*ESPEXCH) + MTURDEU*LOG(DEUPXGS/TUREXCH*DEUEXCH) + MTURBEL*LOG(BELPXGS/TUREXCH*BELEXCH) + MTURFRA*LOG(FRAPXGS/TUREXCH*FRAEXCH) + MTURYPN*LOG(YPNPXGS/TUREXCH*YPNEXCH) + MTURITA*LOG(ITAPXGS/TUREXCH*ITAEXCH) + MTURUSA*LOG(USAPXGS/TUREXCH*USAEXCH) + MTURPOL*LOG(POLPXGS/TUREXCH*POLEXCH) + MTURAUS*LOG(AUSPXGS/TUREXCH*AUSEXCH) + MTURAUT*LOG(AUTPXGS/TUREXCH*AUTEXCH) + MTURCAN*LOG(CANPXGS/TUREXCH*CANEXCH) + MTURCHL*LOG(CHLPXGS/TUREXCH*CHLEXCH) + MTUREST*LOG(ESTPXGS/TUREXCH*ESTEXCH) + MTURGRC*LOG(GRCPXGS/TUREXCH*GRCEXCH) + MTURCZE*LOG(CZEPXGS/TUREXCH*CZEEXCH) + MTURHUN*LOG(HUNPXGS/TUREXCH*HUNEXCH) + MTURISL*LOG(ISLPXGS/TUREXCH*ISLEXCH) + MTURIRL*LOG(IRLPXGS/TUREXCH*IRLEXCH) + MTURISR*LOG(ISRPXGS/TUREXCH*ISREXCH) + MTURKOR*LOG(KORPXGS/TUREXCH*KOREXCH) + MTURLUX*LOG(LUXPXGS/TUREXCH*LUXEXCH) + MTURMEX*LOG(MEXPXGS/TUREXCH*MEXEXCH) + MTURNZL*LOG(NZLPXGS/TUREXCH*NZLEXCH) + MTURPRT*LOG(PRTPXGS/TUREXCH*PRTEXCH) + MTURSVK*LOG(SVKPXGS/TUREXCH*SVKEXCH) + MTURSVN*LOG(SVNPXGS/TUREXCH*SVNEXCH) + MTURCHE*LOG(CHEPXGS/TUREXCH*CHEEXCH) + MTURDAE*LOG(DAEPXGS/TUREXCH*DAEEXCH) + MTUROOP*LOG(OOPPXGS/TUREXCH*OOPEXCH) + MTURBRA*LOG(BRAPXGS/TUREXCH*BRAEXCH) + MTURRUS*LOG(RUSPXGS/TUREXCH*RUSEXCH) + MTURIND*LOG(INDPXGS/TUREXCH*INDEXCH) + MTURCHN*LOG(CHNPXGS/TUREXCH*CHNEXCH) + MTURIDN*LOG(IDNPXGS/TUREXCH*IDNEXCH) + MTURZAF*LOG(ZAFPXGS/TUREXCH*ZAFEXCH) + MTURRWD*LOG(RWDPXGS/TUREXCH*RWDEXCH) $ () FRML _GJRD_ DLOG(TURPMGS) = (TURPMGSU-TURPMGSU(-1)) $ () () () EXPORT PRICES () FRML GTURPXGSU TURPXGSU = XTURDNK*LOG(DNKPMGS/TUREXCH*DNKEXCH) + XTURSWE*LOG(SWEPMGS/TUREXCH*SWEEXCH) + XTURNOR*LOG(NORPMGS/TUREXCH*NOREXCH) + XTURFIN*LOG(FINPMGS/TUREXCH*FINEXCH) + XTURNLD*LOG(NLDPMGS/TUREXCH*NLDEXCH) + XTURGBR*LOG(GBRPMGS/TUREXCH*GBREXCH) + XTURESP*LOG(ESPPMGS/TUREXCH*ESPEXCH) + XTURDEU*LOG(DEUPMGS/TUREXCH*DEUEXCH) + XTURBEL*LOG(BELPMGS/TUREXCH*BELEXCH) + XTURFRA*LOG(FRAPMGS/TUREXCH*FRAEXCH) + XTURYPN*LOG(YPNPMGS/TUREXCH*YPNEXCH) + XTURITA*LOG(ITAPMGS/TUREXCH*ITAEXCH) + XTURUSA*LOG(USAPMGS/TUREXCH*USAEXCH) + XTURPOL*LOG(POLPMGS/TUREXCH*POLEXCH) + XTURAUS*LOG(AUSPMGS/TUREXCH*AUSEXCH) + XTURAUT*LOG(AUTPMGS/TUREXCH*AUTEXCH) + XTURCAN*LOG(CANPMGS/TUREXCH*CANEXCH) + XTURCHL*LOG(CHLPMGS/TUREXCH*CHLEXCH) + XTUREST*LOG(ESTPMGS/TUREXCH*ESTEXCH) + XTURGRC*LOG(GRCPMGS/TUREXCH*GRCEXCH) + XTURCZE*LOG(CZEPMGS/TUREXCH*CZEEXCH) + XTURHUN*LOG(HUNPMGS/TUREXCH*HUNEXCH) + XTURISL*LOG(ISLPMGS/TUREXCH*ISLEXCH) + XTURIRL*LOG(IRLPMGS/TUREXCH*IRLEXCH) + XTURISR*LOG(ISRPMGS/TUREXCH*ISREXCH) + XTURKOR*LOG(KORPMGS/TUREXCH*KOREXCH) + XTURLUX*LOG(LUXPMGS/TUREXCH*LUXEXCH) + XTURMEX*LOG(MEXPMGS/TUREXCH*MEXEXCH) + XTURNZL*LOG(NZLPMGS/TUREXCH*NZLEXCH) + XTURPRT*LOG(PRTPMGS/TUREXCH*PRTEXCH) + XTURSVK*LOG(SVKPMGS/TUREXCH*SVKEXCH) + XTURSVN*LOG(SVNPMGS/TUREXCH*SVNEXCH) + XTURCHE*LOG(CHEPMGS/TUREXCH*CHEEXCH) + XTURDAE*LOG(DAEPMGS/TUREXCH*DAEEXCH) + XTUROOP*LOG(OOPPMGS/TUREXCH*OOPEXCH) + XTURBRA*LOG(BRAPMGS/TUREXCH*BRAEXCH) + XTURRUS*LOG(RUSPMGS/TUREXCH*RUSEXCH) + XTURIND*LOG(INDPMGS/TUREXCH*INDEXCH) + XTURCHN*LOG(CHNPMGS/TUREXCH*CHNEXCH) + XTURIDN*LOG(IDNPMGS/TUREXCH*IDNEXCH) + XTURZAF*LOG(ZAFPMGS/TUREXCH*ZAFEXCH) + XTURRWD*LOG(RWDPMGS/TUREXCH*RWDEXCH) $ () FRML _GJRD_ DLOG(TURPXGS) = (TURPXGSU-TURPXGSU(-1)) $ () () () ******************* () * ZAF * () ******************* () () EXPORT VOLUMES () FRML GZAFXGSDU ZAFXGSDU = XZAFDNK*LOG(DNKMGSD) + XZAFSWE*LOG(SWEMGSD) + XZAFNOR*LOG(NORMGSD) + XZAFFIN*LOG(FINMGSD) + XZAFNLD*LOG(NLDMGSD) + XZAFGBR*LOG(GBRMGSD) + XZAFBEL*LOG(BELMGSD) + XZAFDEU*LOG(DEUMGSD) + XZAFFRA*LOG(FRAMGSD) + XZAFESP*LOG(ESPMGSD) + XZAFYPN*LOG(YPNMGSD) + XZAFITA*LOG(ITAMGSD) + XZAFUSA*LOG(USAMGSD) + XZAFPOL*LOG(POLMGSD) + XZAFAUS*LOG(AUSMGSD) + XZAFAUT*LOG(AUTMGSD) + XZAFCAN*LOG(CANMGSD) + XZAFCHL*LOG(CHLMGSD) + XZAFEST*LOG(ESTMGSD) + XZAFGRC*LOG(GRCMGSD) + XZAFCZE*LOG(CZEMGSD) + XZAFHUN*LOG(HUNMGSD) + XZAFISL*LOG(ISLMGSD) + XZAFIRL*LOG(IRLMGSD) + XZAFISR*LOG(ISRMGSD) + XZAFKOR*LOG(KORMGSD) + XZAFLUX*LOG(LUXMGSD) + XZAFMEX*LOG(MEXMGSD) + XZAFNZL*LOG(NZLMGSD) + XZAFPRT*LOG(PRTMGSD) + XZAFSVK*LOG(SVKMGSD) + XZAFSVN*LOG(SVNMGSD) + XZAFCHE*LOG(CHEMGSD) + XZAFTUR*LOG(TURMGSD) + XZAFDAE*LOG(DAEMGSD) + XZAFOOP*LOG(OOPMGSD) + XZAFBRA*LOG(BRAMGSD) + XZAFRUS*LOG(RUSMGSD) + XZAFIND*LOG(INDMGSD) + XZAFCHN*LOG(CHNMGSD) + XZAFIDN*LOG(IDNMGSD) + XZAFRWD*LOG(RWDMGSD) $ FRML _GJRD DLOG(ZAFXGSD) = (ZAFXGSDU-ZAFXGSDU(-1)) $ FRML GZAFXGSV ZAFXGSV = ZAFXGSD*USAEXCH/(ZAFEXCH*ZAFPXGS) $ () () () IMPORT () FRML _GJRD_ DLOG(ZAFMGSV) = 1.05913*DLOG(ZAFXGSV) - 1.76384*DLOG(ZAFPMGS/ZAFPXGS) -0.67757*LOG(ZAFMGSV(-1)/ZAFXGSV(-1)) -1.00849*LOG(ZAFPMGS(-1)/ZAFPXGS(-1)) +0.02242 $ () FRML GZAFMGSD ZAFMGSD = ZAFMGSV*ZAFPMGS*ZAFEXCH/USAEXCH $ () () () IMPORT PRICES () () FRML GZAFPMGSU ZAFPMGSU = MZAFDNK*LOG(DNKPXGS/ZAFEXCH*DNKEXCH) + MZAFSWE*LOG(SWEPXGS/ZAFEXCH*SWEEXCH) + MZAFNOR*LOG(NORPXGS/ZAFEXCH*NOREXCH) + MZAFFIN*LOG(FINPXGS/ZAFEXCH*FINEXCH) + MZAFNLD*LOG(NLDPXGS/ZAFEXCH*NLDEXCH) + MZAFGBR*LOG(GBRPXGS/ZAFEXCH*GBREXCH) + MZAFESP*LOG(ESPPXGS/ZAFEXCH*ESPEXCH) + MZAFDEU*LOG(DEUPXGS/ZAFEXCH*DEUEXCH) + MZAFBEL*LOG(BELPXGS/ZAFEXCH*BELEXCH) + MZAFFRA*LOG(FRAPXGS/ZAFEXCH*FRAEXCH) + MZAFYPN*LOG(YPNPXGS/ZAFEXCH*YPNEXCH) + MZAFITA*LOG(ITAPXGS/ZAFEXCH*ITAEXCH) + MZAFUSA*LOG(USAPXGS/ZAFEXCH*USAEXCH) + MZAFPOL*LOG(POLPXGS/ZAFEXCH*POLEXCH) + MZAFAUS*LOG(AUSPXGS/ZAFEXCH*AUSEXCH) + MZAFAUT*LOG(AUTPXGS/ZAFEXCH*AUTEXCH) + MZAFCAN*LOG(CANPXGS/ZAFEXCH*CANEXCH) + MZAFCHL*LOG(CHLPXGS/ZAFEXCH*CHLEXCH) + MZAFEST*LOG(ESTPXGS/ZAFEXCH*ESTEXCH) + MZAFGRC*LOG(GRCPXGS/ZAFEXCH*GRCEXCH) + MZAFCZE*LOG(CZEPXGS/ZAFEXCH*CZEEXCH) + MZAFHUN*LOG(HUNPXGS/ZAFEXCH*HUNEXCH) + MZAFISL*LOG(ISLPXGS/ZAFEXCH*ISLEXCH) + MZAFIRL*LOG(IRLPXGS/ZAFEXCH*IRLEXCH) + MZAFISR*LOG(ISRPXGS/ZAFEXCH*ISREXCH) + MZAFKOR*LOG(KORPXGS/ZAFEXCH*KOREXCH) + MZAFLUX*LOG(LUXPXGS/ZAFEXCH*LUXEXCH) + MZAFMEX*LOG(MEXPXGS/ZAFEXCH*MEXEXCH) + MZAFNZL*LOG(NZLPXGS/ZAFEXCH*NZLEXCH) + MZAFPRT*LOG(PRTPXGS/ZAFEXCH*PRTEXCH) + MZAFSVK*LOG(SVKPXGS/ZAFEXCH*SVKEXCH) + MZAFSVN*LOG(SVNPXGS/ZAFEXCH*SVNEXCH) + MZAFCHE*LOG(CHEPXGS/ZAFEXCH*CHEEXCH) + MZAFTUR*LOG(TURPXGS/ZAFEXCH*TUREXCH) + MZAFDAE*LOG(DAEPXGS/ZAFEXCH*DAEEXCH) + MZAFOOP*LOG(OOPPXGS/ZAFEXCH*OOPEXCH) + MZAFBRA*LOG(BRAPXGS/ZAFEXCH*BRAEXCH) + MZAFRUS*LOG(RUSPXGS/ZAFEXCH*RUSEXCH) + MZAFIND*LOG(INDPXGS/ZAFEXCH*INDEXCH) + MZAFCHN*LOG(CHNPXGS/ZAFEXCH*CHNEXCH) + MZAFIDN*LOG(IDNPXGS/ZAFEXCH*IDNEXCH) + MZAFRWD*LOG(RWDPXGS/ZAFEXCH*RWDEXCH) $ () FRML _GJRD_ DLOG(ZAFPMGS) = (ZAFPMGSU-ZAFPMGSU(-1)) $ () () () EXPORT PRICES () FRML GZAFPXGSU ZAFPXGSU = XZAFDNK*LOG(DNKPMGS/ZAFEXCH*DNKEXCH) + XZAFSWE*LOG(SWEPMGS/ZAFEXCH*SWEEXCH) + XZAFNOR*LOG(NORPMGS/ZAFEXCH*NOREXCH) + XZAFFIN*LOG(FINPMGS/ZAFEXCH*FINEXCH) + XZAFNLD*LOG(NLDPMGS/ZAFEXCH*NLDEXCH) + XZAFGBR*LOG(GBRPMGS/ZAFEXCH*GBREXCH) + XZAFESP*LOG(ESPPMGS/ZAFEXCH*ESPEXCH) + XZAFDEU*LOG(DEUPMGS/ZAFEXCH*DEUEXCH) + XZAFBEL*LOG(BELPMGS/ZAFEXCH*BELEXCH) + XZAFFRA*LOG(FRAPMGS/ZAFEXCH*FRAEXCH) + XZAFYPN*LOG(YPNPMGS/ZAFEXCH*YPNEXCH) + XZAFITA*LOG(ITAPMGS/ZAFEXCH*ITAEXCH) + XZAFUSA*LOG(USAPMGS/ZAFEXCH*USAEXCH) + XZAFPOL*LOG(POLPMGS/ZAFEXCH*POLEXCH) + XZAFAUS*LOG(AUSPMGS/ZAFEXCH*AUSEXCH) + XZAFAUT*LOG(AUTPMGS/ZAFEXCH*AUTEXCH) + XZAFCAN*LOG(CANPMGS/ZAFEXCH*CANEXCH) + XZAFCHL*LOG(CHLPMGS/ZAFEXCH*CHLEXCH) + XZAFEST*LOG(ESTPMGS/ZAFEXCH*ESTEXCH) + XZAFGRC*LOG(GRCPMGS/ZAFEXCH*GRCEXCH) + XZAFCZE*LOG(CZEPMGS/ZAFEXCH*CZEEXCH) + XZAFHUN*LOG(HUNPMGS/ZAFEXCH*HUNEXCH) + XZAFISL*LOG(ISLPMGS/ZAFEXCH*ISLEXCH) + XZAFIRL*LOG(IRLPMGS/ZAFEXCH*IRLEXCH) + XZAFISR*LOG(ISRPMGS/ZAFEXCH*ISREXCH) + XZAFKOR*LOG(KORPMGS/ZAFEXCH*KOREXCH) + XZAFLUX*LOG(LUXPMGS/ZAFEXCH*LUXEXCH) + XZAFMEX*LOG(MEXPMGS/ZAFEXCH*MEXEXCH) + XZAFNZL*LOG(NZLPMGS/ZAFEXCH*NZLEXCH) + XZAFPRT*LOG(PRTPMGS/ZAFEXCH*PRTEXCH) + XZAFSVK*LOG(SVKPMGS/ZAFEXCH*SVKEXCH) + XZAFSVN*LOG(SVNPMGS/ZAFEXCH*SVNEXCH) + XZAFCHE*LOG(CHEPMGS/ZAFEXCH*CHEEXCH) + XZAFTUR*LOG(TURPMGS/ZAFEXCH*TUREXCH) + XZAFDAE*LOG(DAEPMGS/ZAFEXCH*DAEEXCH) + XZAFOOP*LOG(OOPPMGS/ZAFEXCH*OOPEXCH) + XZAFBRA*LOG(BRAPMGS/ZAFEXCH*BRAEXCH) + XZAFRUS*LOG(RUSPMGS/ZAFEXCH*RUSEXCH) + XZAFIND*LOG(INDPMGS/ZAFEXCH*INDEXCH) + XZAFCHN*LOG(CHNPMGS/ZAFEXCH*CHNEXCH) + XZAFIDN*LOG(IDNPMGS/ZAFEXCH*IDNEXCH) + XZAFRWD*LOG(RWDPMGS/ZAFEXCH*RWDEXCH) $ () FRML _GJRD_ DLOG(ZAFPXGS) = (ZAFPXGSU-ZAFPXGSU(-1)) $ () *********************************** () * HER STARTER BSU DELEN * () *********************************** () AFTER $ () () Basis†ret er 2009 i det f›lgende () () LANDENES CENTRALKURSER IFT EURO ER INDSAT DIREKTE: () FRA EO71 ER EUROLANDENES SERIER I EURO () DET ER DERFOR KUN IKKE EUROLANDE DER SKAL OMREGNES () 7.46038 DANSKE KRONER () 40.3399 BELGISKE FRANC () 1.95583 D-MARK () 166.386 SPANSKE PESETAS () 6.55957 FRANSKE FRANC () 1936.27 ITALIENSKE LIRE () 2.20371 HOLLANDSE GYLDEN () 5.94573 FINSKE MARK () () FOR SVERIGE, NORGE, UK, USA OG JAPAN BRUGES DEN GENNEMSNITLIGE VALUTAKURS () V’RDIERNE ER: SVERIGE NU:9.1773 FØR:9.28353 () NORGE NU:8.2947 FØR:9.02091 () ENGLAND NU:0.6676 FØR:0.62151 () USA NU:1.1949 FØR:0.89179 () JAPAN NU:129.6446 FØR:108.708 () () BEM’RK ALLE DEFLATORERNE SKAL GES IGENNEM () DEFLATORERNE PASSER TIL PROGNOSEBANKEN () DEFLATORER REGNES NU UD, OG HEDDER BXXXXXX () - OG VALUTAKURSEN UDENFOR CENTRALKURSEN (ER IKKE GJORT) () () DANMARK () FRML IDNKPGDP DNKPGDP = DNKGDP/DNKGDPV $ () DEFLATOR FRML IDNKCPV1 DNKCPV1 = DNKCPV*BDNKPCP*dnkexch/eurexc $ () PCP FRML IDNKIPV1 DNKIPV1 = DNKIPV*BDNKPIB*dnkexch/eurexc $ () PIB FRML IDNKISKV1 DNKISKV1 = DNKISKV*BDNKPISK*dnkexch/eurexc $ () PISK FRML IDNKGDPV1 DNKGDPV1 = DNKGDPV*BDNKPGDP*dnkexch/eurexc $ () PGDP FRML IDNKIGV1 DNKIGV1 = DNKIGV*BDNKPIG*dnkexch/eurexc $ () PIG FRML IDNKCGV1 DNKCGV1 = DNKCGV*BDNKPCG*dnkexch/eurexc $ () PCG FRML IDNKXGSV1 DNKXGSV1 = DNKXGSV*BDNKPXG*dnkexch/eurexc $ () PXGS FRML IDNKMGSV1 DNKMGSV1 = DNKMGSV*BDNKPMG*dnkexch/eurexc $ () PMGS FRML IDNKYFBV1 DNKYFBV1 = DNKYFBV*BDNKPYFB*dnkexch/eurexc $ () PYFB FRML IDNKPCP1 DNKPCP1 = DNKPCP/BDNKPCP*100 $ () PCP FRML IDNKCP1 DNKCP1 = ((DNKCPV1*DNKPCP1)/100) $ () PCP FRML IDNKWR1 DNKWR1 = DNKWR/BDNKWR*100 $ () WR FRML IDNKPYFB1 DNKPYFB1 = DNKPYFB/BDNKPYFB*100 $ FRML IDNKNLG1 DNKNLG1 = DNKNLG*dnkexch/eurexc $ FRML IDNKCB1 DNKCB1 = DNKCB*dnkexch/eurexc $ FRML IDNKGDP1 DNKGDP1 = DNKGDP*dnkexch/eurexc $ FRML IDNKEX1 DNKEX1 = XDNKSWE*LOG(DNKEXCH/SWEEXCH) + XDNKNOR*LOG(DNKEXCH/NOREXCH) + XDNKFIN*LOG(DNKEXCH/FINEXCH) + XDNKDEU*LOG(DNKEXCH/DEUEXCH) + XDNKGBR*LOG(DNKEXCH/GBREXCH) + XDNKFRA*LOG(DNKEXCH/FRAEXCH) + XDNKITA*LOG(DNKEXCH/ITAEXCH) + XDNKBEL*LOG(DNKEXCH/BELEXCH) + XDNKNLD*LOG(DNKEXCH/NLDEXCH) + XDNKESP*LOG(DNKEXCH/ESPEXCH) + XDNKYPN*LOG(DNKEXCH/YPNEXCH) + XDNKUSA*LOG(DNKEXCH/USAEXCH) + XDNKPOL*LOG(DNKEXCH/POLEXCH) + XDNKCZE*LOG(DNKEXCH/CZEEXCH) + XDNKAUS*LOG(DNKEXCH/AUSEXCH) + XDNKAUT*LOG(DNKEXCH/AUTEXCH) + XDNKCAN*LOG(DNKEXCH/CANEXCH) + XDNKCHL*LOG(DNKEXCH/CHLEXCH) + XDNKEST*LOG(DNKEXCH/ESTEXCH) + XDNKGRC*LOG(DNKEXCH/GRCEXCH) + XDNKHUN*LOG(DNKEXCH/HUNEXCH) + XDNKISL*LOG(DNKEXCH/ISLEXCH) + XDNKIRL*LOG(DNKEXCH/IRLEXCH) + XDNKISR*LOG(DNKEXCH/ISREXCH) + XDNKKOR*LOG(DNKEXCH/KOREXCH) + XDNKLUX*LOG(DNKEXCH/LUXEXCH) + XDNKMEX*LOG(DNKEXCH/MEXEXCH) + XDNKNZL*LOG(DNKEXCH/NZLEXCH) + XDNKPRT*LOG(DNKEXCH/PRTEXCH) + XDNKSVK*LOG(DNKEXCH/SVKEXCH) + XDNKSVN*LOG(DNKEXCH/SVNEXCH) + XDNKCHE*LOG(DNKEXCH/CHEEXCH) + XDNKTUR*LOG(DNKEXCH/TUREXCH) + XDNKDAE*LOG(DNKEXCH/DAEEXCH) + XDNKOOP*LOG(DNKEXCH/OOPEXCH) + XDNKBRA*LOG(DNKEXCH/BRAEXCH) + XDNKRUS*LOG(DNKEXCH/RUSEXCH) + XDNKIND*LOG(DNKEXCH/INDEXCH) + XDNKCHN*LOG(DNKEXCH/CHNEXCH) + XDNKIDN*LOG(DNKEXCH/IDNEXCH) + XDNKZAF*LOG(DNKEXCH/ZAFEXCH) + XDNKRWD*LOG(DNKEXCH/RWDEXCH) $ FRML IDNKEX DNKEX = EXP(DNKEX1-BDNKEX1)*100 $ FRML IDNKDDV1 DNKDDV1 = DNKCPV1+DNKIPV1+DNKIGV1+DNKCGV1+DNKISKV1 $ FRML IDNKDV1 DNKDV1 = DNKCPV1+DNKIPV1+DNKIGV1+DNKCGV1+DNKXGSV1+DNKISKV1 $ FRML IDNKTIV1 DNKTIV1 = DNKTI/DNKPGDP*BDNKPGDP*dnkexch/eurexc $ () PGDP FRML IDNKYFV1 DNKYFV1 = DNKYF/DNKPGDP*BDNKPGDP*dnkexch/eurexc $ () PGDP FRML IDNKGNFL1 DNKGNFL1 = DNKGNFL*dnkexch/eurexc $ FRML IDNKREXCH DNKREXCH = (DNKPXGS/BDNKPXG)/(DNKPMGS/BDNKPMG)*100 $ () PXGS OG PMGS FRML IDNKBGNFL DNKBGNFL = DNKGNFL/DNKGDP*100 $ () () SVERIGE () FRML ISWEPGDP SWEPGDP = SWEGDP/SWEGDPV $ () DEFLATOR FRML ISWECPV1 SWECPV1 = SWECPV*BSWEPCP/BSWEEXC $ () PCP FRML ISWEIPV1 SWEIPV1 = SWEIPV*BSWEPIB/BSWEEXC $ () PIB FRML ISWEISKV1 SWEISKV1 = SWEISKV*BSWEPISK/BSWEEXC $ () PISK FRML ISWEGDPV1 SWEGDPV1 = SWEGDPV*BSWEPGDP/BSWEEXC $ () PGDP FRML ISWEIGV1 SWEIGV1 = SWEIGV*BSWEPIG/BSWEEXC $ () PIG FRML ISWECGV1 SWECGV1 = SWECGV*BSWEPCG/BSWEEXC $ () PCG FRML ISWEXGSV1 SWEXGSV1 = SWEXGSV*BSWEPXG/BSWEEXC $ () PXGS FRML ISWEMGSV1 SWEMGSV1 = SWEMGSV*BSWEPMG/BSWEEXC $ () PMGS FRML ISWEYFBV1 SWEYFBV1 = SWEYFBV*BSWEPYFB/BSWEEXC $ FRML ISWEPCP1 SWEPCP1 = SWEPCP/BSWEPCP*100 $ () PCP FRML ISWECP1 SWECP1 = ((SWECPV1*SWEPCP1)/100) $ () PCP FRML ISWEWR1 SWEWR1 = SWEWR/BSWEWR*100 $ () WR FRML ISWEPYFB1 SWEPYFB1 = SWEPYFB/BSWEPYFB*100 $ FRML ISWENLG1 SWENLG1 = SWENLG/BSWEEXC $ FRML ISWECB1 SWECB1 = SWECB/BSWEEXC $ FRML ISWEGDP1 SWEGDP1 = SWEGDP/BSWEEXC $ FRML ISWEEX1 SWEEX1 = XSWEDNK*LOG(SWEEXCH/DNKEXCH) + XSWENOR*LOG(SWEEXCH/NOREXCH) + XSWEFIN*LOG(SWEEXCH/FINEXCH) + XSWEDEU*LOG(SWEEXCH/DEUEXCH) + XSWEGBR*LOG(SWEEXCH/GBREXCH) + XSWEFRA*LOG(SWEEXCH/FRAEXCH) + XSWEITA*LOG(SWEEXCH/ITAEXCH) + XSWEBEL*LOG(SWEEXCH/BELEXCH) + XSWENLD*LOG(SWEEXCH/NLDEXCH) + XSWEESP*LOG(SWEEXCH/ESPEXCH) + XSWEYPN*LOG(SWEEXCH/YPNEXCH) + XSWEUSA*LOG(SWEEXCH/USAEXCH) + XSWEPOL*LOG(SWEEXCH/POLEXCH) + XSWECZE*LOG(SWEEXCH/CZEEXCH) + XSWEAUS*LOG(SWEEXCH/AUSEXCH) + XSWEAUT*LOG(SWEEXCH/AUTEXCH) + XSWECAN*LOG(SWEEXCH/CANEXCH) + XSWECHL*LOG(SWEEXCH/CHLEXCH) + XSWEEST*LOG(SWEEXCH/ESTEXCH) + XSWEGRC*LOG(SWEEXCH/GRCEXCH) + XSWEHUN*LOG(SWEEXCH/HUNEXCH) + XSWEISL*LOG(SWEEXCH/ISLEXCH) + XSWEIRL*LOG(SWEEXCH/IRLEXCH) + XSWEISR*LOG(SWEEXCH/ISREXCH) + XSWEKOR*LOG(SWEEXCH/KOREXCH) + XSWELUX*LOG(SWEEXCH/LUXEXCH) + XSWEMEX*LOG(SWEEXCH/MEXEXCH) + XSWENZL*LOG(SWEEXCH/NZLEXCH) + XSWEPRT*LOG(SWEEXCH/PRTEXCH) + XSWESVK*LOG(SWEEXCH/SVKEXCH) + XSWESVN*LOG(SWEEXCH/SVNEXCH) + XSWECHE*LOG(SWEEXCH/CHEEXCH) + XSWETUR*LOG(SWEEXCH/TUREXCH) + XSWEDAE*LOG(SWEEXCH/DAEEXCH) + XSWEOOP*LOG(SWEEXCH/OOPEXCH) + XSWEBRA*LOG(SWEEXCH/BRAEXCH) + XSWERUS*LOG(SWEEXCH/RUSEXCH) + XSWEIND*LOG(SWEEXCH/INDEXCH) + XSWECHN*LOG(SWEEXCH/CHNEXCH) + XSWEIDN*LOG(SWEEXCH/IDNEXCH) + XSWEZAF*LOG(SWEEXCH/ZAFEXCH) + XSWERWD*LOG(SWEEXCH/RWDEXCH) $ FRML ISWEEX SWEEX = EXP(SWEEX1-BSWEEX1)*100 $ FRML ISWEDDV1 SWEDDV1 = SWECPV1+SWEIPV1+SWEIGV1+SWECGV1+SWEISKV1 $ FRML ISWEDV1 SWEDV1 = SWECPV1+SWEIPV1+SWEIGV1+SWECGV1+SWEXGSV1+SWEISKV1 $ FRML ISWETIV1 SWETIV1 = SWETI/SWEPGDP*BSWEPGDP/BSWEEXC $ FRML ISWEYFV1 SWEYFV1 = SWEYF/SWEPGDP*BSWEPGDP/BSWEEXC $ FRML ISWEGNFL1 SWEGNFL1 = SWEGNFL/BSWEEXC $ FRML ISWEREXCH SWEREXCH = (SWEPXGS/BSWEPXG)/(SWEPMGS*BSWEPMG)*100 $ FRML ISWEBGNFL SWEBGNFL = SWEGNFL/SWEGDP*100 $ () () NORGE () FRML INORPGDP NORPGDP = NORGDP/NORGDPV $ () DEFLATOR FRML INORCPV1 NORCPV1 = NORCPV*BNORPCP/BNOREXC $ () PCP FRML INORIPV1 NORIPV1 = NORIPV*BNORPIB/BNOREXC $ () PIB FRML INORISKV1 NORISKV1 = NORISKV*BNORPISK/BNOREXC $ () PISK FRML INORGDPV1 NORGDPV1 = NORGDPV*BNORPGDP/BNOREXC $ () PGDP FRML INORIGV1 NORIGV1 = NORIGV*BNORPIG/BNOREXC $ () PIG FRML INORCGV1 NORCGV1 = NORCGV*BNORPCG/BNOREXC $ () PCG FRML INORXGSV1 NORXGSV1 = NORXGSV*BNORPXG/BNOREXC $ () PXGS FRML INORMGSV1 NORMGSV1 = NORMGSV*BNORPMG/BNOREXC $ () PMGS FRML INORYFBV1 NORYFBV1 = NORYFBV*BNORPYFB/BNOREXC $ FRML INORPCP1 NORPCP1 = NORPCP/BNORPCP*100 $ () PCP FRML INORCP1 NORCP1 = ((NORCPV1*NORPCP1)/100) $ () PCP FRML INORWR1 NORWR1 = NORWR/BNORWR*100 $ () WR FRML INORPYFB1 NORPYFB1 = NORPYFB/BNORPYFB*100 $ FRML INORNLG1 NORNLG1 = NORNLG/BNOREXC $ FRML INORCB1 NORCB1 = NORCB/BNOREXC $ FRML INORGDP1 NORGDP1 = NORGDP/BNOREXC $ FRML INOREX1 NOREX1 = XNORDNK*LOG(NOREXCH/DNKEXCH) + XNORSWE*LOG(NOREXCH/SWEEXCH) + XNORFIN*LOG(NOREXCH/FINEXCH) + XNORDEU*LOG(NOREXCH/DEUEXCH) + XNORGBR*LOG(NOREXCH/GBREXCH) + XNORFRA*LOG(NOREXCH/FRAEXCH) + XNORITA*LOG(NOREXCH/ITAEXCH) + XNORBEL*LOG(NOREXCH/BELEXCH) + XNORNLD*LOG(NOREXCH/NLDEXCH) + XNORESP*LOG(NOREXCH/ESPEXCH) + XNORYPN*LOG(NOREXCH/YPNEXCH) + XNORUSA*LOG(NOREXCH/USAEXCH) + XNORPOL*LOG(NOREXCH/POLEXCH) + XNORCZE*LOG(NOREXCH/CZEEXCH) + XNORAUS*LOG(NOREXCH/AUSEXCH) + XNORAUT*LOG(NOREXCH/AUTEXCH) + XNORCAN*LOG(NOREXCH/CANEXCH) + XNORCHL*LOG(NOREXCH/CHLEXCH) + XNOREST*LOG(NOREXCH/ESTEXCH) + XNORGRC*LOG(NOREXCH/GRCEXCH) + XNORHUN*LOG(NOREXCH/HUNEXCH) + XNORISL*LOG(NOREXCH/ISLEXCH) + XNORIRL*LOG(NOREXCH/IRLEXCH) + XNORISR*LOG(NOREXCH/ISREXCH) + XNORKOR*LOG(NOREXCH/KOREXCH) + XNORLUX*LOG(NOREXCH/LUXEXCH) + XNORMEX*LOG(NOREXCH/MEXEXCH) + XNORNZL*LOG(NOREXCH/NZLEXCH) + XNORPRT*LOG(NOREXCH/PRTEXCH) + XNORSVK*LOG(NOREXCH/SVKEXCH) + XNORSVN*LOG(NOREXCH/SVNEXCH) + XNORCHE*LOG(NOREXCH/CHEEXCH) + XNORTUR*LOG(NOREXCH/TUREXCH) + XNORDAE*LOG(NOREXCH/DAEEXCH) + XNOROOP*LOG(NOREXCH/OOPEXCH) + XNORBRA*LOG(NOREXCH/BRAEXCH) + XNORRUS*LOG(NOREXCH/RUSEXCH) + XNORIND*LOG(NOREXCH/INDEXCH) + XNORCHN*LOG(NOREXCH/CHNEXCH) + XNORIDN*LOG(NOREXCH/IDNEXCH) + XNORZAF*LOG(NOREXCH/ZAFEXCH) + XNORRWD*LOG(NOREXCH/RWDEXCH) $ FRML INOREX NOREX = EXP(NOREX1-BNOREX1)*100 $ FRML INORDDV1 NORDDV1 = NORCPV1+NORIPV1+NORIGV1+NORCGV1 $ FRML INORDV1 NORDV1 = NORCPV1+NORIPV1+NORIGV1+NORCGV1+NORXGSV1 $ FRML INORTIV1 NORTIV1 = NORTI/NORPGDP*BNORPGDP/BNOREXC $ FRML INORYFV1 NORYFV1 = NORYF/NORPGDP*BNORPGDP/BNOREXC $ FRML INORGNFL1 NORGNFL1 = NORGNFL/BNOREXC $ FRML INORREXCH NORREXCH = (NORPXGS/BNORPXG)/(NORPMGS/BNORPMG)*100 $ FRML INORBGNFL NORBGNFL = NORGNFL/NORGDP*100 $ () () TYSKLAND () FRML IDEUPGDP DEUPGDP = DEUGDP/DEUGDPV $ () DEFLATOR FRML IDEUCPV1 DEUCPV1 = DEUCPV*BDEUPCP $ () PCP FRML IDEUIPV1 DEUIPV1 = DEUIPV*BDEUPIB $ () PIB FRML IDEUISKV1 DEUISKV1 = DEUISKV*BDEUPISK $ () PISK FRML IDEUGDPV1 DEUGDPV1 = DEUGDPV*BDEUPGDP $ () PGDP FRML IDEUIGV1 DEUIGV1 = DEUIGV*BDEUPIG $ () PIG FRML IDEUCGV1 DEUCGV1 = DEUCGV*BDEUPCG $ () PCG FRML IDEUXGSV1 DEUXGSV1 = DEUXGSV*BDEUPXG $ () PXGS FRML IDEUMGSV1 DEUMGSV1 = DEUMGSV*BDEUPMG $ () PMGS FRML IDEUYFBV1 DEUYFBV1 = DEUYFBV*BDEUPYFB $ FRML IDEUPCP1 DEUPCP1 = DEUPCP/BDEUPCP*100 $ () PCP FRML IDEUCP1 DEUCP1 = ((DEUCPV1*DEUPCP1)/100) $ () PCP FRML IDEUWR1 DEUWR1 = DEUWR/BDEUWR*100 $ () WR FRML IDEUPYFB1 DEUPYFB1 = DEUPYFB/BDEUPYFB*100 $ FRML IDEUNLG1 DEUNLG1 = DEUNLG $ FRML IDEUCB1 DEUCB1 = DEUCB $ FRML IDEUGDP1 DEUGDP1 = DEUGDP $ FRML IDEUEX1 DEUEX1 = XDEUDNK*LOG(DEUEXCH/DNKEXCH) + XDEUSWE*LOG(DEUEXCH/SWEEXCH) + XDEUNOR*LOG(DEUEXCH/NOREXCH) + XDEUFIN*LOG(DEUEXCH/FINEXCH) + XDEUGBR*LOG(DEUEXCH/GBREXCH) + XDEUFRA*LOG(DEUEXCH/FRAEXCH) + XDEUITA*LOG(DEUEXCH/ITAEXCH) + XDEUBEL*LOG(DEUEXCH/BELEXCH) + XDEUNLD*LOG(DEUEXCH/NLDEXCH) + XDEUESP*LOG(DEUEXCH/ESPEXCH) + XDEUYPN*LOG(DEUEXCH/YPNEXCH) + XDEUUSA*LOG(DEUEXCH/USAEXCH) + XDEUPOL*LOG(DEUEXCH/POLEXCH) + XDEUCZE*LOG(DEUEXCH/CZEEXCH) + XDEUAUS*LOG(DEUEXCH/AUSEXCH) + XDEUAUT*LOG(DEUEXCH/AUTEXCH) + XDEUCAN*LOG(DEUEXCH/CANEXCH) + XDEUCHL*LOG(DEUEXCH/CHLEXCH) + XDEUEST*LOG(DEUEXCH/ESTEXCH) + XDEUGRC*LOG(DEUEXCH/GRCEXCH) + XDEUHUN*LOG(DEUEXCH/HUNEXCH) + XDEUISL*LOG(DEUEXCH/ISLEXCH) + XDEUIRL*LOG(DEUEXCH/IRLEXCH) + XDEUISR*LOG(DEUEXCH/ISREXCH) + XDEUKOR*LOG(DEUEXCH/KOREXCH) + XDEULUX*LOG(DEUEXCH/LUXEXCH) + XDEUMEX*LOG(DEUEXCH/MEXEXCH) + XDEUNZL*LOG(DEUEXCH/NZLEXCH) + XDEUPRT*LOG(DEUEXCH/PRTEXCH) + XDEUSVK*LOG(DEUEXCH/SVKEXCH) + XDEUSVN*LOG(DEUEXCH/SVNEXCH) + XDEUCHE*LOG(DEUEXCH/CHEEXCH) + XDEUTUR*LOG(DEUEXCH/TUREXCH) + XDEUDAE*LOG(DEUEXCH/DAEEXCH) + XDEUOOP*LOG(DEUEXCH/OOPEXCH) + XDEUBRA*LOG(DEUEXCH/BRAEXCH) + XDEURUS*LOG(DEUEXCH/RUSEXCH) + XDEUIND*LOG(DEUEXCH/INDEXCH) + XDEUCHN*LOG(DEUEXCH/CHNEXCH) + XDEUIDN*LOG(DEUEXCH/IDNEXCH) + XDEUZAF*LOG(DEUEXCH/ZAFEXCH) + XDEURWD*LOG(DEUEXCH/RWDEXCH) $ FRML IDEUEX DEUEX = EXP(DEUEX1-BDEUEX1)*100 $ FRML IDEUDDV1 DEUDDV1 = DEUCPV1+DEUIPV1+DEUIGV1+DEUCGV1+DEUISKV1 $ FRML IDEUDV1 DEUDV1 = DEUCPV1+DEUIPV1+DEUIGV1+DEUCGV1+DEUXGSV1+DEUISKV1 $ FRML IDEUTIV1 DEUTIV1 = DEUTI/DEUPGDP*BDEUPGDP $ FRML IDEUYFV1 DEUYFV1 = DEUYF/DEUPGDP*BDEUPGDP $ FRML IDEUGNFL1 DEUGNFL1 = DEUGNFL $ FRML IDEUREXCH DEUREXCH = (DEUPXGS/BDEUPXG)/(DEUPMGS/BDEUPMG)*100 $ FRML IDEUBGNFL DEUBGNFL = DEUGNFL/DEUGDP*100 $ () () ENGLAND () FRML IGBRPGDP GBRPGDP = GBRGDP/GBRGDPV $ () DEFLATOR FRML IGBRCPV1 GBRCPV1 = GBRCPV*BGBRPCP/BGBREXC $ () PCP FRML IGBRIPV1 GBRIPV1 = GBRIPV*BGBRPIB/BGBREXC $ () PIB FRML IGBRISKV1 GBRISKV1 = GBRISKV*BGBRPISK/BGBREXC $ () PISK FRML IGBRGDPV1 GBRGDPV1 = GBRGDPV*BGBRPGDP/BGBREXC $ () PGDP FRML IGBRIGV1 GBRIGV1 = GBRIGV*BGBRPIG/BGBREXC $ () PIG FRML IGBRCGV1 GBRCGV1 = GBRCGV*BGBRPCG/BGBREXC $ () PCG FRML IGBRXGSV1 GBRXGSV1 = GBRXGSV*BGBRPXG/BGBREXC $ () PXGS FRML IGBRMGSV1 GBRMGSV1 = GBRMGSV*BGBRPMG/BGBREXC $ () PMGS FRML IGBRYFBV1 GBRYFBV1 = GBRYFBV*BGBRPYFB/BGBREXC $ FRML IGBRPCP1 GBRPCP1 = GBRPCP/BGBRPCP*100 $ () PCP FRML IGBRCP1 GBRCP1 = ((GBRCPV1*GBRPCP1)/100) $ () PCP FRML IGBRWR1 GBRWR1 = GBRWR/BGBRWR*100 $ () WR FRML IGBRPYFB1 GBRPYFB1 = GBRPYFB/BGBRPYFB*100 $ FRML IGBRNLG1 GBRNLG1 = GBRNLG/BGBREXC $ FRML IGBRCB1 GBRCB1 = GBRCB/BGBREXC $ FRML IGBRGDP1 GBRGDP1 = GBRGDP/BGBREXC $ FRML IGBREX1 GBREX1 = XGBRDNK*LOG(GBREXCH/DNKEXCH) + XGBRSWE*LOG(GBREXCH/SWEEXCH) + XGBRNOR*LOG(GBREXCH/NOREXCH) + XGBRFIN*LOG(GBREXCH/FINEXCH) + XGBRNLD*LOG(GBREXCH/NLDEXCH) + XGBRFRA*LOG(GBREXCH/FRAEXCH) + XGBRITA*LOG(GBREXCH/ITAEXCH) + XGBRDEU*LOG(GBREXCH/DEUEXCH) + XGBRBEL*LOG(GBREXCH/BELEXCH) + XGBRESP*LOG(GBREXCH/ESPEXCH) + XGBRYPN*LOG(GBREXCH/YPNEXCH) + XGBRUSA*LOG(GBREXCH/USAEXCH) + XGBRPOL*LOG(GBREXCH/POLEXCH) + XGBRCZE*LOG(GBREXCH/CZEEXCH) + XGBRAUS*LOG(GBREXCH/AUSEXCH) + XGBRAUT*LOG(GBREXCH/AUTEXCH) + XGBRCAN*LOG(GBREXCH/CANEXCH) + XGBRCHL*LOG(GBREXCH/CHLEXCH) + XGBREST*LOG(GBREXCH/ESTEXCH) + XGBRGRC*LOG(GBREXCH/GRCEXCH) + XGBRHUN*LOG(GBREXCH/HUNEXCH) + XGBRISL*LOG(GBREXCH/ISLEXCH) + XGBRIRL*LOG(GBREXCH/IRLEXCH) + XGBRISR*LOG(GBREXCH/ISREXCH) + XGBRKOR*LOG(GBREXCH/KOREXCH) + XGBRLUX*LOG(GBREXCH/LUXEXCH) + XGBRMEX*LOG(GBREXCH/MEXEXCH) + XGBRNZL*LOG(GBREXCH/NZLEXCH) + XGBRPRT*LOG(GBREXCH/PRTEXCH) + XGBRSVK*LOG(GBREXCH/SVKEXCH) + XGBRSVN*LOG(GBREXCH/SVNEXCH) + XGBRCHE*LOG(GBREXCH/CHEEXCH) + XGBRTUR*LOG(GBREXCH/TUREXCH) + XGBRDAE*LOG(GBREXCH/DAEEXCH) + XGBROOP*LOG(GBREXCH/OOPEXCH) + XGBRBRA*LOG(GBREXCH/BRAEXCH) + XGBRRUS*LOG(GBREXCH/RUSEXCH) + XGBRIND*LOG(GBREXCH/INDEXCH) + XGBRCHN*LOG(GBREXCH/CHNEXCH) + XGBRIDN*LOG(GBREXCH/IDNEXCH) + XGBRZAF*LOG(GBREXCH/ZAFEXCH) + XGBRRWD*LOG(GBREXCH/RWDEXCH) $ FRML IGBREX GBREX = EXP(GBREX1-BGBREX1)*100 $ FRML IGBRDDV1 GBRDDV1 = GBRCPV1+GBRIPV1+GBRIGV1+GBRCGV1+GBRISKV1 $ FRML IGBRDV1 GBRDV1 = GBRCPV1+GBRIPV1+GBRIGV1+GBRCGV1+GBRXGSV1+GBRISKV1 $ FRML IGBRTIV1 GBRTIV1 = GBRTI/GBRPGDP*BGBRPGDP/BGBREXC $ FRML IGBRYFV1 GBRYFV1 = GBRYF/GBRPGDP*BGBRPGDP/BGBREXC $ FRML IGBRGNFL1 GBRGNFL1 = GBRGNFL/BGBREXC $ FRML IGBRREXCH GBRREXCH = (GBRPXGS/BGBRPXG)/(GBRPMGS/BGBRPMG)*100 $ FRML IGBRBGNFL GBRBGNFL = GBRGNFL/GBRGDP*100 $ () () USA () FRML IUSAPGDP USAPGDP = USAGDP/USAGDPV $ () DEFLATOR FRML IUSACPV1 USACPV1 = USACPV*BUSAPCP/BUSAEXC $ () PCP FRML IUSAIPV1 USAIPV1 = USAIPV*BUSAPIB/BUSAEXC $ () PIB FRML IUSAISKV1 USAISKV1 = USAISKV*BUSAPISK/BUSAEXC $ () PISK FRML IUSAGDPV1 USAGDPV1 = USAGDPV*BUSAPGDP/BUSAEXC $ () PGDP FRML IUSAIGV1 USAIGV1 = USAIGV*BUSAPIG/BUSAEXC $ () PIG FRML IUSACGV1 USACGV1 = USACGV*BUSAPCG/BUSAEXC $ () PCG FRML IUSAXGSV1 USAXGSV1 = USAXGSV*BUSAPXG/BUSAEXC $ () PXGS FRML IUSAMGSV1 USAMGSV1 = USAMGSV*BUSAPMG/BUSAEXC $ () PMGS FRML IUSAYFBV1 USAYFBV1 = USAYFBV*BUSAPYFB/BUSAEXC $ FRML IUSAPCP1 USAPCP1 = USAPCP/BUSAPCP*100 $ () PCP FRML IUSACP1 USACP1 = ((USACPV1*USAPCP1)/100) $ () PCP FRML IUSAWR1 USAWR1 = USAWR/BUSAWR*100 $ () WR FRML IUSAPYFB1 USAPYFB1 = USAPYFB/BUSAPYFB*100 $ FRML IUSANLG1 USANLG1 = USANLG/BUSAEXC $ FRML IUSACB1 USACB1 = USACB/BUSAEXC $ FRML IUSAGDP1 USAGDP1 = USAGDP/BUSAEXC $ FRML IUSAEX1 USAEX1 = XUSADNK*LOG(USAEXCH/DNKEXCH) + XUSASWE*LOG(USAEXCH/SWEEXCH) + XUSANOR*LOG(USAEXCH/NOREXCH) + XUSAFIN*LOG(USAEXCH/FINEXCH) + XUSANLD*LOG(USAEXCH/NLDEXCH) + XUSAGBR*LOG(USAEXCH/GBREXCH) + XUSAESP*LOG(USAEXCH/ESPEXCH) + XUSADEU*LOG(USAEXCH/DEUEXCH) + XUSABEL*LOG(USAEXCH/BELEXCH) + XUSAFRA*LOG(USAEXCH/FRAEXCH) + XUSAYPN*LOG(USAEXCH/YPNEXCH) + XUSAITA*LOG(USAEXCH/ITAEXCH) + XUSAPOL*LOG(USAEXCH/POLEXCH) + XUSACZE*LOG(USAEXCH/CZEEXCH) + XUSAAUS*LOG(USAEXCH/AUSEXCH) + XUSAAUT*LOG(USAEXCH/AUTEXCH) + XUSACAN*LOG(USAEXCH/CANEXCH) + XUSACHL*LOG(USAEXCH/CHLEXCH) + XUSAEST*LOG(USAEXCH/ESTEXCH) + XUSAGRC*LOG(USAEXCH/GRCEXCH) + XUSAHUN*LOG(USAEXCH/HUNEXCH) + XUSAISL*LOG(USAEXCH/ISLEXCH) + XUSAIRL*LOG(USAEXCH/IRLEXCH) + XUSAISR*LOG(USAEXCH/ISREXCH) + XUSAKOR*LOG(USAEXCH/KOREXCH) + XUSALUX*LOG(USAEXCH/LUXEXCH) + XUSAMEX*LOG(USAEXCH/MEXEXCH) + XUSANZL*LOG(USAEXCH/NZLEXCH) + XUSAPRT*LOG(USAEXCH/PRTEXCH) + XUSASVK*LOG(USAEXCH/SVKEXCH) + XUSASVN*LOG(USAEXCH/SVNEXCH) + XUSACHE*LOG(USAEXCH/CHEEXCH) + XUSATUR*LOG(USAEXCH/TUREXCH) + XUSADAE*LOG(USAEXCH/DAEEXCH) + XUSAOOP*LOG(USAEXCH/OOPEXCH) + XUSABRA*LOG(USAEXCH/BRAEXCH) + XUSARUS*LOG(USAEXCH/RUSEXCH) + XUSAIND*LOG(USAEXCH/INDEXCH) + XUSACHN*LOG(USAEXCH/CHNEXCH) + XUSAIDN*LOG(USAEXCH/IDNEXCH) + XUSAZAF*LOG(USAEXCH/ZAFEXCH) + XUSARWD*LOG(USAEXCH/RWDEXCH) $ FRML IUSAEX USAEX = EXP(USAEX1-BUSAEX1)*100 $ FRML IUSADDV1 USADDV1 = USACPV1+USAIPV1+USAIGV1+USACGV1+USAISKV1 $ FRML IUSADV1 USADV1 = USACPV1+USAIPV1+USAIGV1+USACGV1+USAXGSV1+USAISKV1 $ FRML IUSATIV1 USATIV1 = USATI/USAPGDP*BUSAPGDP/BUSAEXC $ FRML IUSAYFV1 USAYFV1 = USAYF/USAPGDP*BUSAPGDP/BUSAEXC $ FRML IUSAGNFL1 USAGNFL1 = USAGNFL/BUSAEXC $ FRML IUSAREXCH USAREXCH = (USAPXGS/BUSAPXG)/(USAPMGS/BUSAPMG)*100 $ FRML IUSABGNFL USABGNFL = USAGNFL/USAGDP*100 $ () () FINLAND () FRML IFINPGDP FINPGDP = FINGDP/FINGDPV $ () DEFLATOR FRML IFINCPV1 FINCPV1 = FINCPV*BFINPCP $ () PCP FRML IFINIPV1 FINIPV1 = FINIPV*BFINPIB $ () PIB FRML IFINISKV1 FINISKV1 = FINISKV*BFINPISK $ () PISK FRML IFINGDPV1 FINGDPV1 = FINGDPV*BFINPGDP $ () PGDP FRML IFINIGV1 FINIGV1 = FINIGV*BFINPIG $ () PIG FRML IFINCGV1 FINCGV1 = FINCGV*BFINPCG $ () PCG FRML IFINXGSV1 FINXGSV1 = FINXGSV*BFINPXG $ () PXGS FRML IFINMGSV1 FINMGSV1 = FINMGSV*BFINPMG $ () PMGS FRML IFINYFBV1 FINYFBV1 = FINYFBV*BFINPYFB $ FRML IFINPCP1 FINPCP1 = FINPCP/BFINPCP*100 $ () PCP FRML IFINCP1 FINCP1 = ((FINCPV1*FINPCP1)/100) $ () PCP FRML IFINWR1 FINWR1 = FINWR/BFINWR*100 $ () WR FRML IFINPYFB1 FINPYFB1 = FINPYFB/BFINPYFB*100 $ FRML IFINNLG1 FINNLG1 = FINNLG $ FRML IFINCB1 FINCB1 = FINCB $ FRML IFINGDP1 FINGDP1 = FINGDP $ FRML IFINEX1 FINEX1 = XFINDNK*LOG(FINEXCH/DNKEXCH) + XFINSWE*LOG(FINEXCH/SWEEXCH) + XFINNOR*LOG(FINEXCH/NOREXCH) + XFINDEU*LOG(FINEXCH/DEUEXCH) + XFINGBR*LOG(FINEXCH/GBREXCH) + XFINFRA*LOG(FINEXCH/FRAEXCH) + XFINITA*LOG(FINEXCH/ITAEXCH) + XFINBEL*LOG(FINEXCH/BELEXCH) + XFINNLD*LOG(FINEXCH/NLDEXCH) + XFINESP*LOG(FINEXCH/ESPEXCH) + XFINYPN*LOG(FINEXCH/YPNEXCH) + XFINUSA*LOG(FINEXCH/USAEXCH) + XFINPOL*LOG(FINEXCH/POLEXCH) + XFINCZE*LOG(FINEXCH/CZEEXCH) + XFINAUS*LOG(FINEXCH/AUSEXCH) + XFINAUT*LOG(FINEXCH/AUTEXCH) + XFINCAN*LOG(FINEXCH/CANEXCH) + XFINCHL*LOG(FINEXCH/CHLEXCH) + XFINEST*LOG(FINEXCH/ESTEXCH) + XFINGRC*LOG(FINEXCH/GRCEXCH) + XFINHUN*LOG(FINEXCH/HUNEXCH) + XFINISL*LOG(FINEXCH/ISLEXCH) + XFINIRL*LOG(FINEXCH/IRLEXCH) + XFINISR*LOG(FINEXCH/ISREXCH) + XFINKOR*LOG(FINEXCH/KOREXCH) + XFINLUX*LOG(FINEXCH/LUXEXCH) + XFINMEX*LOG(FINEXCH/MEXEXCH) + XFINNZL*LOG(FINEXCH/NZLEXCH) + XFINPRT*LOG(FINEXCH/PRTEXCH) + XFINSVK*LOG(FINEXCH/SVKEXCH) + XFINSVN*LOG(FINEXCH/SVNEXCH) + XFINCHE*LOG(FINEXCH/CHEEXCH) + XFINTUR*LOG(FINEXCH/TUREXCH) + XFINDAE*LOG(FINEXCH/DAEEXCH) + XFINOOP*LOG(FINEXCH/OOPEXCH) + XFINBRA*LOG(FINEXCH/BRAEXCH) + XFINRUS*LOG(FINEXCH/RUSEXCH) + XFININD*LOG(FINEXCH/INDEXCH) + XFINCHN*LOG(FINEXCH/CHNEXCH) + XFINIDN*LOG(FINEXCH/IDNEXCH) + XFINZAF*LOG(FINEXCH/ZAFEXCH) + XFINRWD*LOG(FINEXCH/RWDEXCH) $ FRML IFINEX FINEX = EXP(FINEX1-BFINEX1)*100 $ FRML IFINDDV1 FINDDV1 = FINCPV1+FINIPV1+FINIGV1+FINCGV1+FINISKV1 $ FRML IFINDV1 FINDV1 = FINCPV1+FINIPV1+FINIGV1+FINCGV1+FINXGSV1+FINISKV1 $ FRML IFINTIV1 FINTIV1 = FINTI/FINPGDP*BFINPGDP $ FRML IFINYFV1 FINYFV1 = FINYF/FINPGDP*BFINPGDP $ FRML IFINGNFL1 FINGNFL1 = FINGNFL $ FRML IFINREXCH FINREXCH = (FINPXGS/BFINPXG)/(FINPMGS/BFINPMG)*100 $ FRML IFINBGNFL FINBGNFL = FINGNFL/FINGDP*100 $ () () FRANKRIG () FRML IFRAPGDP FRAPGDP = FRAGDP/FRAGDPV $ () DEFLATOR FRML IFRACPV1 FRACPV1 = FRACPV*BFRAPCP $ () PCP FRML IFRAIPV1 FRAIPV1 = FRAIPV*BFRAPIB $ () PIB FRML IFRAISKV1 FRAISKV1 = FRAISKV*BFRAPISK $ () PISK FRML IFRAGDPV1 FRAGDPV1 = FRAGDPV*BFRAPGDP $ () PGDP FRML IFRAIGV1 FRAIGV1 = FRAIGV*BFRAPIG $ () PIG FRML IFRACGV1 FRACGV1 = FRACGV*BFRAPCG $ () PCG FRML IFRAXGSV1 FRAXGSV1 = FRAXGSV*BFRAPXG $ () PXGS FRML IFRAMGSV1 FRAMGSV1 = FRAMGSV*BFRAPMG $ () PMGS FRML IFRAYFBV1 FRAYFBV1 = FRAYFBV*BFRAPYFB $ FRML IFRAPCP1 FRAPCP1 = FRAPCP/BFRAPCP*100 $ () PCP FRML IFRACP1 FRACP1 = ((FRACPV1*FRAPCP1)/100) $ () PCP FRML IFRAWR1 FRAWR1 = FRAWR/BFRAWR*100 $ () WR FRML IFRAPYFB1 FRAPYFB1 = FRAPYFB/BFRAPYFB*100 $ FRML IFRANLG1 FRANLG1 = FRANLG $ FRML IFRACB1 FRACB1 = FRACB $ FRML IFRAGDP1 FRAGDP1 = FRAGDP $ FRML IFRAEX1 FRAEX1 = XFRADNK*LOG(FRAEXCH/DNKEXCH) + XFRASWE*LOG(FRAEXCH/SWEEXCH) + XFRANOR*LOG(FRAEXCH/NOREXCH) + XFRAFIN*LOG(FRAEXCH/FINEXCH) + XFRANLD*LOG(FRAEXCH/NLDEXCH) + XFRAGBR*LOG(FRAEXCH/GBREXCH) + XFRAITA*LOG(FRAEXCH/ITAEXCH) + XFRADEU*LOG(FRAEXCH/DEUEXCH) + XFRABEL*LOG(FRAEXCH/BELEXCH) + XFRAESP*LOG(FRAEXCH/ESPEXCH) + XFRAYPN*LOG(FRAEXCH/YPNEXCH) + XFRAUSA*LOG(FRAEXCH/USAEXCH) + XFRAPOL*LOG(FRAEXCH/POLEXCH) + XFRACZE*LOG(FRAEXCH/CZEEXCH) + XFRAAUS*LOG(FRAEXCH/AUSEXCH) + XFRAAUT*LOG(FRAEXCH/AUTEXCH) + XFRACAN*LOG(FRAEXCH/CANEXCH) + XFRACHL*LOG(FRAEXCH/CHLEXCH) + XFRAEST*LOG(FRAEXCH/ESTEXCH) + XFRAGRC*LOG(FRAEXCH/GRCEXCH) + XFRAHUN*LOG(FRAEXCH/HUNEXCH) + XFRAISL*LOG(FRAEXCH/ISLEXCH) + XFRAIRL*LOG(FRAEXCH/IRLEXCH) + XFRAISR*LOG(FRAEXCH/ISREXCH) + XFRAKOR*LOG(FRAEXCH/KOREXCH) + XFRALUX*LOG(FRAEXCH/LUXEXCH) + XFRAMEX*LOG(FRAEXCH/MEXEXCH) + XFRANZL*LOG(FRAEXCH/NZLEXCH) + XFRAPRT*LOG(FRAEXCH/PRTEXCH) + XFRASVK*LOG(FRAEXCH/SVKEXCH) + XFRASVN*LOG(FRAEXCH/SVNEXCH) + XFRACHE*LOG(FRAEXCH/CHEEXCH) + XFRATUR*LOG(FRAEXCH/TUREXCH) + XFRADAE*LOG(FRAEXCH/DAEEXCH) + XFRAOOP*LOG(FRAEXCH/OOPEXCH) + XFRABRA*LOG(FRAEXCH/BRAEXCH) + XFRARUS*LOG(FRAEXCH/RUSEXCH) + XFRAIND*LOG(FRAEXCH/INDEXCH) + XFRACHN*LOG(FRAEXCH/CHNEXCH) + XFRAIDN*LOG(FRAEXCH/IDNEXCH) + XFRAZAF*LOG(FRAEXCH/ZAFEXCH) + XFRARWD*LOG(FRAEXCH/RWDEXCH) $ FRML IFRAEX FRAEX = EXP(FRAEX1-BFRAEX1)*100 $ FRML IFRADDV1 FRADDV1 = FRACPV1+FRAIPV1+FRAIGV1+FRACGV1+FRAISKV1 $ FRML IFRADV1 FRADV1 = FRACPV1+FRAIPV1+FRAIGV1+FRACGV1+FRAXGSV1+FRAISKV1 $ FRML IFRATIV1 FRATIV1 = FRATI/FRAPGDP*BFRAPGDP $ FRML IFRAYFV1 FRAYFV1 = FRAYF/FRAPGDP*BFRAPGDP $ FRML IFRAGNFL1 FRAGNFL1 = FRAGNFL $ FRML IFRAREXCH FRAREXCH = (FRAPXGS/BFRAPXG)/(FRAPMGS/BFRAPMG)*100 $ FRML IFRABGNFL FRABGNFL = FRAGNFL/FRAGDP*100 $ () () ITALIEN () FRML IITAPGDP ITAPGDP = ITAGDP/ITAGDPV $ () DEFLATOR FRML IITACPV1 ITACPV1 = ITACPV*BITAPCP $ () PCP FRML IITAIPV1 ITAIPV1 = ITAIPV*BITAPIB $ () PIB FRML IITAISKV1 ITAISKV1 = ITAISKV*BITAPISK $ () PISK FRML IITAGDPV1 ITAGDPV1 = ITAGDPV*BITAPGDP $ () PGDP FRML IITAIGV1 ITAIGV1 = ITAIGV*BITAPIG $ () PIG FRML IITACGV1 ITACGV1 = ITACGV*BITAPCG $ () PCG FRML IITAXGSV1 ITAXGSV1 = ITAXGSV*BITAPXG $ () PXGS FRML IITAMGSV1 ITAMGSV1 = ITAMGSV*BITAPMG $ () PMGS FRML IITAYFBV1 ITAYFBV1 = ITAYFBV*BITAPYFB $ FRML IITAPCP1 ITAPCP1 = ITAPCP/BITAPCP*100 $ () PCP FRML IITACP1 ITACP1 = ((ITACPV1*ITAPCP1)/100) $ () PCP FRML IITAWR1 ITAWR1 = ITAWR/BITAWR*100 $ () WR FRML IITAPYFB1 ITAPYFB1 = ITAPYFB/BITAPYFB*100 $ FRML IITANLG1 ITANLG1 = ITANLG $ FRML IITACB1 ITACB1 = ITACB $ FRML IITAGDP1 ITAGDP1 = ITAGDP $ FRML IITAEX1 ITAEX1 = XITADNK*LOG(ITAEXCH/DNKEXCH) + XITASWE*LOG(ITAEXCH/SWEEXCH) + XITANOR*LOG(ITAEXCH/NOREXCH) + XITAFIN*LOG(ITAEXCH/FINEXCH) + XITANLD*LOG(ITAEXCH/NLDEXCH) + XITAGBR*LOG(ITAEXCH/GBREXCH) + XITAESP*LOG(ITAEXCH/ESPEXCH) + XITADEU*LOG(ITAEXCH/DEUEXCH) + XITABEL*LOG(ITAEXCH/BELEXCH) + XITAFRA*LOG(ITAEXCH/FRAEXCH) + XITAYPN*LOG(ITAEXCH/YPNEXCH) + XITAUSA*LOG(ITAEXCH/USAEXCH) + XITAPOL*LOG(ITAEXCH/POLEXCH) + XITACZE*LOG(ITAEXCH/CZEEXCH) + XITAAUS*LOG(ITAEXCH/AUSEXCH) + XITAAUT*LOG(ITAEXCH/AUTEXCH) + XITACAN*LOG(ITAEXCH/CANEXCH) + XITACHL*LOG(ITAEXCH/CHLEXCH) + XITAEST*LOG(ITAEXCH/ESTEXCH) + XITAGRC*LOG(ITAEXCH/GRCEXCH) + XITAHUN*LOG(ITAEXCH/HUNEXCH) + XITAISL*LOG(ITAEXCH/ISLEXCH) + XITAIRL*LOG(ITAEXCH/IRLEXCH) + XITAISR*LOG(ITAEXCH/ISREXCH) + XITAKOR*LOG(ITAEXCH/KOREXCH) + XITALUX*LOG(ITAEXCH/LUXEXCH) + XITAMEX*LOG(ITAEXCH/MEXEXCH) + XITANZL*LOG(ITAEXCH/NZLEXCH) + XITAPRT*LOG(ITAEXCH/PRTEXCH) + XITASVK*LOG(ITAEXCH/SVKEXCH) + XITASVN*LOG(ITAEXCH/SVNEXCH) + XITACHE*LOG(ITAEXCH/CHEEXCH) + XITATUR*LOG(ITAEXCH/TUREXCH) + XITADAE*LOG(ITAEXCH/DAEEXCH) + XITAOOP*LOG(ITAEXCH/OOPEXCH) + XITABRA*LOG(ITAEXCH/BRAEXCH) + XITARUS*LOG(ITAEXCH/RUSEXCH) + XITAIND*LOG(ITAEXCH/INDEXCH) + XITACHN*LOG(ITAEXCH/CHNEXCH) + XITAIDN*LOG(ITAEXCH/IDNEXCH) + XITAZAF*LOG(ITAEXCH/ZAFEXCH) + XITARWD*LOG(ITAEXCH/RWDEXCH) $ FRML IITAEX ITAEX = EXP(ITAEX1-BITAEX1)*100 $ FRML IITADDV1 ITADDV1 = ITACPV1+ITAIPV1+ITAIGV1+ITACGV1+ITAISKV1 $ FRML IITADV1 ITADV1 = ITACPV1+ITAIPV1+ITAIGV1+ITACGV1+ITAXGSV1+ITAISKV1 $ FRML IITATIV1 ITATIV1 = ITATI/ITAPGDP*BITAPGDP $ FRML IITAYFV1 ITAYFV1 = ITAYF/ITAPGDP*BITAPGDP $ FRML IITAGNFL1 ITAGNFL1 = ITAGNFL $ FRML IITAREXCH ITAREXCH = (ITAPXGS/BITAPXG)/(ITAPMGS/BITAPMG)*100 $ FRML IITABGNFL ITABGNFL = ITAGNFL/ITAGDP*100 $ () () HOLLAND () FRML INLDPGDP NLDPGDP = NLDGDP/NLDGDPV $ () DEFLATOR FRML INLDCPV1 NLDCPV1 = NLDCPV*BNLDPCP $ () PCP FRML INLDIPV1 NLDIPV1 = NLDIPV*BNLDPIB $ () PIB FRML INLDISKV1 NLDISKV1 = NLDISKV*BNLDPISK $ () PISK FRML INLDGDPV1 NLDGDPV1 = NLDGDPV*BNLDPGDP $ () PGDP FRML INLDIGV1 NLDIGV1 = NLDIGV*BNLDPIG $ () PIG FRML INLDCGV1 NLDCGV1 = NLDCGV*BNLDPCG $ () PCG FRML INLDXGSV1 NLDXGSV1 = NLDXGSV*BNLDPXG $ () PXGS FRML INLDMGSV1 NLDMGSV1 = NLDMGSV*BNLDPMG $ () PMGS FRML INLDYFBV1 NLDYFBV1 = NLDYFBV*BNLDPYFB $ FRML INLDPCP1 NLDPCP1 = NLDPCP/BNLDPCP*100 $ () PCP FRML INLDCP1 NLDCP1 = ((NLDCPV1*NLDPCP1)/100) $ () PCP FRML INLDWR1 NLDWR1 = NLDWR/BNLDWR*100 $ () WR FRML INLDPYFB1 NLDPYFB1 = NLDPYFB/BNLDPYFB*100 $ FRML INLDNLG1 NLDNLG1 = NLDNLG $ FRML INLDCB1 NLDCB1 = NLDCB $ FRML INLDGDP1 NLDGDP1 = NLDGDP $ FRML INLDEX1 NLDEX1 = XNLDDNK*LOG(NLDEXCH/DNKEXCH) + XNLDSWE*LOG(NLDEXCH/SWEEXCH) + XNLDNOR*LOG(NLDEXCH/NOREXCH) + XNLDFIN*LOG(NLDEXCH/FINEXCH) + XNLDGBR*LOG(NLDEXCH/GBREXCH) + XNLDFRA*LOG(NLDEXCH/FRAEXCH) + XNLDITA*LOG(NLDEXCH/ITAEXCH) + XNLDDEU*LOG(NLDEXCH/DEUEXCH) + XNLDBEL*LOG(NLDEXCH/BELEXCH) + XNLDESP*LOG(NLDEXCH/ESPEXCH) + XNLDYPN*LOG(NLDEXCH/YPNEXCH) + XNLDUSA*LOG(NLDEXCH/USAEXCH) + XNLDPOL*LOG(NLDEXCH/POLEXCH) + XNLDCZE*LOG(NLDEXCH/CZEEXCH) + XNLDAUS*LOG(NLDEXCH/AUSEXCH) + XNLDAUT*LOG(NLDEXCH/AUTEXCH) + XNLDCAN*LOG(NLDEXCH/CANEXCH) + XNLDCHL*LOG(NLDEXCH/CHLEXCH) + XNLDEST*LOG(NLDEXCH/ESTEXCH) + XNLDGRC*LOG(NLDEXCH/GRCEXCH) + XNLDHUN*LOG(NLDEXCH/HUNEXCH) + XNLDISL*LOG(NLDEXCH/ISLEXCH) + XNLDIRL*LOG(NLDEXCH/IRLEXCH) + XNLDISR*LOG(NLDEXCH/ISREXCH) + XNLDKOR*LOG(NLDEXCH/KOREXCH) + XNLDLUX*LOG(NLDEXCH/LUXEXCH) + XNLDMEX*LOG(NLDEXCH/MEXEXCH) + XNLDNZL*LOG(NLDEXCH/NZLEXCH) + XNLDPRT*LOG(NLDEXCH/PRTEXCH) + XNLDSVK*LOG(NLDEXCH/SVKEXCH) + XNLDSVN*LOG(NLDEXCH/SVNEXCH) + XNLDCHE*LOG(NLDEXCH/CHEEXCH) + XNLDTUR*LOG(NLDEXCH/TUREXCH) + XNLDDAE*LOG(NLDEXCH/DAEEXCH) + XNLDOOP*LOG(NLDEXCH/OOPEXCH) + XNLDBRA*LOG(NLDEXCH/BRAEXCH) + XNLDRUS*LOG(NLDEXCH/RUSEXCH) + XNLDIND*LOG(NLDEXCH/INDEXCH) + XNLDCHN*LOG(NLDEXCH/CHNEXCH) + XNLDIDN*LOG(NLDEXCH/IDNEXCH) + XNLDZAF*LOG(NLDEXCH/ZAFEXCH) + XNLDRWD*LOG(NLDEXCH/RWDEXCH) $ FRML INLDEX NLDEX = EXP(NLDEX1-BNLDEX1)*100 $ FRML INLDDDV1 NLDDDV1 = NLDCPV1+NLDIPV1+NLDIGV1+NLDCGV1+NLDISKV1 $ FRML INLDDV1 NLDDV1 = NLDCPV1+NLDIPV1+NLDIGV1+NLDCGV1+NLDXGSV1+NLDISKV1 $ FRML INLDTIV1 NLDTIV1 = NLDTI/NLDPGDP*BNLDPGDP $ FRML INLDYFV1 NLDYFV1 = NLDYF/NLDPGDP*BNLDPGDP $ FRML INLDGNFL1 NLDGNFL1 = NLDGNFL $ FRML INLDREXCH NLDREXCH = (NLDPXGS/BNLDPXG)/(NLDPMGS/BNLDPMG)*100 $ FRML INLDBGNFL NLDBGNFL = NLDGNFL/NLDGDP*100 $ () () BELGIEN () FRML IBELPGDP BELPGDP = BELGDP/BELGDPV $ () DEFLATOR FRML IBELCPV1 BELCPV1 = BELCPV*BBELPCP $ () PCP FRML IBELIPV1 BELIPV1 = BELIPV*BBELPIB $ () PIB FRML IBELISKV1 BELISKV1 = BELISKV*BBELPISK $ () PISK FRML IBELGDPV1 BELGDPV1 = BELGDPV*BBELPGDP $ () PGDP FRML IBELIGV1 BELIGV1 = BELIGV*BBELPIG $ () PIG FRML IBELCGV1 BELCGV1 = BELCGV*BBELPCG $ () PCG FRML IBELXGSV1 BELXGSV1 = BELXGSV*BBELPXG $ () PXGS FRML IBELMGSV1 BELMGSV1 = BELMGSV*BBELPMG $ () PMGS FRML IBELYFBV1 BELYFBV1 = BELYFBV*BBELPYFB $ FRML IBELPCP1 BELPCP1 = BELPCP/BBELPCP*100 $ () PCP FRML IBELCP1 BELCP1 = ((BELCPV1*BELPCP1)/100) $ () PCP FRML IBELWR1 BELWR1 = BELWR/BBELWR*100 $ () WR FRML IBELPYFB1 BELPYFB1 = BELPYFB/BBELPYFB*100 $ FRML IBELNLG1 BELNLG1 = BELNLG $ FRML IBELCB1 BELCB1 = BELCB $ FRML IBELGDP1 BELGDP1 = BELGDP $ FRML IBELEX1 BELEX1 = XBELDNK*LOG(BELEXCH/DNKEXCH) + XBELSWE*LOG(BELEXCH/SWEEXCH) + XBELNOR*LOG(BELEXCH/NOREXCH) + XBELFIN*LOG(BELEXCH/FINEXCH) + XBELGBR*LOG(BELEXCH/GBREXCH) + XBELFRA*LOG(BELEXCH/FRAEXCH) + XBELITA*LOG(BELEXCH/ITAEXCH) + XBELDEU*LOG(BELEXCH/DEUEXCH) + XBELNLD*LOG(BELEXCH/NLDEXCH) + XBELESP*LOG(BELEXCH/ESPEXCH) + XBELYPN*LOG(BELEXCH/YPNEXCH) + XBELUSA*LOG(BELEXCH/USAEXCH) + XBELPOL*LOG(BELEXCH/POLEXCH) + XBELCZE*LOG(BELEXCH/CZEEXCH) + XBELAUS*LOG(BELEXCH/AUSEXCH) + XBELAUT*LOG(BELEXCH/AUTEXCH) + XBELCAN*LOG(BELEXCH/CANEXCH) + XBELCHL*LOG(BELEXCH/CHLEXCH) + XBELEST*LOG(BELEXCH/ESTEXCH) + XBELGRC*LOG(BELEXCH/GRCEXCH) + XBELHUN*LOG(BELEXCH/HUNEXCH) + XBELISL*LOG(BELEXCH/ISLEXCH) + XBELIRL*LOG(BELEXCH/IRLEXCH) + XBELISR*LOG(BELEXCH/ISREXCH) + XBELKOR*LOG(BELEXCH/KOREXCH) + XBELLUX*LOG(BELEXCH/LUXEXCH) + XBELMEX*LOG(BELEXCH/MEXEXCH) + XBELNZL*LOG(BELEXCH/NZLEXCH) + XBELPRT*LOG(BELEXCH/PRTEXCH) + XBELSVK*LOG(BELEXCH/SVKEXCH) + XBELSVN*LOG(BELEXCH/SVNEXCH) + XBELCHE*LOG(BELEXCH/CHEEXCH) + XBELTUR*LOG(BELEXCH/TUREXCH) + XBELDAE*LOG(BELEXCH/DAEEXCH) + XBELOOP*LOG(BELEXCH/OOPEXCH) + XBELBRA*LOG(BELEXCH/BRAEXCH) + XBELRUS*LOG(BELEXCH/RUSEXCH) + XBELIND*LOG(BELEXCH/INDEXCH) + XBELCHN*LOG(BELEXCH/CHNEXCH) + XBELIDN*LOG(BELEXCH/IDNEXCH) + XBELZAF*LOG(BELEXCH/ZAFEXCH) + XBELRWD*LOG(BELEXCH/RWDEXCH) $ FRML IBELEX BELEX = EXP(BELEX1-BBELEX1)*100 $ FRML IBELDDV1 BELDDV1 = BELCPV1+BELIPV1+BELIGV1+BELCGV1+BELISKV1 $ FRML IBELDV1 BELDV1 = BELCPV1+BELIPV1+BELIGV1+BELCGV1+BELXGSV1+BELISKV1 $ FRML IBELTIV1 BELTIV1 = BELTI/BELPGDP*BBELPGDP $ FRML IBELYFV1 BELYFV1 = BELYF/BELPGDP*BBELPGDP $ FRML IBELGNFL1 BELGNFL1 = BELGNFL $ FRML IBELREXCH BELREXCH = (BELPXGS/BBELPXG)/(BELPMGS/BBELPMG)*100 $ FRML IBELBGNFL BELBGNFL = BELGNFL/BELGDP*100 $ () () SPANIEN () FRML IESPPGDP ESPPGDP = ESPGDP/ESPGDPV $ () DEFLATOR FRML IESPCPV1 ESPCPV1 = ESPCPV*BESPPCP $ () PCP FRML IESPIPV1 ESPIPV1 = ESPIPV*BESPPIB $ () PIB FRML IESPISKV1 ESPISKV1 = ESPISKV*BESPPISK $ () PISK FRML IESPGDPV1 ESPGDPV1 = ESPGDPV*BESPPGDP $ () PGDP FRML IESPIGV1 ESPIGV1 = ESPIGV*BESPPIG $ () PIG FRML IESPCGV1 ESPCGV1 = ESPCGV*BESPPCG $ () PCG FRML IESPXGSV1 ESPXGSV1 = ESPXGSV*BESPPXG $ () PXGS FRML IESPMGSV1 ESPMGSV1 = ESPMGSV*BESPPMG $ () PMGS FRML IESPYFBV1 ESPYFBV1 = ESPYFBV*BESPPYFB $ FRML IESPPCP1 ESPPCP1 = ESPPCP/BESPPCP*100 $ () PCP FRML IESPCP1 ESPCP1 = ((ESPCPV1*ESPPCP1)/100) $ () PCP FRML IESPWR1 ESPWR1 = ESPWR/BESPWR*100 $ () WR FRML IESPPYFB1 ESPPYFB1 = ESPPYFB/BESPPYFB*100 $ FRML IESPNLG1 ESPNLG1 = ESPNLG $ FRML IESPCB1 ESPCB1 = ESPCB $ FRML IESPGDP1 ESPGDP1 = ESPGDP $ FRML IESPEX1 ESPEX1 = XESPDNK*LOG(ESPEXCH/DNKEXCH) + XESPSWE*LOG(ESPEXCH/SWEEXCH) + XESPNOR*LOG(ESPEXCH/NOREXCH) + XESPFIN*LOG(ESPEXCH/FINEXCH) + XESPNLD*LOG(ESPEXCH/NLDEXCH) + XESPGBR*LOG(ESPEXCH/GBREXCH) + XESPITA*LOG(ESPEXCH/ITAEXCH) + XESPDEU*LOG(ESPEXCH/DEUEXCH) + XESPBEL*LOG(ESPEXCH/BELEXCH) + XESPFRA*LOG(ESPEXCH/FRAEXCH) + XESPYPN*LOG(ESPEXCH/YPNEXCH) + XESPUSA*LOG(ESPEXCH/USAEXCH) + XESPPOL*LOG(ESPEXCH/POLEXCH) + XESPCZE*LOG(ESPEXCH/CZEEXCH) + XESPAUS*LOG(ESPEXCH/AUSEXCH) + XESPAUT*LOG(ESPEXCH/AUTEXCH) + XESPCAN*LOG(ESPEXCH/CANEXCH) + XESPCHL*LOG(ESPEXCH/CHLEXCH) + XESPEST*LOG(ESPEXCH/ESTEXCH) + XESPGRC*LOG(ESPEXCH/GRCEXCH) + XESPHUN*LOG(ESPEXCH/HUNEXCH) + XESPISL*LOG(ESPEXCH/ISLEXCH) + XESPIRL*LOG(ESPEXCH/IRLEXCH) + XESPISR*LOG(ESPEXCH/ISREXCH) + XESPKOR*LOG(ESPEXCH/KOREXCH) + XESPLUX*LOG(ESPEXCH/LUXEXCH) + XESPMEX*LOG(ESPEXCH/MEXEXCH) + XESPNZL*LOG(ESPEXCH/NZLEXCH) + XESPPRT*LOG(ESPEXCH/PRTEXCH) + XESPSVK*LOG(ESPEXCH/SVKEXCH) + XESPSVN*LOG(ESPEXCH/SVNEXCH) + XESPCHE*LOG(ESPEXCH/CHEEXCH) + XESPTUR*LOG(ESPEXCH/TUREXCH) + XESPDAE*LOG(ESPEXCH/DAEEXCH) + XESPOOP*LOG(ESPEXCH/OOPEXCH) + XESPBRA*LOG(ESPEXCH/BRAEXCH) + XESPRUS*LOG(ESPEXCH/RUSEXCH) + XESPIND*LOG(ESPEXCH/INDEXCH) + XESPCHN*LOG(ESPEXCH/CHNEXCH) + XESPIDN*LOG(ESPEXCH/IDNEXCH) + XESPZAF*LOG(ESPEXCH/ZAFEXCH) + XESPRWD*LOG(ESPEXCH/RWDEXCH) $ FRML IESPEX ESPEX = EXP(ESPEX1-BESPEX1)*100 $ FRML IESPDDV1 ESPDDV1 = ESPCPV1+ESPIPV1+ESPIGV1+ESPCGV1+ESPISKV1 $ FRML IESPDV1 ESPDV1 = ESPCPV1+ESPIPV1+ESPIGV1+ESPCGV1+ESPXGSV1+ESPISKV1 $ FRML IESPTIV1 ESPTIV1 = ESPTI/ESPPGDP*BESPPGDP $ FRML IESPYFV1 ESPYFV1 = ESPYF/ESPPGDP*BESPPGDP $ FRML IESPGNFL1 ESPGNFL1 = ESPGNFL $ FRML IESPREXCH ESPREXCH = (ESPPXGS/BESPPXG)/(ESPPMGS/BESPPMG)*100 $ FRML IESPBGNFL ESPBGNFL = ESPGNFL/ESPGDP*100 $ () () JAPAN () FRML IYPNPGDP YPNPGDP = YPNGDP/YPNGDPV $ () DEFLATOR FRML IYPNCPV1 YPNCPV1 = YPNCPV*BYPNPCP/BYPNEXC $ () PCP FRML IYPNIPV1 YPNIPV1 = YPNIPV*BYPNPIB/BYPNEXC $ () PIB FRML IYPNISKV1 YPNISKV1 = YPNISKV*BYPNPISK/BYPNEXC $ () PISK FRML IYPNGDPV1 YPNGDPV1 = YPNGDPV*BYPNPGDP/BYPNEXC $ () PGDP FRML IYPNIGV1 YPNIGV1 = YPNIGV*BYPNPIG/BYPNEXC $ () PIG FRML IYPNCGV1 YPNCGV1 = YPNCGV*BYPNPCG/BYPNEXC $ () PCG FRML IYPNXGSV1 YPNXGSV1 = YPNXGSV*BYPNPXG/BYPNEXC $ () PXGS FRML IYPNMGSV1 YPNMGSV1 = YPNMGSV*BYPNPMG/BYPNEXC $ () PMGS FRML IYPNYFBV1 YPNYFBV1 = YPNYFBV*BYPNPYFB/BYPNEXC $ FRML IYPNPCP1 YPNPCP1 = YPNPCP/BYPNPCP*100 $ () PCP FRML IYPNCP1 YPNCP1 = ((YPNCPV1*YPNPCP1)/100) $ () PCP FRML IYPNWR1 YPNWR1 = YPNWR/BYPNWR*100 $ () WR FRML IYPNPYFB1 YPNPYFB1 = YPNPYFB/BYPNPYFB*100 $ FRML IYPNNLG1 YPNNLG1 = YPNNLG/BYPNEXC $ FRML IYPNCB1 YPNCB1 = YPNCB/BYPNEXC $ FRML IYPNGDP1 YPNGDP1 = YPNGDP/BYPNEXC $ FRML IYPNEX1 YPNEX1 = XYPNDNK*LOG(YPNEXCH/DNKEXCH) + XYPNSWE*LOG(YPNEXCH/SWEEXCH) + XYPNNOR*LOG(YPNEXCH/NOREXCH) + XYPNFIN*LOG(YPNEXCH/FINEXCH) + XYPNNLD*LOG(YPNEXCH/NLDEXCH) + XYPNGBR*LOG(YPNEXCH/GBREXCH) + XYPNESP*LOG(YPNEXCH/ESPEXCH) + XYPNDEU*LOG(YPNEXCH/DEUEXCH) + XYPNBEL*LOG(YPNEXCH/BELEXCH) + XYPNFRA*LOG(YPNEXCH/FRAEXCH) + XYPNUSA*LOG(YPNEXCH/USAEXCH) + XYPNITA*LOG(YPNEXCH/ITAEXCH) + XYPNPOL*LOG(YPNEXCH/POLEXCH) + XYPNCZE*LOG(YPNEXCH/CZEEXCH) + XYPNAUS*LOG(YPNEXCH/AUSEXCH) + XYPNAUT*LOG(YPNEXCH/AUTEXCH) + XYPNCAN*LOG(YPNEXCH/CANEXCH) + XYPNCHL*LOG(YPNEXCH/CHLEXCH) + XYPNEST*LOG(YPNEXCH/ESTEXCH) + XYPNGRC*LOG(YPNEXCH/GRCEXCH) + XYPNHUN*LOG(YPNEXCH/HUNEXCH) + XYPNISL*LOG(YPNEXCH/ISLEXCH) + XYPNIRL*LOG(YPNEXCH/IRLEXCH) + XYPNISR*LOG(YPNEXCH/ISREXCH) + XYPNKOR*LOG(YPNEXCH/KOREXCH) + XYPNLUX*LOG(YPNEXCH/LUXEXCH) + XYPNMEX*LOG(YPNEXCH/MEXEXCH) + XYPNNZL*LOG(YPNEXCH/NZLEXCH) + XYPNPRT*LOG(YPNEXCH/PRTEXCH) + XYPNSVK*LOG(YPNEXCH/SVKEXCH) + XYPNSVN*LOG(YPNEXCH/SVNEXCH) + XYPNCHE*LOG(YPNEXCH/CHEEXCH) + XYPNTUR*LOG(YPNEXCH/TUREXCH) + XYPNDAE*LOG(YPNEXCH/DAEEXCH) + XYPNOOP*LOG(YPNEXCH/OOPEXCH) + XYPNBRA*LOG(YPNEXCH/BRAEXCH) + XYPNRUS*LOG(YPNEXCH/RUSEXCH) + XYPNIND*LOG(YPNEXCH/INDEXCH) + XYPNCHN*LOG(YPNEXCH/CHNEXCH) + XYPNIDN*LOG(YPNEXCH/IDNEXCH) + XYPNZAF*LOG(YPNEXCH/ZAFEXCH) + XYPNRWD*LOG(YPNEXCH/RWDEXCH) $ FRML IYPNEX YPNEX = EXP(YPNEX1-BYPNEX1)*100 $ FRML IYPNDDV1 YPNDDV1 = YPNCPV1+YPNIPV1+YPNIGV1+YPNCGV1+YPNISKV1 $ FRML IYPNDV1 YPNDV1 = YPNCPV1+YPNIPV1+YPNIGV1+YPNCGV1+YPNXGSV1+YPNISKV1 $ FRML IYPNTIV1 YPNTIV1 = YPNTI/YPNPGDP*BYPNPGDP/BYPNEXC $ FRML IYPNYFV1 YPNYFV1 = YPNYF/YPNPGDP*BYPNPGDP/BYPNEXC $ FRML IYPNGNFL1 YPNGNFL1 = YPNGNFL/BYPNEXC $ FRML IYPNREXCH YPNREXCH = (YPNPXGS/BYPNPXG)/(YPNPMGS/BYPNPMG)*100 $ FRML IYPNBGNFL YPNBGNFL = YPNGNFL/YPNGDP*100 $ () TJEKKIET () FRML ICZEPGDP CZEPGDP = CZEGDP/CZEGDPV $ () DEFLATOR FRML ICZECPV1 CZECPV1 = CZECPV*BCZEPCP/BCZEEXC $ () PCP FRML ICZEIPV1 CZEIPV1 = CZEIPV*BCZEPIB/BCZEEXC $ () PIB FRML ICZEISKV1 CZEISKV1 = CZEISKV*BCZEPISK/BCZEEXC $ () PISK FRML ICZEGDPV1 CZEGDPV1 = CZEGDPV*BCZEPGDP/BCZEEXC $ () PGDP FRML ICZEIGV1 CZEIGV1 = CZEIGV*BCZEPIG/BCZEEXC $ () PIG FRML ICZECGV1 CZECGV1 = CZECGV*BCZEPCG/BCZEEXC $ () PCG FRML ICZEXGSV1 CZEXGSV1 = CZEXGSV*BCZEPXG/BCZEEXC $ () PXGS FRML ICZEMGSV1 CZEMGSV1 = CZEMGSV*BCZEPMG/BCZEEXC $ () PMGS FRML ICZEYFBV1 CZEYFBV1 = CZEYFBV*BCZEPYFB/BCZEEXC $ FRML ICZEPCP1 CZEPCP1 = CZEPCP/BCZEPCP*100 $ () PCP FRML ICZECP1 CZECP1 = ((CZECPV1*CZEPCP1)/100) $ () PCP FRML ICZEWR1 CZEWR1 = CZEWR/BCZEWR*100 $ () WR FRML ICZEPYFB1 CZEPYFB1 = CZEPYFB/BCZEPYFB*100 $ FRML ICZENLG1 CZENLG1 = CZENLG/BCZEEXC $ FRML ICZECB1 CZECB1 = CZECB/BCZEEXC $ FRML ICZEGDP1 CZEGDP1 = CZEGDP/BCZEEXC $ FRML ICZEEX1 CZEEX1 = XCZEDNK*LOG(CZEEXCH/DNKEXCH) + XCZESWE*LOG(CZEEXCH/SWEEXCH) + XCZENOR*LOG(CZEEXCH/NOREXCH) + XCZEFIN*LOG(CZEEXCH/FINEXCH) + XCZENLD*LOG(CZEEXCH/NLDEXCH) + XCZEGBR*LOG(CZEEXCH/GBREXCH) + XCZEESP*LOG(CZEEXCH/ESPEXCH) + XCZEDEU*LOG(CZEEXCH/DEUEXCH) + XCZEBEL*LOG(CZEEXCH/BELEXCH) + XCZEFRA*LOG(CZEEXCH/FRAEXCH) + XCZEYPN*LOG(CZEEXCH/YPNEXCH) + XCZEITA*LOG(CZEEXCH/ITAEXCH) + XCZEUSA*LOG(CZEEXCH/USAEXCH) + XCZEPOL*LOG(CZEEXCH/POLEXCH) + XCZEAUS*LOG(CZEEXCH/AUSEXCH) + XCZEAUT*LOG(CZEEXCH/AUTEXCH) + XCZECAN*LOG(CZEEXCH/CANEXCH) + XCZECHL*LOG(CZEEXCH/CHLEXCH) + XCZEEST*LOG(CZEEXCH/ESTEXCH) + XCZEGRC*LOG(CZEEXCH/GRCEXCH) + XCZEHUN*LOG(CZEEXCH/HUNEXCH) + XCZEISL*LOG(CZEEXCH/ISLEXCH) + XCZEIRL*LOG(CZEEXCH/IRLEXCH) + XCZEISR*LOG(CZEEXCH/ISREXCH) + XCZEKOR*LOG(CZEEXCH/KOREXCH) + XCZELUX*LOG(CZEEXCH/LUXEXCH) + XCZEMEX*LOG(CZEEXCH/MEXEXCH) + XCZENZL*LOG(CZEEXCH/NZLEXCH) + XCZEPRT*LOG(CZEEXCH/PRTEXCH) + XCZESVK*LOG(CZEEXCH/SVKEXCH) + XCZESVN*LOG(CZEEXCH/SVNEXCH) + XCZECHE*LOG(CZEEXCH/CHEEXCH) + XCZETUR*LOG(CZEEXCH/TUREXCH) + XCZEDAE*LOG(CZEEXCH/DAEEXCH) + XCZEOOP*LOG(CZEEXCH/OOPEXCH) + XCZEBRA*LOG(CZEEXCH/BRAEXCH) + XCZERUS*LOG(CZEEXCH/RUSEXCH) + XCZEIND*LOG(CZEEXCH/INDEXCH) + XCZECHN*LOG(CZEEXCH/CHNEXCH) + XCZEIDN*LOG(CZEEXCH/IDNEXCH) + XCZEZAF*LOG(CZEEXCH/ZAFEXCH) + XCZERWD*LOG(CZEEXCH/RWDEXCH) $ FRML ICZEEX CZEEX = EXP(CZEEX1-BCZEEX1)*100 $ FRML ICZEDDV1 CZEDDV1 = CZECPV1+CZEIPV1+CZEIGV1+CZECGV1+CZEISKV1 $ FRML ICZEDV1 CZEDV1 = CZECPV1+CZEIPV1+CZEIGV1+CZECGV1+CZEXGSV1+CZEISKV1 $ FRML ICZETIV1 CZETIV1 = CZETI/CZEPGDP*BCZEPGDP/BCZEEXC $ FRML ICZEYFV1 CZEYFV1 = CZEYF/CZEPGDP*BCZEPGDP/BCZEEXC $ FRML ICZEGNFL1 CZEGNFL1 = CZEGNFL/BCZEEXC $ FRML ICZEREXCH CZEREXCH = (CZEPXGS/BCZEPXG)/(CZEPMGS*BCZEPMG)*100 $ FRML ICZEBGNFL CZEBGNFL = CZEGNFL/CZEGDP*100 $ () POLEN () FRML IPOLPGDP POLPGDP = POLGDP/POLGDPV $ () DEFLATOR FRML IPOLCPV1 POLCPV1 = POLCPV*BPOLPCP/BPOLEXC $ () PCP FRML IPOLIPV1 POLIPV1 = POLIPV*BPOLPIB/BPOLEXC $ () PIB FRML IPOLISKV1 POLISKV1 = POLISKV*BPOLPISK/BPOLEXC $ () PISK FRML IPOLGDPV1 POLGDPV1 = POLGDPV*BPOLPGDP/BPOLEXC $ () PGDP FRML IPOLIGV1 POLIGV1 = POLIGV*BPOLPIG/BPOLEXC $ () PIG FRML IPOLCGV1 POLCGV1 = POLCGV*BPOLPCG/BPOLEXC $ () PCG FRML IPOLXGSV1 POLXGSV1 = POLXGSV*BPOLPXG/BPOLEXC $ () PXGS FRML IPOLMGSV1 POLMGSV1 = POLMGSV*BPOLPMG/BPOLEXC $ () PMGS FRML IPOLYFBV1 POLYFBV1 = POLYFBV*BPOLPYFB/BPOLEXC $ FRML IPOLPCP1 POLPCP1 = POLPCP/BPOLPCP*100 $ () PCP FRML IPOLCP1 POLCP1 = ((POLCPV1*POLPCP1)/100) $ () PCP FRML IPOLWR1 POLWR1 = POLWR/BPOLWR*100 $ () WR FRML IPOLPYFB1 POLPYFB1 = POLPYFB/BPOLPYFB*100 $ FRML IPOLNLG1 POLNLG1 = POLNLG/BPOLEXC $ FRML IPOLCB1 POLCB1 = POLCB/BPOLEXC $ FRML IPOLGDP1 POLGDP1 = POLGDP/BPOLEXC $ FRML IPOLEX1 POLEX1 = XPOLDNK*LOG(POLEXCH/DNKEXCH) + XPOLSWE*LOG(POLEXCH/SWEEXCH) + XPOLNOR*LOG(POLEXCH/NOREXCH) + XPOLFIN*LOG(POLEXCH/FINEXCH) + XPOLNLD*LOG(POLEXCH/NLDEXCH) + XPOLGBR*LOG(POLEXCH/GBREXCH) + XPOLESP*LOG(POLEXCH/ESPEXCH) + XPOLDEU*LOG(POLEXCH/DEUEXCH) + XPOLBEL*LOG(POLEXCH/BELEXCH) + XPOLFRA*LOG(POLEXCH/FRAEXCH) + XPOLYPN*LOG(POLEXCH/YPNEXCH) + XPOLITA*LOG(POLEXCH/ITAEXCH) + XPOLUSA*LOG(POLEXCH/USAEXCH) + XPOLCZE*LOG(POLEXCH/CZEEXCH) + XPOLAUS*LOG(POLEXCH/AUSEXCH) + XPOLAUT*LOG(POLEXCH/AUTEXCH) + XPOLCAN*LOG(POLEXCH/CANEXCH) + XPOLCHL*LOG(POLEXCH/CHLEXCH) + XPOLEST*LOG(POLEXCH/ESTEXCH) + XPOLGRC*LOG(POLEXCH/GRCEXCH) + XPOLHUN*LOG(POLEXCH/HUNEXCH) + XPOLISL*LOG(POLEXCH/ISLEXCH) + XPOLIRL*LOG(POLEXCH/IRLEXCH) + XPOLISR*LOG(POLEXCH/ISREXCH) + XPOLKOR*LOG(POLEXCH/KOREXCH) + XPOLLUX*LOG(POLEXCH/LUXEXCH) + XPOLMEX*LOG(POLEXCH/MEXEXCH) + XPOLNZL*LOG(POLEXCH/NZLEXCH) + XPOLPRT*LOG(POLEXCH/PRTEXCH) + XPOLSVK*LOG(POLEXCH/SVKEXCH) + XPOLSVN*LOG(POLEXCH/SVNEXCH) + XPOLCHE*LOG(POLEXCH/CHEEXCH) + XPOLTUR*LOG(POLEXCH/TUREXCH) + XPOLDAE*LOG(POLEXCH/DAEEXCH) + XPOLOOP*LOG(POLEXCH/OOPEXCH) + XPOLBRA*LOG(POLEXCH/BRAEXCH) + XPOLRUS*LOG(POLEXCH/RUSEXCH) + XPOLIND*LOG(POLEXCH/INDEXCH) + XPOLCHN*LOG(POLEXCH/CHNEXCH) + XPOLIDN*LOG(POLEXCH/IDNEXCH) + XPOLZAF*LOG(POLEXCH/ZAFEXCH) + XPOLRWD*LOG(POLEXCH/RWDEXCH) $ FRML IPOLEX POLEX = EXP(POLEX1-BPOLEX1)*100 $ FRML IPOLDDV1 POLDDV1 = POLCPV1+POLIPV1+POLIGV1+POLCGV1+POLISKV1 $ FRML IPOLDV1 POLDV1 = POLCPV1+POLIPV1+POLIGV1+POLCGV1+POLXGSV1+POLISKV1 $ FRML IPOLTIV1 POLTIV1 = POLTI/POLPGDP*BPOLPGDP/BPOLEXC $ FRML IPOLYFV1 POLYFV1 = POLYF/POLPGDP*BPOLPGDP/BPOLEXC $ FRML IPOLGNFL1 POLGNFL1 = POLGNFL/BPOLEXC $ FRML IPOLREXCH POLREXCH = (POLPXGS/BPOLPXG)/(POLPMGS*BPOLPMG)*100 $ FRML IPOLBGNFL POLBGNFL = POLGNFL/POLGDP*100 $ () Ungarn FRML IHUNXGSV1 HUNXGSV1 = HUNXGSV*BHUNPXG*HUNexch/eurexc $ FRML IHUNMGSV1 HUNMGSV1 = HUNMGSV*BHUNPMG*HUNexch/eurexc $ () Østrig FRML IAUTXGSV1 AUTXGSV1 = AUTXGSV*BAUTPXG*AUTexch/eurexc $ FRML IAUTMGSV1 AUTMGSV1 = AUTMGSV*BAUTPMG*AUTexch/eurexc $ () Irland FRML IIREXGSV1 IREXGSV1 = IREXGSV*BIREPXG*IREexch/eurexc $ FRML IIREMGSV1 IREMGSV1 = IREMGSV*BIREPMG*IREexch/eurexc $ () Portugal FRML IPRTXGSV1 PRTXGSV1 = PRTXGSV*BPRTPXG*PRTexch/eurexc $ FRML IPRTMGSV1 PRTMGSV1 = PRTMGSV*BPRTPMG*PRTexch/eurexc $ () Grækenland FRML IGRCXGSV1 GRCXGSV1 = GRCXGSV*BGRCPXG*GRCexch/eurexc $ FRML IGRCMGSV1 GRCMGSV1 = GRCMGSV*BGRCPMG*GRCexch/eurexc $ () EU27 FRML IEU27CPV EU27CPV = (DNKCPV1+SWECPV1+FINCPV1+DEUCPV1+GBRCPV1+FRACPV1 +ITACPV1+NLDCPV1+BELCPV1+ESPCPV1+POLCPV1+CZECPV1) *seu27cpv $ FRML IEU27ET EU27ET = (DNKET+SWEET+FINET+DEUET+GBRET+FRAET+ITAET+NLDET +BELET+ESPET+POLET+CZEET)*seu27ET $ FRML IEU27LF EU27LF = (DNKLF+SWELF+FINLF+DEULF+GBRLF+FRALF+ITALF+NLDLF +BELLF+ESPLF+POLLF+CZELF)*seu27LF $ FRML IEU27POP EU27POP = (DNKPOP+SWEPOP+FINPOP+DEUPOP+GBRPOP+FRAPOP+ITAPOP +NLDPOP+BELPOP+ESPPOP+POLPOP+CZEPOP)*seu27POP $ FRML IEU27un EU27un = (DNKun+SWEun+FINun+DEUun+GBRun+FRAun+ITAun+NLDun +BELun+ESPun+POLun+CZEun)*seu27un $ FRML IEU27pcp EU27pcp = ((DNKCP1+SWECP1+FINCP1+DEUCP1+GBRCP1+FRACP1+ITACP1 +NLDCP1+BELCP1+ESPCP1+POLCP1+CZECP1)/(DNKCPV1+SWECPV1 +FINCPV1+DEUCPV1+GBRCPV1+FRACPV1+ITACPV1+NLDCPV1 +BELCPV1+ESPCPV1+POLCPV1+CZECPV1))*seu27pcp $ FRML IEU27gdpv EU27gdpv =(DNKgdpv1+SWEgdpv1+FINgdpv1+DEUgdpv1+GBRgdpv1+FRAgdpv1 +ITAgdpv1+NLDgdpv1+BELgdpv1+ESPgdpv1+POLgdpv1+CZEgdpv1) *seu27gdpv $ FRML IEU27gdp EU27gdp = (DNKgdp1+SWEgdp1+FINgdp1+DEUgdp1+GBRgdp1+FRAgdp1+ITAgdp1 +NLDgdp1+BELgdp1+ESPgdp1+POLgdp1+CZEgdp1)*seu27gdp $ FRML IEU27cgv EU27cgv = (DNKcgv1+SWEcgv1+FINcgv1+DEUcgv1+GBRcgv1+FRAcgv1+ITAcgv1 +NLDcgv1+BELcgv1+ESPcgv1+POLcgv1+CZEcgv1)*seu27cgv $ FRML IEU27XGSV EU27XGSV =(DNKXGSV1+SWEXGSV1+FINXGSV1+DEUXGSV1+GBRXGSV1+FRAXGSV1 +ITAXGSV1+NLDXGSV1+BELXGSV1+ESPXGSV1+POLXGSV1+CZEXGSV1) *seu27XGSV $ FRML IEU27MGSV EU27MGSV =(DNKMGSV1+SWEMGSV1+FINMGSV1+DEUMGSV1+GBRMGSV1+FRAMGSV1 +ITAMGSV1+NLDMGSV1+BELMGSV1+ESPMGSV1+POLMGSV1+CZEMGSV1) *seu27MGSV $ FRML IEU27itv EU27itv = (DNKigv1+SWEigv1+FINigv1+DEUigv1+GBRigv1+FRAigv1+ITAigv1 +NLDigv1+BELigv1+ESPigv1+POLigv1+CZEigv1+DNKipv1+SWEipv1 +FINipv1+DEUipv1+GBRipv1+FRAipv1+ITAipv1+NLDipv1+BELipv1 +ESPipv1+POLipv1+CZEipv1)*seu27itv $ FRML IEU27PGDP EU27PGDP = EU27GDP/EU27GDPV $ FRML IEU27unr EU27unr = EU27un/EU27LF*100 $ FRML IEU27BNLG EU27BNLG =((DNKnlg1+SWEnlg1+FINnlg1+DEUnlg1+GBRnlg1+FRAnlg1+ITAnlg1 +NLDnlg1+BELnlg1+ESPnlg1+POLnlg1+CZEnlg1)/(DNKgdp1+SWEgdp1 +FINgdp1+DEUgdp1+GBRgdp1+FRAgdp1+ITAgdp1+NLDgdp1+ BELgdp1+ESPgdp1+POLgdp1+CZEgdp1))*100 $ FRML IEU27BCB EU27BCB = ((DNKcb1+SWEcb1+FINcb1+DEUcb1+GBRcb1+FRAcb1+ITAcb1+NLDcb1 +BELcb1+ESPcb1+POLcb1+CZEcb1)/(DNKgdp1+SWEgdp1+FINgdp1 +DEUgdp1+GBRgdp1+FRAgdp1+ITAgdp1+NLDgdp1+BELgdp1 +ESPgdp1+POLgdp1+CZEgdp1))*100 $ () EURO FRML IEUROCPV EUROCPV = (FINCPV1+DEUCPV1+FRACPV1+ITACPV1+NLDCPV1+BELCPV1+ESPCPV1) *sEUROcpv $ FRML IEUROET EUROET = (FINET+DEUET+FRAET+ITAET+NLDET+BELET+ESPET)*sEUROET $ FRML IEUROLF EUROLF = (FINLF+DEULF+FRALF+ITALF+NLDLF+BELLF+ESPLF)*sEUROLF $ FRML IEUROPOP EUROPOP = (FINPOP+DEUPOP+FRAPOP+ITAPOP+NLDPOP+BELPOP+ESPPOP)*sEUROPOP $ FRML IEUROun EUROun = (FINun+DEUun+FRAun+ITAun+NLDun+BELun+ESPun)*sEUROun $ FRML IEUROpcp EUROpcp = ((FINCP1+DEUCP1+FRACP1+ITACP1+NLDCP1+BELCP1+ESPCP1)/ (FINCPV1+DEUCPV1+FRACPV1+ITACPV1+NLDCPV1+BELCPV1+ESPCPV1)) *sEUROpcp $ FRML IEUROgdpv EUROgdpv =(FINgdpv1+DEUgdpv1+FRAgdpv1+ITAgdpv1+NLDgdpv1+BELgdpv1 +ESPgdpv1)*sEUROgdpv $ FRML IEUROgdp EUROgdp = (FINgdp1+DEUgdp1+FRAgdp1+ITAgdp1+NLDgdp1+BELgdp1+ESPgdp1) *sEUROgdp $ FRML IEUROcgv EUROcgv = (FINcgv1+DEUcgv1+FRAcgv1+ITAcgv1+NLDcgv1+BELcgv1+ESPcgv1) *sEUROcgv $ FRML IEUROXGSV EUROXGSV =(FINXGSV1+DEUXGSV1+FRAXGSV1+ITAXGSV1+NLDXGSV1+BELXGSV1+ ESPXGSV1)*sEUROXGSV $ FRML IEUROMGSV EUROMGSV =(FINMGSV1+DEUMGSV1+FRAMGSV1+ITAMGSV1+NLDMGSV1+BELMGSV1+ ESPMGSV1)*sEUROMGSV $ FRML IEUROitv EUROitv = (FINigv1+DEUigv1+FRAigv1+ITAigv1+NLDigv1+BELigv1+ESPigv1 +FINipv1+DEUipv1+FRAipv1+ITAipv1+NLDipv1+BELipv1+ESPipv1) *sEUROitv $ FRML IEUROPGDP EUROPGDP = EUROGDP/EUROGDPV $ FRML IEUROunr EUROunr = EUROun/EUROLF*100 $ FRML IEUROBNLG EUROBNLG =((FINnlg1+DEUnlg1+FRAnlg1+ITAnlg1+NLDnlg1+BELnlg1+ESPnlg1)/ (FINgdp1+DEUgdp1+FRAgdp1+ITAgdp1+NLDgdp1+BELgdp1+ESPgdp1))*100 $ FRML IEUROBCB EUROBCB = ((FINcb1+DEUcb1+FRAcb1+ITAcb1+NLDcb1+BELcb1+ESPcb1)/ (FINgdp1+DEUgdp1+FRAgdp1+ITAgdp1+NLDgdp1+BELgdp1+ESPgdp1))*100 $ () North FRML InorthCPV northCPV = (DNKCPV1+SWECPV1+FINCPV1+NORCPV1)*snorthcpv $ FRML InorthET northET = (DNKET+SWEET+FINET+NORET) $ FRML InorthLF northLF = (DNKLF+SWELF+FINLF+NORLF) $ FRML Inorthpopt northpopt = (DNKpopt+SWEpopt+FINpopt+NORpopt) $ FRML Inorthun northun = NORTHLF-NORTHET $ FRML Inorthpcp northpcp = ((DNKCP1+SWECP1+FINCP1+NORCP1)/(DNKCPV1+SWECPV1 +FINCPV1+NORCPV1))*snorthpcp $ FRML Inorthgdpv northgdpv =(DNKgdpv1+SWEgdpv1+FINgdpv1+NORgdpv1)*snorthgdpv $ FRML Inorthgdp northgdp = (DNKgdp1+SWEgdp1+FINgdp1+NORgdp1) $ FRML InorthXGSV northXGSV =(DNKXGSV1+SWEXGSV1+FINXGSV1+NORXGSV1)*snorthXGSV $ FRML InorthMGSV northMGSV =(DNKMGSV1+SWEMGSV1+FINMGSV1+NORMGSV1)*snorthMGSV $ FRML Inorthunr northunr = northun/northLF*100 $ FRML InorthBNLG northBNLG =((DNKnlg1+SWEnlg1+FINnlg1+NORnlg1)/(DNKgdp1+SWEgdp1 +FINgdp1+NORgdp1))*100 $ FRML InorthBCB northBCB = ((DNKcb1+SWEcb1+FINcb1+NORcb1)/(DNKgdp1+SWEgdp1 +FINgdp1+NORgdp1))*100 $ () west FRML IwestCPV westCPV = (DEUCPV1+FRACPV1+NLDCPV1+BELCPV1)*swestcpv $ FRML IwestET westET = (DEUET+FRAET+NLDET+BELET)*swestET $ FRML IwestLF westLF = (DEULF+FRALF+NLDLF+BELLF)*swestLF $ FRML Iwestpopt westpopt = (DEUpopt+FRApopt+NLDpopt+BELpopt)*swestpopt $ FRML Iwestun westun = WESTLF-WESTET $ FRML Iwestpcp westpcp = ((DEUCP1+FRACP1+NLDCP1+BELCP1)/(DEUCPV1+FRACPV1 +NLDCPV1+BELCPV1))*swestpcp $ FRML Iwestgdpv westgdpv =(DEUgdpv1+FRAgdpv1+NLDgdpv1+BELgdpv1)*swestgdpv $ FRML Iwestgdp westgdp = (DEUgdp1+FRAgdp1+NLDgdp1+BELgdp1)*swestgdp $ FRML IwestXGSV westXGSV =(DEUXGSV1+FRAXGSV1+NLDXGSV1+BELXGSV1+AUTXGSV1)*swestXGSV $ FRML IwestMGSV westMGSV =(DEUMGSV1+FRAMGSV1+NLDMGSV1+BELMGSV1+AUTMGSV1)*swestMGSV $ FRML Iwestunr westunr = westun/westLF*100 $ FRML IwestBNLG westBNLG =((DEUnlg1+FRAnlg1+NLDnlg1+BELnlg1)/(DEUgdp1+FRAgdp1 +NLDgdp1+BELgdp1))*100*swestbnlg $ FRML IwestBCB westBCB = ((DEUcb1+FRAcb1+NLDcb1+BELcb1)/(DEUgdp1+FRAgdp1 +NLDgdp1+BELgdp1))*100*swestbcb $ () south FRML IsouthCPV southCPV = (ITACPV1+ESPCPV1)*ssouthcpv $ FRML IsouthET southET = (ITAET+ESPET)*ssouthET $ FRML IsouthLF southLF = (ITALF+ESPLF)*ssouthLF $ FRML Isouthpopt southpopt = (ITApopt+ESPpopt)*ssouthpopt $ FRML Isouthun southun = SOUTHLF-SOUTHET $ FRML Isouthpcp southpcp = ((ITACP1+ESPCP1)/(ITACPV1+ESPCPV1))*ssouthpcp $ FRML Isouthgdpv southgdpv =(ITAgdpv1+ESPgdpv1)*ssouthgdpv $ FRML Isouthgdp southgdp = (ITAgdp1+ESPgdp1)*ssouthgdp $ FRML IsouthXGSV southXGSV =(ITAXGSV1+ESPXGSV1+GRCXGSV1+PRTXGSV1+IREXGSV1)*ssouthXGSV $ FRML IsouthMGSV southMGSV =(ITAMGSV1+ESPMGSV1+GRCMGSV1+PRTMGSV1+IREMGSV1)*ssouthMGSV $ FRML Isouthunr southunr = southun/southLF*100 $ FRML IsouthBNLG southBNLG =((ITAnlg1+ESPnlg1)/(ITAgdp1+ESPgdp1))*100*ssouthbnlg $ FRML IsouthBCB southBCB = ((ITAcb1+ESPcb1)/(ITAgdp1+ESPgdp1))*100*ssouthbcb $ () east FRML IeastCPV eastCPV = (POLCPV1+CZECPV1)*seastcpv $ FRML IeastET eastET = (POLET+CZEET)*seastET $ FRML IeastLF eastLF = (POLLF+CZELF)*seastLF $ FRML Ieastpopt eastpopt = (POLpopt+CZEpopt)*seastpopt $ FRML Ieastun eastun = EASTLF-EASTET $ FRML Ieastpcp eastpcp = ((POLCP1+CZECP1)/(POLCPV1+CZECPV1))*seastpcp $ FRML Ieastgdpv eastgdpv =(POLgdpv1+CZEgdpv1)*seastgdpv $ FRML Ieastgdp eastgdp = (POLgdp1+CZEgdp1)*seastgdp $ FRML IeastXGSV eastXGSV =(POLXGSV1+CZEXGSV1+HUNXGSV1)*seastXGSV $ FRML IeastMGSV eastMGSV =(POLMGSV1+CZEMGSV1+HUNMGSV1)*seastMGSV $ FRML Ieastunr eastunr = eastun/eastLF*100 $ FRML IeastBNLG eastBNLG =((POLnlg1+CZEnlg1)/(POLgdp1+CZEgdp1))*100*seastbnlg $ FRML IeastBCB eastBCB = ((POLcb1+CZEcb1)/(POLgdp1+CZEgdp1))*100*seastbcb $ () () EU (gamle EU15 variabler - stemmer ikke historisk) () () () FRML IEU3CPV EU3CPV = (DNKCPV1+SWECPV1+FINCPV1+DEUCPV1+GBRCPV1 () +FRACPV1+ITACPV1+NLDCPV1+BELCPV1+ESPCPV1)*1.07039 $ () FRML IEU3ET EU3ET = (DNKET+SWEET+FINET+DEUET+GBRET () +FRAET+ITAET+NLDET+BELET+ESPET)*1.09766 $ () FRML IEU3LF EU3LF = (DNKLF+SWELF+FINLF+DEULF+GBRLF () +FRALF+ITALF+NLDLF+BELLF+ESPLF)*1.09455 $ () FRML IEU3POPT EU3POPT = (DNKPOPT+SWEPOPT+FINPOPT+DEUPOPT+GBRPOPT () +FRAPOPT+ITAPOPT+NLDPOPT+BELPOPT+ESPPOPT)*1.09726 $ () () FRML IEU3UNR EU3UNR = .244*DEUUNR+.017*DNKUNR () () +.189*FRAUNR+.045*NLDUNR () () +.178*ITAUNR+.091*ESPUNR () () +.165*GBRUNR+.014*FINUNR () () +.031*BELUNR+.026*SWEUNR $ () () FRML IEU3UN EU3UN = EU3ET/(100/EU3UNR-1) $ () FRML IEU3UN EU3UN = (DNKUN+SWEUN+FINUN+DEUUN+GBRUN () +FRAUN+ITAUN+NLDUN+BELUN+ESPUN) * 1.07042 $ () FRML IEU3UNR EU3UNR = EU3UN/EU3LF*100 $ () FRML IEU3PCP EU3PCP = .244*DEUPCP1+.017*DNKPCP1 () +.189*FRAPCP1+.045*NLDPCP1 () +.178*ITAPCP1+.091*ESPPCP1 () +.165*GBRPCP1+.014*FINPCP1 () +.031*BELPCP1+.026*SWEPCP1 $ () FRML IEU3PMGS EU3PMGS = .244*DEUPMGS+.017*DNKPMGS () +.189*FRAPMGS+.045*NLDPMGS () +.178*ITAPMGS+.091*ESPPMGS () +.165*GBRPMGS+.014*FINPMGS () +.031*BELPMGS+.026*SWEPMGS $ () FRML IEU3PXGS EU3PXGS = .244*DEUPXGS+.017*DNKPXGS () +.189*FRAPXGS+.045*NLDPXGS () +.178*ITAPXGS+.091*ESPPXGS () +.165*GBRPXGS+.014*FINPXGS () +.031*BELPXGS+.026*SWEPXGS $ () FRML IEU3WR EU3WR = .244*DEUWR1+.017*DNKWR1 () +.189*FRAWR1+.045*NLDWR1 () +.178*ITAWR1+.091*ESPWR1 () +.165*GBRWR1+.014*FINWR1 () +.031*BELWR1+.026*SWEWR1 $ () FRML IEU3IPV EU3IPV = (DNKIPV1+SWEIPV1+FINIPV1+DEUIPV1+GBRIPV1 () +FRAIPV1+ITAIPV1+NLDIPV1+BELIPV1+ESPIPV1)*1.07039 $ () FRML IEU3ISKV EU3ISKV = (DNKISKV1+SWEISKV1+FINISKV1+DEUISKV1+GBRISKV1 () +FRAISKV1+ITAISKV1+NLDISKV1+BELISKV1+ESPISKV1)*1.0097 $ () FRML IEU3EP EU3EP = (DNKEP+SWEEP+FINEP+DEUEP+GBREP () +FRAEP+ITAEP+NLDEP+BELEP+ESPEP)*1.07039 $ () FRML IEU3GDPV EU3GDPV = (DNKGDPV1+SWEGDPV1+FINGDPV1+DEUGDPV1+GBRGDPV1 () +FRAGDPV1+ITAGDPV1+NLDGDPV1+BELGDPV1+ESPGDPV1) () *1.04077 $ () FRML IEU3GDP EU3GDP = (DNKGDP1+SWEGDP1+FINGDP1+DEUGDP1+GBRGDP1 () +FRAGDP1+ITAGDP1+NLDGDP1+BELGDP1+ESPGDP1) () *1.04077 $ () FRML IEU3PGDP EU3PGDP = EU3GDP/EU3GDPV $ () () FRML IEU3BNLG EU3BNLG = .244*DEUBNLG+.017*DNKBNLG () +.189*FRABNLG+.045*NLDBNLG () +.178*ITABNLG+.091*ESPBNLG () +.165*GBRBNLG+.014*FINBNLG () +.031*BELBNLG+.026*SWEBNLG $ () FRML IEU3NLG EU3NLG = DNKNLG1+SWENLG1+FINNLG1+DEUNLG1+GBRNLG1 () +FRANLG1+ITANLG1+NLDNLG1+BELNLG1+ESPNLG1 $ () FRML IEU3BCB EU3BCB = .244*DEUBCB+.017*DNKBCB () +.189*FRABCB+.045*NLDBCB () +.178*ITABCB+.091*ESPBCB () +.165*GBRBCB+.014*FINBCB () +.031*BELBCB+.026*SWEBCB $ () FRML IEU3CB EU3CB = DNKCB1+SWECB1+FINCB1+DEUCB1+GBRCB1 () +FRACB1+ITACB1+NLDCB1+BELCB1+ESPCB1 $ () FRML IEUROCB EUROCB = FINCB1+DEUCB1+FRACB1+ITACB1+NLDCB1+BELCB1+ESPCB1 $ () FRML IEU3IGV EU3IGV = (DNKIGV1+SWEIGV1+FINIGV1+DEUIGV1+GBRIGV1 () +FRAIGV1+ITAIGV1+NLDIGV1+BELIGV1+ESPIGV1)*1.07039 $ () FRML IEU3CGV EU3CGV = (DNKCGV1+SWECGV1+FINCGV1+DEUCGV1+GBRCGV1 () +FRACGV1+ITACGV1+NLDCGV1+BELCGV1+ESPCGV1)*1.07039 $ () FRML IEU3XGSV EU3XGSV = (DNKXGSV1+SWEXGSV1+FINXGSV1+DEUXGSV1+GBRXGSV1 () +FRAXGSV1+ITAXGSV1+NLDXGSV1+BELXGSV1+ESPXGSV1) () *1.1558 $ () FRML IEU3MGSV EU3MGSV = (DNKMGSV1+SWEMGSV1+FINMGSV1+DEUMGSV1+GBRMGSV1 () +FRAMGSV1+ITAMGSV1+NLDMGSV1+BELMGSV1+ESPMGSV1) () *1.0752 $ () FRML IEU3ITV EU3ITV = EU3IPV+EU3IGV $ () FRML IEU3IRL EU3IRL = .244*DEUIRL+.017*DNKIRL () +.189*FRAIRL+.045*NLDIRL () +.178*ITAIRL+.091*ESPIRL () +.165*GBRIRL+.014*FINIRL () +.031*BELIRL+.026*SWEIRL $ () FRML IEU3EX1 EU3EX1 = ( 24.672*LOG(DEUEXCH/YPNEXCH) () + 75.328*LOG(DEUEXCH/USAEXCH))/100 $ () FRML IEU3EX EU3EX = EXP(EU3EX1-BEU3EX1)*100 $ () FRML IEU3TDDV EU3TDDV = (DNKDDV1+SWEDDV1+FINDDV1+DEUDDV1+GBRDDV1 () +FRADDV1+ITADDV1+NLDDDV1+BELDDV1+ESPDDV1)*1.0241 $ () FRML IEU3DV EU3DV = (DNKDV1+SWEDV1+FINDV1+DEUDV1+GBRDV1 () +FRADV1+ITADV1+NLDDV1+BELDV1+ESPDV1)*1.07039 $ () FRML IEU3TIV EU3TIV = (DNKTIV1+SWETIV1+FINTIV1+DEUTIV1+GBRTIV1 () +FRATIV1+ITATIV1+NLDTIV1+BELTIV1+ESPTIV1)*1.07039 $ () FRML IEU3YFV EU3YFV = (DNKYFV1+SWEYFV1+FINYFV1+DEUYFV1+GBRYFV1 () +FRAYFV1+ITAYFV1+NLDYFV1+BELYFV1+ESPYFV1)*1.07039 $ () FRML IEU3GNFL EU3GNFL =(DNKGNFL1+SWEGNFL1+FINGNFL1+DEUGNFL1+GBRGNFL1 () +FRAGNFL1+ITAGNFL1+NLDGNFL1+BELGNFL1+ESPGNFL1) $ () FRML IEU3REXCH EU3REXCH = (EU3PXGS/1.2460)/(EU3PMGS/1.1660)*100 $ () FRML IEU3BGNFL EU3BGNFL = EU3GNFL/EU3GDP*100 $ () FRML IEU3CPV1 EU3CPV1 = EU3CPV $ () FRML IEU3PCP1 EU3PCP1 = EU3PCP $ () FRML IEU3WR1 EU3WR1 = EU3WR $ () FRML IEU3IPV1 EU3IPV1 = EU3IPV $ () FRML IEU3GDPV1 EU3GDPV1 = EU3GDPV $ () FRML IEU3GDP1 EU3GDP1 = EU3GDP $ () FRML IEU3PGDP1 EU3PGDP1 = EU3PGDP $ () FRML IEU3NLG1 EU3NLG1 = EU3NLG $ () FRML IEU3IGV1 EU3IGV1 = EU3IGV $ () FRML IEU3CGV1 EU3CGV1 = EU3CGV $ () FRML IEU3CB1 EU3CB1 = EU3CB $ () FRML IEU3XGSV1 EU3XGSV1 = EU3XGSV $ () FRML IEU3MGSV1 EU3MGSV1 = EU3MGSV $ () FRML IEU3DDV1 EU3DDV1 = EU3TDDV $ () FRML IEU3DV1 EU3DV1 = EU3DV $ () FRML IEU3TIV1 EU3TIV1 = EU3TIV $ () FRML IEU3YFV1 EU3YFV1 = EU3YFV $ () FRML IEU3GNFL1 EU3GNFL1 = EU3GNFL $ () () () EURO OMRDET () FRML IEURYFBV EURYFBV = DEUYFBV1+FRAYFBV1+ESPYFBV1+NLDYFBV1+BELYFBV1+FINYFBV1+ITAYFBV1 $ () FRML IEURPYFB EURPYFB = (DEUYFBV1*DEUPYFB1+FRAYFBV1*FRAPYFB1+ESPYFBV1*ESPPYFB1+ () NLDYFBV1*NLDPYFB1+BELYFBV1*BELPYFB1+FINYFBV1*FINPYFB1+ () ITAYFBV1*ITAPYFB1)/EURYFBV $ ()