svar.ado

是一个经济学管理应用软件 很难找的 但是经济学学生又必须用到

		global T_Abari `abari'

		_mkpmats, neqs(`neqs') lr
		local kiparms "`r(kiparms)'"

		local cns_ki `lrconstraints' `imp_cnski'
		local fullcns `lrconstraints' `imp_cnski'


		foreach cnsitem of local cns_ki {
			constraint get `cnsitem'
			if "`cns_ki_list'" == "" {
				local cns_ki_list "`r(contents)'"
			}
			else {
				local cns_ki_list "`cns_ki_list':`r(contents)'"
			}	
		}

		if "`from'" == "" {
			mat `starts' = J(1,`neqs'*`neqs',1)
			local base = `neqs'*`neqs'
			forvalues i = 1/`base' {
				mat `starts'[1,`i'] = 1+`i'/100
			}
			local init  "init(`starts', copy)"
		}
		else {
			local init  "init(`from')"
			capture ml model d2 _svarlrd2  `kiparms' if `touse', /*
				*/ const(`fullcns') max `mlopts' search(off) /*
				*/ nopreserve svarconst `init' iter(0) nolog
			if _rc > 0 {
				di as err "initial values not feasible"
				
				if "`imp_cnski'" != "" {
					constraint drop `imp_cnski' 
				}	
				exit _rc
			}	
				
			mat `starts' = e(b)	
		
		}

		if "`idencheck'" == "" {
			_svaridenlr, b(`starts') cnsk(`cns_ki') 	/*	
				 */ neqs(`neqs') sigma(`sigma')		/*
				 */  bigt(`N') impcns(`imp_cnski')	/*
				 */ abar(`abar') abari(`abari')
		}	 

		
		di as txt "Estimating long-run parameters"
		capture noi ml model d2 _svarlrd2  `kiparms' if `touse', /*
			*/ const(`fullcns') max `mlopts' search(off) /*
			*/ nopreserve svarconst `init' `log' 

		if _rc > 0 {
			if "`imp_cnski'" != "" {
				constraint drop `imp_cnski' 
			}	
			exit _rc
		}	
		

	}

				/* drop global macros used in 
				 * ML evaluator */
	capture macro drop T_T T_neqs T_sigma
	
	mat `b_svar' = e(b)
	mat `v_svar' = e(V)
	scalar `ll_svar' = e(ll)
	local rc_ml   = e(rc)
	local ic_ml   = e(ic)
	local rank       = e(rank)

	mat `Cns' = get(Cns)

/* calculate number of independent restrictions */

/* 	since e(rank) = rank of e(V)
	      e(rank) = number of estimated parms 
	           - number of independent restrictions imposed
*/		   

	local N_cns = e(k)-e(rank)

	ereturn post  `b_svar' `v_svar' `Cns', esample(`touse') obs(`N') 

	ereturn matrix b_var = `b_var'
	ereturn matrix V_var = `v_var'

	if  "`lreq'`lrconstraints'`lrcns'" == "" { 
		local overid_df = `N_cns' - 2*(`neqs')^2+.5*((`neqs')^2+`neqs') 
		eret scalar oid_df = `overid_df'
	}
	else {
		local overid_df = `N_cns' - (`neqs')^2+.5*((`neqs')^2+`neqs') 
		eret scalar oid_df = `overid_df'
	}
	if `overid_df' > 0 {
		if "`dfk'" != "" {
			eret scalar chi2_oid = 2*(`ll_dfk_var'- `ll_svar')
		}
		else {
			eret scalar chi2_oid = 2*(`ll_var'- `ll_svar')
		}
	}

	if `overid_df' < 0 {
		di as err "the number of overidentifying restrictions " /*
			*/ " is negative"
		di as err "the fitted model might not be identified"	
	}	

	
	if  "`lreq'`lrconstraints'`lrcns'" == "" { 
		mat `a_est' = J(`neqs', `neqs', 0)
		mat `b_est' = J(`neqs', `neqs', 0)
		forvalues j = 1/`neqs' {
			forvalues i = 1/`neqs' {
				mat `a_est'[`i',`j'] = _b[a_`i'_`j':_cons]
				mat `b_est'[`i',`j'] = _b[b_`i'_`j':_cons]
			}
		}
		mat colnames `a_est' = `eqnames_var'
		mat rownames `a_est' = `eqnames_var'
		mat colnames `b_est' = `eqnames_var'
		mat rownames `b_est' = `eqnames_var'
	}
	else {
		mat `a_est' = I(`neqs')
		mat `klr_est' = J(`neqs', `neqs', 0)
		forvalues j = 1/`neqs' {
			forvalues i = 1/`neqs' {
				mat `klr_est'[`i',`j'] = _b[c_`i'_`j':_cons]
			}
		}
		mat `b_est' = `abar'*`klr_est'

		mat colnames `klr_est' = `eqnames_var'
		mat rownames `klr_est' = `eqnames_var'
		mat colnames `b_est' = `eqnames_var'
		mat rownames `b_est' = `eqnames_var'
		mat colnames `abar' = `eqnames_var'
		mat rownames `abar' = `eqnames_var'
	}
	

	if "`imp_cnsa'`imp_cnsb'" != "" {
		constraint drop `imp_cnsa' `imp_cnsb'
	}	

	if "`imp_cnski'" != "" {
		constraint drop `imp_cnski' 
	}	

	
	if  "`lreq'`lrconstraints'`lrcns'" != "" { 
		tempname atemp
		mat `atemp' = I(rowsof(`abar'))

		eret mat A  = `atemp'
		eret mat A1 = `abar'
		eret mat B = `b_est'
		eret mat C  = `klr_est'
		eret local lrmodel  lrmodel

		local k_eq  = (`neqs'^2)
		local k_aux = (`neqs'^2)

		if "`lreq'" != "" {
			eret mat lreq `lreq' , copy
		}
		if "`lrcns'" != "" {
			eret mat lrcns `lrcns'
		}	

		eret local cns_lr "`cns_ki_list'"
	}
	else {
		local k_eq  = 2*(`neqs'^2)
		local k_aux = 2*(`neqs'^2)

		if "`aeq'" != "" {
			eret mat aeq `aeq', copy
		}
		if "`beq'" != "" {
			eret mat beq `beq', copy
		}
		if "`acns'" != "" {
			eret mat acns `acns', copy
		}
		if "`bcns'" != "" {
			eret mat bcns `bcns', copy
		}

		eret local cns_a "`cns_a_list'"
		eret local cns_b "`cns_b_list'"
	}

	if  "`lreq'`lrconstraints'`lrcns'" == "" { 
		eret mat A `a_est', copy
		eret mat B `b_est', copy
	}

	eret mat bf_var	= `bf_var' 
	eret mat G_var  = `G_var'
	eret mat Sigma  = `sigma' 
	
	if "`cnslist_var'" != "" {
		eret mat Cns_var = `Cns_var'
	}


	eret scalar rc_ml = `rc_ml'
	eret scalar ic_ml = `ic_ml'
	eret scalar N_cns = `N_cns'
	eret scalar neqs  = `neqs'		// now undocumented
	eret scalar k_dv  = `neqs'		// follow convention
	eret scalar neqs_var  = `neqs'		// undocumented
	eret scalar k_dv_var  = `neqs'		// follow convention

	eret scalar k_eq_var  = `neqs'
	eret scalar k_eq  = `k_eq'
	eret scalar k_aux = `k_aux'

	eret scalar df_eq_var = `df_eq_var'
	eret scalar k_var = `k_var'
	eret scalar tparms_var = `tparms_var'
	
	eret scalar sbic_var 	= `sbic_var'
	eret scalar hqic_var 	= `hqic_var'
	eret scalar aic_var 	= `aic_var'
	eret scalar fpe_var 	= `fpe_var'

	eret scalar mlag_var   	= `mlag_var' 
	eret scalar tmax    	= `tmax_var'
	eret scalar tmin    	= `tmin_var'
	eret scalar N_gaps_var  = `N_gaps_var'
	eret scalar T_var       = `T_var'

	eret scalar detsig_var     = `detsig_var'
	eret scalar detsig_ml_var  = `detsig_ml_var'
	eret scalar ll_var         = `ll_var'
	eret scalar ll		   = `ll_svar'
	
	if "`small'" != "" {
		eret scalar df_r_var 		= `df_r_var'
		eret scalar df_r                = `T_var'-`rank'
		local dfr                	= `T_var'-`rank'
		forvalues i = 1/`neqs' {
			eret scalar obs_`i'_var	= `obs_`i'_var'
			eret scalar k_`i'_var 	= `k_`i'_var'
			eret scalar rmse_`i'_var= `rmse_`i'_var'
			eret scalar r2_`i'_var  = `r2_`i'_var'
			eret scalar ll_`i'_var	= `ll_`i'_var'
			eret scalar df_m`i'_var	= `df_m`i'_var'
			eret scalar df_r`i'_var	= `df_r`i'_var'
			eret scalar F_`i'_var	= `F_`i'_var'
		}
	}	
	else {
		forvalues i = 1/`neqs' {
			eret scalar obs_`i'_var	= `obs_`i'_var'
			eret scalar k_`i'_var 	= `k_`i'_var'
			eret scalar rmse_`i'_var= `rmse_`i'_var'
			eret scalar r2_`i'_var  = `r2_`i'_var'
			eret scalar ll_`i'_var	= `ll_`i'_var'
			eret scalar df_m`i'_var	= `df_m`i'_var'
			eret scalar chi2_`i'_var= `chi2_`i'_var'
		}
	}
	eret local title "Structural vector autoregression"
	eret local small `small'
	eret local lutstats_var `lutstats'
	eret local tsfmt "`tsfmt'"
	eret local timevar "`timevar'"

	eret local endog_var `endog_var' 
	eret local exog_var `exog_var'
	eret local eqnames_var `eqnames_var'
	eret local depvar_var   `depvar_var'
	eret local lags_var `lags_var'
	eret local nocons_var `nocons_var'
	eret local vcetype EIM

	if "`varconstraints'" != "" {
		eret local constraints_var constraints_var
	}	
	
	if "`dfk'" != "" {
		eret local dfk_var dfk
	}	
	
	eret local predict svar_p
	eret local cmd svar
	
	Dheadernew

	if "`e(small)'" != "" {
		ETable2 , level(`level') dfr(`dfr')
	}
	else {
		ETable2 , level(`level') 
	}
end


program define _mkpmats , rclass
	syntax , neqs(numlist max=1 >0) [ lr ]

	if "`lr'" == "" {
		forvalues i = 1/`neqs' {
			forvalues j = 1/`neqs' {
				local aparms " `aparms' (a_`j'_`i':) "
				local bparms " `bparms' (b_`j'_`i':) "
			}
		}

		return local aparms "`aparms'"
		return local bparms "`bparms'"
	}
	else {
		forvalues i = 1/`neqs' {
			forvalues j = 1/`neqs' {
				local kiparms " `kiparms' (c_`j'_`i':) "
			}
		}

		return local kiparms "`kiparms'"
	}
end


program define _PARSEab

	syntax , mat(string) name(string) neqs(integer) tname(string)
	
	local toks : word count `mat'
	if `toks' == 1 {
		capture confirm matrix `mat'
		if _rc > 0 {
			di as err "`name'(`mat') does not define a matrix"
			exit 198
		}	
		mat `tname' = `mat'
		exit
	}
	capture matrix input `tname' = `mat'
	if _rc > 0 {
		di as err "`name'(`mat') does not define a matrix"
		exit 198
	}	

