predictnl.ado

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

program FillG
	args G exp y touse pvars pcoms maxiter

	tempname b
	mat `b' = e(b)

	tokenize `G'
	local i 1
	while "``i''" != "" {
Deriv ``i'' `i' = `"`exp'"' `y' `b' `touse' "`pvars'" `"`pcoms'"' `maxiter'
		local i = `i' + 1
	}
end


program Deriv /* var j = exp y b touse pvars pcoms*/
	args var j equals exp y b touse pvars pcoms maxi

	tempvar w w2 absd absy
	tempname meand r0 

	Post `b' `j' "abs(`b'[1,`j'])*.01+.01" 
	ExpEval `w' `"`exp'"' `touse' "`pvars'" `pcoms'

	capture assert `w'==`y' if `touse'

	if !_rc {                                /* deriv is zero */
		exit
	}

	qui gen double `absd' = abs(`w'-`y') if `touse'
	summ `absd' if `touse', meanonly
	scalar `meand' = r(mean)
	qui gen double `absy' = abs(`y') if `touse'
	summ `absy' if `touse', meanonly
	scalar `r0' = r(mean)

	tempname db goal0 goal1 

	scalar `db' = abs(`b'[1,`j'])*.01 + .01

	scalar `goal0' = `r0'*1e-6 + 1e-6
	scalar `goal1' = `r0'*1e-5 + 1e-5

	local i 0
	while `meand' < `goal0' | `meand' > `goal1' {
 		scalar `db' = ((`goal0'+`goal1')/2)*`db'/`meand'
		if `db' < .  & `i' <= `maxi' { 
			Post `b' `j' `db' 
		}
		else {
			if `i'>`maxi' {
di as err "Maximum number of iterations exceeded."
				exit 498
			}
			exit
		}
		capture drop `w'
		ExpEval `w' `"`exp'"' `touse' "`pvars'" `pcoms'
		qui replace `absd' = abs(`w'-`y') if `touse'
		summ `absd' if `touse', meanonly
		scalar `meand' = r(mean)
		local i = `i' + 1
	}
	
	Post `b' `j' -`db'
	ExpEval `w2' `"`exp'"' `touse' "`pvars'" `pcoms'
	qui gen double `var' = (`w' - `w2') / (2*`db') if `touse'
end

program PostI, eclass 
	tempname b2 v2
	mat `b2' = e(b)
	mat `v2' = e(V)
	local cmd "`e(cmd)'"            

	if "`cmd'"=="probit" | "`cmd'"=="dprobit" {               
		ereturn post `b2' `v2', noclear
		ereturn local cmd "svyprobit"
		ereturn local predict "svylog_p"
		exit
	}
	if "`cmd'"=="logit" | "`cmd'"=="logistic" {
		ereturn post `b2' `v2', noclear
		ereturn local cmd "svylogit"
		ereturn local predict "svylog_p"
		exit
	}
	if "`cmd'"=="mlogit" {
		ereturn post `b2' `v2', noclear
		ereturn local cmd "svymlogit"
		tempname C
		mat `C' = e(cat)
		local k = colsof(`C')
		forvalues i = 1/`k' {
			local cati = `C'[1,`i']
			local cats : label (`e(depvar)') `cati'
			local cats = trim(substr(`"`cats'"',1,c(namelen)))
			local coln `"`coln' `"`cats'"'"'
		}
		mat coleq `C' = `coln'
		ereturn matrix cat = `C'
		exit
	}
        if "`cmd'" == "ologit" | "`cmd'" == "oprobit" & missing(e(version)) {
                local dep "`e(depvar)'"
                local cname : colnames `b2'
		tokenize `cname'
		local fname
                while "`1'" != "" {
                        local junk : subinstr local 1 /*
				*/ "_cut" "cut", count(local a)
                        if `a' == 1 {
                                local fname "`fname' `junk':_cons"
                        }
                        else local fname "`fname' `dep':`1'"
                        mac shift
                }
                mat colnames `b2'= `fname'
                mat colnames `v2'= `fname'
                mat rownames `v2'= `fname'
		ereturn post `b2' `v2', noclear
                if "`cmd'" == "oprobit" {
                        ereturn local cmd "svyoprobit"
                        ereturn local predict "ologit_p"
                }
                else ereturn local cmd "svyologit"
		exit
        }
        if ("`cmd'" == "tobit" | "`cmd'" == "cnreg") & missing(e(version)) {
                local cname : colnames `b2'
                tokenize `cname'
                local fname
		while "`1'" != "" {
                        if "`1'" != "_se" {
                                local fname "`fname' model:`1'"
                        }
                        else local fname "`fname' sigma:_cons"
                        mac shift
                }
                tempname sigma
                scalar `sigma' = `b2'[1,colsof(`b2')]
                mat colnames `b2' = `fname'
                mat colnames `v2' = `fname'
                mat rownames `v2' = `fname'
		ereturn post `b2' `v2', noclear
                ereturn scalar sigma = `sigma'
                ereturn local cmd "intreg"
		exit
        }
	ereturn post `b2' `v2', noclear
