capture program drop overfit
program overfit, rclass
* Calculates Bilger and Manning (2015) overfitting statistics
version 11.2
********************************************************************* Syntax *********************************************************************
gettoken 0 cmdest : 0, parse(":") bind quotes
* if there is nothing before the colon, 0 = empty string
if `"`0'"'==":" {
local 0 ""
}
else {
* take the colon out of cmdest
gettoken colon cmdest : cmdest, parse(":")
if `"`colon'"' != ":" {
di as err "'colon' found were ':' expected"
exit 198
}
}
syntax [ anything(name=anyof) ] [, predopt(string) nbgrp(integer 10) splitnorand nbiter(integer 100) seed(integer 1) efficient ///
noiterbar noresults hist(string asis) showmod showslopes ///
savemod(string asis) savepred(string asis) procnb(integer 1)]
******************************************************** Parse arguments *******************************************************
* Separate the options from the estimation command
gettoken cmdest cmdopt : cmdest, parse(",") bind quotes
* Do not allow if, in and using conditions, nor weights.
noifinusingweight `cmdest'
* Find out which estimation method was used
gettoken method vlist: cmdest
* Separate dependant variable from covariates
gettoken y xlist: vlist
* Result of parsing:
* cmdest: estimation command including dependent variable Y and regressors X1,...XK, without options.
* cmdopt: any option passed to the estimation command.
* method: estimation command used, e.g. glm.
* vlist: list of all variables used, that is the dependent variable Y and all regressors X1,...XK.
* y: dependent variable.
* xlist: all regressors X1,...XK.
******************************************************** Check options *******************************************************
* predopt: options to pass to the predict command so that it predicts the expectation of y
if ("`predopt'" != "") {
local predopt ", `predopt'"
}
* nbgrp: number of sub-samples to be randomly split from the whole sample (default: 100)
if (`nbgrp' < 2) {
di as err "Option nbgrp must be an integer greater than 1."
exit 198
}
* splitnorand: observations are assigned to the groups on a non-random basis but according to their order.
* The first n/nbgrp observation are assigned to group 1, and so on.
* nbiter: number of repetitions of the multi-way Copas (default: 1)
if (`nbiter' <= 0) {
di as err "Option nbiter must be a strictly positive integer."
exit 198
}
* if option splinorand is specified, all iterations would produce the same result and nbiter is set a 1.
if ("`splitnorand'" != "") {
local nbiter = 1
}
* seed: initialize the seed number for the random splits, and restore the initial seed number before exiting. Must be a positive integer.
if (`seed' <= 0) {
di as err "Option seed must be a strictly positive integer."
exit 198
}
* efficient: requires that the more efficient method B, default is method A
* Method A
* In-sample prediction in only one group at a time
* Only uses a fraction of the possible in-sample predictions
* Outofsample and Insample have a smiliar precision
* Method B
* In-sample prediction in all groups left out when estimating the model
* Uses all possible in-sample predictions
* Insample more precisely estimated, which also improves Overfit
* WARNING: this method can be untractable as estimating the slopes requires setting nobs at sample size * nbgrp
* This method is for use with small data sets where efficiency is an issue.
* noiterbar: prevents overfit from showing the iteration progress.
* noresults: prevents overfit from displaying the results.
* hist: displays histograms of the shrinkage statistics and saves them into file {it:string}.gph on current directory.
* Creates temporary files ___outofsample.gph, insample.gph, and overfit.gph which need to be erased manually.
* showmod, showslopes: displays the estimations of the model and of the slope statistics
* savemod: save the estimated models into file string.dta
* showmod: display model estimations
if ("`showmod'"!="") {
local showmod "noisily"
}
* showslopes: display slope estimations
if ("`showslopes'"!="") {
local showslopes "noisily"
}
* showpred: displays summary statistics of the predictions
* procnb: processor number that will be added in front to the name of the temporary datasets. This allows multiprocessing.
* Must be positive a positive integer. Default is 1.
if (`procnb'<0) {
di as err "Option procnb must be a positive integer."
exit 198
}
else {
local procnb "`procnb'_"
}
***************************************************** Local variables ******************************************************
tempvar u group
* u: uniformely distributed random numbers used to split the sample
* group: categorical variable indicating the group
tempvar yhat
* yhat: raw scale predictions
tempname overfit crashes iota overfit_mean overfit_sd
matrix `overfit' = J(`nbiter',3,.)
matrix colnames `overfit' = "out-of-sample bias" "in-sample bias" overfitting
local rownames ""
forvalues i = 1/`nbiter' {
local rownames "`rownames' iter`i'"
}
matrix rownames `overfit' = `rownames'
* matrix crashes: gives for each iteration how many estimations have crashed
matrix `crashes' = J(`nbiter',3,0)
matrix rownames `crashes' = `rownames'
matrix colnames `crashes' = model delta alpha
* iota: vector of ones
matrix `iota' = J(`nbiter',1,1)
* overfit_mean: average slopes over nbiter
* overfit_sd: standard deviation of the slopes over nbiter
if (`"`savemod'"' != "") {
tempname nbrows
* nbrows: number of estimations which have succeeded
}
quietly {
**************************************************** Body *******************************************************
* Save the initial seed number
local initialseed = c(seed)
* Set the seed number
set seed `seed'
********** METHOD A ***********
if ("`efficient'" == "") {
* Initialization for method A only
tempvar yhat_in yhat_out
gen double `yhat_in' = .
gen double `yhat_out' = .
* yhat_in: in-sample raw scale predictions
* yhat_out: out-of-sample raw scale predictions
* uniform random number
gen double `u' = _n
* If the estimated coefficients need to be saved, save a copy of the data set
if (`"`savemod'"' != "") {
save ___`procnb'tempdata, replace
}
forvalues it = 1/`nbiter' {
* Assign groups
if ("`splitnorand'"=="") {
replace `u' = uniform()
}
xtile `group' = `u', nq(`nbgrp')
* Estimation of the model and prediction
forvalues gp = 1/`nbgrp' {
* Estimation on nbgrp-1 subsamples
capture `showmod' `cmdest' if `gp' != `group' `cmdopt'
if (_rc==0) {
* Save the estimated coefficients
if (`"`savemod'"' != "") {
if (`gp'==1) {
matrix _beta_ = (`gp',e(b))
}
else {
matrix _beta_ = (_beta_ \ `gp',e(b))
}
}
* Raw scale prediction
predict double `yhat' `predopt'
* Assign the out-of-sample prediction to the current group
replace `yhat_out' = `yhat' if `group' == `gp'
* Assign the in-sample predictions
* Only use the predictions for one group (the group after or the first group if the last group is being considered)
if (`gp' != `nbgrp') {
replace `yhat_in' = `yhat' if `group' == `gp'+1
}
else {
replace `yhat_in' = `yhat' if `group' == 1
}
* Save predictions
if (`"`savepred'"'!="") {
save ___`procnb'tempdata2, replace
if (`gp'==1) {
gen obs_id = _n
lab var obs_id "position of the observation in the original data set"
gen iter = `it'
lab var iter "iteration number"
gen estnb = `gp'
lab var estnb "estimation number for a given iteration"
gen group = `group'
lab var group "group to which the observation has been affected"
rename `y' y
lab var y "dependent variable"
rename `yhat' yhat`gp'
lab var yhat`gp' "raw scale prediction"
keep obs_id iter estnb group y yhat`gp'
order obs_id iter estnb group y yhat`gp'
save ___`procnb'tempdata3, replace
}
else if (`gp'>1 & `gp'<`nbgrp') {
gen obs_id = _n
lab var obs_id "position of the observation in the original data set"
rename `yhat' yhat`gp'
lab var yhat`gp' "raw scale prediction using model `gp'"
keep obs_id yhat`gp'
merge 1:1 obs_id using ___`procnb'tempdata3
order yhat`gp', last
drop _merge
save ___`procnb'tempdata3, replace
}
else {
gen obs_id = _n
lab var obs_id "position of the observation in the original data set"
rename `yhat' yhat`gp'
lab var yhat`gp' "raw scale prediction"
keep obs_id yhat`gp'
merge 1:1 obs_id using ___`procnb'tempdata3
order yhat`gp', last
drop _merge
if (`it'==1) {
save `"`savepred'"', replace
}
else {
append using `"`savepred'"'
save `"`savepred'"', replace
}
}
use ___`procnb'tempdata2, clear
}
* Reinitialization
drop `yhat'
}
else if (_rc==1) {
exit 1
}
else {
matrix `crashes'[`it',1] = `crashes'[`it',1] + 1
}
}
*** Estimation of the slope statistics ***
* Out-of-sample shrinkage
capture `showslopes' reg `y' `yhat_out'
if (_rc==0) {
matrix `overfit'[`it',1] = 100*(1-_b["`yhat_out'"])
}
else if (_rc==1) {
exit 1
}
else {
matrix `crashes'[`it',2] = 1
}
* In-sample shrinkage
capture `showslopes' reg `y' `yhat_in'
if (_rc==0) {
matrix `overfit'[`it',2] = 100*(1-_b["`yhat_in'"])
}
else if (_rc==1) {
exit 1
}
else {
matrix `crashes'[`it',3] = 1
}
* Overfitting
matrix `overfit'[`it',3] = 100*(1 - (100-`overfit'[`it',1]) / (100-`overfit'[`it',2]))
* Reinitialization
replace `yhat_in' = .
replace `yhat_out' = .
if (`"`savemod'"' == "") {
drop `group'
}
* Save the estimated coefficients into file `savemod'.dta
if (`"`savemod'"' != "") {
scalar `nbrows' = rowsof(_beta_)
local nbr = `nbrows'
svmat _beta_
rename _beta_1 estnb
lab var estnb "estimation number for a given iteration"
gen iter = `it'
lab var iter "iteration number"
keep iter estnb _beta_*
order iter estnb _beta_*
drop if _n > `nbr'
if (`it'==1) {
save `"`savemod'"', replace
}
else {
append using `"`savemod'"'
save `"`savemod'"', replace
}
* Coefficient names
if (`it'==`nbiter') {
local coefnames: colfullnames _beta_
gettoken tok coefnames: coefnames
local i = 2
foreach name of local coefnames {
local name: subinstr local name ":" "_", all
rename _beta_`i' `name'
local ++i
}
save `"`savemod'"', replace
}
use ___`procnb'tempdata, clear
}
* Display progress
if ("`iterbar'" != "noiterbar") {
noisily displayIter `it' 50
}
}
}
********** METHOD B **********
else {
* Initialization for method B only
* Save sample size
local ssize = _N
* Local variables for estimation and raw scale predictions
forvalues gp = 1/`nbgrp' {
tempvar yhat_`gp'
}
* Local variable that records the estimation number
tempvar estnb
gen int `estnb' = 1
* Save data set (the user will have to remove it manually)
save ___`procnb'tempdata, replace
forvalues it = 1/`nbiter' {
* Assign groups
if ("`splitnorand'"=="") {
gen `u' = uniform()
}
else {
gen `u' = _n
}
xtile `group' = `u', nq(`nbgrp')
* Estimation of the model and prediction
forvalues gp = 1/`nbgrp' {
* Estimation on nbgrp-1 subsamples
capture `showmod' `cmdest' if `gp' != `group' `cmdopt'
* Estimation scale prediction
if (_rc==0) {
* Save the estimated coefficients
if (`"`savemod'"' != "") {
if (`gp'==1) {
matrix _beta_ = (`gp',e(b))
}
else {
matrix _beta_ = (_beta_ \ `gp',e(b))
}
}
* Raw scale prediction
predict double `yhat_`gp'' `predopt'
}
else if (_rc==1) {
exit 1
}
else {
gen `yhat_`gp'' = .
matrix `crashes'[`it',1] = `crashes'[`it',1] + 1
}
}
* Only keep relevant variables
keep `estnb' `group' `y' `yhat_1'-`yhat_`nbgrp''
* Save predictions
if (`"`savepred'"'!="") {
save ___`procnb'tempdata2, replace
gen obs_id = _n-int((_n-1)/`ssize')*`ssize'
lab var obs_id "position of the observation in the original data set"
gen iter = `it'
lab var iter "iteration number"
rename `estnb' estnb
lab var estnb "estimation number for a given iteration"
rename `group' group
lab var group "group to which the observation has been affected"
rename `y' y
lab var y "dependent variable"
forvalues gp = 1/`nbgrp' {
rename `yhat_`gp'' yhat`gp'
lab var yhat`gp' "raw scale prediction using model `gp'"
}
order obs_id iter estnb group y
if (`it'==1) {
save `"`savepred'"', replace
}
else {
append using `"`savepred'"'
save `"`savepred'"', replace
}
use ___`procnb'tempdata2, replace
}
* Save predictions of the first estimation
gen double `yhat' = `yhat_1'
drop `yhat_1'
* Pile up all the predictions
forvalues gp = 2/`nbgrp' {
local newssize = `gp' * `ssize'
set obs `newssize'
replace `estnb' = `gp' if _n > (`gp'-1)*`ssize' & _n <= `gp'*`ssize'
replace `group' = `group'[_n-(`gp'-1)*`ssize'] if _n > (`gp'-1)*`ssize' & _n <= `gp'*`ssize'
replace `y' = `y'[_n-(`gp'-1)*`ssize'] if _n > (`gp'-1)*`ssize' & _n <= `gp'*`ssize'
replace `yhat' = `yhat_`gp''[_n-(`gp'-1)*`ssize'] if _n > (`gp'-1)*`ssize' & _n <= `gp'*`ssize'
drop `yhat_`gp''
}
* Estimation of the slope statistics
* Out-of-sample
capture `showslopes' reg `y' `yhat' if `estnb' == `group'
if (_rc==0) {
matrix `overfit'[`it',1] = 100*(1-_b["`yhat'"])
}
else if (_rc==1) {
exit 1
}
else {
matrix `crashes'[`it',2] = 1
}
* In-sample slope
capture `showslopes' reg `y' `yhat' if `estnb' != `group'
if (_rc==0) {
matrix `overfit'[`it',2] = 100*(1-_b["`yhat'"])
}
else if (_rc==1) {
exit 1
}
else {
matrix `crashes'[`it',3] = 1
}
* Overfitting slope
matrix `overfit'[`it',3] = 100*(1 - (100-`overfit'[`it',1]) / (100-`overfit'[`it',2]))
* Save the estimated coefficients into file `savemod'.dta
if (`"`savemod'"' != "") {
scalar `nbrows' = rowsof(_beta_)
local nbr = `nbrows'
svmat _beta_
rename _beta_1 estnb
lab var estnb "estimation number for a given iteration"
gen iter = `it'
lab var iter "iteration number"
keep iter estnb _beta_*
order iter estnb _beta_*
drop if _n > `nbr'
if (`it'==1) {
save `"`savemod'"', replace
}
else {
append using `"`savemod'"'
save `"`savemod'"', replace
}
* Coefficient names
if (`it'==`nbiter') {
local coefnames: colfullnames _beta_
gettoken tok coefnames: coefnames
local i = 2
foreach name of local coefnames {
local name: subinstr local name ":" "_", all
rename _beta_`i' `name'
local ++i
}
save `"`savemod'"', replace
}
}
* Reinitialization
use ___`procnb'tempdata, clear
* Show progress
if ("`iterbar'" != "noiterbar") {
noisily displayIter `it' 50
}
}
}
*********** Compute the average and standard deviation of the shrinkage statistics **********
* All shrinkage statistics
if (`nbiter'==1) {
tempname missing
matrix `missing' = J(1,3,.)
matrix `overfit_mean' = (`overfit' \ `missing')
}
else {
matrix `overfit_mean' = `iota'' * `overfit' / `nbiter'
matrix `overfit_sd' = vecdiag((`overfit' - `iota'*`overfit_mean')' * (`overfit' - `iota'*`overfit_mean') / `nbiter')
forvalues i = 1/3 {
matrix `overfit_sd'[1,`i'] = sqrt(`overfit_sd'[1,`i'])
}
matrix `overfit_mean' = (`overfit_mean' \ `overfit_sd')
}
matrix rownames `overfit_mean' = estimate se
matrix colnames `overfit_mean' = "out-of-sample bias" "in-sample bias" overfitting
* All non-missing shrinkage statistics
tempname missingvalues iota3 nbcrashes overfit_nomissing
* missingvalues: equals 1 if there is at least one missing value in the shrinkage statistics, and 0 otherwise
scalar `missingvalues' = matmissing(`overfit')
* iota3: vector of 3 ones
matrix `iota3' = J(3,1,1)
* nbcrashes: number of crashes that occured for each iteration.
matrix `nbcrashes' = `iota''*`crashes'*`iota3'
scalar `nbcrashes' = `nbcrashes'[1,1]
* overfit_nomissing: mean and standard deviation of all non missing statistics
if (`missingvalues' == 1 | `nbcrashes' > 0) {
tempname overfit_mis0 notmissing nbnotmissing val
* overfit_mis0: shrinkage statistics with missing values replaced by zeros.
* notmissing: matrix containing one if a shrinkage statistic is not missing, and 0 otherwise.
* nbnotmissing: matrix containing the number of non-missing shrinkage statistics (dim: 1x4)
* val: value of a given shrinkage statistic
matrix `overfit_mis0' = `overfit'
matrix `notmissing' = J(`nbiter',3,1)
forvalues it = 1/`nbiter' {
forvalues j = 1/3 {
scalar `val' = `overfit'[`it',`j']
if (`val'==.) {
matrix `overfit_mis0'[`it',`j'] = 0
matrix `notmissing'[`it',`j'] = 0
}
}
}
* Compute mean and standard deviation
matrix `nbnotmissing' = `iota''*`notmissing'
capture matrix `overfit_nomissing' = `iota''*`overfit_mis0' * inv(diag(`nbnotmissing'))
* When there is a division by 0, do it manually to prevent stata from crashing:
if (_rc!=0) {
tempname nbnotm
matrix `overfit_nomissing' = `iota''*`overfit_mis0'
forvalues j=1/3 {
scalar `nbnotm' = `nbnotmissing'[1,`j']
if (`nbnotm' != 0) {
matrix `overfit_nomissing'[1,`j'] = `overfit_nomissing'[1,`j']/`nbnotm'
}
else {
matrix `overfit_nomissing'[1,`j'] = .
}
}
}
capture matrix `overfit_sd' = vecdiag((`overfit_mis0' - `notmissing'*diag(`overfit_nomissing'))' * ///
(`overfit_mis0' - `notmissing'*diag(`overfit_nomissing')) * inv(diag(`nbnotmissing')))
* When there is a division by 0, do it manually to prevent stata from crashing:
if (_rc!=0) {
matrix `overfit_sd' = J(1,3,.)
tempname nbnotm
forvalues j=1/3 {
scalar `nbnotm' = `nbnotmissing'[1,`j']
if (`nbnotm' != 0) {
matrix `overfit_sd'[1,`j'] = (`overfit_mis0'[1..`nbiter',`j']-`notmissing'[1..`nbiter',`j']*`overfit_nomissing'[1,`j'])' * ///
(`overfit_mis0'[1..`nbiter',`j']-`notmissing'[1..`nbiter',`j']*`overfit_nomissing'[1,`j']) / `nbnotm'
}
}
}
forvalues i = 1/3 {
matrix `overfit_sd'[1,`i'] = sqrt(`overfit_sd'[1,`i'])
}
matrix `overfit_nomissing' = (`overfit_nomissing' \ `overfit_sd' \ `nbnotmissing')
matrix rownames `overfit_nomissing' = estimate se n
matrix colnames `overfit_nomissing' = "out-of-sample bias" "in-sample bias" overfitting
}
* All shrinkage statistics not involving any crash
tempname overfit_nocrash
* overfit_nocrash: mean and standard deviation of all shrinkage statistics that involve no crash
if (`nbcrashes' > 0) {
tempname nocrashes nbnocrashes crash1 crash2 crash3
* nocrashes: matrix containing one if there was no crash when computing a shrinkage statistic, and 0 otherwise
* nbnocrashes: matrix containing the number of iterations with no crash
* crash1: number of crashes occuring in the estimation command
* crash2: equals 1 if a crash occured when estimating the outofsample statistic
* crash3: equals 1 if a crash occured when estimating the insample statistic
matrix `nocrashes' = J(`nbiter',3,1)
forvalues it = 1/`nbiter' {
scalar `crash1' = `crashes'[`it',1]
scalar `crash2' = `crashes'[`it',2]
scalar `crash3' = `crashes'[`it',3]
* outofsample
if (`crash1'>0 | `crash2'==1) {
matrix `nocrashes'[`it',1] = 0
}
* insample
if (`crash1'>0 | `crash3'==1) {
matrix `nocrashes'[`it',2] = 0
}
* overfit
if (`crash1'>0 | `crash2'==1 | `crash3'==1) {
matrix `nocrashes'[`it',3] = 0
}
}
* Compute mean and standard deviation
matrix `nbnocrashes' = `iota''*`nocrashes'
capture matrix `overfit_nocrash' = vecdiag(`nocrashes''*`overfit_mis0' * inv(diag(`nbnocrashes')))
* When there is a division by 0, do it manually to prevent stata from crashing:
if (_rc!=0) {
tempname nbnoc
matrix `overfit_nocrash' = J(1,3,.)
forvalues j=1/3 {
scalar `nbnoc' = `nbnocrashes'[1,`j']
if (`nbnoc' != 0) {
matrix `overfit_nocrash'[1,`j'] = `nocrashes'[1..`nbiter',`j']'*`overfit_mis0'[1..`nbiter',`j']/`nbnoc'
}
}
}
capture matrix `overfit_sd' = vecdiag((`overfit_mis0' - `nocrashes'*diag(`overfit_nocrash'))' * (`overfit_mis0' - `nocrashes'*diag(`overfit_nocrash')) * inv(diag(`nbnocrashes')))
* When there is a division by 0, do it manually to prevent stata from crashing:
if (_rc!=0) {
matrix `overfit_sd' = J(1,3,.)
tempname nbnoc
forvalues j=1/3 {
scalar `nbnoc' = `nbnotmissing'[1,`j']
if (`nbnoc' != 0) {
matrix `overfit_sd'[1,`j'] = (diag(`nocrashes'[1..`nbiter',`j'])*`overfit_mis0'[1..`nbiter',`j']-`nocrashes'[1..`nbiter',`j']*`overfit_nocrash'[1,`j'])' * ///
(diag(`nocrashes'[1..`nbiter',`j'])*`overfit_mis0'[1..`nbiter',`j']-`nocrashes'[1..`nbiter',`j']*`overfit_nocrash'[1,`j']) / `nbnoc'
}
}
}
forvalues i = 1/3 {
matrix `overfit_sd'[1,`i'] = sqrt(`overfit_sd'[1,`i'])
}
matrix `overfit_nocrash' = (`overfit_nocrash' \ `overfit_sd' \ `nbnocrashes')
matrix rownames `overfit_nocrash' = estimate se n
matrix colnames `overfit_nocrash' = "out-of-sample bias" "in-sample bias" overfitting
}
* Display estimation results
if ("`results'" != "noresults") {
if (`nbcrashes' == 0) {
noisily di _newline(2) as result "Shrinkage statistics (expressed in percent)"
noisily matrix list `overfit_mean', noheader format(%18.2f)
}
else {
if (`nbcrashes' == 1) {
noisily di _newline(2) as error "Warning: " `nbcrashes' " crash has occurred when estimating the model or the shrinkage statistics during an iteration. "
}
else {
noisily di _newline(2) as error "Warning: " `nbcrashes' " crashes have occurred when estimating the model or the shrinkage statistics for one or more iterations. "
}
noisily di "See matrix r(crashes) for details."
/*
noisily di _newline(2) as result "Shrinkage statistics averaged on all non-missing iterations"
noisily di as result "(expressed in percent)"
noisily matrix list `overfit_nomissing', noheader format(%18.2f)
*/
noisily di _newline(2) as result "Shrinkage statistics averaged over the (n) crash-free iterations"
noisily di as result "(expressed in percent)"
noisily matrix list `overfit_nocrash', noheader format(%18.2f)
* Only returns the no-crash averages
matrix `overfit_mean' = `overfit_nocrash'
}
}
* Draw histograms
if (`"`hist'"' != "") {
* Create shrinkage variables
svmat `overfit'
hist `overfit'1, xtitle("out-of-sample bias") color(edkblue)
graph save ___`procnb'_outofsample, replace
hist `overfit'2, xtitle("in-sample bias") color(eltblue)
graph save ___`procnb'_insample, replace
hist `overfit'3, xtitle("overfitting") ytitle("") color(midblue)
graph save ___`procnb'_overfit, replace
graph combine ___`procnb'_outofsample.gph ___`procnb'_insample.gph ___`procnb'_overfit.gph, xcommon ycommon
graph save `"`hist'"', replace
drop `overfit'1 `overfit'2 `overfit'3
}
* Return results
return matrix shrinkage_iter = `overfit', copy
return matrix shrinkage_mean = `overfit_mean', copy
return matrix crashes = `crashes', copy
return scalar missingvalues = `missingvalues'
return scalar nbcrashes = `nbcrashes'
}
* Restores the initial seed number
set seed `initialseed'
* Delete temporary files
capture erase ___`procnb'*
end
* Program that does not allow if, in and using conditions neither weights in the estimation command
capture program drop noifinusingweight
program noifinusingweight
version 11.2
syntax [anything(name=anyof)]
end
************************************************************************
* Program that displays a bar showing the number of completed iterations.
capture program drop displayIter
program displayIter
version 11.2
args it itergrp
if (`it' == 1) {
di _newline(1) "Iterations"
di "." _continue
}
else if (`it' != int(`it'/`itergrp')*`itergrp') {
di "." _continue
}
else {
* Number of columns to skip to indent iteration numbers
local nbcol = int(log(10*`itergrp'/`it')/log(10))
di ". " _skip(`nbcol') "`it'"
}
end