|
|
|
|
| program coefplot
|
| version 11
|
| nobreak {
|
| capt mata: mata drop COEFPLOT_STRUCT
|
| capt n break _coefplot `macval(0)'
|
| local rc = _rc
|
| capt mata: mata drop COEFPLOT_STRUCT
|
| exit `rc'
|
| }
|
| end
|
|
|
| program _coefplot, rclass
|
|
|
| parse_subgraphs `macval(0)'
|
| parse_globalopts `macval(opts)'
|
|
|
|
|
|
|
| tempname ecurrent
|
| _est hold `ecurrent', restore estsystem nullok
|
| mata: COEFPLOT_STRUCT = coefplot_struct_init()
|
|
|
|
|
| local i 0
|
| local N_plots 0
|
| forv j = 1/`n_subgr' {
|
| if "`recycle'"=="" local i 0
|
| local firstplot_`j' = `i'+1
|
| parse_plots `j' `macval(subgr_`j')'
|
| if ("`recycle'"=="" & `n_subgr'>1) {
|
| combine_plotopts, `macval(opts)' _opts0(`macval(plotopts1prev)')
|
| local plotopts1prev `macval(plotopts)'
|
| local opts `macval(plotopts)' `macval(options)'
|
| }
|
| merge_subgropts, `macval(opts)' _opts0(`subgropts0' `plotopts0' `macval(modelopts0)')
|
|
|
| parse_subgropts `j', `subgropts'
|
| forv k = 1/`n_plots_`j'' {
|
| local ++i
|
| local twplotopts1_`i' `twplotopts1_`i'' `twplotopts1'
|
| parse_models `j' `k' `macval(plot_`j'_`k')'
|
|
|
| if `n_models_`j'_`k''==1 & `"`model_`j'_`k'_1'"'=="_skip" {
|
| if `"`opts'"'!="" {
|
| di as err "options not allowed with _skip"
|
| exit 198
|
| }
|
| continue
|
| }
|
| if (`i'>`N_plots') {
|
| parse_get_popt_i `i', `macval(twplotopts0)'
|
| if `"`macval(plotopts)'"'!="" {
|
| merge_plotopts, `macval(plotopts)'
|
| local popt_mopts_`i' `macval(modelopts2)'
|
| merge_plotopts, `macval(opts)'
|
| _opts0(`macval(modelopts2)' `plotopts' `_opts0' `options')
|
|
|
| local opts `macval(modelopts2)' `plotopts' `_opts0' `options'
|
| }
|
| }
|
| else {
|
| if `"`macval(popt_mopts_`i')'"'!="" {
|
| merge_plotopts, `macval(opts)' _opts0(`macval(popt_mopts_`i')')
|
|
|
| local opts `macval(modelopts2)' `plotopts' `_opts0' `options'
|
| }
|
| }
|
| if ("`recycle'"=="" & `n_subgr'>1) {
|
| combine_plotopts, `macval(opts)' _opts0(`macval(plotopts2_`i')')
|
| local plotopts2_`i' `macval(plotopts)'
|
| local opts `macval(plotopts)' `macval(options)'
|
| }
|
| merge_plotopts, `macval(opts)' _opts0(`macval(plotopts1)' `macval(modelopts1)')
|
|
|
| if `"`_opts0'"'!="" error 198
|
| local modelopts_`j'_`k' `macval(modelopts2)'
|
| local twplotopts_`i' `twplotopts_`i'' `options'
|
| local plotopts_`i' `plotopts'
|
| }
|
| local lastplot_`j' `i'
|
| local N_plots = max(`N_plots', `i')
|
| }
|
|
|
| local customoffset 0
|
| forv i = 1/`N_plots' {
|
| parse_plotopts `i', `plotopts_`i''
|
| if `"`offset_`i''"'!="" local customoffset 1
|
| }
|
|
|
| forv i = 1/`N_plots' {
|
| local cis_`i' = `"`cismooth_`i''"'!=""
|
| if `cis_`i'' {
|
| if `"`cismooth_`i''"'=="cismooth" local cismooth_`i'
|
| parse_cismooth `i', `cismooth_`i''
|
|
|
| }
|
| else local cis_n_`i' = 0
|
| }
|
|
|
|
|
| local i 0
|
| forv j = 1/`n_subgr' {
|
| if "`recycle'"=="" local i 0
|
| forv k = 1/`n_plots_`j'' {
|
| local ++i
|
| if `n_models_`j'_`k''==1 & `"`macval(model_`j'_`k'_1)'"'=="_skip" {
|
| continue
|
| }
|
| forv l = 1/`n_models_`j'_`k'' {
|
| parse_model `macval(model_`j'_`k'_`l')'
|
| if `"`matrix'"'=="" {
|
| if `"`model'"'=="." {
|
| _est unhold `ecurrent'
|
| }
|
| else {
|
| qui est restore `model'
|
| }
|
| }
|
| collect_coefs `"`model'"'
|
| "`matrix'"
|
| "`atmode'"
|
| `i'
|
| `j'
|
| "`cis_levels_`i''"
|
| , `macval(opts)' _opts0(`macval(modelopts_`j'_`k')')
|
|
|
|
|
| local n_ci = `n_ci' - `cis_n_`i''
|
| if `"`matrix'"'=="" & `"`model'"'=="." {
|
| _est hold `ecurrent', restore estsystem nullok
|
| }
|
| if "`n_ci_`i''"=="" local n_ci_`i' 0
|
| local n_ci_`i' = max(`n_ci_`i'', `n_ci')
|
| mata: coefplot_add_label(COEFPLOT_STRUCT, "by", `j', "model", 0)
|
| if `"`equation'"'!="" {
|
| if `"`model'"'=="." local model `"`equation'"'
|
| else local model `"`model'=`equation'"'
|
| }
|
| mata: coefplot_add_label(COEFPLOT_STRUCT, "plot", `i', "model", 0)
|
| }
|
| }
|
| }
|
| forv i = 1/`N_plots' {
|
| if `n_ci_`i''>0 {
|
| parse_ciopts_nocilwincr `i', `ciopts_`i'' `cirecast_`i''
|
| parse_ciopts `i' `n_ci_`i'' `ciopts_`i'' `cirecast_`i''
|
| }
|
| }
|
| mata: coefplot_set_r(COEFPLOT_STRUCT)
|
| local mlbllen = max(1, min(c(maxstrvarlen), `mlbllen'))
|
| if `r'==0 {
|
| di as txt "(nothing to plot)"
|
| exit
|
| }
|
|
|
|
|
| if `"`horizontal'`vertical'"'=="" {
|
| if `atmode' local vertical vertical
|
| else local horizontal horizontal
|
| }
|
| if `"`horizontal'"'!="" {
|
| local xaxis y
|
| local yaxis x
|
| local offdir "-"
|
| local reverse yscale(reverse)
|
| local plotregion plotregion(margin(t=0 b=0))
|
| }
|
| else {
|
| local xaxis x
|
| local yaxis y
|
| local offdir "+"
|
| local plotregion plotregion(margin(l=0 r=0))
|
| }
|
| if `atmode' {
|
| if "`bycoefs'"!="" {
|
| di as err "at() and bycoefs not both allowed"
|
| exit 198
|
| }
|
| local grid `"`grid'`gridopts'"'
|
| foreach opt in order coeflabels eqlabels relocate headings
|
| groups grid {
|
| if `"``opt''"'!="" {
|
| di as err "at() and `opt'() not both allowed"
|
| exit 198
|
| }
|
| }
|
| mata: coefplot_add_eq_and_grp(COEFPLOT_STRUCT)
|
| local reverse
|
| local plotregion
|
| local meqs 0
|
| }
|
| else {
|
| if `"`eqstrict'"'!="" local meqs 1
|
| else {
|
| mata: coefplot_multiple_eqs(COEFPLOT_STRUCT)
|
| }
|
| mata: coefplot_arrange(COEFPLOT_STRUCT)
|
| mata: coefplot_coeflbls(COEFPLOT_STRUCT)
|
| coeflbls "`labels'" `"`clinteract'"'
|
| if "`bycoefs'"!="" {
|
| mata: coefplot_bycoefs(COEFPLOT_STRUCT)
|
| local meqs 0
|
| }
|
| mata: coefplot_catvals(COEFPLOT_STRUCT)
|
|
|
| mata: coefplot_headings(COEFPLOT_STRUCT)
|
|
|
| }
|
|
|
|
|
| if `"`generate'"'=="" {
|
| if (_N > `r') & "`nodrop'"=="" {
|
| preserve
|
| qui keep in 1/`r'
|
| }
|
| else if (_N < `r') {
|
| preserve
|
| qui set obs `r'
|
| }
|
| }
|
| else {
|
| if (_N < `r') {
|
| di as txt "need to create additional observations; " _c
|
| di as txt "press break to abort"
|
| more
|
| set obs `r'
|
| }
|
| }
|
| tempname by plot at mlbl mlpos b V se t df pval eq grp
|
| qui gen `by' = .
|
| qui gen `plot' = .
|
| qui gen `at' = .
|
| qui gen str`mlbllen' `mlbl' = ""
|
| qui gen `mlpos' = .
|
| qui gen `b' = .
|
| qui gen `V' = .
|
| qui gen `se' = .
|
| qui gen `t' = .
|
| qui gen `df' = .
|
| qui gen `pval' = .
|
| if `"`format'"'!="" {
|
| format `format' `b' `V' `se' `t' `pval'
|
| }
|
| qui gen `eq' = .
|
| qui gen `grp' = .
|
| forv i = 1/`N_ci' {
|
| tempname ll`i' ul`i'
|
| qui gen `ll`i'' = .
|
| qui gen `ul`i'' = .
|
| if `"`format'"'!="" {
|
| format `format' `ll`i'' `ul`i''
|
| }
|
| }
|
| forv i = 1/`N_aux' {
|
| tempname aux`i'
|
| qui gen `aux`i'' = .
|
| if `"`format'"'!="" {
|
| format `format' `aux`i''
|
| }
|
| }
|
| if `"`generate'"'!="" {
|
| preserve
|
| if "`replace'"!="" {
|
| capt label drop `generate'by
|
| capt label drop `generate'plot
|
| }
|
| local returnvars
|
| local i 0
|
| foreach v in by plot at mlbl mlpos b V se t df pval {
|
| local ++i
|
| local varl: word `i' of
|
| "subgraph ID"
|
| "plot ID"
|
| "plot position (category axis)"
|
| "marker label"
|
| "marker label position"
|
| "coefficient"
|
| "variance"
|
| "standard error"
|
| "t or z statistic"
|
| "degrees of freedom"
|
| "p-value"
|
| if "`replace'"!="" {
|
| capt confirm new variable `generate'`v', exact
|
| if _rc {
|
| drop `generate'`v'
|
| }
|
| }
|
| rename ``v'' `generate'`v'
|
| lab var `generate'`v' `"`varl'"'
|
| local `v' `generate'`v'
|
| local returnvars `returnvars' `generate'`v'
|
| }
|
| forv i = 1/`N_ci' {
|
| foreach v in ll ul {
|
| if "`v'"=="ll" local varl "CI`i': lower limit"
|
| else local varl "CI`i': upper limit"
|
| if "`replace'"!="" {
|
| capt confirm new variable `generate'`v'`i', exact
|
| if _rc {
|
| drop `generate'`v'`i'
|
| }
|
| }
|
| rename ``v'`i'' `generate'`v'`i'
|
| lab var `generate'`v'`i' `"`varl'"'
|
| local `v'`i' `generate'`v'`i'
|
| local returnvars `returnvars' `generate'`v'`i'
|
| }
|
| }
|
| forv i = 1/`N_aux' {
|
| local varl "Auxiliary variable `i'"
|
| if "`replace'"!="" {
|
| capt confirm new variable `generate'aux`i', exact
|
| if _rc {
|
| drop `generate'aux`i'
|
| }
|
| }
|
| rename `aux`i'' `generate'aux`i'
|
| lab var `generate'aux`i' `"`varl'"'
|
| local aux`i' `generate'aux`i'
|
| local returnvars `returnvars' `generate'aux`i'
|
| }
|
| }
|
| mata: coefplot_put(COEFPLOT_STRUCT)
|
| mata: coefplot_apply_transform(COEFPLOT_STRUCT)
|
| qui compress `at' `df' `plot' `by' `eq' `grp' `mlpos'
|
|
|
|
|
| set_by_and_plot_labels `plot' `by'
|
| if `"`plotlabels'"'!="" {
|
| set_labels "`plot'" "`N_plots'" `"`plotlabels'"'
|
| }
|
| if `"`pltrunc'`plwrap'"'!="" {
|
| truncwrap_vlabels "`plot'" "`N_plots'" "`pltrunc'"
|
| "`plwrap'" "`plbreak'"
|
| }
|
| if "`bycoefs'"=="" {
|
| if `"`bylabels'"'!="" {
|
| set_labels "`by'" "`n_subgr'" `"`bylabels'"'
|
| }
|
| if `"`bltrunc'`blwrap'"'!="" {
|
| truncwrap_vlabels "`by'" "`n_subgr'" "`bltrunc'"
|
| "`blwrap'" "`blbreak'"
|
| }
|
| }
|
| if `atmode'==0 {
|
| if "`grid'"=="" & "`xaxis'"=="y" {
|
| if `N_plots'>1 & `"`offsets'"'=="" local grid between
|
| else local grid within
|
| }
|
| get_axis_labels `at' `eq' `grp' "`grid'" `"`groups'"'
|
|
|
| if `meqs'==0 | "`noeqlabels'"!="" local eqlabels
|
| if `"`cltrunc'`clwrap'"'!="" {
|
| if "`bycoefs'"=="" {
|
| truncwrap_labels xlabels "`cltrunc'" "`clwrap'"
|
| "`clbreak'" `"`xlabels'"'
|
| }
|
| else {
|
| truncwrap_vlabels "`by'" "`n_subgr'" "`cltrunc'"
|
| "`clwrap'" "`clbreak'"
|
| }
|
| }
|
| if "`bycoefs'"!="" {
|
| if `"`bylabels'"'!="" {
|
| reset_xlabels `"`bylabels'"' `"`xlabels'"'
|
| }
|
| if `"`bltrunc'`blwrap'"'!="" {
|
| truncwrap_labels xlabels "`bltrunc'" "`blwrap'"
|
| "`blbreak'" `"`xlabels'"'
|
| }
|
| }
|
| if `"`clangle'"'=="" local clangle angle(horizontal)
|
| local xlabel `xaxis'label(`xlabels', nogrid `clangle' `clopts')
|
| local xrange `xaxis'scale(range(`xrange'))
|
| if !inlist("`grid'", "", "none") {
|
| local xtick `xaxis'tick(`xgrid', notick tlstyle(none) grid `gridopts')
|
|
|
|
|
| }
|
| else local xtick
|
| if "`eqashead'"!="" {
|
| merge_eqlabels_hlbls `"`eqlabels'"' `"`hlbls'"'
|
|
|
| }
|
| if `"`eqtrunc'`eqwrap'"'!="" {
|
| if `"`eqlabels'"'!="" {
|
| truncwrap_labels eqlabels "`eqtrunc'" "`eqwrap'"
|
| "`eqbreak'" `"`eqlabels'"'
|
| }
|
| }
|
| if `"`gtrunc'`gwrap'"'!="" {
|
| if `"`groups'"'!="" {
|
| truncwrap_labels groups "`gtrunc'" "`gwrap'"
|
| "`gbreak'" `"`groups'"'
|
| }
|
| }
|
| if `"`htrunc'`hwrap'"'!="" {
|
| if `"`hlbls'"'!="" {
|
| truncwrap_labels hlbls "`htrunc'" "`hwrap'"
|
| "`hbreak'" `"`hlbls'"'
|
| }
|
| }
|
| }
|
|
|
|
|
| if `customoffset' {
|
| forv i = 1/`N_plots' {
|
| if "`offset_`i''"!="" {
|
| qui replace `at' = `at' `offdir' `offset_`i'' if `plot'==`i'
|
| }
|
| }
|
| }
|
| else if `atmode'==0 & `"`offsets'"'=="" & `N_plots'>1 {
|
| if "`recycle'"=="" | `n_subgr'==1 {
|
| qui replace `at' = `at' - 0.5 + `plot'/(`N_plots'+1)
|
| }
|
| else {
|
| forv j=1/`n_subgr' {
|
| qui replace `at' = `at' - 0.5 +
|
| (`plot'-`firstplot_`j''+1) /
|
| (`lastplot_`j''-`firstplot_`j''+2) if `by'==`j'
|
| }
|
| }
|
| }
|
|
|
|
|
| forv i=1/`N_plots' {
|
| foreach opt in ifopt weightopt mlabel mlabvposition {
|
| if `"``opt'_`i''"'!="" {
|
| mata: coefplot_inject_temvars("`opt'_`i'", `N_ci', `N_aux')
|
| }
|
| }
|
| }
|
|
|
|
|
| forv i=1/`N_plots' {
|
| if `"`mlabel_`i''"'!="" {
|
| if `"`mlabel_`i''"'=="mlabel(`mlbl')" continue
|
| parse_mlabel_exp, `mlabel_`i''
|
| capt confirm variable `mlblexp'
|
| if _rc==0 continue
|
| capt replace `mlbl' = `mlblexp' if `plot'==`i'
|
| if _rc {
|
| di as err "invalid expression in mlabel()"
|
| exit 198
|
| }
|
| local mlabel_`i' mlabel(`mlbl')
|
| }
|
| }
|
|
|
|
|
| local addaxis 1
|
| local eqaxis 2
|
| local axisalt alt
|
| if (`"`eqlabels'"'!="" & `"`groups'"'!="") | (`"`addplotbelow'"'!="") local axisalt
|
| if `"`groups'"'!="" {
|
| local ++eqaxis
|
| local addaxis `addaxis' 2
|
| local groupsopts `xaxis'scale(axis(2) `axisalt' noline)
|
| `xaxis'title("", axis(2))
|
| `xaxis'label(`groups', axis(2) noticks tlstyle(none) `gopts')
|
| }
|
| if `"`eqlabels'"'!="" {
|
| local addaxis `addaxis' `eqaxis'
|
| local eqaxisopts `xaxis'scale(axis(`eqaxis') `axisalt' noline)
|
| `xaxis'title("", axis(`eqaxis'))
|
| `xaxis'label(`eqlabels', axis(`eqaxis') noticks
|
| tlstyle(none) `eqopts')
|
| }
|
| local axisalt
|
| if "`addaxis'"!="1" {
|
| local addaxis `xaxis'axis(`addaxis')
|
| if `"`addplotbelow'"'!="" {
|
| if (`"`eqlabels'"'!="")+(`"`groups'"'!="")==1 {
|
| local axisalt `xaxis'scale(alt)
|
| }
|
| }
|
| }
|
| else local addaxis
|
| if `"`hlbls'"'!="" {
|
| local hlblsopts
|
| `xaxis'label(`hlbls', custom add tlstyle(none) `hopts')
|
| }
|
| local j 0
|
| if `"`addplot'"'!="" {
|
| mata: coefplot_inject_temvars("addplot", `N_ci', `N_aux')
|
| if `"`addplotbelow'"'!="" {
|
| capt two `addplot' ||, nodraw
|
| if _rc==0 local j `.Graph.last_style'
|
| capt confirm integer number `j'
|
| if _rc local j 0
|
| }
|
| }
|
| local plots
|
| local legendlbls
|
| local legendorder
|
| forv i=1/`N_plots' {
|
| local key
|
| if "`n_ci_`i''"=="" {
|
| continue
|
|
|
| }
|
| local n_ci = `n_ci_`i'' + `cis_n_`i''
|
| if `n_ci'==0 & `"`cionly_`i''"'!="" {
|
| continue
|
| }
|
| local axis
|
| if `"`axis_`i''"'!="" {
|
| local axis `yaxis'axis(`axis_`i'')
|
| }
|
| local ciplots
|
| if (`n_ci')>0 {
|
| get_pstyle_id `=mod(`i'-1,`pcycle')+1', `pstyle_`i''
|
| forv k = 1/`n_ci' {
|
| local lw
|
| if `k'>`cis_n_`i'' {
|
| local l = `k' - `cis_n_`i''
|
| local ciopts `ciopts_`i'_`l''
|
| parse_ciopts_recast_pstyle, `ciopts'
|
|
|
| if "`nocilwincr_`i''"=="" {
|
| local lw: di 1 + log10(`l')/log10(2)
|
| local lw lwidth(*`lw')
|
| }
|
| local ciplotcmd rspike `ll`k'' `ul`k'' `at'
|
| if (substr(`"`cirecast'"',1,2)=="pc") {
|
| local ciplotcmd `cirecast' `ll`k'' `at' `ul`k'' `at'
|
| if `"`cirecast'"'=="pcrarrow" {
|
| local ciplotcmd pcarrow `ul`k'' `at' `ll`k'' `at'
|
| }
|
| }
|
| else if `"`cirecast'"'!="" {
|
| local ciopts `ciopts' recast(`cirecast')
|
| }
|
| }
|
| else {
|
| local l 0
|
| local cirecast
|
| local cipstyle `cis_pstyle_`i''
|
| local lw: word `k' of `cis_lwidth_`i''
|
| local lw lwidth(*`lw')
|
| local lcinten: word `k' of `cis_intens_`i''
|
| local ciopts lcolor("`cis_color_`i''*`lcinten'") `cipstyle'
|
| local ciplotcmd rspike `ll`k'' `ul`k'' `at'
|
| }
|
| if `"`cipstyle'"'!="" local pstyle
|
| else {
|
| set_pstyle `pstyle_id' `"`cirecast'"'
|
| }
|
| local ciplots `ciplots'
|
| (`ciplotcmd' if `plot'==`i'`ifopt_`i'', `addaxis'
|
| `pstyle' `lw' `axis' `ciopts' `horizontal')
|
| }
|
| }
|
| if "`citop_`i''"=="" & `n_ci'>0 {
|
| local plots `plots' `ciplots'
|
| local j = `j' + `cis_n_`i''
|
| if inrange(`key_`i'', 1, `n_ci_`i'') {
|
| local key = `j' + `key_`i''
|
| }
|
| local j = `j' + `n_ci_`i''
|
| }
|
| if `"`cionly_`i''"'=="" {
|
| if `"`pstyle_`i''"'!="" local pstyle `pstyle_`i''
|
| else {
|
| set_pstyle `=mod(`i'-1,`pcycle')+1' `"`recast_`i''"'
|
| }
|
| if `"`recast_`i''"'!="" local recast recast(`recast_`i'')
|
| else local recast
|
| if `"`horizontal'"'=="" | inlist(`"`recast_`i''"',
|
| "area", "bar", "spike", "dropline", "dot") {
|
| local plots `plots'
|
| (scatter `b' `at'
|
| if `plot'==`i'`ifopt_`i''`weightopt_`i'',
|
| `addaxis' `pstyle' `twplotopts0' `twplotopts1_`i''
|
| `axis' `recast' `mlabel_`i'' `mlabvposition_`i''
|
| `twplotopts_`i'' `horizontal')
|
| }
|
| else {
|
| local plots `plots'
|
| (scatter `at' `b'
|
| if `plot'==`i'`ifopt_`i''`weightopt_`i'',
|
| `addaxis' `pstyle' `twplotopts0' `twplotopts1_`i''
|
| `axis' `recast' `mlabel_`i'' `mlabvposition_`i''
|
| `twplotopts_`i'')
|
| }
|
| local ++j
|
| if `key_`i''==0 {
|
| local key `j'
|
| }
|
| }
|
| local plotlab `"`: lab `plot' `i''"'
|
| gettoken trash : plotlab, qed(hasquotes)
|
| if `hasquotes'==0 {
|
| local plotlab `"`"`plotlab'"'"'
|
| }
|
| if "`citop_`i''"!="" & `n_ci'>0 {
|
| local plots `plots' `ciplots'
|
| local j = `j' + `cis_n_`i''
|
| if inrange(`key_`i'', 1, `n_ci_`i'') {
|
| local key = `j' + `key_`i''
|
| }
|
| local j = `j' + `n_ci_`i''
|
| }
|
| if "`key'"!="" {
|
| local legendlbls `legendlbls' label(`key' `plotlab')
|
| local legendorder `legendorder' `key'
|
| }
|
| }
|
| if `"`legendorder'"'!="" {
|
| local legendorder all order(`legendorder')
|
| if `N_plots'==1 {
|
| if `n_subgr'==1 & `"`legend'"'=="" {
|
| local legendorder `legendorder' off
|
| }
|
| }
|
| }
|
| else local legendorder off
|
| if `n_subgr'>1 {
|
| local byopt `by', note("")
|
| if (`N_plots'==1 & `"`bylegend'"'=="") | `"`legendorder'"'=="off" {
|
| local byopt `byopt' legend(off)
|
| }
|
| local byopt by(`byopt' `bylegend' `byopts')
|
| }
|
| else local byopt
|
| if `"`plots'"'=="" {
|
| di as txt "(nothing to plot)"
|
| exit
|
| }
|
| if `"`addplot'"'!="" {
|
| if `"`addplotbelow'"'!="" {
|
| local plots `addplot' || `plots' ||
|
| }
|
| else {
|
| local plots `plots' || `addplot' ||
|
| }
|
| }
|
| local plots two `plots', `axisalt' `groupsopts' `eqaxisopts'
|
| `xlabel' `hlblsopts' `xtick' `xrange' `reverse' yti("") xti("")
|
| legend(`legendlbls' `legendorder') `legend' `plotregion' `byopt' `twopts'
|
| `plots'
|
|
|
|
|
| if `"`generate'"'!="" {
|
| restore, not
|
| di as txt _n "Generated variables:" _c
|
| describe `returnvars'
|
| }
|
| return local graph `plots'
|
| return local labels `"`xlabels'"'
|
| return local eqlabels `"`eqlabels'"'
|
| return local groups `"`groups'"'
|
| return local headings `"`hlbls'"'
|
| return local legend `"`legendlbls' `legendorder'"'
|
| return scalar n_plots = `N_plots'
|
| return scalar n_subgr = `n_subgr'
|
| return scalar n_ci = `N_ci'
|
| end
|
|
|
| program parse_subgraphs
|
| local i 0
|
| local empty 1
|
| while (`"`macval(0)'"'!="") {
|
| gettoken subgraph 0 : 0, parse("|") bind
|
| if `"`macval(subgraph)'"'=="|" {
|
| gettoken subgraph 0 : 0, parse("|") bind
|
| if `"`macval(subgraph)'"'!="|" error 198
|
| if `empty' {
|
| local ++i
|
| c_local subgr_`i' "."
|
| }
|
| else local empty 1
|
| continue
|
| }
|
| if `"`0'"'=="" {
|
| _parse comma subgraph opts : subgraph
|
| }
|
| if `"`macval(subgraph)'"'!="" {
|
| local empty 0
|
| local ++i
|
| c_local subgr_`i' `"`macval(subgraph)'"'
|
| }
|
| }
|
| if `i'==0 {
|
| local i 1
|
| c_local subgr_1 "."
|
| }
|
| c_local n_subgr `i'
|
| c_local opts `macval(opts)'
|
| end
|
|
|
| program parse_globalopts
|
| syntax [,
|
|
|
| HORizontal
|
| VERTical
|
| sort SORT2(str)
|
| orderby(str)
|
| order(str asis)
|
| BYCoefs
|
| noRECycle
|
| grid(str)
|
| noOFFsets
|
| format(str)
|
| noLABels
|
| COEFLabels(str asis)
|
| NOEQLABels
|
| EQLabels(str asis)
|
| eqstrict
|
| HEADings(str asis)
|
| GROUPs(str asis)
|
| PLOTLabels(str asis)
|
| bylabels(str asis)
|
| GENerate GENerate2(name)
|
| RELOCate(str asis)
|
| replace
|
| addplot(str asis)
|
| NODROP
|
| LEGend(passthru)
|
| BYOPts(str asis)
|
| Bname(passthru)
|
| rename(passthru)
|
| EQREName(passthru)
|
| PCYCle(int 15)
|
|
|
| play(passthru)
|
| XOVERHANGs
|
| YOVERHANGs
|
| fxsize(passthru)
|
| fysize(passthru)
|
|
|
| ]
|
| _get_gropts, graphopts(`options') gettwoway
|
| local twopts `s(twowayopts)' `play' `xoverhangs' `yoverhangs' `fxsize' `fysize'
|
| local opts0 `bname' `macval(rename)' `macval(eqrename)' `s(graphopts)'
|
| if `"`sort'`sort2'"'!="" {
|
| parse_sort `sort2'
|
| }
|
| if `"`orderby'"'!="" {
|
| parse_orderby `orderby', `recycle'
|
| }
|
| if `"`generate'"'!="" & `"`generate2'"'=="" {
|
| local generate "__"
|
| }
|
| else local generate `"`generate2'"'
|
| if `"`grid'"'!="" {
|
| parse_grid, `grid'
|
| }
|
| if `"`coeflabels'"'!="" {
|
| parse_coeflabels `coeflabels'
|
|
|
| }
|
| if `"`clinteract'"'=="" {
|
| local clinteract `"" # ""'
|
| }
|
| parse_eqlabels "`noeqlabels'" `eqlabels'
|
|
|
|
|
|
|
| if `"`headings'"'!="" {
|
| if `"`eqashead'"'!="" {
|
| di as err "eqlabels(, asheadings) and headings() not both allowed"
|
| exit 198
|
| }
|
| parse_headings `headings'
|
| }
|
| else if `"`hgap'"'=="" local hgap 0
|
| if `"`eqashead'"'!="" {
|
| if "`bycoefs'"!="" {
|
| di as err "eqlabels(, asheadings) and bycoefs not both allowed"
|
| exit 198
|
| }
|
| }
|
| if `"`groups'"'!="" {
|
| parse_groups `groups'
|
| }
|
| else local ggap 0
|
| if `"`plotlabels'"'!="" {
|
| parse_plotlabels `plotlabels'
|
| }
|
| if `"`bylabels'"'!="" {
|
| parse_bylabels `bylabels'
|
| }
|
| if `"`format'"'!="" {
|
| confirm numeric format `format'
|
| }
|
| if `"`horizontal'"'!="" {
|
| if `"`vertical'"'!="" {
|
| di as err "horizontal and vertical not both allowed"
|
| exit 198
|
| }
|
| }
|
| if `"`addplot'"'!="" {
|
| parse_addplot `addplot'
|
| }
|
| parse_byopts, `byopts'
|
| foreach opt in
|
| horizontal
|
| vertical
|
| sort
|
| orderby
|
| order
|
| bycoefs
|
| recycle
|
| grid gridopts
|
| offsets
|
| format
|
| labels
|
| coeflabels cltrunc clwrap clbreak clinteract clangle clopts
|
| noeqlabels
|
| eqlabels eqashead eqxlab eqgap eqtrunc eqwrap eqbreak eqopts
|
| eqstrict
|
| headings hxlab hoff hgap htrunc hwrap hbreak hopts
|
| groups ggap gtrunc gwrap gbreak gopts
|
| plotlabels plwrap pltrunc plbreak
|
| bylabels blwrap bltrunc blbreak
|
| relocate
|
| generate
|
| replace
|
| addplot addplotbelow
|
| nodrop
|
| legend
|
| bylegend
|
| byopts
|
| {
|
| c_local `opt' `"``opt''"'
|
| }
|
| c_local pcycle `pcycle'
|
| c_local twopts `twopts'
|
| merge_subgropts, `macval(opts0)'
|
| c_local subgropts0 `subgropts'
|
| c_local plotopts0 `plotopts1'
|
| c_local modelopts0 `macval(modelopts1)'
|
| c_local twplotopts0 `twplotopts1'
|
| end
|
|
|
| program parse_sort
|
| syntax [anything] [, Descending by(str) ]
|
| if `"`anything'"'=="" {
|
| local subgr .
|
| local plot .
|
| }
|
| else {
|
| gettoken subgr rest : anything, parse(":")
|
| if `"`rest'"'=="" {
|
| local plot `"`subgr'"'
|
| local subgr .
|
| }
|
| else if `"`subgr'"'==":" {
|
| local subgr .
|
| gettoken plot rest : rest
|
| }
|
| else {
|
| gettoken colon rest : rest, parse(":")
|
| if `"`colon'"'!=":" {
|
| di as err "sort(): invalid syntax"
|
| exit 198
|
| }
|
| gettoken plot rest : rest
|
| }
|
| if `"`rest'"'!="" {
|
| di as err "sort(): invalid syntax"
|
| exit 198
|
| }
|
| foreach t in subgr plot {
|
| if `"``t''"'=="" local `t' .
|
| else if `"``t''"'!="." {
|
| capt confirm integer number ``t''
|
| if _rc==0 {
|
| local rc = (``t''<=0)
|
| }
|
| else local rc 1
|
| if `rc' {
|
| di as err "sort(): invalid syntax"
|
| exit 198
|
| }
|
| }
|
| }
|
| }
|
| capt parse_sort_by, `by'
|
| if _rc {
|
| di as err `"sort(): '`by'' not allowed in by()"'
|
| exit 198
|
| }
|
| local descending = ("`descending'"!="")
|
| c_local sort `"`subgr' `plot' `descending' "`by'""'
|
| end
|
| program parse_sort_by
|
| syntax [, b v se t tabs df p ll ul aux * ]
|
| local by `b' `v' `se' `t' `tabs' `df' `p' `ll' `ul' `aux'
|
| if `: list sizeof by'>1 exit 198
|
| if inlist("`by'","ll", "ul", "aux") {
|
| if `"`options'"'=="" local by `by' 1
|
| else {
|
| capt confirm integer number `options'
|
| if _rc==0 {
|
| local rc = (`options'<=0)
|
| }
|
| else local rc 1
|
| if `rc' exit 198
|
| local by `by' `options'
|
| }
|
| }
|
| else if `"`options'"'!="" exit 198
|
| if `"`by'"'=="" local by b
|
| c_local by `by'
|
| end
|
|
|
| program parse_orderby
|
| syntax [anything] [, norecycle ]
|
| gettoken subgr rest : anything, parse(":")
|
| if `"`rest'"'=="" {
|
| local plot `"`subgr'"'
|
| local subgr 1
|
| }
|
| else if `"`subgr'"'==":" {
|
| local subgr 1
|
| gettoken plot rest : rest
|
| }
|
| else {
|
| gettoken colon rest : rest, parse(":")
|
| if `"`colon'"'!=":" {
|
| di as err "orderby(): invalid syntax"
|
| exit 198
|
| }
|
| if "`recycle'"!="" {
|
| di as err "orderby(): subgraph not allowed with norecycle"
|
| exit 198
|
| }
|
| gettoken plot rest : rest
|
| }
|
| if `"`rest'"'!="" {
|
| di as err "orderby(): invalid syntax"
|
| exit 198
|
| }
|
| foreach t in subgr plot {
|
| if `"``t''"'=="" local `t' 1
|
| else {
|
| capt confirm integer number ``t''
|
| if _rc==0 {
|
| local rc = (``t''<=0)
|
| }
|
| else local rc 1
|
| if `rc' {
|
| di as err "orderby(): invalid syntax"
|
| exit 198
|
| }
|
| }
|
| }
|
| if "`recycle'"!="" local subgr .
|
| c_local orderby `subgr' `plot'
|
| end
|
|
|
| program parse_grid
|
| syntax [, Between Within None * ]
|
| if ("`between'"!="") + ("`within'"!="") + ("`none'"!="") > 1 {
|
| di as err "grid(): only one of between, within, and none allowed"
|
| exit 198
|
| }
|
| c_local grid `between' `within' `none'
|
| c_local gridopts `options'
|
| end
|
|
|
| program parse_coeflabels
|
| mata: coefplot_parsecomma("coeflabels", "0", "0")
|
| syntax [, Truncate(numlist integer max=1 >0)
|
| Wrap(numlist integer max=1 >0) noBreak
|
| Interaction(str asis) angle(passthru) * ]
|
| c_local coeflabels `"`coeflabels'"'
|
| c_local cltrunc `truncate'
|
| c_local clwrap `wrap'
|
| c_local clbreak `break'
|
| c_local clinteract `"`interaction'"'
|
| c_local clangle `angle'
|
| c_local clopts `options'
|
| end
|
|
|
| program parse_eqlabels
|
| gettoken noeqlabels 0 : 0
|
| mata: st_local("0", strltrim(st_local("0")))
|
| mata: coefplot_parsecomma("eqlabels", "0", "0")
|
| syntax [, LABels LABels2(str asis)
|
| OFFset(real 0) ASHEADings noGap Gap2(numlist max=1)
|
| Truncate(numlist integer max=1 >0)
|
| Wrap(numlist integer max=1 >0) noBreak * ]
|
| if "`labels'"!="" & `"`labels2'"'=="" {
|
| local labels2 `"" # ""'
|
| }
|
| if "`gap'"!="" local gap2 0
|
| else if "`gap2'"=="" {
|
| if "`noeqlabels'"!="" local gap2 0
|
| else local gap2 1
|
| }
|
| if "`asheadings'"!="" {
|
| c_local hoff `offset'
|
| c_local hgap `gap2'
|
| c_local htrunc `truncate'
|
| c_local hwrap `wrap'
|
| c_local hbreak `break'
|
| c_local hopts `options'
|
| c_local eqgap 0
|
| }
|
| else {
|
| if `offset'!=0 {
|
| di as err "eqlabels(): offset() only allowed with asheadings"
|
| exit 198
|
| }
|
| c_local eqgap `gap2'
|
| c_local eqtrunc `truncate'
|
| c_local eqwrap `wrap'
|
| c_local eqbreak `break'
|
| c_local eqopts `options'
|
| }
|
| c_local eqxlab `"`labels2'"'
|
| c_local eqlabels `"`eqlabels'"'
|
| c_local eqashead `asheadings'
|
| end
|
|
|
| program parse_headings
|
| mata: coefplot_parsecomma("headings", "0", "0")
|
| syntax [, OFFset(real 0) noGap Gap2(real 1)
|
| Truncate(numlist integer max=1 >0)
|
| Wrap(numlist integer max=1 >0) noBreak * ]
|
| if "`gap'"!="" local gap2 0
|
| c_local headings `"`headings'"'
|
| c_local hoff `offset'
|
| c_local hgap `gap2'
|
| c_local htrunc `truncate'
|
| c_local hwrap `wrap'
|
| c_local hbreak `break'
|
| c_local hopts `options'
|
| end
|
|
|
| program parse_groups
|
| mata: coefplot_parsecomma("groups", "0", "0")
|
| syntax [, noGap Gap2(real 1)
|
| Truncate(numlist integer max=1 >0)
|
| Wrap(numlist integer max=1 >0) noBreak * ]
|
| if "`gap'"!="" local gap2 0
|
| c_local groups `"`groups'"'
|
| c_local ggap `gap2'
|
| c_local gtrunc `truncate'
|
| c_local gwrap `wrap'
|
| c_local gbreak `break'
|
| c_local gopts `options'
|
| end
|
|
|
| program parse_plotlabels
|
| mata: coefplot_parsecomma("plotlabels", "0", "0")
|
| syntax [, Truncate(numlist integer max=1 >0)
|
| Wrap(numlist integer max=1 >0) noBreak ]
|
| c_local plotlabels `"`plotlabels'"'
|
| c_local pltrunc `truncate'
|
| c_local plwrap `wrap'
|
| c_local plbreak `break'
|
| end
|
|
|
| program parse_bylabels
|
| mata: coefplot_parsecomma("bylabels", "0", "0")
|
| syntax [, Truncate(numlist integer max=1 >0)
|
| Wrap(numlist integer max=1 >0) noBreak ]
|
| c_local bylabels `"`bylabels'"'
|
| c_local bltrunc `truncate'
|
| c_local blwrap `wrap'
|
| c_local blbreak `break'
|
| end
|
|
|
| program parse_addplot
|
| _parse expand addplot addplotopts : 0 ,
|
| common(below by() nodraw draw name() SAVing() play())
|
| forv i=1/`addplot_n' {
|
| local addplot `addplot' (`addplot_`i'')
|
| }
|
| local addplot `addplot' `addplotopts_if' `addplotopts_in'
|
| _parse combop addplotopts_op : addplotopts_op, option(below) opsin rightmost
|
| parse_addplotopts, `addplotopts_op'
|
| if `"`options'"'!="" {
|
| local addplot `addplot', `options'
|
| }
|
| c_local addplot `addplot'
|
| c_local addplotbelow `below'
|
| end
|
| program parse_addplotopts
|
| syntax [, below by(passthru) NODRAW draw name(passthru)
|
| SAVing(passthru) play(passthru) * ]
|
| foreach opt in nodraw draw {
|
| if `"``opt''"'!="" {
|
| di as err "`opt' not allowed within addplot()"
|
| exit 198
|
| }
|
| }
|
| foreach opt in by name saving play {
|
| if `"``opt''"'!="" {
|
| di as err "`opt'() not allowed within addplot()"
|
| exit 198
|
| }
|
| }
|
| local options: subinstr local options "below" "", all word
|
| c_local below `below'
|
| c_local options `options'
|
| end
|
|
|
| program parse_byopts
|
| syntax [, LEGend(passthru) * ]
|
| c_local bylegend `legend'
|
| c_local byopts `options'
|
| end
|
|
|
| program merge_subgropts
|
| merge_plotopts `macval(0)'
|
| _merge_subgropts, `options'
|
| _merge_subgropts _opt0_, `_opts0'
|
| if `"`_opt0_options'"'!="" error 198
|
| if `"`bylabel'"'!="" {
|
| c_local subgropts `bylabel'
|
| }
|
| else {
|
| c_local subgropts `_opt0_bylabel'
|
| }
|
| c_local modelopts1 `macval(modelopts2)'
|
| c_local plotopts1 `plotopts'
|
| c_local twplotopts1 `options'
|
| end
|
| program _merge_subgropts
|
| syntax [anything] [, BYLABel(passthru) * ]
|
| c_local `anything'bylabel `bylabel'
|
| c_local `anything'options `options'
|
| end
|
|
|
| program parse_subgropts
|
| syntax anything [, BYLABel(str asis) ]
|
| gettoken lbl rest : bylabel, qed(qed)
|
| if `"`lbl'"'!="" & `"`rest'"'=="" & `qed' {
|
| local bylabel `"`lbl'"'
|
| }
|
| mata: coefplot_add_label(COEFPLOT_STRUCT, "by", `anything', "bylabel", 0)
|
| end
|
|
|
| program parse_plots
|
| gettoken j 0 : 0
|
| _parse comma 0 opts : 0
|
| gettoken comma opts : opts, parse(",")
|
| local i 0
|
| while (`"`macval(0)'"'!="") {
|
| gettoken plot 0: 0, match(hasparen)
|
| local estexpand 0
|
| if `"`hasparen'"'=="" {
|
| if strpos(`"`plot'"',"(")==0 {
|
| if strpos(`"`plot'"',"*") | strpos(`"`plot'"',"?") {
|
| local estexpand 1
|
| }
|
| }
|
| }
|
| if `estexpand' {
|
| qui estimates dir `plot'
|
| foreach plot in `r(names)' {
|
| local ++i
|
| c_local plot_`j'_`i' `"`macval(plot)'"'
|
| }
|
| }
|
| else {
|
| local ++i
|
| c_local plot_`j'_`i' `"`macval(plot)'"'
|
| }
|
| }
|
| if `i'==0 {
|
| local i 1
|
| c_local plot_`j'_1 "."
|
| }
|
| c_local n_plots_`j' `i'
|
| c_local opts `macval(opts)'
|
| end
|
|
|
| program parse_get_popt_i
|
| gettoken i 0 : 0, parse(",")
|
| syntax [, p`i'(str asis) * ]
|
| c_local plotopts `macval(p`i')'
|
| c_local twplotopts0 `macval(options)'
|
| end
|
|
|
| program combine_plotopts
|
| syntax [, _opts0(str asis) * ]
|
| _merge_plotopts, `macval(options)'
|
| _merge_plotopts _opt0_, `macval(_opts0)'
|
| if `"`mlabels'"'!="" local _opt0_mlabel
|
| if `"`mlabel'"'!="" local _opt0_mlabels
|
| if `"`cismooths'"'!="" local _opt0_cismooth
|
| if `"`cismooth'"'!="" local _opt0_cismooths
|
| if `"`nokey'`key'`key2'"'!="" {
|
| local _opt0_nokey
|
| local _opt0_key
|
| local _opt0_key2
|
| }
|
| local 0
|
| foreach opt of local opts {
|
| if `"``opt''"'!="" {
|
| local 0 `0' ``opt''
|
| }
|
| else {
|
| local 0 `0' `_opt0_`opt''
|
| }
|
| }
|
| c_local plotopts `0'
|
| c_local options `macval(options)'
|
| end
|
|
|
| program merge_plotopts
|
| merge_modelopts `macval(0)'
|
| _merge_plotopts, `options'
|
| _merge_plotopts _opt0_, `_opts0'
|
| if `"`mlabels'"'!="" local _opt0_mlabel
|
| if `"`mlabel'"'!="" local _opt0_mlabels
|
| if `"`mlabels'`mlabel'"'!="" local mlabels2
|
| if `"`cismooths'"'!="" local _opt0_cismooth
|
| if `"`cismooth'"'!="" local _opt0_cismooths
|
| if `"`nokey'`key'`key2'"'!="" {
|
| local _opt0_nokey
|
| local _opt0_key
|
| local _opt0_key2
|
| }
|
| local 0
|
| foreach opt of local opts {
|
| if `"``opt''"'!="" {
|
| local 0 `0' ``opt''
|
| }
|
| else {
|
| local 0 `0' `_opt0_`opt''
|
| }
|
| }
|
| c_local modelopts2 `macval(modelopts)' `mlabels2'
|
| c_local plotopts `0'
|
| c_local options `options'
|
| c_local _opts0 `_opt0_options'
|
| end
|
|
|
| program _merge_plotopts
|
| syntax [anything] [,
|
| LABel(passthru)
|
| offset(passthru)
|
| PSTYle(passthru)
|
| AXis(passthru)
|
| recast(passthru)
|
| MLabels MLabel(passthru)
|
| MLABVposition(passthru)
|
| cionly
|
| citop
|
| CISmooths CISmooth(passthru)
|
| CIOPts(passthru)
|
| CIREcast(passthru)
|
| IFopt(passthru)
|
| Weightopt(passthru)
|
| NOKEY key KEY2(passthru)
|
|
|
| if `"`mlabel'"'!="" local mlabels
|
| if `"`cismooth'"'!="" local cismooths
|
| local opts
|
| label
|
| offset
|
| pstyle
|
| axis
|
| recast
|
| mlabels mlabel
|
| mlabvposition
|
| cionly
|
| citop
|
| cismooths cismooth
|
| ciopts
|
| cirecast
|
| ifopt
|
| weightopt
|
| nokey key key2
|
| foreach opt of local opts {
|
| c_local `anything'`opt' ``opt''
|
| }
|
| c_local `anything'options `options'
|
| c_local opts `opts'
|
| end
|
|
|
| program parse_plotopts
|
| syntax anything [,
|
| LABel(str asis)
|
| offset(str asis)
|
| PSTYle(passthru)
|
| AXis(numlist integer max=1 >0 <10)
|
| recast(str)
|
| MLabels MLabel(passthru)
|
| MLABVposition(passthru)
|
| cionly
|
| citop
|
| CISmooths CISmooth(str asis)
|
| CIOPts(str asis)
|
| CIREcast(str)
|
| IFopt(str asis)
|
| Weightopt(str asis)
|
| NOKEY key KEY2(str)
|
| ]
|
| if `"`label'"'!="" {
|
| gettoken lbl rest : label, qed(qed)
|
| if `"`lbl'"'!="" & `"`rest'"'=="" & `qed' {
|
| local label `"`lbl'"'
|
| }
|
| mata: coefplot_add_label(COEFPLOT_STRUCT, "plot", `anything', "label", 1)
|
| }
|
| if `"`mlabels'"'!="" local mlabel mlabel(@b)
|
| if `"`cismooths'"'!="" local cismooth cismooth
|
| if `"`cirecast'"'!="" local cirecast recast(`cirecast')
|
| if `"`offset'"'!="" {
|
| capt parse_offset `offset'
|
| if _rc {
|
| di as err `"invalid offset(): `offset'"'
|
| exit 198
|
| }
|
| }
|
| if `"`ifopt'"'!="" local ifopt `" & (`ifopt')"'
|
| if `"`weightopt'"'!="" local weightopt `" [aw=`weightopt']"'
|
| local key0 0
|
| if `"`nokey'"'!="" local key0 -1
|
| if `"`key'`key2'"'!="" {
|
| if `key0'<0 {
|
| di as err "nokey and key() not both allowed"
|
| exit 198
|
| }
|
| if `"`key2'"'!="" {
|
| gettoken key2ci key2 : key2
|
| if `"`key2ci'"'!="ci" {
|
| di as err "invalid syntax in key()"
|
| exit 198
|
| }
|
| if `"`key2'"'!="" {
|
| capt confirm integer number `key2'
|
| if _rc==0 {
|
| capt assert (`key2'>0)
|
| }
|
| if _rc {
|
| di as err "invalid syntax in key()"
|
| exit 198
|
| }
|
| }
|
| else local key2 1
|
| local key0 `key2'
|
| }
|
| }
|
| local key `key0'
|
| foreach opt in
|
| offset
|
| pstyle
|
| axis
|
| recast
|
| mlabel
|
| mlabvposition
|
| cionly
|
| citop
|
| cismooth
|
| ciopts
|
| cirecast
|
| ifopt
|
| weightopt
|
| key
|
| {
|
| c_local `opt'_`anything' `"``opt''"'
|
| }
|
| end
|
|
|
| program parse_offset
|
| local offset = `0'
|
| local 0 `", offset(`offset')"'
|
| syntax [, offset(numlist max=1) ]
|
| c_local offset `offset'
|
| end
|
|
|
| program parse_models
|
| gettoken j 0 : 0
|
| gettoken k 0 : 0
|
| local i 0
|
| local empty 1
|
| while (`"`macval(0)'"'!="") {
|
| gettoken model 0 : 0, parse("\") bind
|
| if `"`macval(model)'"'=="\" {
|
| if `empty' {
|
| local ++i
|
| c_local model_`j'_`k'_`i' "."
|
| }
|
| else local empty 1
|
| continue
|
| }
|
| _parse comma model opts : model
|
| if `"`macval(0)'"'=="" {
|
| gettoken comma plotopts : opts, parse(",")
|
| local opts
|
| }
|
| if `"`model'`macval(opts)'"'!="" {
|
| local empty 0
|
| if strpos(`"`model'"',"(") {
|
| local ++i
|
| c_local model_`j'_`k'_`i' `"`model'`macval(opts)'"'
|
| }
|
| else {
|
| if `"`model'"'=="" local model .
|
| foreach ename of local model {
|
| if strpos(`"`ename'"',"*") | strpos(`"`ename'"',"?") {
|
| qui estimates dir `ename'
|
| local ename `"`r(names)'"'
|
| }
|
| foreach mm of local ename {
|
| local ++i
|
| c_local model_`j'_`k'_`i' `"`mm'`macval(opts)'"'
|
| }
|
| }
|
| }
|
| }
|
| }
|
| if `i'==0 {
|
| local i 1
|
| c_local model_`j'_`k'_1 "."
|
| }
|
| c_local n_models_`j'_`k' `i'
|
| c_local opts `macval(plotopts)'
|
| end
|
|
|
| program parse_model
|
| _parse comma 0 opts : 0
|
| gettoken comma opts : opts, parse(",")
|
| capt parse_model_matrix, `0'
|
| if _rc {
|
| gettoken model rest : 0
|
| if `"`rest'"'!="" {
|
| di as err `"`rest' not allowed"'
|
| exit 198
|
| }
|
| if `"`model'"'=="" local model .
|
| }
|
| c_local model `"`model'"'
|
| c_local matrix `"`matrix'"'
|
| c_local opts `macval(opts)'
|
| end
|
| program parse_model_matrix
|
| syntax, Matrix(str)
|
| gettoken model : matrix, parse(" [")
|
| if `"`model'"'=="" error 198
|
| c_local model `"`model'"'
|
| c_local matrix `"`matrix'"'
|
| end
|
|
|
| program merge_modelopts
|
| syntax [, _opts0(str asis) * ]
|
| _merge_modelopts, `macval(options)'
|
| _merge_modelopts _opt0_, `macval(_opts0)'
|
| if `"`sename'"'!="" local _opt0_vname
|
| if `"`vname'"'!="" local _opt0_sename
|
| if `"`asequation'"'!="" local _opt0_asequation2
|
| local 0
|
| foreach opt of local opts {
|
| if `"``opt''"'!="" {
|
| if "`opt'"=="mlabels2" {
|
| c_local mlabels2 ``opt''
|
| }
|
| else {
|
| local 0 `macval(0)' `macval(`opt')'
|
| }
|
| }
|
| else {
|
| if "`opt'"=="mlabels2" {
|
| c_local mlabels2 `_opt0_`opt''
|
| }
|
| else {
|
| local 0 `macval(0)' `macval(_opt0_`opt')'
|
| }
|
| }
|
| }
|
| c_local modelopts `macval(0)'
|
| c_local options `options'
|
| c_local _opts0 `_opt0_options'
|
| end
|
| program _merge_modelopts
|
| syntax [anything] [,
|
| OMITted
|
| BASElevels
|
| Bname(passthru)
|
| ATname ATname2(passthru)
|
| SWAPnames
|
| keep(passthru)
|
| drop(passthru)
|
| rename(passthru)
|
| EQREName(passthru)
|
| ASEQuation ASEQuation2(passthru)
|
| eform EFORM2(passthru)
|
| rescale(passthru)
|
| TRANSform(passthru)
|
| MLABELS2(passthru)
|
| noci
|
| Levels(passthru)
|
| CIname(passthru)
|
| Vname(passthru)
|
| SEname(passthru)
|
| DFname(passthru)
|
| citype(passthru)
|
| aux(passthru)
|
|
|
| if "`atname'"!="" & `"`atname2'"'=="" local atname2 "atname2(at)"
|
| if `"`asequation2'"'!="" local asequation
|
| if "`eform'"!="" & `"`eform2'"'=="" local eform2 "eform2(*)"
|
| if `"`sename'"'!="" & `"`vname'"'!="" {
|
| di as err "se() and v() not both allowed"
|
| exit 198
|
| }
|
| local opts
|
| omitted
|
| baselevels
|
| bname
|
| atname2
|
| swapnames
|
| keep
|
| drop
|
| rename
|
| eqrename
|
| asequation
|
| asequation2
|
| eform2
|
| rescale
|
| transform
|
| mlabels2
|
| ci
|
| levels
|
| ciname
|
| vname
|
| sename
|
| dfname
|
| citype
|
| aux
|
| foreach opt of local opts {
|
| c_local `anything'`opt' `macval(`opt')'
|
| }
|
| c_local `anything'options `options'
|
| c_local opts `opts'
|
| end
|
|
|
| program collect_coefs
|
| gettoken model 0 : 0
|
| gettoken matrix 0 : 0
|
| gettoken atmode 0 : 0
|
| gettoken i 0 : 0
|
| gettoken j 0 : 0
|
| gettoken cis 0 : 0
|
|
|
|
|
| merge_modelopts `macval(0)'
|
| local 0 , `macval(modelopts)' `mlabels2' `options' `_opts0'
|
| syntax [,
|
| OMITted
|
| BASElevels
|
| Bname(str)
|
| ATname2(str)
|
| SWAPnames
|
| keep(str asis)
|
| drop(str asis)
|
| rename(str asis)
|
| EQREName(str asis)
|
| ASEQuation ASEQuation2(str)
|
| EFORM2(str asis)
|
| rescale(str asis)
|
| TRANSform(str asis)
|
| MLABELS2(str asis)
|
| noci
|
| Levels(numlist)
|
| CIname(str asis)
|
| Vname(str)
|
| SEname(str)
|
| DFname(str)
|
| citype(str)
|
| aux(str)
|
| ]
|
| if `"`atname2'"'!="" {
|
| if "`atmode'"=="0" {
|
| di as err "must specify at for all or none"
|
| exit 198
|
| }
|
| local atmode 1
|
| parse_at_transform `atname2'
|
| capt parse_at_is_matrix, `atname2'
|
| }
|
| else {
|
| if "`atmode'"=="1" {
|
| di as err "must specify at for all or none"
|
| exit 198
|
| }
|
| local atmode 0
|
| }
|
| if `"`macval(rename)'"'!="" {
|
| parse_rename `macval(rename)'
|
| }
|
| if `"`macval(eqrename)'"'!="" {
|
| parse_eqrename `macval(eqrename)'
|
| }
|
| if "`cis'"!="" local ci
|
| parse_cilevels `"`levels'"' `"`ciname'"' "`cis'"
|
| parse_citype, `citype'
|
| if `"`matrix'"'!="" local bname `"`matrix'"'
|
| if "`asequation'"!="" & `"`asequation2'"'=="" {
|
| if "`model'"=="." local asequation2 "_"
|
| else local asequation2 `"`model'"'
|
| }
|
| if `"`aux'"'!="" {
|
| parse_aux `aux'
|
| }
|
|
|
| local empty 0
|
| local equation
|
| mata: coefplot_keepdrop(COEFPLOT_STRUCT)
|
| if `empty' {
|
| local n_ci 0
|
| di as txt
|
| `"(`model': no coefficients found, all dropped, or none kept)"'
|
| }
|
|
|
|
|
| c_local equation `equation'
|
| c_local atmode `atmode'
|
| c_local n_ci `n_ci'
|
| if `"`mlabels2'"'!="" {
|
| c_local mlabel_`i' mlabel(@mlbl)
|
| c_local mlabvposition_`i' mlabvposition(@mlpos)
|
| }
|
| end
|
|
|
| program parse_at_transform
|
| syntax [anything] [, Transform(str) ]
|
| if `"`anything'"'=="" local anything at
|
| c_local atname2 `"`anything'"'
|
| c_local attransform `"`transform'"'
|
| end
|
|
|
| program parse_at_is_matrix
|
| syntax, Matrix(str)
|
| c_local atname2 `"`matrix'"'
|
| c_local atismatrix "matrix"
|
| end
|
|
|
| program parse_rename
|
| mata: coefplot_parsecomma("rename", "0", "0")
|
| syntax [, Regex]
|
| c_local `eq'rename `"`macval(rename)'"'
|
| c_local `eq'renameregex `regex'
|
| end
|
|
|
| program parse_eqrename
|
| mata: coefplot_parsecomma("rename", "0", "0")
|
| syntax [, Regex]
|
| c_local eqrename `"`macval(rename)'"'
|
| c_local eqrenameregex `regex'
|
| end
|
|
|
| program parse_aux
|
| gettoken s 0 : 0, bind
|
| while (`"`s'"'!="") {
|
| local s = subinstr(`"`s'"', " ", "", .)
|
| if substr(`"`s'"', 1, 1)=="[" {
|
| local aux `aux'`s'
|
| }
|
| else {
|
| local aux `aux' `s'
|
| }
|
| gettoken s 0 : 0, bind
|
| }
|
| c_local aux `"`aux'"'
|
| end
|
|
|
| program parse_citype
|
| local citypes logit probit atanh log
|
| syntax [, `citypes' NORMal ]
|
| local citype `logit' `probit' `atanh' `log' `normal'
|
| if `: list sizeof citype'>1 {
|
| di as err "citype(): only one of logit, probit, atanh, log, and normal allowed"
|
| exit 198
|
| }
|
| local citype: list posof "`citype'" in citypes
|
| c_local citype `citype'
|
| end
|
|
|
| program parse_cilevels
|
| args levels names cis
|
| if "`cis'"!="" {
|
| foreach level of local cis {
|
| local ll `ll' `level'
|
| local nn `"`nn'`space'"""'
|
| local space " "
|
| }
|
| }
|
| while (1) {
|
| gettoken l levels : levels
|
| gettoken n names : names, match(paren)
|
| if `"`l'`n'"'=="" {
|
| continue, break
|
| }
|
| if `"`n'"'=="" {
|
| parse_cilevel, levels(`l')
|
| local ll `ll' `level'
|
| local nn `"`nn'`space'"""'
|
| }
|
| else {
|
| capt confirm number `n'
|
| if _rc {
|
| gettoken empty : n
|
| if `"`empty'"'=="" {
|
| parse_cilevel
|
| local ll `ll' `level'
|
| }
|
| else {
|
| local ll `ll' .
|
| }
|
| local nn `"`nn'`space'`"`n'"'"'
|
| }
|
| else {
|
| parse_cilevel, levels(`n')
|
| local ll `ll' `level'
|
| local nn `"`nn'`space'"""'
|
| }
|
| }
|
| local space " "
|
| }
|
| if `"`ll'"'=="" {
|
| parse_cilevel
|
| local ll `level'
|
| local nn `""""'
|
| }
|
| c_local levels `ll'
|
| c_local ciname `"`nn'"'
|
| end
|
| program parse_cilevel
|
| syntax [, level(cilevel) levels(numlist min=1 max=1 >0 <100) ]
|
| if `"`levels'"'=="" {
|
| c_local level `level'
|
| }
|
| else {
|
| c_local level `levels'
|
| }
|
| end
|
|
|
| program parse_cismooth
|
| syntax anything(name=j) [, Color(str) PSTYle(passthru) n(int 50)
|
| Intensity(numlist min=2 max=2 >=0 <=100)
|
| LWidth(numlist min=2 max=2 >=0 <=1000) ]
|
| if `n'<4 {
|
| di as err "cismooth(n()) must be >= 4"
|
| exit 198
|
| }
|
| if "`intensity'"!="" {
|
| gettoken imin imax : intensity
|
| }
|
| else {
|
| local imin = (1+3) / (ceil(`n'/2)+3) * 100
|
| local imax 100
|
| }
|
| if "`lwidth'"!="" {
|
| gettoken wmin wmax : lwidth
|
| local lwidth
|
| }
|
| else {
|
| local wmin 2
|
| local wmax 15
|
| }
|
| local d = 100/`n'
|
| local lmax = 100 - `d'/2
|
| forv i = 1/`n' {
|
| if mod(`i',2)==0 {
|
| local l = `d'/2 + (`i'/2-1)*`d'
|
| }
|
| else {
|
| local l = `d'/2 + (`n'-`i'/2-.5)*`d'
|
| }
|
| local levels `levels' `:di `l''
|
| local inten = (`imin' + (`imax'-`imin') / (ceil(`n'/2)-1) *
|
| (ceil(`i'/2)-1))/100
|
| local intens `intens' `:di `inten''
|
| local lw = 4 + (`l'-1)/(`lmax'-1) * (100-4)
|
| local lw = 100 / `lw'
|
| local lw = `wmin' + (`lw'-1) / (25-1) * (`wmax'-`wmin')
|
| local lwidth `lwidth' `:di `lw''
|
| }
|
| c_local cis_levels_`j' `levels'
|
| c_local cis_n_`j' `n'
|
| c_local cis_intens_`j' `intens'
|
| c_local cis_lwidth_`j' `lwidth'
|
| c_local cis_color_`j' `"`color'"'
|
| c_local cis_pstyle_`j' `"`pstyle'"'
|
| end
|
|
|
| program get_pstyle_id
|
| syntax anything(name=i) [, PSTYle(str) ]
|
| if `"`pstyle'"'=="" {
|
| local id `i'
|
| }
|
| else {
|
| local id = substr(`"`pstyle'"', 2, 2)
|
| capt confirm number `id'
|
| if _rc {
|
| local id = substr(`"`pstyle'"', 2, 1)
|
| capt confirm number `id'
|
| }
|
| if _rc {
|
| local id `i'
|
| }
|
| }
|
| c_local pstyle_id `id'
|
| end
|
|
|
| program parse_ciopts_nocilwincr
|
| syntax anything(name=i) [, recast(str) LWidth(str) * ]
|
| if `"`recast'`lwidth'"'!="" {
|
| c_local nocilwincr_`i' 1
|
| }
|
| end
|
|
|
| program parse_ciopts_recast_pstyle
|
| syntax [, recast(str) PSTYle(str) * ]
|
| if `"`pstyle'"'!="" {
|
| local options `options' pstyle(`pstyle')
|
| }
|
| c_local cirecast `"`recast'"'
|
| c_local cipstyle `"`pstyle'"'
|
| c_local ciopts `options'
|
| end
|
|
|
| program set_pstyle
|
| args i recast
|
| if `"`recast'"'=="" {
|
| c_local pstyle pstyle(p`i')
|
| exit
|
| }
|
| if inlist(`"`recast'"', "line", "rline")
|
| c_local pstyle pstyle(p`i'line)
|
| else if inlist(`"`recast'"', "area", "rarea")
|
| c_local pstyle pstyle(p`i'area)
|
| else if inlist(`"`recast'"', "bar", "rbar")
|
| c_local pstyle pstyle(p`i'bar)
|
| else if inlist(`"`recast'"', "dot")
|
| c_local pstyle pstyle(p`i'dot)
|
| else c_local pstyle pstyle(p`i')
|
| end
|
|
|
| program parse_ciopts
|
| gettoken j 0 : 0
|
| gettoken n 0 : 0
|
| gettoken opt 0 : 0, bind
|
| local opts
|
| while (`"`opt'"'!="") {
|
| gettoken paren: opt, parse("(")
|
| if `"`paren'"'=="(" {
|
| local opts `opts'`opt'
|
| }
|
| else {
|
| local opts `opts' `opt'
|
| }
|
| gettoken opt 0 : 0, bind
|
| }
|
| local ciopts `", `opts'"'
|
| gettoken opt opts : opts, bind
|
| local i 0
|
| while (`"`opt'"'!="") {
|
| local ++i
|
| gettoken optname optcontents : opt, parse("(")
|
| if `"`optcontents'"'=="" {
|
| gettoken opt opts : opts, bind
|
| continue
|
| }
|
| _parse factor ciopts : ciopts, option(`optname') to(`optname'(X))
|
| gettoken opt opts : opts, bind
|
| }
|
| _parse factordot ciopts : ciopts, n(`n')
|
|
|
| gettoken opt ciopts : ciopts
|
| gettoken opt ciopts : ciopts, bind
|
| while (`"`opt'"'!="") {
|
| mata: coefplot_combine_ciopts()
|
| gettoken opt ciopts : ciopts, bind
|
| }
|
| forv i=1/`n' {
|
| c_local ciopts_`j'_`i' `opt_`i'' `options'
|
| }
|
| end
|
|
|
| program parse_mlabel_exp
|
| syntax [ , MLabel(str asis) ]
|
| c_local mlblexp `"`mlabel'"'
|
| end
|
|
|
| program coeflbls
|
| args labels interact
|
| mata: coefplot_get_coefs(COEFPLOT_STRUCT)
|
| local i 0
|
| foreach v of local coefs {
|
| local ++i
|
| if (`"`v'"'=="") continue
|
| if (`"`v'"'==`"`last'"') {
|
| mata: coefplot_add_label(COEFPLOT_STRUCT, "coef", `i', "coeflbl", 1)
|
| continue
|
| }
|
| mata: coefplot_get_coeflbl(COEFPLOT_STRUCT, `i')
|
| if `"`coeflbl'"'=="" {
|
| if `"`labels'"'!="" {
|
| local coeflbl `"`v'"'
|
| }
|
| else {
|
| compile_xlabel, v(`v') interact(`interact')
|
| }
|
| }
|
| mata: coefplot_add_label(COEFPLOT_STRUCT, "coef", `i', "coeflbl", 1)
|
| }
|
| end
|
|
|
| program compile_xlabel
|
| syntax [, v(str) interact(str) ]
|
| gettoken vi vrest: v, parse("#")
|
| while (`"`vi'"') !="" {
|
| local xlabi
|
| if `"`vi'"'=="#" {
|
| local xlabi `"`interact'"'
|
| }
|
| else if strpos(`"`vi'"',".")==0 {
|
| capt confirm variable `vi', exact
|
| if _rc==0 {
|
| local xlabi: var lab `vi'
|
| }
|
| if `"`xlabi'"'=="" {
|
| local xlabi `"`vi'"'
|
| }
|
| }
|
| else {
|
| gettoken li vii : vi, parse(".")
|
| gettoken dot vii : vii, parse(".")
|
| capt confirm variable `vii', exact
|
| if _rc==0 & `"`vii'"'!="" {
|
| capt confirm number `li'
|
| if _rc {
|
| local xlabi: var lab `vii'
|
| if (`"`xlabi'"'=="") local xlabi `"`vii'"'
|
| if (substr(`"`li'"',1,1)=="c")
|
| local li = substr(`"`li'"',2,.)
|
| if (`"`li'"'!="") local xlabi `"`li'.`xlabi'"'
|
| }
|
| else {
|
| local viilab : value label `vii'
|
| if `"`viilab'"'!="" {
|
| local xlabi: label `viilab' `li'
|
| }
|
| else {
|
| local viilab: var lab `vii'
|
| if (`"`viilab'"'=="") local viilab `"`vii'"'
|
| local xlabi `"`viilab'=`li'"'
|
| }
|
| }
|
| }
|
| if `"`xlabi'"'=="" {
|
| local xlabi `"`vi'"'
|
| }
|
| }
|
| local xlab `"`xlab'`xlabi'"'
|
| gettoken vi vrest: vrest, parse("#")
|
| }
|
| c_local coeflbl `"`xlab'"'
|
| end
|
|
|
| program set_by_and_plot_labels
|
| args plot by
|
|
|
| qui levelsof `plot', local(levels)
|
| foreach l of local levels {
|
| mata: coefplot_get_plotlbl(COEFPLOT_STRUCT, `l')
|
| lab def `plot' `l' `"`plotlbl'"', add
|
| }
|
| lab val `plot' `plot', nofix
|
|
|
| qui levelsof `by', local(levels)
|
| foreach l of local levels {
|
| mata: coefplot_get_bylbl(COEFPLOT_STRUCT, `l')
|
| lab def `by' `l' `"`bylbl'"', add
|
| }
|
| lab val `by' `by', nofix
|
| end
|
|
|
| program get_axis_labels
|
| args x eq grp grid groups
|
|
|
| qui levelsof `eq', local(levels)
|
| local j 0
|
| foreach l of local levels {
|
| local ++j
|
| su `x' if `eq'==`l', meanonly
|
| local pos: di %9.0g r(min) + (r(max)-r(min))/2
|
| local pos: list retok pos
|
| mata: coefplot_get_eqlbl(COEFPLOT_STRUCT, `j')
|
| local eqlabels `eqlabels' `pos' `"`eqlbl'"'
|
| }
|
| c_local eqlabels `"`eqlabels'"'
|
|
|
| if `"`groups'"'!="" {
|
| local j 0
|
| foreach glab of local groups {
|
| local ++j
|
| foreach l of local levels {
|
| su `x' if `grp'==`j' & `eq'==`l', mean
|
| if r(N)>0 {
|
| local pos: di %9.0g r(min) + (r(max)-r(min))/2
|
| local pos: list retok pos
|
| local glbls `glbls' `pos' `"`glab'"'
|
| }
|
| }
|
| }
|
| c_local groups `glbls'
|
| }
|
|
|
| mata: coefplot_ticks_and_labels(COEFPLOT_STRUCT)
|
| c_local xrange `xrange'
|
| c_local xlabels `xlabels'
|
| c_local xgrid `xgrid'
|
| end
|
|
|
| program merge_eqlabels_hlbls
|
| args eqlab hlab
|
| gettoken lab eqlab : eqlab
|
| gettoken lab eqlab : eqlab, quotes
|
| while (`"`lab'"'!="") {
|
| gettoken val hlab : hlab
|
| local hlbls `"`hlbls'`val' `lab' "'
|
| gettoken lab eqlab : eqlab
|
| gettoken lab eqlab : eqlab, quotes
|
| }
|
| c_local hlbls `"`hlbls'"'
|
| c_local eqlabels ""
|
| end
|
|
|
| program truncwrap_vlabels
|
| args v n trunc wrap break
|
| forv i = 1/`n' {
|
| local lbl: label `v' `i'
|
| truncwrap_label lbl "`trunc'" "`wrap'" "`break'" `"`lbl'"'
|
|
|
| lab def `v' `i' `"`lbl'"', modify
|
| }
|
| end
|
|
|
| program truncwrap_labels
|
| args local trunc wrap break lbls
|
| local labels
|
| local skip 1
|
| foreach lbl of local lbls {
|
| if `skip' {
|
| local labels `labels' `lbl'
|
| local skip 0
|
| continue
|
| }
|
| truncwrap_label lbl "`trunc'" "`wrap'" "`break'" `"`lbl'"'
|
|
|
| local labels `labels' `"`lbl'"'
|
| local skip 1
|
| }
|
| c_local `local' `"`labels'"'
|
| end
|
|
|
| program truncwrap_label
|
| args local trunc wrap break lbl
|
| capt mata: coefplot_lbl_is_multiline()
|
| if _rc exit
|
| if "`break'"!="" local break ", `break'"
|
| if "`trunc'"!="" {
|
| local lbl: piece 1 `trunc' of `"`lbl'"'`break'
|
| capt truncwrap_label_check_quotes `"`lbl'"'
|
| if _rc exit
|
| }
|
| if "`wrap'"!="" {
|
| local i 0
|
| local space
|
| while (1) {
|
| local ++i
|
| local piece: piece `i' `wrap' of `"`lbl'"'`break'
|
| capt truncwrap_label_check_quotes `"`piece'"'
|
| if _rc exit
|
| if `"`piece'"'=="" {
|
| if `i'==1 {
|
| local newlbl `"`lbl'"'
|
| }
|
| else if `i'==2 {
|
| local newlbl `"`newlbl'`space'"""'
|
| }
|
| continue, break
|
| }
|
| local newlbl `"`newlbl'`space'`"`piece'"'"'
|
| local space " "
|
| }
|
| local lbl `"`newlbl'"'
|
| }
|
| c_local `local' `"`lbl'"'
|
| end
|
| program truncwrap_label_check_quotes
|
| syntax [anything]
|
| end
|
|
|
| program set_labels
|
| args v n lbls
|
| local i 0
|
| foreach lbl of local lbls {
|
| local ++i
|
| if `i'>`n' continue, break
|
| lab def `v' `i' `"`lbl'"', modify
|
| }
|
| end
|
|
|
| program reset_xlabels
|
| args lbls xlbls
|
| local labels
|
| local skip 1
|
| foreach lbl of local xlbls {
|
| if `skip' {
|
| local labels `labels' `lbl'
|
| local skip 0
|
| continue
|
| }
|
| if `"`lbls'"'!="" {
|
| gettoken lbl lbls : lbls
|
| }
|
| local labels `labels' `"`lbl'"'
|
| local skip 1
|
| }
|
| c_local xlabels `"`labels'"'
|
| end
|
|
|
| version 11
|
| mata:
|
| mata set matastrict on
|
|
|
| struct coefplot_struct
|
| {
|
| real scalar r, xmin
|
|
|
| real colvector b, V, se, t, df, pval, at, plot, by, eq, grp, mlpos
|
| real matrix ci, aux
|
|
|
| string colvector coefnm, eqnm, coeflbl, eqlbl, plotlbl, bylbl, mlbl, trans
|
| }
|
|
|
| struct coefplot_struct scalar coefplot_struct_init()
|
| {
|
| struct coefplot_struct scalar C
|
|
|
| return(C)
|
| }
|
|
|
| void coefplot_keepdrop(struct coefplot_struct scalar C)
|
| {
|
| real scalar i, j, level, r, brow, bcol, row, col, emode,
|
| firsteqonly, meqs, citype
|
| real colvector b, p, at, V, se, t, df, pval, mlpos
|
| real matrix ci, aux, tmp
|
| string scalar model, bname, cname, rename, attrans, attmp
|
| string rowvector keep, drop, cnames, levels, llul
|
| string colvector eqnm, coefnm, mlbl, trans
|
|
|
|
|
| emode = (st_local("matrix")=="")
|
|
|
| model = st_local("model")
|
| bname = st_local("bname")
|
| if (bname=="") {
|
| if (st_global("e(mi)")=="mi") bname = "b_mi"
|
| else bname = "b"
|
| }
|
| coefplot_parse_input(model, "b", bname, brow, bcol)
|
| if (emode) bname = "e(" + bname + ")"
|
| b = st_matrix(bname)
|
| if (b==J(0,0,.)) {
|
| st_local("empty", "1")
|
| return
|
| }
|
| coefplot_invalid_subscript(model, bname, b, brow, bcol)
|
| b = b[brow, bcol]
|
| if (brow<.) {
|
| b = b'
|
| eqnm = st_matrixcolstripe(bname)[.,1]
|
| coefnm = st_matrixcolstripe(bname)[.,2]
|
| }
|
| else {
|
| eqnm = st_matrixrowstripe(bname)[.,1]
|
| coefnm = st_matrixrowstripe(bname)[.,2]
|
| }
|
| _editvalue(eqnm, "", "_")
|
| meqs = !allof(eqnm, eqnm[1])
|
| r = rows(b)
|
|
|
| se = J(r,1,.)
|
| V = J(r,1,.)
|
| if ((cname = st_local("sename"))!="") {
|
| coefplot_parse_cname(model, "se", cname, row, col, emode, 0, bname, brow, bcol)
|
| tmp = st_matrix(cname)
|
| if (coefplot_notfound(model, cname, tmp)==0) {
|
| coefplot_invalid_subscript(model, cname, tmp, row, col)
|
| tmp = tmp[row, col]
|
| if (row<.) tmp = tmp'
|
| if (coefplot_notconformable(model, cname, tmp, r, 1)==0) {
|
| se = tmp
|
| V = tmp:^2
|
| }
|
| }
|
| }
|
| else if ((cname = st_local("vname"))!="") {
|
| if (emode) cname = "e(" + cname + ")"
|
| tmp = st_matrix(cname)
|
| if (coefplot_notfound(model, cname, tmp)==0) {
|
| if (coefplot_notconformable(model, cname, tmp, r, r)==0) {
|
| V = diagonal(tmp)
|
| se = sqrt(V)
|
| }
|
| }
|
| }
|
| else if (emode){
|
| if (st_global("e(mi)")=="mi") cname = "e(V_mi)"
|
| else cname = "e(V)"
|
| tmp = st_matrix(cname)
|
| if (coefplot_notfound(model, cname, tmp, 1)==0) {
|
| if (coefplot_notconformable(model, cname, tmp, r, r, 1)==0) {
|
| V = diagonal(tmp)
|
| se = sqrt(V)
|
| }
|
| }
|
| }
|
|
|
| df = J(r,1,.)
|
| if ((cname = st_local("dfname"))!="") {
|
| if (strtoreal(cname)<. | cname==".") {
|
| df = J(r, 1, strtoreal(cname))
|
| }
|
| else {
|
| coefplot_parse_input(model, "df", cname, row, col)
|
| if (emode) cname = "e(" + cname + ")"
|
| tmp = st_matrix(cname)
|
| if (coefplot_notfound(model, cname, tmp)==0) {
|
| coefplot_invalid_subscript(model, cname, tmp, row, col)
|
| tmp = tmp[row, col]
|
| if (row<.) tmp = tmp'
|
| if (coefplot_notconformable(model, cname, tmp, r, 1)==0) {
|
| df = tmp
|
| }
|
| }
|
| }
|
| }
|
| else if (emode) {
|
| if ((st_global("e(mi)")=="mi") &
|
| (tmp=st_matrix("e(df_mi)")')!=J(0,0,.)) {
|
| if (coefplot_notconformable(model, "e(df_mi)", tmp, r, 1)==0) {
|
| df = tmp
|
| }
|
| }
|
| else if (st_numscalar("e(df_r)")!=J(0,0,.)) {
|
| df = J(r, 1, st_numscalar("e(df_r)"))
|
| }
|
| }
|
|
|
| ci = J(r, 0, .)
|
| if (st_local("ci")=="") {
|
| cnames = tokens(st_local("ciname"))
|
| levels = tokens(st_local("levels"))
|
| citype = strtoreal(st_local("citype"))
|
| for (j=1; j<=cols(levels); j++) {
|
| ci = ci, J(r, 2, .)
|
| if ((cname = strtrim(cnames[j]))!="") {
|
| if (cols(tokens(cname))==1) {
|
| llul = (cname+"[1]", cname+"[2]")
|
| }
|
| else {
|
| if (strpos(cname, "[")==0) {
|
| llul = tokens(cname)
|
| if (cols(llul)!=2) {
|
| printf("{txt}(%s: invalid syntax in %s)\n",
|
| model, "ci()")
|
| exit(error(198))
|
| }
|
| }
|
| else {
|
| if (strpos(cname, "]")==strlen(cname)) {
|
| llul = (substr(cname, 1, strpos(cname, " ")-1),
|
| substr(cname, strpos(cname, " ")+1, .))
|
| }
|
| else {
|
| llul = (substr(cname, 1, strpos(cname, "]")),
|
| substr(cname, strpos(cname, "]")+1, .))
|
| }
|
| }
|
| }
|
| for (i=1; i<=2; i++) {
|
| cname = llul[i]
|
| coefplot_parse_cname(model, "ci", cname, row, col, emode,
|
| 0, bname, brow, bcol)
|
| tmp = st_matrix(cname)
|
| if (coefplot_notfound(model, cname, tmp)==0) {
|
| coefplot_invalid_subscript(model, cname, tmp, row, col)
|
| tmp = tmp[row, col]
|
| if (row<.) tmp = tmp'
|
| if (coefplot_notconformable(model, cname, tmp, r, 1)==0) {
|
| ci[,(j*2-2+i)] = tmp
|
| }
|
| }
|
| }
|
| }
|
| else {
|
| level = 1 - (1 - strtoreal(levels[j])/100)/2
|
| tmp = J(r, 1, .)
|
| for (i=1; i<=r; i++) {
|
| tmp[i] = df[i]>2e17 ? invnormal(level) :
|
| invttail(df[i], 1-level)
|
| }
|
| if (citype==1) {
|
| tmp = tmp :* se :/ (b:* (1 :- b))
|
| ci[|1,(j*2-1) \ .,(j*2)|] =
|
| invlogit((logit(b) :- tmp, logit(b) :+ tmp))
|
| }
|
| else if (citype==2) {
|
| tmp = tmp :* se :/ normalden(invnormal(b))
|
| ci[|1,(j*2-1) \ .,(j*2)|] =
|
| normal((invnormal(b) :- tmp, invnormal(b) :+ tmp))
|
| }
|
| else if (citype==3) {
|
| tmp = tmp :* se :/ (1 :- b:^2)
|
| ci[|1,(j*2-1) \ .,(j*2)|] =
|
| tanh((atanh(b) :- tmp, atanh(b) :+ tmp))
|
| }
|
| else if (citype==4) {
|
| tmp = tmp :* se :/ b
|
| ci[|1,(j*2-1) \ .,(j*2)|] = exp((ln(b) :- tmp, ln(b) :+ tmp))
|
| }
|
| else {
|
| ci[|1,(j*2-1) \ .,(j*2)|] = (b :- tmp:*se, b :+ tmp:*se)
|
| }
|
| }
|
| }
|
| }
|
|
|
| at = J(r,1,1)
|
| cname = st_local("atname2")
|
| if ((cname!="") & (cname!="_coef") & (cname!="_eq")) {
|
| if ( emode &
|
| st_global("e(cmd)")=="margins" &
|
| (st_local("bname")=="" | st_local("bname")=="b") &
|
| (st_numscalar("e(k_at)")!=J(0,0,.) ?
|
| st_numscalar("e(k_at)")>0 : 0) &
|
| (cname=="at" | strtoreal(cname)<.)
|
| )
|
| {
|
| if (cname=="at") cname = "1"
|
| at = coefplot_get_margins_at("e", strtoreal(cname), coefnm)'
|
|
|
| }
|
| else {
|
| coefplot_parse_cname(model, "at", cname, row, col, emode,
|
| st_local("atismatrix")!="", bname, brow, bcol)
|
| tmp = st_matrix(cname)
|
| if (coefplot_notfound(model, cname, tmp)==0) {
|
| coefplot_invalid_subscript(model, cname, tmp, row, col)
|
| tmp = tmp[row, col]
|
| if (row<.) tmp = tmp'
|
| if (coefplot_notconformable(model, cname, tmp, r, 1)==0) {
|
| at = tmp
|
| }
|
| }
|
| }
|
| }
|
|
|
| cnames = tokens(st_local("aux"))
|
| aux = J(r, cols(cnames), .)
|
| for (j=1; j<=cols(cnames); j++) {
|
| cname = cnames[j]
|
| coefplot_parse_cname(model, "aux", cname, row, col, emode, 0, bname, brow, bcol)
|
| tmp = st_matrix(cname)
|
| if (coefplot_notfound(model, cname, tmp)==0) {
|
| coefplot_invalid_subscript(model, cname, tmp, row, col)
|
| tmp = tmp[row, col]
|
| if (row<.) tmp = tmp'
|
| if (coefplot_notconformable(model, cname, tmp, r, 1)==0) {
|
| aux[,j] = tmp
|
| }
|
| }
|
| }
|
|
|
|
|
|
|
| coefnm = subinstr(coefnm,"bn.", ".")
|
| coefnm = subinstr(coefnm,"bno.", "o.")
|
|
|
| p = J(r, 1, 1)
|
| if (st_local("omitted")=="") {
|
| p = p :* (!strmatch(coefnm, "*o.*"))
|
| }
|
| else {
|
| coefnm = substr(coefnm, 1:+2*(substr(coefnm, 1, 2):=="o."), .)
|
| coefnm = subinstr(coefnm, "o.", ".")
|
| }
|
|
|
| if (st_local("baselevels")=="") {
|
| p = p :* (!strmatch(coefnm, "*b.*"))
|
| }
|
| else {
|
| coefnm = subinstr(coefnm, "b.", ".")
|
| }
|
|
|
| firsteqonly = 1
|
| keep = st_local("keep")
|
| if (keep!="") {
|
| keep = coefplot_parse_namelist(keep, "", "keep")
|
| if (!allof(keep[,1], "")) firsteqonly = 0
|
| keep[,1] = editvalue(keep[,1],"","*")
|
| p = p :* (rowsum(strmatch(eqnm, keep[,1]') :&
|
| strmatch(coefnm, keep[,2]')):>0)
|
| }
|
|
|
| drop = st_local("drop")
|
| if (drop!="") {
|
| drop = coefplot_parse_namelist(drop, "", "drop")
|
| if (!allof(drop[,1], "")) firsteqonly = 0
|
| drop[,1] = editvalue(drop[,1],"","*")
|
| p = p :* (!(rowsum(strmatch(eqnm, drop[,1]') :&
|
| strmatch(coefnm, drop[,2]'))))
|
| }
|
|
|
| if (firsteqonly) {
|
| for (i=1; i<=r; i++) {
|
| if (p[i]==1) {
|
| p = p :* (eqnm:==eqnm[i])
|
| break
|
| }
|
| }
|
| }
|
|
|
| if (allof(p, 0)) {
|
| st_local("empty", "1")
|
| return
|
| }
|
| b = select(b, p)
|
| V = select(V, p)
|
| se = select(se, p)
|
| df = select(df, p)
|
| ci = select(ci, p)
|
| eqnm = select(eqnm, p)
|
| coefnm = select(coefnm, p)
|
| at = select(at, p)
|
| aux = select(aux, p)
|
| r = rows(b)
|
|
|
| t = b:/se
|
| pval = J(r,1,.)
|
| for (i=1; i<=r; i++) {
|
| pval[i] = (df[i]>=. ? 1-normal(abs(t[i])) : ttail(df[i],abs(t[i])))*2
|
| }
|
|
|
|
|
| coefplot_eform(b, ci, eqnm, coefnm)
|
|
|
|
|
| coefplot_rescale(b, ci, eqnm, coefnm)
|
|
|
|
|
| trans = coefplot_collect_transforms(eqnm, coefnm)
|
|
|
|
|
| mlbl = J(r,1,"")
|
| mlpos = J(r,1,.)
|
| coefplot_mlabels(mlbl, mlpos, eqnm, coefnm)
|
|
|
|
|
| rename = st_local("rename")
|
| if (rename!="") {
|
| coefplot_rename(rename, st_local("renameregex")!="",
|
| eqnm, coefnm)
|
| }
|
|
|
|
|
| if (st_local("asequation2")!="") {
|
| eqnm = J(r, 1, st_local("asequation2"))
|
| }
|
| rename = st_local("eqrename")
|
| if (rename!="") {
|
| coefplot_rename(rename, st_local("eqrenameregex")!="",
|
| J(r, 1, ""), eqnm)
|
| }
|
|
|
|
|
| if (st_local("atname2")=="_coef") {
|
| at = strtoreal(coefnm)
|
| }
|
| else if (st_local("atname2")=="_eq") {
|
| at = strtoreal(eqnm)
|
| }
|
|
|
|
|
| if ((attrans=st_local("attransform"))!="") {
|
| attmp = st_tempname()
|
| attrans = subinstr(attrans, "@", "scalar(" + attmp + ")")
|
| for (i=1; i<=r; i++) {
|
| st_numscalar(attmp, at[i])
|
| stata("scalar " + attmp + " = " + attrans)
|
| at[i] = st_numscalar(attmp)
|
| }
|
| }
|
|
|
|
|
| coefplot_missing(model, b)
|
| for (j=1; j<=cols(levels); j++) {
|
| coefplot_cimissing(model, j, ci[|1,(j*2-1) \ .,(j*2)|])
|
| }
|
| coefplot_atmissing(model, at)
|
|
|
|
|
| if (st_local("swapnames")!="") swap(coefnm, eqnm)
|
| st_local("n_ci", strofreal(cols(ci)/2))
|
| if (cols(C.ci)>cols(ci)) {
|
| ci = ci, J(rows(ci), cols(C.ci)-cols(ci), .)
|
| }
|
| else if (cols(C.ci)<cols(ci)) {
|
| C.ci = C.ci, J(rows(C.ci), cols(ci)-cols(C.ci), .)
|
| }
|
| C.ci = C.ci \ ci
|
| if (cols(C.aux)>cols(aux)) {
|
| aux = aux, J(rows(aux), cols(C.aux)-cols(aux), .)
|
| }
|
| else if (cols(C.aux)<cols(aux)) {
|
| C.aux = C.aux, J(rows(C.aux), cols(aux)-cols(C.aux), .)
|
| }
|
| C.aux = C.aux \ aux
|
| C.b = C.b \ b
|
| C.V = C.V \ V
|
| C.se = C.se \ se
|
| C.t = C.t \ t
|
| C.df = C.df \ df
|
| C.pval = C.pval \ pval
|
| C.coefnm = C.coefnm \ coefnm
|
| C.eqnm = C.eqnm \ eqnm
|
| C.trans = C.trans \ trans
|
| C.at = C.at \ at
|
| C.mlbl = C.mlbl \ mlbl
|
| C.mlpos = C.mlpos \ mlpos
|
| C.plot = C.plot \ J(r, 1, strtoreal(st_local("i")))
|
| C.by = C.by \ J(r, 1, strtoreal(st_local("j")))
|
| if (firsteqonly==0 & allof(eqnm, eqnm[1]) & meqs) {
|
| st_local("equation", eqnm[1])
|
| }
|
| }
|
|
|
| void coefplot_invalid_subscript(string scalar model, string scalar opt,
|
| real matrix b, real scalar row, real scalar col)
|
| {
|
| if ((row<. & row>rows(b)) | (col<. & col>cols(b))) {
|
| printf("{err}%s: invalid subscript for %s\n", model, opt)
|
| exit(503)
|
| }
|
| }
|
|
|
| void coefplot_parse_input(string scalar model, string scalar opt,
|
| string scalar s, real scalar row, real scalar col)
|
| {
|
| transmorphic t
|
| string scalar r, c
|
| string rowvector tokens
|
|
|
| t = tokeninit(" ", ("[", "]", ","))
|
| tokenset(t, s)
|
| tokens = tokengetall(t)
|
| if (cols(tokens)>6) coefplot_parse_input_error(model, opt)
|
| if (!st_isname(tokens[1])) coefplot_parse_input_error(model, opt)
|
| s = tokens[1]
|
| if (cols(tokens)==1) {
|
| row = 1; col = .
|
| return
|
| }
|
| if (cols(tokens)<4) coefplot_parse_input_error(model, opt)
|
| if (tokens[2]!="[" | tokens[cols(tokens)]!="]")
|
| coefplot_parse_input_error(model, opt)
|
| if (cols(tokens)==4) {
|
| r = tokens[3]
|
| c = "."
|
| }
|
| else if ((r=tokens[3])==",") {
|
| if (cols(tokens)!=5) coefplot_parse_input_error(model, opt)
|
| r = "."
|
| c = tokens[4]
|
| }
|
| else {
|
| if (tokens[4]!=",") coefplot_parse_input_error(model, opt)
|
| r = tokens[3]
|
| if (cols(tokens)==5) c = "."
|
| else c = tokens[5]
|
| }
|
| if (((r==".") + (c=="."))!=1) coefplot_parse_input_error(model, opt)
|
| if (r==".") row = .
|
| else row = coefplot_parse_input_num(model,opt, r)
|
| if (c==".") col = .
|
| else col = coefplot_parse_input_num(model,opt, c)
|
| }
|
|
|
| real scalar coefplot_parse_input_num(string scalar model, string scalar opt,
|
| string scalar s)
|
| {
|
| real scalar num
|
|
|
| num = strtoreal(s)
|
| if (missing(num)) coefplot_parse_input_error(model, opt)
|
| return(num)
|
| }
|
|
|
| void coefplot_parse_input_error(string scalar model, string scalar opt)
|
| {
|
| printf("{err}%s: invalid syntax in %s()\n", model, opt)
|
| exit(198)
|
| }
|
|
|
| void coefplot_parse_cname(string scalar model, string scalar opt,
|
| string scalar cname, real scalar row, real scalar col, real scalar emode,
|
| real scalar atismat, string scalar bname, real scalar brow, real scalar bcol)
|
| {
|
| if (emode) {
|
| coefplot_parse_input(model, opt, cname, row, col)
|
| if (!atismat) cname = "e(" + cname + ")"
|
| }
|
| else {
|
| if (coefplot_parse_input_isposint(cname)) {
|
| row = brow; col = bcol
|
| if (row<.) row = strtoreal(cname)
|
| else col = strtoreal(cname)
|
| cname = bname
|
| }
|
| else coefplot_parse_input(model, opt, cname, row, col)
|
| }
|
| }
|
|
|
| real scalar coefplot_parse_input_isposint(string scalar cname)
|
| {
|
| real scalar n
|
|
|
| n = strtoreal(cname)
|
| return(!missing(n) & n==trunc(n) & n>0)
|
| }
|
|
|
| real scalar coefplot_notfound(
|
| string scalar model, string scalar name, real matrix e, | real scalar q)
|
| {
|
| if (e==J(0,0,.)) {
|
| if (args()<4 | q==0) {
|
| printf("{txt}(%s: %s not found)\n", model, name)
|
| }
|
| return(1)
|
| }
|
| return(0)
|
| }
|
|
|
| real scalar coefplot_notconformable(
|
| string scalar model, string scalar name, real matrix e,
|
| real scalar r, real scalar c, | real scalar q)
|
| {
|
| if (rows(e)!=r | cols(e)!=c) {
|
| if (args()<6 |q==0) {
|
| printf("{txt}(%s: %s not conformable)\n", model, name)
|
| }
|
| return(1)
|
| }
|
| return(0)
|
| }
|
|
|
| void coefplot_eform(real colvector b, real matrix ci, string colvector eq,
|
| string colvector coef)
|
| {
|
| real scalar i
|
| string matrix eform
|
| real colvector match, p
|
|
|
| eform = st_local("eform2")
|
| if (eform=="") {
|
| return
|
| }
|
| if (eform=="*") {
|
| b = exp(b)
|
| ci = exp(ci)
|
| return
|
| }
|
| eform = coefplot_parse_namelist(eform, "*", "eform")
|
| match = J(rows(b), 1, 0)
|
| for (i=1; i<=rows(eform); i++) {
|
| p = select(1::rows(match), strmatch(eq, eform[i,1]) :&
|
| strmatch(coef, eform[i,2]))
|
| if (rows(p)==0) continue
|
| match[p] = J(rows(p), 1, 1)
|
| }
|
| p = select(1::rows(match), match)
|
| if (rows(p)==0) return
|
| b[p] = exp(b[p])
|
| ci[p,] = exp(ci[p,.])
|
| }
|
|
|
| void coefplot_rescale(real colvector b, real matrix ci, string colvector eq,
|
| string colvector coef)
|
| {
|
| real scalar i, j
|
| string matrix rescale, names
|
| real colvector c, match, p
|
|
|
| rescale = st_local("rescale")
|
| if (rescale=="") {
|
| return
|
| }
|
| if (strtoreal(rescale)<.) {
|
| c = strtoreal(rescale)
|
| }
|
| else {
|
| rescale = coefplot_parse_matchlist(rescale, "rescale")
|
| c = J(rows(b), 1, 1)
|
| match = J(rows(b), 1, 0)
|
| for (i=1; i<=rows(rescale); i++) {
|
| if (strtoreal(rescale[i,2])>=.) {
|
| display("{err}rescale(): invalid value")
|
| exit(198)
|
| }
|
| names = coefplot_parse_namelist(rescale[i,1], "*", "rescale")
|
| for (j=1; j<=rows(names); j++) {
|
| p = select(1::rows(match), strmatch(eq, names[j,1]) :&
|
| strmatch(coef, names[j,2]) :& (match:==0))
|
| if (rows(p)==0) continue
|
| c[p] = J(rows(p), 1, strtoreal(rescale[i,2]))
|
| match[p] = J(rows(p), 1, 1)
|
| }
|
| }
|
| }
|
| b = b :* c
|
| ci = ci :* c
|
| }
|
|
|
| string colvector coefplot_collect_transforms(string colvector eq,
|
| string colvector coef)
|
| {
|
| real scalar i, j
|
| string matrix trans, names
|
| string colvector T
|
| real colvector match, p
|
|
|
| T = J(rows(eq), 1, "")
|
| trans = st_local("transform")
|
| if (trans=="") {
|
| return(T)
|
| }
|
| trans = coefplot_parse_matchlist(trans, "transform")
|
| match = J(rows(eq), 1, 0)
|
| for (i=1; i<=rows(trans); i++) {
|
| names = coefplot_parse_namelist(trans[i,1], "*", "transform")
|
| for (j=1; j<=rows(names); j++) {
|
| p = select(1::rows(match), strmatch(eq, names[j,1]) :&
|
| strmatch(coef, names[j,2]) :& (match:==0))
|
| if (rows(p)==0) continue
|
| T[p] = J(rows(p), 1, trans[i,2])
|
| match[p] = J(rows(p), 1, 1)
|
| }
|
| }
|
| return(T)
|
| }
|
|
|
| void coefplot_mlabels(string colvector mlbl, real colvector mlpos,
|
| string colvector eq, string colvector coef)
|
| {
|
| real scalar i, j
|
| string matrix mlab, names
|
| real colvector match, p
|
|
|
| mlab = st_local("mlabels2")
|
| if (mlab=="") {
|
| return
|
| }
|
| mlab = coefplot_parse_matchlist(mlab, "mlabels", 2)
|
| match = J(rows(eq), 1, 0)
|
| for (i=1; i<=rows(mlab); i++) {
|
| names = coefplot_parse_namelist(mlab[i,1], "*", "mlabels")
|
| for (j=1; j<=rows(names); j++) {
|
| p = select(1::rows(match), strmatch(eq, names[j,1]) :&
|
| strmatch(coef, names[j,2]) :& (match:==0))
|
| if (rows(p)==0) continue
|
| mlbl[p] = J(rows(p), 1, mlab[i,3])
|
| mlpos[p] = J(rows(p), 1, strtoreal(mlab[i,2]))
|
| match[p] = J(rows(p), 1, 1)
|
| }
|
| }
|
| }
|
|
|
| void coefplot_rename(string scalar rename, real scalar regex,
|
| string colvector eq, string colvector coef)
|
| {
|
| real scalar i, j, rl
|
| real colvector p, p0, match
|
| string matrix names
|
|
|
| if (regex) {
|
| rename = coefplot_parse_matchlist(rename, "rename")
|
| p0 = 1::rows(coef)
|
| for (i=1; i<=rows(rename); i++) {
|
| if (rows(p0)==0) return
|
| names = coefplot_parse_namelist(rename[i,1], "*", "rename")
|
| for (j=1; j<=rows(names); j++) {
|
| match = (strmatch(eq[p0], names[j,1]) :& regexm(coef[p0], names[j,2]))
|
| p = select(p0, match)
|
| if (rows(p)==0) continue
|
| coef[p] = coefplot_regexr(coef[p], names[j,2], rename[i,2])
|
| p0 = select(p0, match:==0)
|
| }
|
| }
|
| return
|
| }
|
| rename = coefplot_parse_matchlist(rename, "rename")
|
| p0 = 1::rows(coef)
|
| for (i=1; i<=rows(rename); i++) {
|
| if (rows(p0)==0) return
|
|
|
|
|
|
|
| names = coefplot_parse_namelist(rename[i,1], "*", "rename")
|
| for (j=1; j<=rows(names); j++) {
|
| if (substr(names[j,2],1,1)=="*") {
|
| rl = strlen(names[j,2])-1
|
| match = strmatch(eq[p0], names[j,1]) :&
|
| (substr(coef[p0], -rl, .):==substr(names[j,2], -rl, .))
|
| p = select(p0, match)
|
| if (rows(p)==0) continue
|
| coef[p] = substr(coef[p], 1, strlen(coef[p]) :- rl) :+ rename[i,2]
|
| }
|
| else if (substr(names[j,2],-1,1)=="*") {
|
| rl = strlen(names[j,2])-1
|
| match = strmatch(eq[p0], names[j,1]) :&
|
| (substr(coef[p0], 1, rl):==substr(names[j,2], 1, rl))
|
| p = select(p0, match)
|
| if (rows(p)==0) continue
|
| coef[p] = rename[i,2] :+ substr(coef[p], 1 + rl, .)
|
| }
|
| else {
|
| match = strmatch(eq[p0], names[j,1]) :& (coef[p0]:==names[j,2])
|
| p = select(p0, match)
|
| if (rows(p)==0) continue
|
| coef[p] = J(rows(p), 1, rename[i,2])
|
| }
|
| p0 = select(p0, match:==0)
|
| }
|
| }
|
| }
|
|
|
| string matrix coefplot_regexr(string matrix x, string matrix y, string matrix z)
|
| {
|
| string matrix res
|
| real scalar r, R, c, C
|
| transmorphic scalar rx, cx, ry, cy, rz, cz
|
|
|
| R = max((rows(x),rows(y),rows(z)))
|
| C = max((cols(x),cols(y),cols(z)))
|
| rx = (rows(x)==1 ? &1 : (rows(x)<R ? _error(3200) : &r))
|
| cx = (cols(x)==1 ? &1 : (cols(x)<C ? _error(3200) : &c))
|
| ry = (rows(y)==1 ? &1 : (rows(y)<R ? _error(3200) : &r))
|
| cy = (cols(y)==1 ? &1 : (cols(y)<C ? _error(3200) : &c))
|
| rz = (rows(z)==1 ? &1 : (rows(z)<R ? _error(3200) : &r))
|
| cz = (cols(z)==1 ? &1 : (cols(z)<C ? _error(3200) : &c))
|
| res = J(R,C, "")
|
| for (r=1;r<=R;r++) {
|
| for (c=1;c<=C;c++) {
|
| res[r,c] = _coefplot_regexr(x[*rx,*cx], y[*ry,*cy], z[*rz,*cz])
|
| }
|
| }
|
| return(res)
|
| }
|
| string scalar _coefplot_regexr(string scalar s0, string scalar from, string scalar to)
|
| {
|
| real scalar i, j
|
| string scalar s, t, BSLASH
|
| string rowvector sub
|
| pragma unset s
|
|
|
| if (regexm(s0, from)) {
|
| sub = regexs()
|
| sub = (sub, J(1, 10-cols(sub), ""))
|
| BSLASH = "\"
|
| for (i=1; i<=strlen(to); i++) {
|
| if ((t=substr(to,i,1))==BSLASH) {
|
| i++
|
| if ((t=substr(to,i,1))==BSLASH) s = s + BSLASH
|
| else if ((j=strtoreal(t))<.) s = s + sub[j+1]
|
| else s = s + BSLASH + t
|
| }
|
| else s = s + t
|
| }
|
| return(subinstr(s0, sub[1], s, 1))
|
| }
|
| else return(s0)
|
| }
|
|
|
| real rowvector coefplot_get_margins_at(string scalar rtype,
|
| real scalar pos, string colvector coefnm)
|
| {
|
| real scalar i, j, r, c
|
| real matrix at0
|
| real rowvector at, p, atstats
|
|
|
| at0 = st_matrix(rtype + "(at)")
|
| r = rows(at0)
|
| coefnm = subinstr(coefnm, "1bn._at", "1._at")
|
| c = rows(coefnm)
|
| at = J(1, c, .)
|
| for (i=1; i<=r; i++) {
|
| atstats = tokens(st_global(rtype + "(atstats" + strofreal(i) +
|
| ")")) :== "values"
|
| atstats = select(1..cols(atstats), atstats)
|
| if (pos>cols(atstats)) continue
|
| j = atstats[pos]
|
| p = select(1..c, strmatch(coefnm, strofreal(i) + "._at*")')
|
| at[p] = J(1, cols(p), at0[i,j])
|
| }
|
| return(at)
|
| }
|
|
|
| void coefplot_missing(string scalar model, real colvector b)
|
| {
|
| if (hasmissing(b)) {
|
| printf("{txt}(%s: b missing for some coefficients)\n", model)
|
| }
|
| }
|
|
|
| void coefplot_atmissing(string scalar model, real colvector at)
|
| {
|
| if (hasmissing(at)) {
|
| if (nonmissing(at)) {
|
| printf("{txt}(%s: 'at' missing for some coefficients)\n", model)
|
| return
|
| }
|
| printf("{txt}(%s: could not determine 'at')\n", model)
|
| }
|
| }
|
|
|
| void coefplot_cimissing(string scalar model, real scalar ci, real matrix tmp)
|
| {
|
| if (hasmissing(tmp)) {
|
| if (nonmissing(tmp)) {
|
| printf("{txt}(%s: CI%g missing for some coefficients)\n",
|
| model, ci)
|
| return
|
| }
|
| printf("{txt}(%s: could not determine CI%g)\n", model, ci)
|
| }
|
| }
|
|
|
| void coefplot_add_label(struct coefplot_struct scalar C,
|
| string scalar name, real scalar i, string scalar lbl, real scalar force)
|
| {
|
| pointer(string colvector) scalar l
|
|
|
| if (name=="plot") l = &C.plotlbl
|
| else if (name=="by") l = &C.bylbl
|
| else if (name=="coef") l = &C.coeflbl
|
| else return
|
| if (rows(*l)<i) {
|
|
|
| }
|
| if (force | (*l)[i,1]=="") {
|
| (*l)[i,1] = st_local(lbl)
|
| }
|
| }
|
|
|
| void coefplot_set_r(struct coefplot_struct scalar C)
|
| {
|
| C.r = rows(C.b)
|
| st_local("r", strofreal(C.r))
|
| st_local("N_ci", strofreal(cols(C.ci)/2))
|
| st_local("N_aux", strofreal(cols(C.aux)))
|
| st_local("mlbllen", strofreal(max(strlen(C.mlbl))))
|
| }
|
|
|
| void coefplot_add_eq_and_grp(struct coefplot_struct scalar C)
|
| {
|
| C.eq = J(C.r, 1, 1)
|
| C.grp = J(C.r, 1, 0)
|
| }
|
|
|
| void coefplot_arrange(struct coefplot_struct scalar C)
|
| {
|
| real colvector p
|
|
|
| p = coefplot_niceorder(C.eqnm, C.coefnm, C.plot, C.by, C.r)
|
| coefplot_order(p, coefplot_orderby(st_local("orderby"), C), C)
|
| coefplot_order(p, coefplot_sort(p, st_local("sort"), C), C)
|
| coefplot_order(p, st_local("order"), C)
|
| C.b = C.b[p]
|
| C.V = C.V[p]
|
| C.se = C.se[p]
|
| C.t = C.t[p]
|
| C.df = C.df[p]
|
| C.pval = C.pval[p]
|
| C.at = C.at[p]
|
| C.aux = C.aux[p,]
|
| C.mlbl = C.mlbl[p]
|
| C.mlpos = C.mlpos[p]
|
| C.plot = C.plot[p]
|
| C.by = C.by[p]
|
| C.ci = C.ci[p,]
|
| C.coefnm = C.coefnm[p]
|
| C.eqnm = C.eqnm[p]
|
| C.trans = C.trans[p]
|
| st_local("r", strofreal(C.r))
|
| }
|
|
|
| real colvector coefplot_niceorder(string colvector eqnm, string colvector coefnm,
|
| real colvector plot, real colvector by, real scalar r)
|
| {
|
| real matrix Y
|
| real scalar i, a0, b0, s0, a, b, s
|
| real colvector p
|
|
|
| p = order((eqnm, coefnm, strofreal(plot), strofreal(by)), 1..4)
|
| Y = (1::r)
|
| Y = Y, Y, Y
|
| a0 = b0 = a = b = 1
|
| for (i=2; i<=r; i++) {
|
|
|
| s0 = (eqnm[p[i]]==eqnm[p[i-1]])
|
| if (s0) {
|
| b0++
|
| }
|
| if (s0==0 | i==r) {
|
| Y[p[|a0 \ b0|],1] = J(b0-a0+1, 1, min(Y[p[|a0 \ b0|],1]))
|
| a0 = b0 + 1
|
| b0 = a0
|
| }
|
|
|
| s = coefnm[p[i]]==coefnm[p[i-1]] & eqnm[p[i]]==eqnm[p[i-1]]
|
| if (s) {
|
| b++
|
| }
|
| if (s==0) {
|
| if (coefnm[p[i-1]]=="_cons") {
|
| Y[p[|a \ b|],2] = J(b-a+1, 1, .)
|
| }
|
| else {
|
| Y[p[|a \ b|],2] = J(b-a+1, 1, min(Y[p[|a \ b|],2]))
|
| }
|
| a = b + 1
|
| b = a
|
| }
|
| if (i==r) {
|
| if (coefnm[p[i]]=="_cons") {
|
| Y[p[|a \ b|],2] = J(b-a+1, 1, .)
|
| }
|
| else {
|
| Y[p[|a \ b|],2] = J(b-a+1, 1, min(Y[p[|a \ b|],2]))
|
| }
|
| }
|
| }
|
| return(order(Y, 1..3))
|
| }
|
|
|
| string scalar coefplot_orderby(string scalar order, struct coefplot_struct scalar C)
|
| {
|
| real scalar i
|
| string rowvector s
|
| real colvector p
|
| string colvector eqs, coefs
|
|
|
| if (order=="") return("")
|
| s = tokens(order)
|
| if (s[1]==".") p = select(1::C.r, C.plot:==strtoreal(s[2]))
|
| else p = select(1::C.r, (C.by:==strtoreal(s[1]) :& C.plot:==strtoreal(s[2])))
|
| if (rows(p)==0) return("")
|
| eqs = C.eqnm[p]; coefs = C.coefnm[p]
|
| p = coefplot_niceorder(eqs, coefs, J(rows(p),1,1), J(rows(p),1,1), rows(p))
|
| eqs = ("`"+`"""') :+ eqs[p] :+ (`"""' + "'")
|
| coefs = ("`"+`"""') :+ coefs[p] :+ (`"""' + "'")
|
| s = eqs[1] + ": " + coefs[1]
|
| for (i=2; i<=rows(p); i++) {
|
| if (eqs[i]!=eqs[i-1]) s = s + " * " + eqs[i] + ":"
|
| if (coefs[i]==`"`"_cons"'"') continue
|
| s = s + " " + coefs[i]
|
| }
|
| s = s + " *"
|
| return(s)
|
| }
|
|
|
| string scalar coefplot_sort(real colvector p0, string scalar sort,
|
| struct coefplot_struct scalar C)
|
| {
|
| real scalar subgr, plot, desc, c, i
|
| string rowvector s
|
| real colvector p, eq, v, df
|
| string colvector eqs, coefs
|
|
|
| if (sort=="") return("")
|
|
|
| s = tokens(sort)
|
| subgr = strtoreal(s[1])
|
| plot = strtoreal(s[2])
|
| desc = (s[3]=="1")
|
| s = tokens(s[4])
|
| if (length(s)>1) c = strtoreal(s[2])
|
| else c = 1
|
| s = s[1]
|
|
|
| p = p0
|
| if (subgr<.) {
|
| p = select(p, C.by[p]:==subgr)
|
| if (rows(p)==0) return("")
|
| }
|
| if (plot<.) {
|
| p = select(p, C.plot[p]:==plot)
|
| if (rows(p)==0) return("")
|
| }
|
| if (s=="b") v = C.b[p]
|
| else if (s=="v") v = C.V[p]
|
| else if (s=="se") v = C.se[p]
|
| else if (s=="t") v = C.t[p]
|
| else if (s=="tabs") v = abs(C.t[p])
|
| else if (s=="df") v = C.df[p]
|
| else if (s=="p") v = C.pval[p]
|
| else if (s=="ll") {
|
| if ((c*2)>cols(C.ci)) return("")
|
| v = C.ci[p,c*2-1]
|
| }
|
| else if (s=="ul") {
|
| if ((c*2)>cols(C.ci)) return("")
|
| v = C.ci[p,c*2]
|
| }
|
| else if (s=="aux") {
|
| if (c>cols(C.aux)) return("")
|
| v = C.aux[p,c]
|
| }
|
|
|
| if (desc) v = -v
|
| eqs = C.eqnm[p]
|
| eq = J(rows(eqs),1,1)
|
| for (i=2; i<=rows(eq); i++) {
|
| if (eqs[i]!=eqs[i-1]) eq[i] = eq[i-1]+1
|
| else eq[i] = eq[i-1]
|
| }
|
| p = sort((eq, v, p), 1..3)[,3]
|
|
|
| eqs = ("`"+`"""') :+ C.eqnm[p] :+ (`"""' + "'")
|
| coefs = ("`"+`"""') :+ C.coefnm[p] :+ (`"""' + "'")
|
| s = eqs[1] + ": " + coefs[1]
|
| for (i=2; i<=rows(p); i++) {
|
| if (eqs[i]!=eqs[i-1]) s = s + " * " + eqs[i] + ":"
|
| s = s + " " + coefs[i]
|
| }
|
| s = s + " *"
|
| return(s)
|
| }
|
|
|
| void coefplot_order(real colvector p0, string scalar order,
|
| struct coefplot_struct scalar C)
|
| {
|
| real scalar i, j, k
|
| real colvector p, tag, tmp
|
| string colvector eqs
|
|
|
| if (order=="") return
|
| order = coefplot_parse_namelist(order, "", "order")
|
| if (order[1,1]=="" & !allof(order[,1], "")) {
|
| display("{err}inconsistent order(): " +
|
| "specify equations for all or for none")
|
| exit(198)
|
| }
|
| p = J(0,1,.)
|
| tag = J(C.r, 1, 0)
|
| k = 0
|
|
|
| if (order[1,1]!="") {
|
| for (i=1; i<=rows(order); i++) {
|
| k++
|
| if (order[i,2]==".") {
|
| coefplot_appendemptyrow(C, order[i,1], tag, p0)
|
| p = p \ C.r
|
| continue
|
| }
|
| tag = tag :+ (k * strmatch(C.coefnm[p0], order[i,2]) :* !tag :*
|
| (C.eqnm[p0]:==order[i,1]))
|
| if (anyof(tag, k)) {
|
| p = p \ select(p0, tag:==k)
|
| }
|
| }
|
| if (anyof(tag, 0)) {
|
| p = p \ select(p0, tag:==0)
|
| }
|
| swap(p,p0); return
|
| }
|
|
|
| order = order[,2]'
|
| eqs = C.eqnm[p0[1]]
|
| for (i=2; i<=C.r; i++) {
|
| if (C.eqnm[p0[i]]!=C.eqnm[p0[i-1]]) {
|
| eqs = eqs \ C.eqnm[p0[i]]
|
| }
|
| }
|
| for (j=1; j<=rows(eqs); j++) {
|
| for (i=1; i<=cols(order); i++) {
|
| k++
|
| if (order[i]==".") {
|
| coefplot_appendemptyrow(C, eqs[j], tag, p0)
|
| p = p \ C.r
|
| continue
|
| }
|
| tag = tag :+ (k * strmatch(C.coefnm[p0], order[i]) :* !tag :*
|
| (C.eqnm[p0]:==eqs[j]))
|
| if (anyof(tag, k)) {
|
| p = p \ select(p0, tag:==k)
|
| }
|
| }
|
| tmp = (tag:==0):&(C.eqnm[p0]:==eqs[j])
|
| if (any(tmp)) {
|
| p = p \ select(p0, tmp)
|
| tag = tag :+ tmp
|
| }
|
| }
|
| swap(p,p0); return
|
| }
|
|
|
| void coefplot_appendemptyrow(struct coefplot_struct scalar C,
|
| string scalar eq, real colvector tag, real colvector p0)
|
| {
|
| C.b = C.b \ .
|
| C.V = C.V \ .
|
| C.se = C.se \ .
|
| C.t = C.t \ .
|
| C.df = C.df \ .
|
| C.pval = C.pval \ .
|
| C.at = C.at \ 1
|
| C.aux = C.aux \ J(1, cols(C.aux), .)
|
| C.mlbl = C.mlbl \ ""
|
| C.mlpos = C.mlpos \ .
|
| C.plot = C.plot \ .
|
| C.by = C.by \ .
|
| C.ci = C.ci \ J(1, cols(C.ci), .)
|
| C.coefnm = C.coefnm \ ""
|
| C.eqnm = C.eqnm \ eq
|
| C.trans = C.trans \ ""
|
| tag = tag \ .
|
| C.r = C.r + 1
|
| p0 = p0 \ C.r
|
| }
|
|
|
| void coefplot_coeflbls(struct coefplot_struct scalar C)
|
| {
|
| real scalar i, j, k
|
| real colvector tag
|
| string matrix labels, names
|
|
|
| C.coeflbl = J(C.r, 1, "")
|
| tag = J(C.r, 1, 0)
|
| labels = coefplot_parse_matchlist(st_local("coeflabels"), "coeflabels")
|
| for (j=1; j<=rows(labels); j++) {
|
| names = coefplot_parse_namelist(labels[j,1], "*", "coeflabels")
|
| for (k=1; k<=rows(names); k++) {
|
| tag = tag :+ j * strmatch(C.eqnm, names[k,1]) :*
|
| strmatch(C.coefnm, names[k,2]) :* (tag:==0)
|
| }
|
| }
|
| _editmissing(tag, 0)
|
| for (i=1; i<=C.r; i++) {
|
| if (tag[i] & C.plot[i]<.) {
|
| C.coeflbl[i] = labels[tag[i],2]
|
| }
|
| }
|
| }
|
|
|
| void coefplot_multiple_eqs(struct coefplot_struct scalar C)
|
| {
|
| real scalar i, meqs
|
| string matrix eq
|
|
|
| eq = C.eqnm, strofreal(C.plot), strofreal(C.by)
|
|
|
| _sort(eq, (3,2,1))
|
| meqs = 0
|
| for (i=2; i<=rows(eq); i++) {
|
| if (eq[i,1]!=eq[i-1,1] & eq[i,2]==eq[i-1,2] & eq[i,3]==eq[i-1,3]) {
|
| meqs = 1
|
| break
|
| }
|
| }
|
| if (meqs==0) {
|
| C.eqnm = J(rows(C.eqnm), 1, "_")
|
| }
|
| st_local("meqs", strofreal(meqs))
|
| }
|
|
|
| void coefplot_bycoefs(struct coefplot_struct scalar C)
|
| {
|
| real scalar i, j, k, meqs
|
| real colvector p
|
| string scalar eql
|
| string colvector bylbl, last, eqlbls
|
|
|
| meqs = (st_local("meqs")!="0") & (st_local("noeqlabels")=="")
|
| if (meqs) eqlbls = tokens(st_local("eqlabels"))'
|
| bylbl = C.bylbl
|
| C.bylbl = C.coeflbl
|
| swap(C.at, C.by)
|
| j = 0
|
| k = 1
|
| for (i=1; i<=C.r; i++) {
|
| if (i>1) {
|
| if (C.eqnm[i]!=C.eqnm[i-1]) k++
|
| }
|
| if ((C.eqnm[i], C.coefnm[i])!=last) j++
|
| last = (C.eqnm[i], C.coefnm[i])
|
| C.by[i] = j
|
| if (meqs) {
|
| if (k<=rows(eqlbls)) eql = eqlbls[k]
|
| else eql = C.eqnm[i]
|
| C.bylbl[j] = eql + ": " + C.bylbl[i]
|
| }
|
| else C.bylbl[j] = C.bylbl[i]
|
| }
|
| C.bylbl = C.bylbl[|1 \ j|]
|
| C.eqnm = J(C.r, 1, "_")
|
| C.coefnm = strofreal(C.at)
|
| C.coeflbl = J(C.r, 1, "")
|
| for (i=1; i<=C.r; i++) {
|
| C.coeflbl[i] = bylbl[C.at[i]]
|
| }
|
| C.at = J(C.r, 1, 1)
|
| p = coefplot_niceorder(C.eqnm, C.coefnm, C.plot, C.by, C.r)
|
| C.b = C.b[p]
|
| C.V = C.V[p]
|
| C.se = C.se[p]
|
| C.t = C.t[p]
|
| C.df = C.df[p]
|
| C.pval = C.pval[p]
|
| C.at = C.at[p]
|
| C.aux = C.aux[p,]
|
| C.mlbl = C.mlbl[p]
|
| C.mlpos = C.mlpos[p]
|
| C.plot = C.plot[p]
|
| C.by = C.by[p]
|
| C.ci = C.ci[p,]
|
| C.coefnm = C.coefnm[p]
|
| C.eqnm = C.eqnm[p]
|
| C.trans = C.trans[p]
|
| C.coeflbl = C.coeflbl[p]
|
| st_local("n_subgr", strofreal(rows(C.bylbl)))
|
| }
|
|
|
| void coefplot_catvals(struct coefplot_struct scalar C)
|
| {
|
| real scalar i, j, k, e, eqgap, ggap
|
| real colvector pos, at0
|
| string scalar glbls, xlab
|
| string colvector eqs
|
| string matrix groups, names
|
|
|
|
|
| for (i=2; i<=C.r; i++ ) {
|
| C.at[i] = C.at[i-1] +
|
| ((C.coefnm[i]!=C.coefnm[i-1])
|
| | (C.eqnm[i]!=C.eqnm[i-1])
|
| | (C.plot[i]==.))
|
| }
|
|
|
|
|
| coefplot_relocate(C)
|
| C.xmin = min(C.at)
|
|
|
|
|
| eqs = tokens(st_local("eqlabels"))'
|
| xlab = st_local("eqxlab")
|
| C.eq = J(C.r, 1, 1)
|
| C.eqlbl = J(C.r, 1, "")
|
| j = 1
|
| if (j>rows(eqs)) C.eqlbl[j] = coefplot_get_xlab(C.eqnm[1], xlab)
|
| else C.eqlbl[j] = eqs[j]
|
| for (i=2; i<=C.r; i++ ) {
|
| C.eq[i] = C.eq[i-1]
|
| if (C.eqnm[i]!=C.eqnm[i-1]) {
|
| j++
|
| if (j>rows(eqs)) C.eqlbl[j] = coefplot_get_xlab(C.eqnm[i], xlab)
|
| else C.eqlbl[j] = eqs[j]
|
| C.eq[i] = C.eq[i] + 1
|
| }
|
| }
|
| C.eqlbl = C.eqlbl[|1,1 \ j,.|]
|
|
|
|
|
| groups = st_local("groups")
|
| C.grp = J(C.r, 1, 0)
|
| if (groups!="") {
|
| groups = coefplot_parse_matchlist(groups, "groups")
|
| eqs = uniqrows(C.eqnm)
|
| for (e=1; e<=rows(eqs); e++) {
|
| for (j=1; j<=rows(groups); j++) {
|
| names = coefplot_parse_namelist(groups[j,1], "*", "groups")
|
| for (k=1; k<=rows(names); k++) {
|
| C.grp = C.grp :+ j * strmatch(C.eqnm, names[k,1]) :*
|
| strmatch(C.coefnm, names[k,2]) :* (C.grp:==0) :*
|
| (C.eqnm:==eqs[e]) :* (C.plot:<.)
|
| }
|
| for (i=1; i<=C.r; i++) {
|
| pos = select(1::C.r, (C.grp:==j) :& (C.eqnm:==eqs[e]))
|
| if (length(pos)>0) {
|
| C.grp[|pos[1] \ pos[rows(pos)]|] =
|
| J((pos[rows(pos)]-pos[1]+1), 1, j)
|
| }
|
| }
|
| }
|
| }
|
| for (j=1; j<=rows(groups); j++) {
|
| glbls = glbls + " " + "`" + `"""' + groups[j,2] + `"""' + "'"
|
| }
|
| st_local("groups", strtrim(glbls))
|
| }
|
|
|
|
|
| eqgap = strtoreal(st_local("eqgap"))
|
| ggap = strtoreal(st_local("ggap"))
|
| if (eqgap==0 & ggap==0) return
|
| at0 = C.at
|
| for (i=2; i<=C.r; i++ ) {
|
| C.at[i] = C.at[i-1] +
|
| (at0[i,1] - at0[i-1,1]) +
|
| (C.eqnm[i]!=C.eqnm[i-1])*eqgap +
|
| (C.eqnm[i]==C.eqnm[i-1] & C.grp[i]!=C.grp[i-1])*ggap
|
| }
|
| }
|
|
|
| string scalar coefplot_get_xlab(string scalar v, string scalar interact)
|
| {
|
| if (interact=="") return(v)
|
| stata("compile_xlabel, v(" + v + ") interact(" + interact + ")")
|
| return(st_local("coeflbl"))
|
| }
|
|
|
| void coefplot_relocate(struct coefplot_struct scalar C)
|
| {
|
| real scalar i, j, k
|
| real colvector tag, p
|
| string matrix pos, names
|
|
|
| if (st_local("relocate")=="") return
|
|
|
|
|
| tag = J(C.r, 1, 0)
|
| pos = coefplot_parse_matchlist(st_local("relocate"), "relocate")
|
| for (j=1; j<=rows(pos); j++) {
|
| names = coefplot_parse_namelist(pos[j,1], "*", "relocate")
|
| for (k=1; k<=rows(names); k++) {
|
| tag = tag :+ j * strmatch(C.eqnm, names[k,1]) :*
|
| strmatch(C.coefnm, names[k,2]) :* (tag:==0)
|
| }
|
| }
|
| _editmissing(tag, 0)
|
| p = strtoreal(pos[,2])
|
| for (i=1; i<=C.r; i++) {
|
| if (tag[i] & (C.plot[i]<.)) {
|
| C.at[i] = p[tag[i]]
|
| }
|
| }
|
|
|
|
|
| p = order((C.at, (1::C.r)), (1,2))
|
| C.b = C.b[p]
|
| C.V = C.V[p]
|
| C.se = C.se[p]
|
| C.t = C.t[p]
|
| C.df = C.df[p]
|
| C.pval = C.pval[p]
|
| C.at = C.at[p]
|
| C.aux = C.aux[p,]
|
| C.mlbl = C.mlbl[p]
|
| C.mlpos = C.mlpos[p]
|
| C.plot = C.plot[p]
|
| C.by = C.by[p]
|
| C.ci = C.ci[p,]
|
| C.coefnm = C.coefnm[p]
|
| C.eqnm = C.eqnm[p]
|
| C.trans = C.trans[p]
|
| C.coeflbl = C.coeflbl[p]
|
| }
|
|
|
| void coefplot_headings(struct coefplot_struct scalar C)
|
| {
|
| real scalar i, j, k, off, gap, fskip
|
| real colvector tag
|
| string scalar hlbls
|
| string matrix headings, names
|
|
|
| off = strtoreal(st_local("hoff"))
|
| gap = strtoreal(st_local("hgap"))
|
|
|
|
|
| if (st_local("eqashead")!="") {
|
| fskip = C.at[1]
|
| j = 0
|
| for (i=1; i<=C.r; i++) {
|
| if (C.eq[i]!=j) {
|
| C.at[|i \ .|] = C.at[|i \ .|] :+ 1 :+ (gap*(i>1))
|
| hlbls = hlbls + " " + strofreal(C.at[i] - fskip + off)
|
| }
|
| j = C.eq[i]
|
| }
|
| st_local("hlbls", strtrim(hlbls))
|
| return
|
| }
|
|
|
|
|
| headings = st_local("headings")
|
| if (headings=="") {
|
| st_local("hlbls", "")
|
| return
|
| }
|
| tag = J(C.r, 1, 0)
|
| if (C.r>1) {
|
| tag[|2 \ .|] = tag[|2 \ .|] :+
|
| (C.at[|2 \ .|]:==C.at[|1 \ C.r-1|])
|
| _editvalue(tag, 1, .)
|
| }
|
| headings = coefplot_parse_matchlist(headings, "headings")
|
| for (j=1; j<=rows(headings); j++) {
|
| names = coefplot_parse_namelist(headings[j,1], "*", "headings")
|
| for (k=1; k<=rows(names); k++) {
|
| tag = tag :+ j * strmatch(C.eqnm,names[k,1]) :*
|
| strmatch(C.coefnm, names[k,2]) :* (tag:==0)
|
| }
|
| }
|
| _editmissing(tag, 0)
|
| for (i=1; i<=C.r; i++) {
|
| if (tag[i] & (C.plot[i]<.)) {
|
| C.at[|i \ .|] = C.at[|i \ .|] :+ 1 :+ (gap*(i>1))
|
| hlbls = hlbls + " " + strofreal(C.at[i] - 1 + off) + " " +
|
| "`" + `"""' + headings[tag[i],2] + `"""' + "'"
|
| }
|
| }
|
| st_local("hlbls", strtrim(hlbls))
|
| }
|
|
|
| string matrix coefplot_parse_matchlist(string scalar s, string scalar opt,
|
| | real scalar nc0)
|
| {
|
| transmorphic t
|
| real scalar c, a, b, j, i, nc
|
| real rowvector eqpos
|
| string rowvector stok
|
| string matrix res
|
|
|
| if (args()==3) nc = nc0
|
| else nc = 1
|
| if (s=="") return(J(0,1+nc,""))
|
| t = tokeninit(" ", "=")
|
| tokenset(t, s)
|
| stok = tokengetall(t)
|
| c = cols(stok)
|
| a = b = i = 1
|
| eqpos = select(1::c, stok':=="=")'
|
| res = J(cols(eqpos), 1+nc, "")
|
| for (j=1; j<=cols(eqpos); j++) {
|
| b = eqpos[j]
|
| if (b==a | b==c | (b+nc)>cols(stok)) {
|
| printf("{err}%s(): invalid matchlist\n", opt)
|
| exit(198)
|
| }
|
| res[i,] = (invtokens(stok[|a \ b-1|]), stok[|b+1 \ b+nc|])
|
| a = b + 1 + nc
|
| i++
|
| }
|
| if (a<=c) {
|
| printf("{err}%s(): invalid matchlist\n", opt)
|
| exit(198)
|
| }
|
| nc = nc + 1
|
| for (i=1; i<=rows(res); i++) {
|
| if (substr(res[i,nc], 1, 1)==`"""') {
|
| res[i,nc] = substr(res[i,nc], 2, strlen(res[i,nc])-2)
|
| }
|
| else if (substr(res[i,nc], 1, 2)=="`" + `"""') {
|
| res[i,nc] = substr(res[i,nc], 3, strlen(res[i,nc])-4)
|
| }
|
| }
|
| return(res)
|
| }
|
|
|
| string matrix coefplot_parse_namelist(string scalar s, string scalar defeq,
|
| string scalar opt)
|
| {
|
| transmorphic t
|
| real scalar i, c
|
| string rowvector stok
|
| string matrix res
|
|
|
| if (s=="") return(J(0,2,""))
|
| t = tokeninit(" ", ":")
|
| tokenset(t, s)
|
| stok = tokengetall(t)
|
| c = cols(stok)
|
| for (i=1; i<=c; i++) {
|
| if (substr(stok[i], 1, 1)==`"""') {
|
| stok[i] = substr(stok[i], 2, strlen(stok[i])-2)
|
| }
|
| else if (substr(stok[i], 1, 2)=="`" + `"""') {
|
| stok[i] = substr(stok[i], 3, strlen(stok[i])-4)
|
| }
|
| }
|
| res = J(0, 2, "")
|
| for (i=1;i<=c;i++) {
|
| if (i+1<=c) {
|
| if (stok[i+1]==":") {
|
| if (stok[i]==":") {
|
| printf("{err}%s(): invalid namelist\n", opt)
|
| exit(198)
|
| }
|
| if (i+2<=c) {
|
| if (stok[i+2]==":") {
|
| printf("{err}%s(): invalid namelist\n", opt)
|
| exit(198)
|
| }
|
| if (i+3<=c) {
|
| if (stok[i+3]==":") {
|
| res = res \ (stok[i], "*")
|
| i++
|
| continue
|
| }
|
| }
|
| res = res \ (stok[i], stok[i+2])
|
| defeq = stok[i]
|
| i = i + 2
|
| continue
|
| }
|
| res = res \ (stok[i], "*")
|
| i++
|
| continue
|
| }
|
| }
|
| if (stok[i]==":") {
|
| printf("{err}%s(): invalid namelist\n", opt)
|
| exit(198)
|
| }
|
| res = res \ (defeq, stok[i])
|
| }
|
| return(res)
|
| }
|
|
|
| void coefplot_put(struct coefplot_struct scalar C)
|
| {
|
| real scalar i
|
| real rowvector vi
|
|
|
| st_store((1,C.r), st_local("b"), C.b)
|
| st_store((1,C.r), st_local("V"), C.V)
|
| st_store((1,C.r), st_local("se"), C.se)
|
| st_store((1,C.r), st_local("t"), C.t)
|
| st_store((1,C.r), st_local("df"), C.df)
|
| st_store((1,C.r), st_local("pval"), C.pval)
|
| st_store((1,C.r), st_local("at"), C.at)
|
| st_sstore((1,C.r), st_local("mlbl"), C.mlbl)
|
| st_store((1,C.r), st_local("mlpos"), C.mlpos)
|
| st_store((1,C.r), st_local("plot"), C.plot)
|
| st_store((1,C.r), st_local("by"), C.by)
|
| st_store((1,C.r), st_local("eq"), C.eq)
|
| st_store((1,C.r), st_local("grp"), C.grp)
|
| vi = J(1, cols(C.ci), .)
|
| for (i=1; i<=(cols(vi)/2); i++) {
|
| vi[1,i*2-1] = st_varindex(st_local("ll" + strofreal(i)))
|
| vi[1,i*2] = st_varindex(st_local("ul" + strofreal(i)))
|
| }
|
| st_store((1,C.r), vi, C.ci)
|
| vi = J(1, cols(C.aux), .)
|
| for (i=1; i<=cols(vi); i++) {
|
| vi[1,i] = st_varindex(st_local("aux" + strofreal(i)))
|
| }
|
| st_store((1,C.r), vi, C.aux)
|
| }
|
|
|
| void coefplot_apply_transform(struct coefplot_struct scalar C)
|
| {
|
| real scalar i, j, rc, x0, x1, mis
|
| string scalar trans0, trans, trans1
|
| string rowvector vname
|
| real rowvector vpos
|
|
|
| if (allof(C.trans[i], "")) return
|
| vname = J(1, cols(C.ci), "")
|
| for (j=1; j<=(cols(C.ci)/2); j++) {
|
| vname[j*2-1] = st_local("ll"+strofreal(j))
|
| vname[j*2] = st_local("ul"+strofreal(j))
|
| }
|
| vname = st_local("b"), vname
|
| vpos = st_varindex(vname)
|
| mis = 0
|
| for (i=1; i<=C.r; i++) {
|
| if (C.trans[i]=="") continue
|
| if (C.trans[i]!=trans0) trans0 = C.trans[i]
|
| trans = _coefplot_inject_temvars(trans0, cols(C.ci), cols(C.aux))
|
| for (j=1; j<=cols(vname); j++) {
|
| trans1 = subinstr(trans, "@", vname[j])
|
| x0 = _st_data(i, vpos[j])
|
| rc = _stata("replace " + vname[j] + " = " + trans1 + " in " + strofreal(i), 1)
|
| if (rc) {
|
| printf("{err}transform '%s' invalid\n", trans0)
|
| exit(198)
|
| }
|
| x1 = _st_data(i, vpos[j])
|
| if (x1>=. & x1!=x0) mis = 1
|
| }
|
| }
|
| if (mis) {
|
| display("{txt}(transform missing for some coefficients or CIs)")
|
| }
|
| }
|
|
|
| void coefplot_lbl_is_multiline()
|
| {
|
| string scalar lbl
|
|
|
| lbl = strtrim(st_local("lbl"))
|
| if ((substr(lbl, 1, 1)==`"""' | substr(lbl, 1, 2)==("`" + `"""'))) {
|
| return(499)
|
| }
|
| }
|
|
|
| void coefplot_get_coefs(struct coefplot_struct scalar C)
|
| {
|
| st_local("coefs",
|
| invtokens("`" :+ `"""' :+ C.coefnm' :+ `"""' :+ "'"))
|
| }
|
|
|
| void coefplot_get_coeflbl(struct coefplot_struct scalar C, real scalar i)
|
| {
|
| st_local("coeflbl", C.coeflbl[i])
|
| }
|
|
|
| void coefplot_get_plotlbl(struct coefplot_struct scalar C, real scalar i)
|
| {
|
| st_local("plotlbl", C.plotlbl[i])
|
| }
|
|
|
| void coefplot_get_bylbl(struct coefplot_struct scalar C, real scalar i)
|
| {
|
| st_local("bylbl", C.bylbl[i])
|
| }
|
|
|
| void coefplot_get_eqlbl(struct coefplot_struct scalar C, real scalar i)
|
| {
|
| st_local("eqlbl", C.eqlbl[i])
|
| }
|
|
|
| void coefplot_ticks_and_labels(struct coefplot_struct scalar C)
|
| {
|
| real scalar i, between
|
| string scalar labels, grid, space
|
|
|
| between = (st_local("grid")=="between")
|
| st_local("xrange", strofreal(C.xmin-0.5) + " " +
|
| strofreal(max(C.at)+0.5))
|
| if (between & C.plot[1]<.) {
|
| if (C.xmin<min(C.at)) {
|
| grid = strofreal(C.at[1] - min((0.5, (C.at[1]-C.xmin)/2))) + " "
|
| }
|
| }
|
| for (i=1; i<=C.r; i++) {
|
| if (i>1) {
|
| if ((C.eqnm[i], C.coefnm[i])==(C.eqnm[i-1], C.coefnm[i-1])) {
|
| continue
|
| }
|
| if (between & C.plot[i-1]<.) {
|
| grid = grid + space +
|
| strofreal(C.at[i-1] + min((0.5, (C.at[i]-C.at[i-1])/2)))
|
| }
|
| }
|
| if (C.plot[i]<.) {
|
| labels = labels + space + strofreal(C.at[i]) +
|
| " `" + `"""' + C.coeflbl[i] + `"""' + "'"
|
| if (between==0) grid = grid + space + strofreal(C.at[i])
|
| else if (i>1) {
|
| grid = grid + space +
|
| strofreal(C.at[i] - min((0.5, (C.at[i]-C.at[i-1])/2)))
|
| }
|
| space = " "
|
| }
|
| }
|
| st_local("xlabels", labels)
|
| st_local("xgrid", grid)
|
| }
|
|
|
| void coefplot_combine_ciopts()
|
| {
|
| string scalar opt, p
|
|
|
| opt = st_local("opt")
|
| p = substr(opt, 2, strpos(opt,"(")-2)
|
| if (strtoreal(p)<.) {
|
| opt = substr(opt, 3+strlen(p), strlen(opt)-3-strlen(p))
|
| st_local("opt_"+p, st_local("opt_"+p) + " " + opt)
|
| }
|
| else {
|
| st_local("options", st_local("options") + " " + opt)
|
| }
|
| }
|
|
|
| void coefplot_parsecomma(string scalar lhs, string scalar rhs, string scalar lin)
|
| {
|
| transmorphic t
|
| string scalar l, r, token
|
|
|
| t = tokeninit("", ",", (`""""', `"`""'"'), 0, 0)
|
| tokenset(t, st_local(lin))
|
| while ((token = tokenget(t))!="") {
|
| if (token==",") {
|
| r = token
|
| while ((token = tokenget(t))!="") {
|
| r = r + token
|
| }
|
| st_local(lhs, l)
|
| st_local(rhs, r)
|
| return
|
| }
|
| l = l + token
|
| }
|
| st_local(lhs, l)
|
| st_local(rhs, r)
|
| }
|
|
|
| void coefplot_inject_temvars(string scalar s, real scalar nci,
|
| real scalar naux)
|
| {
|
| st_local(s, _coefplot_inject_temvars(st_local(s), nci, naux))
|
| }
|
| string scalar _coefplot_inject_temvars(string scalar s, real scalar nci,
|
| real scalar naux)
|
| {
|
| real scalar i
|
| string scalar v, vname
|
| string rowvector nspace
|
|
|
| nspace = J(1, nci*2 + naux, "")
|
| for (i=1; i<=nci; i++) {
|
| nspace[i*2-1] = "ll" + strofreal(i)
|
| nspace[i*2] = "ul" + strofreal(i)
|
| }
|
| for (i=1; i<=naux; i++) {
|
| nspace[nci*2+i] = "aux" + strofreal(i)
|
| }
|
| nspace = nspace, ("b", "V", "se", "t", "df", "pval", "at", "mlbl", "mlpos", "plot", "by")
|
| while (regexm(s,"@[Va-z]+[0-9]*")) {
|
| v = regexs()
|
| vname = substr(v, 2, .)
|
| if (vname=="ll" | vname=="ul" | vname=="aux") {
|
| vname = vname + "1"
|
| }
|
| if (anyof(nspace, vname)==0) {
|
| printf("{err}%s not found\n", v)
|
| exit(error(111))
|
| }
|
| s = subinstr(s, v, st_local(vname), 1)
|
| }
|
| return(s)
|
| }
|
|
|
| end
|
|
|
|
|
|
|
|
|