end	

program define _svar_mkmatcns, rclass
		syntax , mat(string) name(string) neqs(integer) 	/*
			*/ tname(string) type(string) [ eq ]
		_PARSEab, mat(`mat') name(`name') neqs(`neqs') tname(`tname')
		
		capture assert rowsof(`tname') == `neqs'
		if _rc > 0 {
			di as err "`type' matrix does not have the "/*
				*/ " correct row dimension"
			exit 198
		}		
		capture assert colsof(`tname') == `neqs'
		if _rc > 0 {
			di as err "`type' matrix does not have the "/*
				*/ " correct column dimension"
			exit 198
		}		
		if "`eq'" == "" {
			_svar_cnsmac, mat(`tname') name(`name') neqs(`neqs')
		}
		else {
			_svar_eqmac, mat(`tname') name(`name') 	/*
				*/ neqs(`neqs') 
		}
		local cnsmac "`r(cnsmac)'"
		gettoken tok cnsmac: cnsmac ,parse(":") 
		if "`cnsmac'" == "" {
			di as err "no constraints implied by matrix `a'"
			exit 498
		}	
		while "`cnsmac'" != "" {
			gettoken tok cnsmac:cnsmac, parse(":")
			if "`tok'" != ":" {
				_svar_newcns `tok'
				local svar_cnslist `svar_cnslist' `r(new)'

			}
		}
		ret local svar_cnslist `svar_cnslist'
end 		


program define Dheadernew
	local neqs = e(neqs)
	local vlist "`e(endog_var)'"

	di
	di as txt "Structural vector autoregression"
	di

	matrix dispCns, r
	if r(k) > 0 {
		di as txt "Constraints:"
		matrix dispCns
		di
	}		


	local t0 : di `e(tsfmt)' e(tmin)
	local tN : di `e(tsfmt)' e(tmax)

	di as txt "Sample:" as result "`t0' `tN'"		///
		as txt "{col 52}No. of obs{col 68}= " as res %9.0f e(N)

	if e(oid_df) < 1 {
		di as txt "Exactly identified model"		///
			"{col 52}Log likelihood{col 68}= " 	///
			as res %9.8g e(ll)	
	}
	else {
		di as txt "Overidentified model"		///
			"{col 52}Log likelihood{col 68}= " 	///
			as res %9.8g e(ll)	
	}
	di
end

program define _getAbar 
	syntax , nlags(integer) neqs(integer) abar(string) nexog(integer) /*
		*/ ncons(integer)

	tempname b 

	mat `b' = e(b)
	mat `abar' = I(`neqs')

	local col 0
	forvalues i = 1/`neqs' {
		forvalues j = 1/`neqs' {
			forvalues lg = 1/`nlags' {
				local ++col
				mat `abar'[`i',`j'] = `abar'[`i',`j'] 	/*
					*/ - `b'[1,`col']
			}
		}
		local col = `col' + `nexog' + `ncons'
	}
end


program define ETable2, eclass
	syntax , level(cilevel) [ full  dfr(numlist max = 1 >0)]

	tempname b v bt vt esample rowt eres
		
	mat `b' = e(b)
	mat `v' = e(V)

	local k_eq  = e(k_eq)
	local k_aux = e(k_aux)
	local sep   = e(neqs)^2
		
	nobreak {
		capture _est hold `eres', varname(`esample') restore
		eret post `b' `v'
		if "`dfr'" != "" {
			eret scalar df_r = `dfr'
		}	

		eret scalar k_eq  = `k_eq'
		eret scalar k_aux = `k_aux'

		eret local cmd "svar"

		_coef_table , level(`level') separator(`sep')

		_est unhold `eres'
	}
	
	
	if e(oid_df) >= 1 {
		di as txt "LR test of identifying restrictions:"	/// 
			"{col 39}chi2(" as res %3.0f e(oid_df)		/// 
			as txt ")= " _col(51) as res %7.4g e(chi2_oid)	///
			as txt "{col 60}Prob > chi2{col 72}="  		///
			 as res %6.3f chi2tail(e(oid_df),e(chi2_oid))
	}		
end