end

program CheckValid, eclass
	args command term touse var

	capture drop `var'
	capture noi `command', if `touse'
	if _rc {
		di as err `"`term' invalid"'
		exit 198
	}
end

program CheckBeta, eclass
	args f exp touse pvars pcoms force

	tempvar new
	tempname V oldest

	capture ExpEval `new' `"`exp'"' `touse' "`pvars'" `pcoms'
	capture assert reldif(`new',`f') < 1e-12 if `touse'
	if _rc {
		di as err /*
*/ "expression unsuitable for numerical derivative calculation"
		exit 498
	}

	if "`force'"=="" {
		mat `V' = e(V)
		local k = colsof(`V')
		mat `V'[1,1] = I(`k')
	
		_estimates hold `oldest', copy	
		preserve
		capture noisily nobreak {
			eret repost V = `V'
			capture drop `new'
			local scalars : e(scalars)
			foreach s of local scalars {
				if e(`s')~=int(e(`s')) {
					ereturn local `s' 
				}
			}
			tsrevar `e(depvar)', list
			if "`r(varlist)'"!="" {
				foreach k of varlist `r(varlist)' {
					capture replace `k' = 0
				}
			}
			capture ExpEval `new' `"`exp'"' `touse' "`pvars'" /*
				*/ `pcoms'
			capture assert reldif(`new',`f') < 1e-12 if `touse'
			if _rc {
				di as err /*
*/ "expression is a function of possibly stochastic quantities other than e(b)"
				exit 498
			}
		}
		restore
		_estimates unhold `oldest'
		if _rc {
			exit _rc
		}
	}
end

program Post, eclass /* b j deltab */
	tempname b2 
	mat `b2' = `1'
	mat `b2'[1,`2'] = `1'[1,`2'] + (`3')
	ereturn repost b=`b2'
end

program Scorebeta 
	syntax newvarname [if] [in] [, eq(passthru)]

	tempname beta
	matrix `beta' = e(b)

	qui mat score double `varlist' = `beta' `if' `in', `eq'
end

program CheckOpts, sclass
	syntax [,  se(string) VARiance(string) wald(string) /* 
		*/ p(string) ci(string)] 

	if `"`se'"'!="" {
		local wc : word count `se'
		if `wc' > 1 {
			di as err "may only specify one se variable"
			exit 103
		}
		confirm new variable `se'
	}
	if `"`variance'"'!="" {
		local wc : word count `variance'
		if `wc' > 1 {
			di as err "may only specify one var variable"
			exit 103
		}
		confirm new variable `variance'
	}
	if `"`wald'"'!="" {
		local wc : word count `wald'
		if `wc' > 1 {
			di as err "may only specify one Wald variable"
			exit 103
		}
		confirm new variable `wald'
	}
	if `"`p'"'!="" {
		local wc : word count `p'
		if `wc' > 1 {
			di as err "may only specify one p variable"
			exit 103
		}
		confirm new variable `p'
	}
	if `"`ci'"'!="" {
		local wc : word count `ci'
		if `wc' != 2 {
			di as err "must specify exactly two ci variables"
			exit cond(`wc'<2,102,103)
		}
		confirm new variable `ci'
		local ci1 : word 1 of `ci'
		local ci2 : word 2 of `ci'
	}
	sreturn local se "`se'"
	sreturn local var "`variance'"
	sreturn local wald "`wald'"
	sreturn local p "`p'"
	sreturn local ci1 "`ci1'"
	sreturn local ci2 "`ci2'"
end

program DenomDOF, rclass
	if "`e(cmd)'" != "" {
		return scalar df_r = e(df_r)
		exit
	}
	capture est dir
	if !_rc {
		return scalar df_r = _result(5)
		exit
	}
	return scalar df_r = .
end

program FixExp, rclass
	args exp com
	while `"`exp'"' != "" {
		gettoken ub exp: exp, /*
			*/ parse(`" "`'~:;,<>\/?!@|#$%^&*()-+=[]{}"') quotes
		if `"`ub'"' != "_b" & `"`ub'"' != "_se" {
			local myexp `"`myexp'`ub'"'
			continue
		}
		gettoken bracket exp : exp, parse(" [")
		if `"`bracket'"' != "[" {             /* False alarm */
			local myexp `"`myexp'`ub'`bracket'"'
			continue
		}
		gettoken arg exp: exp, parse(" ]")
		if "`com'"=="tobit" | "`com'"=="cnreg" {
			local arg : subinstr local arg "_se" "/sigma"
		}
		else {                        /* ologit, oprobit */
			local arg : subinstr local arg "_cut" "/cut"
		}
		local myexp `"`myexp'`ub'`bracket'`arg'"'
	}
	return local exp `"`myexp'"'
end

exit

Internal documentation

The delta-method formula is

           V = GVG'

where G is the derivative vector of predict_exp with respect to e(b).