frontier.ado

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

				mat `b0' = `bx', `mu', `ltgamma', `lnsigS2'
			}
			else {
				local nzs : word count `zhet'
				tempname zd
				if "`znocns'"=="" {
					local nzs = `nzs'+1
					mat `zd' = J(1,`nzs',0)
					mat `zd'[1,`nzs'] = `mu'
				}
				else {
					mat `zd' = J(1,`nzs',0)
				}
				mat `b0'=`bx', `zd', `ltgamma', `lnsigS2'
			} 
		}
		local start "init(`b0', copy)"
	}

					/* Normal-Half Normal Model, default*/
	if "`dist'" == "hnormal" {
		local mlprog "fron_hn"
		local title "Stoc. frontier normal/half-normal model"
	}
						/* Normal-Exponential Model */
	if "`dist'" == "exponential" {
		local mlprog "fron_ex"
		local title "Stoc. frontier normal/exponential model"
	}
					/* Normal-Truncated Normal model */
	if "`dist'" == "tnormal" {
		if "`utransformed'" == "" {
			local mlprog "fron_tn"
		}
		else {
			local mlprog "fron_tn2"
			local star "*"
		}
		local title "Stoc. frontier normal/truncated-normal model"


		ml model d2 `mlprog' (`lhs': `lhs'=`varlist', `nocns') 	/*
			*/ (mu: `zhet', `znocns') 			/*
			*/ (ilgtgamma: ) 				/*
			*/ (lnsigma2: ) 				/*
			*/ `wtopt' if `touse', collinear 		/* 
			*/ max miss `start' search(off) nopreserve 	/*
			*/ `mlopts' `log' 				/*
			*/ title("`title'") 				/*
			*/ `difficult' `score'

		`star' UnTrans
	}
	else {
		ml model d2 `mlprog' (`lhs': `lhs'=`varlist', `nocns')  /*
			*/ (lnsig2v: `vhet', `vnocns') 			/*
			*/ (lnsig2u: `uhet', `unocns') 			/*
			*/ `wtopt' if `touse', collinear 		/* 
			*/ max miss `start' search(off) nopreserve 	/*
			*/ `mlopts' `log' 				/*
			*/ title("`title'") 				/*
			*/ `difficult' `score'
	}

			/* One-sided generalised likelihood-ratio test */
	if "`ll0_u'" != "" & "`u'`v'`cns'" == "" ///
	& "`e(vcetype)'" != "Robust" {
		eret scalar ll_c = `ll0_u'
		if e(ll) < e(ll_c) {
			eret scalar chi2_c = 0
		}
		else	eret scalar chi2_c = 2*(e(ll)-e(ll_c))
	}

	if "`u'`v'" == "" & "`zhet'" == "" {
		eret scalar z = `m3t'
		eret scalar p_z = `p_m3t'
	}

	if "`dist'" != "tnormal" {
		if "`uhet'"=="" {
			eret scalar sigma_u = exp([lnsig2u]_cons/2) 
		}
		if "`vhet'"=="" {
			eret scalar sigma_v = exp([lnsig2v]_cons/2) 
		}
		eret local v_hetvar "`vhet'"
		eret local u_hetvar "`uhet'"
	}
	else {
		eret local cm "`zhet'"
		tempname s2 g
		scalar `s2' = exp([lnsigma2]_cons)
		scalar `g'  = [ilgtgamma]_cons
		scalar `g'  = exp(`g')/(1+exp(`g'))
		eret scalar sigma_u = sqrt(`g'*`s2')
		eret scalar sigma_v = sqrt((1-`g')*`s2')
	}

	eret local wtype "`weight'"
	eret local wexp "`exp'"
	eret local predict "fron_p"
	eret local dist "`dist'"
	eret local function "`function'"
	eret local het "`u'`v'"

	eret local cmd "frontier"		/* last eret */

	Replay, level(`level')	
	mac drop S_COST
end


program define UnTrans, eclass

	tempname b b0 b1 V s J
	matrix `b' = e(b)
	matrix `V' = e(V)
	local dim = colsof(matrix(`b'))

	scalar `s' = `b'[1,`dim'] 		/* ln(sigmaS^2) */
	scalar `s' = exp(0.5*`s')		/* sigmaS */

					/* Compute Jacobian. */

	matrix `b1'= -0.5*`b'[1,1..`dim'-2]
	matrix `J' = (diag(J(1,`dim'-2,1/`s')), J(`dim'-2,1,0) /*
		*/, `b1'' \ J(2,`dim'-2, 0), I(2) )

				/* Untransform variance `V'. */

	mat `V' = `J''*syminv(`V')*`J'
	mat `V' = syminv(0.5*(`V' + `V''))	/* make it symmetric */

				/* Untransform coefficient vector. */

	matrix `b0' = `b'[1,1..`dim'-2]
	matrix `b0' = `s'*`b0'
	matrix `b'  = `b0', `b'[1,`dim'-1], `b'[1,`dim']

						/* Repost. */

	eret repost b=`b' V=`V'

					/* Redo Wald test. */

	if "`e(chi2type)'"=="Wald" {
		eret scalar chi2 = .
		eret scalar p = .

		_evlist

		if "`s(varlist)'"!="" {
			capture test `s(varlist)', min
			eret scalar df_m = r(df)
			eret scalar chi2 = r(chi2)
			eret scalar p = r(p)
		}
	}

end


/* ---------------------------DISPLAY------------------------------------- */

program define Replay
	syntax [, Level(cilevel)]

	if "`e(dist)'" != "tnormal" {
		if "`e(het)'" == "" {
			ml display, level(`level') first plus
		
			_diparm lnsig2v, level(`level')
			_diparm lnsig2u, level(`level')

			di as text "{hline 13}" _col(14) `"{c +}"' "{hline 64}"
		
			_diparm lnsig2v, level(`level') func( exp(0.5*@) ) /*
				*/ der( 0.5*exp(0.5*@) ) label(sigma_v)
			_diparm lnsig2u, level(`level') func( exp(0.5*@) ) /*
				*/ der( 0.5*exp(0.5*@) ) label(sigma_u)
			_diparm lnsig2v lnsig2u, level(`level') /*
				*/ func( exp(@1)+exp(@2) ) /*
				*/ der( exp(@1) exp(@2) ) label(sigma2)
			_diparm lnsig2v lnsig2u, level(`level') /*
				*/ func( sqrt(exp(@2-@1))) /*
				*/ der( -0.5*exp(0.5*@1) 0.5*exp(0.5*@2) ) /*
				*/ label(lambda) 
			di as text "{hline 13}" _col(14) `"{c BT}"' /*
				*/"{hline 64}"
		}

		else if "`e(het)'" == "v" {
			ml display, level(`level') plus

			_diparm lnsig2u, level(`level') func( exp(0.5*@) ) /*
				*/ der( 0.5*exp(0.5*@) ) label(sigma_u)

			di as text "{hline 13}" _col(14) `"{c BT}"' /*
				*/ "{hline 64}"
		}	

		else if "`e(het)'" == "u" {
			ml display, level(`level') plus

			_diparm lnsig2v, level(`level') func( exp(0.5*@) ) /*
				*/ der( 0.5*exp(0.5*@) ) label(sigma_v)
			di as text "{hline 13}" _col(14) /*
				*/ `"{c BT}"' "{hline 64}"
		}			

		else if "`e(het)'" == "uv" {
			ml display, level(`level')
		}
	}
	else {
		if "`e(cm)'" == "" {
			ml display, level(`level') first plus
		
			_diparm mu, level(`level') 
		}
		else {
			ml display, level(`level') neq(2) plus
		}

		_diparm lnsigma2, level(`level')
		_diparm ilgtgamma, level(`level')

		di as text "{hline 13}" _col(14) `"{c +}"' "{hline 64}"
		
		_diparm lnsigma2, level(`level') exp label(sigma2)
		_diparm ilgtgamma, level(`level') ilogit label(gamma)
		_diparm lnsigma2 ilgtgamma, /*
			*/ func( exp(@1)*exp(@2)/(1+exp(@2)) ) /*
			*/ der( exp(@1)*exp(@2)/(1+exp(@2)) /*
			*/ exp(@1)*(exp(@2)/(1+exp(@2))/*
			*/-(exp(@2)/(1+exp(@2)))^2) ) /*
			*/ label(sigma_u2)
		_diparm lnsigma2 ilgtgamma, /*
			*/ func( exp(@1)*(1-exp(@2)/(1+exp(@2))) ) /*
			*/ der( exp(@1)*(1-exp(@2)/(1+exp(@2)))  /*
			*/ (-exp(@1))*(exp(@2)/(1+exp(@2))/*
			*/-(exp(@2)/(1+exp(@2)))^2)) /*
			*/ label(sigma_v2) 
		di as text "{hline 13}" _col(14) `"{c BT}"' "{hline 64}"
	}

						/* LR test */
	if "`e(het)'"=="" & "`e(vcetype)'" != "Robust" /*
		*/ & "`e(dist)'" != "tnormal" { 
			DispLR
	}
						/* 3rd moment test */
	if "`e(dist)'" == "tnormal" & "`e(cm)'" == "" {
		if `"`e(function)'"' == "cost" {
			local sign ">"
		}
		else {
			local sign "<"
		}
			
		di as text "H0: No inefficiency component: " _c
		di as text _col(43) "z = " as res %7.3f e(z) _c

		di _col(64) as text "Prob`sign'=z = "  /*
			*/ as result %5.3f e(p_z)
	}
	/* All -ml display's except in the case of e(het)="uv"
	   are called with plus, which prevents convergence not
	   achieved message from appearing even if appropos, so
	   call _prefix_footnote to add it if needed.		*/
	if "`e(het)'" != "uv" {
		_prefix_footnote
	}
end


program define DispLR

	if e(chi2_c)>=. {
		exit
	}

	tempname pval
					/* half-normal or exponential */
	if `"`e(dist)'"' ~= "tnormal" {
        	scalar `pval' = chi2tail(1, e(chi2_c))*0.5
	}

        if e(chi2_c)==0 { 
		scalar `pval'= 1 
	}

	if ((e(chi2_c) > 0.005) & (e(chi2_c)<1e+2)) /*
		*/ | (e(chi2_c)==0) {
                local fmt "%-6.2f"
        }
        else {
		local fmt "%-6.2e"
	}

       	di as text "Likelihood-ratio test of sigma_u=0: " _c

        di _col(37) in smcl "{help j_chibar##|_new:chibar2(01) = }" /*
        	*/ as result `fmt' e(chi2_c) _c
        di _col(58) as text "Prob>=chibar2 = " as result %5.3f /*
                */ `pval'

end



/* ----------------------------------------------------------------- */

program define ParseDist
	args 	retmac 		/* local macro to hold result
	*/	colon 		/* ":" ignored 
	*/	distribution	/* distribution or family */

	local 0 ", `distribution'"
	syntax [, Hnormal Exponential Tnormal * ]

	if `"`options'"' != "" {
		di as error "distribution(`options') not allowed"
		exit 198
	}

	local wc : word count `hnormal' `exponential' `tnormal'

	if `wc' > 1 {
		di as error "distribution() invalid, only " /*
			*/ "one distribution can be specified"
		exit 198
	}

	if `wc' == 0 {
		c_local `retmac' hnormal
	}
	else	c_local `retmac' `hnormal'`exponential'`tnormal'

end

/* Given a list "cat dog lizard", the following program returns 
   "cat, dog, and lizard".  The list "cat dog" becomes "cat and dog"
*/
program define AddCommas

	args	   output	/* Destination for cleaned list
		*/ colon	/* ":"
		*/ orig		/* List of tokens to be fixed. */

	local n : word count `orig'
	tokenize `orig'
	local newlist `"`1'"'
	if `n' > 1 {
		forvalues i = 2/`=`n'-1' {
			local newlist `"`newlist', ``i''"'
		}
		if `n' > 2 {
			local comma ","
		}
		local newlist `"`newlist'`comma' and ``n''"'
	}
	
	c_local `output' `newlist'
	
end

/* ---------------------------END----------------------------------- */