add 30

30/paper.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7a4d6d6dfe479cf46d6d94f1f1c9f35333e47722eb11986151953e99e7aecd79
+size 523522

30/replication_package/Adofiles/DCdensity_2009/DCdensity.ado

@@ -0,0 +1,440 @@
+//Notes:
+//  This ado file was created by Brian Kovak, a Ph.D. student at the University
+//  of Michigan, under the direction of Justin McCrary.  McCrary made some
+//  cosmetic alterations to the code, added some further error traps, and
+//  ran some simulations to ensure that
+//  there was no glitch in implementation.  This file is not the basis for
+//  the estimates in McCrary (2008), however.
+
+//  The purpose of the file is to create a STATA command, -DCdensity-, which
+//  will allow for ready estimation of a discontinuous density function, as
+//  outlined in McCrary (2008), "Manipulation of the Running Variable in the
+//  Regression Discontinuity Design: A Density Test", Journal of Econometrics.
+
+//  The easiest way to use the file is to put it in your ado subdirectory.  If
+//  you don't know where that is, try using -sysdir- at the Stata prompt.
+
+//  A feature of the program is that it is much faster than older STATA routines
+//  (e.g., -kdensity-).  The source of the speed improvements is the use of
+//  MATA for both looping and for estimation of the regressions, and the lack of
+//  use of -preserve-.
+
+// An example program showing how to use -DCdensity- is given in the file
+// DCdensity_example.do
+
+// JRM, 9/2008
+
+// Update: Fixed bug that occurs when issuing something like
+// DCdensity Z if female==1, breakpoint(0) generate(Xj Yj r0 fhat se_fhat) graphname(DCdensity_example.eps)
+
+// Update 11.17.2009: Fixed bugs in XX matrix (see comments) and in hright (both code typos)
+                                                                     
+
+capture program drop DCdensity
+program DCdensity, rclass
+{
+  version 9.0
+  set more off
+  pause on
+  syntax varname(numeric) [if/] [in/], breakpoint(real) GENerate(string) ///
+    [ b(real 0) h(real 0) at(string) graphname(string) noGRaph]
+  
+  marksample touse
+  
+  //Advanced user switch
+  //0 - supress auxiliary output  1 - display aux output
+  local verbose 1 
+ 
+  //Bookkeeping before calling MATA function
+  //"running variable" in terminology of McCrary (2008)
+  local R "`varlist'"
+
+  tokenize `generate'
+  local wc : word count `generate' 
+  if (`wc'!=5) {
+    //generate(Xj Yj r0 fhat se_fhat) is suggested
+    di "Specify names for five variables in generate option"
+    di "1. Name of variable in which to store cell midpoints of histogram"
+    di "2. Name of variable in which to store cell heights of histogram"
+    di "3. Name of variable in which to store evaluation sequence for local linear regression loop"
+    di "4. Name of variable in which to store local linear density estimate"
+    di "5. Name of variable in which to store standard error of local linear density estimate"
+    error 198
+  }
+  else {
+    local cellmpname = "`1'"
+    local cellvalname = "`2'"
+    local evalname = "`3'"
+    local cellsmname = "`4'"
+    local cellsmsename = "`5'"
+    confirm new var `1'
+    confirm new var `2'
+    capture confirm new var `3'
+    if (_rc!=0 & "`at'"!="`3'") error 198
+    confirm new var `4'
+    confirm new var `5'
+  }
+
+  //If the user does not specify the evaluation sequence, this it is taken to be the histogram midpoints
+  if ("`at'" == "") {
+    local at  = "`1'"
+  }
+
+  //Call MATA function
+  mata: DCdensitysub("`R'", "`touse'", `breakpoint', `b', `h', `verbose', "`cellmpname'", "`cellvalname'", ///
+                     "`evalname'", "`cellsmname'", "`cellsmsename'", "`at'")
+
+  //Dump MATA return codes into STATA return codes 
+  return scalar theta = r(theta)
+  return scalar se = r(se)
+  return scalar binsize = r(binsize)
+  return scalar bandwidth = r(bandwidth)
+
+  //if user wants the graph...
+  if ("`graph'"!="nograph") { 
+    tempvar hi
+    quietly gen `hi' = `cellsmname' + 1.96*`cellsmsename'
+    tempvar lo
+    quietly gen `lo' = `cellsmname' - 1.96*`cellsmsename'
+    gr twoway (scatter `cellvalname' `cellmpname', msymbol(circle_hollow) mcolor(gray))           ///
+      (line `cellsmname' `evalname' if `evalname' < `breakpoint', lcolor(black) lwidth(medthick))   ///
+        (line `cellsmname' `evalname' if `evalname' > `breakpoint', lcolor(black) lwidth(medthick))   ///
+          (line `hi' `evalname' if `evalname' < `breakpoint', lcolor(black) lwidth(vthin))              ///
+            (line `lo' `evalname' if `evalname' < `breakpoint', lcolor(black) lwidth(vthin))              ///
+              (line `hi' `evalname' if `evalname' > `breakpoint', lcolor(black) lwidth(vthin))              ///
+                (line `lo' `evalname' if `evalname' > `breakpoint', lcolor(black) lwidth(vthin)),             ///
+                  xline(`breakpoint', lcolor(black)) ylabel(0(0.0005)0.001,labsize(huge)) xlabel(`breakpoint', labsize(huge)) graphregion(color(white)) legend(off)
+    if ("`graphname'"!="") {
+      di "Exporting graph as `graphname'"
+      graph export `graphname', replace
+    }
+  }
+}
+end
+
+
+mata:
+mata set matastrict on
+
+void DCdensitysub(string scalar runvar, string scalar tousevar, real scalar c, real scalar b, ///
+                  real scalar h, real scalar verbose, string scalar cellmpname, string scalar cellvalname, ///
+                  string scalar evalname, string scalar cellsmname, string scalar cellsmsename, ///
+                  string scalar atname) {
+  //   inputs: runvar - name of stata running variable ("R" in McCrary (2008))
+  //             tousevar - name of variable indicating which obs to use
+  //             c - point of potential discontinuity
+  //             b - bin size entered by user (zero if default is to be used)
+  //             h - bandwidth entered by user (zero if default is to be used)
+  //             verbose - flag for extra messages printing to screen
+  //             cellmpname - name of new variable that will hold the histogram cell midpoints
+  //             cellvalname - name of new variable that will hold the histogram values
+  //             evalname - name of new variable that will hold locations where the histogram smoothing was
+  //                        evaluated
+  //             cellsmname - name of new variable that will hold the smoothed histogram cell values
+  //             cellsmsename - name of new variable that will hold standard errors for smoothed histogram cells
+  //             atname - name of existing stata variable holding points at which to eval smoothed histogram
+
+  //declarations for general use and histogram generation
+  real colvector run						// stata running variable
+  string scalar statacom					// string to hold stata commands
+  real scalar errcode                                           // scalar to hold return code for stata commands
+  real scalar rn, rsd, rmin, rmax, rp75, rp25, riqr     	// scalars for summary stats of running var
+  real scalar l, r						// midpoint of lowest bin and highest bin in histogram
+  real scalar lc, rc						// midpoint of bin just left of and just right of breakpoint
+  real scalar j							// number of bins spanned by running var
+  real colvector binnum						// each obs bin number
+  real colvector cellval					// histogram cell values
+  real scalar i							// counter
+  real scalar cellnum						// cell value holder for histogram generation
+  real colvector cellmp						// histogram cell midpoints
+
+  //Set up histogram grid
+
+  st_view(run, ., runvar, tousevar)     //view of running variable--only observations for which `touse'=1
+
+  //Get summary stats on running variable
+  statacom = "quietly summarize " + runvar + " if " + tousevar + ", det"
+  errcode=_stata(statacom,1)
+  if (errcode!=0) {
+    "Unable to successfully execute the command "+statacom
+    "Check whether you have given Stata enough memory"
+  }
+  rn = st_numscalar("r(N)")
+  rsd = st_numscalar("r(sd)")
+  rmin = st_numscalar("r(min)")
+  rmax = st_numscalar("r(max)")
+  rp75 = st_numscalar("r(p75)") 
+  rp25 = st_numscalar("r(p25)")
+  riqr = rp75 - rp25
+
+  if ( (c<=rmin) | (c>=rmax) ) {
+    printf("Breakpoint must lie strictly within range of running variable\n")
+    _error(3498)
+  }
+  
+  //set bin size to default in paper sec. III.B unless provided by the user
+  if (b == 0) {
+    b = 2*rsd*rn^(-1/2)
+    if (verbose) printf("Using default bin size calculation, bin size = %f\n", b)
+  }
+
+  //bookkeeping
+  l = floor((rmin-c)/b)*b+b/2+c  // midpoint of lowest bin in histogram
+  r = floor((rmax-c)/b)*b+b/2+c  // midpoint of lowest bin in histogram
+  lc = c-(b/2) // midpoint of bin just left of breakpoint
+  rc = c+(b/2) // midpoint of bin just right of breakpoint
+  j = floor((rmax-rmin)/b)+2
+
+  //create bin numbers corresponding to run... See McCrary (2008, eq 2)
+  binnum = round((((floor((run :- c):/b):*b:+b:/2:+c) :- l):/b) :+ 1)  // bin number for each obs
+
+  //generate histogram 
+  cellval = J(j,1,0)  // initialize cellval as j-vector of zeros
+  for (i = 1; i <= rn; i++) {
+    cellnum = binnum[i]
+    cellval[cellnum] = cellval[cellnum] + 1
+  }
+  
+  cellval = cellval :/ rn  // convert counts into fractions
+  cellval = cellval :/ b  // normalize histogram to integrate to 1
+  cellmp = range(1,j,1)  // initialize cellmp as vector of integers from 1 to j
+  cellmp = floor(((l :+ (cellmp:-1):*b):-c):/b):*b:+b:/2:+c  // convert bin numbers into cell midpoints
+  
+  //place histogram info into stata data set
+  real colvector stcellval					// stata view for cell value variable
+  real colvector stcellmp					// stata view for cell midpoint variable
+
+  (void) st_addvar("float", cellvalname)
+  st_view(stcellval, ., cellvalname)
+  (void) st_addvar("float", cellmpname)
+  st_view(stcellmp, ., cellmpname)
+  stcellval[|1\j|] = cellval
+  stcellmp[|1\j|] = cellmp
+  
+  //Run 4th order global polynomial on histogram to get optimal bandwidth (if necessary)
+  real matrix P							// projection matrix returned from orthpoly command
+  real matrix betaorth4						// coeffs from regression of orthogonal powers of cellmp
+  real matrix beta4						// coeffs from normal regression of powers of cellmp
+  real scalar mse4						// mean squared error from polynomial regression
+  real scalar hleft, hright					// bandwidth est from polynomial left of and right of breakpoint
+  real scalar leftofc, rightofc	      			        // bin number just left of and just right of breakpoint
+  real colvector cellmpleft, cellmpright			// cell midpoints left of and right of breakpoint
+  real colvector fppleft, fppright				// fit second deriv of hist left of and right of breakpoint
+
+  //only calculate optimal bandwidth if user hasn't provided one
+  if (h == 0) {
+    //separate cells left of and right of the cutoff
+    leftofc =  round((((floor((lc - c)/b)*b+b/2+c) - l)/b) + 1) // bin number just left of breakpoint
+    rightofc = round((((floor((rc - c)/b)*b+b/2+c) - l)/b) + 1) // bin number just right of breakpoint
+    if (rightofc-leftofc != 1) {
+      printf("Error occurred in optimal bandwidth calculation\n")
+      _error(3498)
+    }
+    cellmpleft = cellmp[|1\leftofc|]
+    cellmpright = cellmp[|rightofc\j|]
+
+    //estimate 4th order polynomial left of the cutoff
+    statacom = "orthpoly " + cellmpname + ", generate(" + cellmpname + "*) deg(4) poly(P)"
+    errcode=_stata(statacom,1)
+    if (errcode!=0) {
+      "Unable to successfully execute the command "+statacom
+      "Check whether you have given Stata enough memory"
+    }
+    P = st_matrix("P")
+    statacom = "reg " + cellvalname + " " + cellmpname + "1-" + cellmpname + "4 if " + cellmpname + " < " + strofreal(c)
+    errcode=_stata(statacom,1)
+    if (errcode!=0) {
+      "Unable to successfully execute the command "+statacom
+      "Check whether you have given Stata enough memory"
+    }
+    mse4 = st_numscalar("e(rmse)")^2
+    betaorth4 = st_matrix("e(b)")
+    beta4 = betaorth4 * P
+    fppleft = 2*beta4[2] :+ 6*beta4[3]:*cellmpleft + 12*beta4[4]:*cellmpleft:^2
+    hleft = 3.348 * ( mse4*(c-l) / sum( fppleft:^2) )^(1/5)
+
+    //estimate 4th order polynomial right of the cutoff
+    P = st_matrix("P")
+    statacom = "reg " + cellvalname + " " + cellmpname + "1-" + cellmpname + "4 if " + cellmpname + " > " + strofreal(c)
+    errcode=_stata(statacom,1)
+    if (errcode!=0) {
+      "Unable to successfully execute the command "+statacom
+      "Check whether you have given Stata enough memory"
+    }
+    mse4 = st_numscalar("e(rmse)")^2
+    betaorth4 = st_matrix("e(b)")
+    beta4 = betaorth4 * P
+    fppright = 2*beta4[2] :+ 6*beta4[3]:*cellmpright + 12*beta4[4]:*cellmpright:^2
+    hright = 3.348 * ( mse4*(r-c) / sum( fppright:^2) )^(1/5)
+    statacom = "drop " + cellmpname + "1-" + cellmpname + "4"
+    errcode=_stata(statacom,1)
+    if (errcode!=0) {
+      "Unable to successfully execute the command "+statacom
+      "Check whether you have given Stata enough memory"
+    }
+
+    //set bandwidth to average of calculations from left and right
+    h = 0.5*(hleft + hright)
+    if (verbose) printf("Using default bandwidth calculation, bandwidth = %f\n", h)
+  }
+
+  //Add padding zeros to histogram (to assist smoothing)
+  real scalar padzeros						// number of zeros to pad on each side of hist
+  real scalar jp						// number of histogram bins including padded zeros
+
+  padzeros = ceil(h/b)  // number of zeros to pad on each side of hist
+  jp = j + 2*padzeros
+  if (padzeros >= 1) {
+    //add padding to histogram variables
+    cellval = ( J(padzeros,1,0) \ cellval \ J(padzeros,1,0) )
+    cellmp = ( range(l-padzeros*b,l-b,b) \ cellmp \ range(r+b,r+padzeros*b,b) )
+    //dump padded histogram variables out to stata
+    stcellval[|1\jp|] = cellval
+    stcellmp[|1\jp|] = cellmp
+  }
+
+  //Generate point estimate of discontinuity
+  real colvector dist						// distance from a given observation
+  real colvector w						// triangle kernel weights
+  real matrix XX, Xy						// regression matrcies for weighted regression
+  real rowvector xmean, ymean					// means for demeaning regression vars
+  real colvector beta						// regression estimates from weighted reg.
+  real colvector ehat						// predicted errors from weighted reg.
+  real scalar fhatr, fhatl					// local linear reg. estimates at discontinuity
+                                                                //   estimated from right and left, respectively
+  real scalar thetahat						// discontinuity estimate
+  real scalar sethetahat					// standard error of discontinuity estimate
+  
+  //Estimate left of discontinuity
+  dist = cellmp :- c  // distance from potential discontinuity
+  w = rowmax( (J(jp,1,0), (1:-abs(dist:/h))) ):*(cellmp:<c)  // triangle kernel weights for left
+  w = (w:/sum(w)) :* jp  // normalize weights to sum to number of cells (as does stata aweights)
+  xmean = mean(dist, w)
+  ymean = mean(cellval, w)
+  XX = quadcrossdev(dist,xmean,w,dist,xmean)    //fixed error on 11.17.2009
+  Xy = quadcrossdev(dist,xmean,w,cellval,ymean)
+  beta = invsym(XX)*Xy
+  beta = beta \ ymean-xmean*beta
+  fhatl = beta[2,1]
+  
+  //Estimate right of discontinuity
+  w = rowmax( (J(jp,1,0), (1:-abs(dist:/h))) ):*(cellmp:>=c)  // triangle kernel weights for right
+  w = (w:/sum(w)) :* jp  // normalize weights to sum to number of cells (as does stata aweights)
+  xmean = mean(dist, w)
+  ymean = mean(cellval, w)
+  XX = quadcrossdev(dist,xmean,w,dist,xmean)   //fixed error on 11.17.2009
+  Xy = quadcrossdev(dist,xmean,w,cellval,ymean)
+  beta = invsym(XX)*Xy
+  beta = beta \ ymean-xmean*beta
+  fhatr = beta[2,1]
+  
+  //Calculate and display discontinuity estimate
+  thetahat = ln(fhatr) - ln(fhatl)
+  sethetahat = sqrt( (1/(rn*h)) * (24/5) * ((1/fhatr) + (1/fhatl)) )
+  printf("\nDiscontinuity estimate (log difference in height): %f\n", thetahat)
+  printf("                                                   (%f)\n", sethetahat)
+
+  loopover=1 //This is an advanced user switch to get rid of LLR smoothing
+  //Can be used to speed up simulation runs--the switch avoids smoothing at
+  //eval points you aren't studying
+  
+  //Perform local linear regression (LLR) smoothing
+  if (loopover==1) {
+    real scalar cellsm						// smoothed histogram cell values
+    real colvector stcellsm					// stata view for smoothed values
+    real colvector atstata					// stata view for at variable (evaluation points)
+    real colvector at						// points at which to evaluate LLR smoothing
+    real scalar evalpts						// number of evaluation points
+    real colvector steval						// stata view for LLR smothing eval points
+
+    // if evaluating at cell midpoints
+    if (atname == cellmpname) {  
+      at = cellmp[|padzeros+1\padzeros+j|]
+      evalpts = j
+    }
+    else {
+      st_view(atstata, ., atname)
+      evalpts = nonmissing(atstata)
+      at = atstata[|1\evalpts|]
+    }
+    
+    if (verbose) printf("Performing LLR smoothing.\n")
+    if (verbose) printf("%f iterations will be performed \n",j)
+    
+    cellsm = J(evalpts,1,0)  // initialize smoothed histogram cell values to zero
+    // loop over all evaluation points
+    for (i = 1; i <= evalpts; i++) {
+      dist = cellmp :- at[i]
+      //set weights relative to current bin - note comma below is row join operator, not two separate args
+      w = rowmax( (J(jp,1,0), ///
+        (1:-abs(dist:/h))):*((cellmp:>=c)*(at[i]>=c):+(cellmp:<c):*(at[i]<c)) )
+      //manually obtain weighted regression coefficients
+      w = (w:/sum(w)) :* jp  // normalize weights to sum to N (as does stata aweights)
+      xmean = mean(dist, w)
+      ymean = mean(cellval, w)
+      XX = quadcrossdev(dist,xmean,w,dist,xmean)  //fixed error on 11.17.2009 
+      Xy = quadcrossdev(dist,xmean,w,cellval,ymean)
+      beta = invsym(XX)*Xy
+      beta = beta \ ymean-xmean*beta
+      cellsm[i] = beta[2,1]
+      //Show dots
+      if (verbose) {
+        if (mod(i,10) == 0) {
+          printf(".")
+          displayflush()
+          if (mod(i,500) == 0) {
+            printf(" %f LLR iterations\n",i)
+            displayflush()
+          }
+        }
+      }
+    }
+    printf("\n")
+  
+    //set up stata variable to hold evaluation points for smoothed values
+    (void) st_addvar("float", evalname)
+    st_view(steval, ., evalname)
+    steval[|1\evalpts|] = at
+
+    //set up stata variable to hold smoothed values
+    (void) st_addvar("float", cellsmname)
+    st_view(stcellsm, ., cellsmname)
+    stcellsm[|1\evalpts|] = cellsm
+    
+    //Calculate standard errors for LLR smoothed values
+    real scalar m					// amount of kernel being truncated by breakpoint
+    real colvector cellsmse				// standard errors of smoothed histogram
+    real colvector stcellsmse				// stata view for cell midpoint variable
+    cellsmse = J(evalpts,1,0)  // initialize standard errors to zero
+    for (i = 1; i <= evalpts; i++) {
+      if (at[i] > c) {
+        m = max((-1, (c-at[i])/h))
+        cellsmse[i] = ((12*cellsm[i])/(5*rn*h))* ///
+          (2-3*m^11-24*m^10-83*m^9-72*m^8+42*m^7+18*m^6-18*m^5+18*m^4-3*m^3+18*m^2-15*m)/ ///
+            (1+m^6+6*m^5-3*m^4-4*m^3+9*m^2-6*m)^2
+        cellsmse[i] = sqrt(cellsmse[i])
+      }
+      if (at[i] < c) {
+        m = min(((c-at[i])/h, 1))
+        cellsmse[i] = ((12*cellsm[i])/(5*rn*h))* ///
+          (2+3*m^11-24*m^10+83*m^9-72*m^8-42*m^7+18*m^6+18*m^5+18*m^4-3*m^3+18*m^2+15*m)/ ///
+            (1+m^6-6*m^5-3*m^4+4*m^3+9*m^2+6*m)^2
+        cellsmse[i] = sqrt(cellsmse[i])
+      }
+    }
+    //set up stata variable to hold standard errors for smoothed values
+    (void) st_addvar("float", cellsmsename)
+    st_view(stcellsmse, ., cellsmsename)
+    stcellsmse[|1\evalpts|] = cellsmse
+  }
+  //End of loop over evaluation points
+  
+  //Fill in STATA return codes
+  st_rclear()
+  st_numscalar("r(theta)", thetahat)
+  st_numscalar("r(se)", sethetahat)
+  st_numscalar("r(binsize)", b)
+  st_numscalar("r(bandwidth)", h)
+}
+end
+

30/replication_package/Adofiles/rd_2021/rdbwdensity.ado

@@ -0,0 +1,342 @@
+********************************************************************************
+* RDDENSITY STATA PACKAGE -- rdbwdensity
+* Authors: Matias D. Cattaneo, Michael Jansson, Xinwei Ma
+********************************************************************************
+*!version 2.3 2021-02-28
+
+capture program drop rdbwdensity
+
+program define rdbwdensity, eclass
+syntax varlist(max=1) [if] [in] [, 	///
+  C(real 0) 						///
+  P(integer 2) 						///
+  KERnel(string) 					///
+  FITselect(string) 				///
+  VCE(string)						///
+  noREGularize 			    		///
+  NLOCalmin (integer -1)			///
+  NUNIquemin (integer -1)			///
+  noMASSpoints						///
+  ]
+	
+	marksample touse
+
+	if ("`kernel'"=="") local kernel = "triangular"
+	local kernel = lower("`kernel'")
+	if ("`fitselect'"=="") local fitselect = "unrestricted"
+	local fitselect = lower("`fitselect'")
+	if ("`vce'"=="") local vce = "jackknife"
+	local vce = lower("`vce'")
+
+	preserve
+	qui keep if `touse'
+
+	local x "`varlist'"
+
+	qui drop if `x'==.
+	
+	qui su `x'
+	local x_min = r(min)
+	local x_max = r(max)
+	local N = r(N)
+
+	qui su `x' if `x'<`c'
+	local xl_min = r(min)
+	local xl_max = r(max)
+	local Nl = r(N)
+
+	qui su `x' if `x'>=`c'
+	local xr_min = r(min)
+	local xr_max = r(max)
+	local Nr = r(N)
+	
+	****************************************************************************
+	*** BEGIN ERROR HANDLING *************************************************** 
+	if (`c'<=`x_min' | `c'>=`x_max'){
+		di "{err}{cmd:c()} should be set within the range of `x'."  
+		exit 125
+	}
+	
+	if (`Nl'<10 | `Nr'<10){
+		di "{err}Not enough observations to perform calculations."  
+		exit 2001
+	}
+	
+	if (`p'!=1 & `p'!=2 & `p'!=3 & `p'!=4 & `p'!=5 & `p'!=6 & `p'!=7){
+		di "{err}{cmd:p()} should be an integer value less or equal than 7."  
+		exit 125
+	}
+		
+	if ("`kernel'"!="uniform" & "`kernel'"!="triangular" & "`kernel'"!="epanechnikov"){
+		di "{err}{cmd:kernel()} incorrectly specified."  
+		exit 7
+	}
+
+	if ("`fitselect'"!="restricted" & "`fitselect'"!="unrestricted"){
+		di "{err}{cmd:fitselect()} incorrectly specified."  
+		exit 7
+	}
+
+	if ("`vce'"!="jackknife" & "`vce'"!="plugin"){ 
+		di "{err}{cmd:vce()} incorrectly specified."  
+		exit 7
+	}
+	
+	if ("`regularize'" == "") {
+		local regularize = 1
+	}
+	else {
+		local regularize = 0
+	}
+
+	if ("`masspoints'" == "") {
+		local masspoints = 1
+	}
+	else {
+		local masspoints = 0
+	}
+
+	if (`nlocalmin' < 0) {
+		local nlocalmin = 20 + `p' + 1
+	}
+
+	if (`nuniquemin' < 0) {
+		local nuniquemin = 20 + `p' + 1
+	}
+	*** END ERROR HANDLING ***************************************************** 
+	****************************************************************************
+
+	qui replace `x' = `x'-`c'
+	qui sort `x'
+
+	****************************************************************************
+	*** BEGIN MATA ESTIMATION ************************************************** 
+	mata{
+	*display("got here!")
+	X = st_data(.,("`x'"), 0);
+	
+	XUnique   	= rddensity_unique(X)
+	freqUnique  = XUnique[., 2]
+	indexUnique = XUnique[., 4]
+	XUnique     = XUnique[., 1]
+	NUnique     = length(XUnique)
+	NlUnique    = sum(XUnique :<  0)
+	NrUnique    = sum(XUnique :>= 0)
+	
+	masspoints_flag = sum(freqUnique :!= 1) > 0 & `masspoints'
+	st_numscalar("masspoints_flag", masspoints_flag)
+
+	****************************************************************************
+	** Kernel Constants
+	****************************************************************************
+	if ("`fitselect'"=="unrestricted") {
+		if ("`kernel'"=="uniform") {
+		Bsq_p=(0.24999999999999966693,0.01000000000000004878,0.00014172335600917503246,0.00000098418997230168060921,0.0000000039855627124297920874,0.000000000010481435883708594505,0.000000000000019251413808407223054,0.000000000000000026041096146069883723)
+		}
+		else if ("`kernel'"=="triangular") {
+		Bsq_p=(0.15999999999999992006,0.0051020408163267062795,0.00006298815822632821272,0.00000039855626977185269366,0.0000000015093255191922687787,0.0000000000037733140674455142929,0.0000000000000066614606382066531783,0.00000000000000000871923521295076001)
+		}
+		else if ("`kernel'"=="epanechnikov") {
+		Bsq_p=(0.17728531855955703689,0.0059878117913833833058,0.000076742107318398123782,0.00000049855793475223530487,0.0000000019253854002580922299,0.0000000000048868584327480008077,0.0000000000000087317551910484345913,0.000000000000000011557177676615075784)
+		}
+	}
+	else if ("`fitselect'"=="restricted") {
+		if ("`kernel'"=="uniform") {
+		Splus=(0,0,0,0,0,0,0,0,0,0,0,0\0,0.1666666667,0.25,0.125,0.1,0.08333333333,0.07142857143,0.0625,0.05555555556,0.05,0.04545454545,0.04166666667\0,0.25,0.5,0.1666666667,0.125,0.1,0.08333333333,0.07142857143,0.0625,0.05555555556,0.05,0.04545454545\0,0.125,0.1666666667,0.1,0.08333333333,0.07142857143,0.0625,0.05555555556,0.05,0.04545454545,0.04166666667,0.03846153846\0,0.1,0.125,0.08333333333,0.07142857143,0.0625,0.05555555556,0.05,0.04545454545,0.04166666667,0.03846153846,0.03571428571\0,0.08333333333,0.1,0.07142857143,0.0625,0.05555555556,0.05,0.04545454545,0.04166666667,0.03846153846,0.03571428571,0.03333333333\0,0.07142857143,0.08333333333,0.0625,0.05555555556,0.05,0.04545454545,0.04166666667,0.03846153846,0.03571428571,0.03333333333,0.03125\0,0.0625,0.07142857143,0.05555555556,0.05,0.04545454545,0.04166666667,0.03846153846,0.03571428571,0.03333333333,0.03125,0.02941176471\0,0.05555555556,0.0625,0.05,0.04545454545,0.04166666667,0.03846153846,0.03571428571,0.03333333333,0.03125,0.02941176471,0.02777777778\0,0.05,0.05555555556,0.04545454545,0.04166666667,0.03846153846,0.03571428571,0.03333333333,0.03125,0.02941176471,0.02777777778,0.02631578947\0,0.04545454545,0.05,0.04166666667,0.03846153846,0.03571428571,0.03333333333,0.03125,0.02941176471,0.02777777778,0.02631578947,0.025\0,0.04166666667,0.04545454545,0.03846153846,0.03571428571,0.03333333333,0.03125,0.02941176471,0.02777777778,0.02631578947,0.025,0.02380952381)
+		Gplus=(0,0,0,0,0,0,0,0,0,0,0,0\0,0.03333333333,0.05208333333,0.02430555556,0.01904761905,0.015625,0.01322751323,0.01145833333,0.0101010101,0.009027777778,0.008158508159,0.00744047619\0,0.05208333333,0.08333333333,0.0375,0.02916666667,0.02380952381,0.02008928571,0.01736111111,0.01527777778,0.01363636364,0.01231060606,0.01121794872\0,0.02430555556,0.0375,0.01785714286,0.0140625,0.01157407407,0.009821428571,0.008522727273,0.007523148148,0.006730769231,0.006087662338,0.005555555556\0,0.01904761905,0.02916666667,0.0140625,0.01111111111,0.009166666667,0.007792207792,0.006770833333,0.005982905983,0.005357142857,0.004848484848,0.004427083333\0,0.015625,0.02380952381,0.01157407407,0.009166666667,0.007575757576,0.006448412698,0.005608974359,0.00496031746,0.004444444444,0.004024621212,0.003676470588\0,0.01322751323,0.02008928571,0.009821428571,0.007792207792,0.006448412698,0.005494505495,0.004783163265,0.004232804233,0.003794642857,0.003437738732,0.003141534392\0,0.01145833333,0.01736111111,0.008522727273,0.006770833333,0.005608974359,0.004783163265,0.004166666667,0.003689236111,0.003308823529,0.002998737374,0.00274122807\0,0.0101010101,0.01527777778,0.007523148148,0.005982905983,0.00496031746,0.004232804233,0.003689236111,0.003267973856,0.002932098765,0.002658160553,0.002430555556\0,0.009027777778,0.01363636364,0.006730769231,0.005357142857,0.004444444444,0.003794642857,0.003308823529,0.002932098765,0.002631578947,0.002386363636,0.002182539683\0,0.008158508159,0.01231060606,0.006087662338,0.004848484848,0.004024621212,0.003437738732,0.002998737374,0.002658160553,0.002386363636,0.002164502165,0.001980027548\0,0.00744047619,0.01121794872,0.005555555556,0.004427083333,0.003676470588,0.003141534392,0.00274122807,0.002430555556,0.002182539683,0.001980027548,0.001811594203)
+		}
+		else if ("`kernel'"=="triangular") {
+		Splus=(0,0,0,0,0,0,0,0,0,0,0,0\0,0.08333333333,0.1666666667,0.05,0.03333333333,0.02380952381,0.01785714286,0.01388888889,0.01111111111,0.009090909091,0.007575757576,0.00641025641\0,0.1666666667,0.5,0.08333333333,0.05,0.03333333333,0.02380952381,0.01785714286,0.01388888889,0.01111111111,0.009090909091,0.007575757576\0,0.05,0.08333333333,0.03333333333,0.02380952381,0.01785714286,0.01388888889,0.01111111111,0.009090909091,0.007575757576,0.00641025641,0.005494505495\0,0.03333333333,0.05,0.02380952381,0.01785714286,0.01388888889,0.01111111111,0.009090909091,0.007575757576,0.00641025641,0.005494505495,0.004761904762\0,0.02380952381,0.03333333333,0.01785714286,0.01388888889,0.01111111111,0.009090909091,0.007575757576,0.00641025641,0.005494505495,0.004761904762,0.004166666667\0,0.01785714286,0.02380952381,0.01388888889,0.01111111111,0.009090909091,0.007575757576,0.00641025641,0.005494505495,0.004761904762,0.004166666667,0.003676470588\0,0.01388888889,0.01785714286,0.01111111111,0.009090909091,0.007575757576,0.00641025641,0.005494505495,0.004761904762,0.004166666667,0.003676470588,0.003267973856\0,0.01111111111,0.01388888889,0.009090909091,0.007575757576,0.00641025641,0.005494505495,0.004761904762,0.004166666667,0.003676470588,0.003267973856,0.002923976608\0,0.009090909091,0.01111111111,0.007575757576,0.00641025641,0.005494505495,0.004761904762,0.004166666667,0.003676470588,0.003267973856,0.002923976608,0.002631578947\0,0.007575757576,0.009090909091,0.00641025641,0.005494505495,0.004761904762,0.004166666667,0.003676470588,0.003267973856,0.002923976608,0.002631578947,0.002380952381\0,0.00641025641,0.007575757576,0.005494505495,0.004761904762,0.004166666667,0.003676470588,0.003267973856,0.002923976608,0.002631578947,0.002380952381,0.002164502165)
+		Gplus=(0,0,0,0,0,0,0,0,0,0,0,0\0,0.01031746032,0.02222222222,0.005853174603,0.003736772487,0.002579365079,0.001881914382,0.001430976431,0.001123413623,0.0009046509047,0.0007437007437,0.0006219474969\0,0.02222222222,0.05,0.0123015873,0.007738095238,0.005291005291,0.003835978836,0.002904040404,0.002272727273,0.001825951826,0.001498501499,0.001251526252\0,0.005853174603,0.0123015873,0.003373015873,0.002175925926,0.001512746513,0.001109307359,0.0008466070966,0.0006664631665,0.0005377955378,0.0004428210678,0.0003707893414\0,0.003736772487,0.007738095238,0.002175925926,0.001414141414,0.0009884559885,0.0007277444777,0.0005570818071,0.0004395604396,0.0003553391053,0.0002930035651,0.000245621753\0,0.002579365079,0.005291005291,0.001512746513,0.0009884559885,0.0006937506938,0.000512384441,0.0003931914646,0.0003108465608,0.0002516764281,0.0002077851343,0.0001743612425\0,0.001881914382,0.003835978836,0.001109307359,0.0007277444777,0.000512384441,0.0003793825222,0.0002917139078,0.0002309951758,0.0001872718784,0.000154780147,0.0001299991432\0,0.001430976431,0.002904040404,0.0008466070966,0.0005570818071,0.0003931914646,0.0002917139078,0.0002246732026,0.0001781499637,0.0001445917726,0.0001196172249,0.0001005451663\0,0.001123413623,0.002272727273,0.0006664631665,0.0004395604396,0.0003108465608,0.0002309951758,0.0001781499637,0.0001414210909,0.0001148916061,9.512417407e-05,8.001258001e-05\0,0.0009046509047,0.001825951826,0.0005377955378,0.0003553391053,0.0002516764281,0.0001872718784,0.0001445917726,0.0001148916061,9.341535657e-05,7.739735012e-05,6.514127067e-05\0,0.0007437007437,0.001498501499,0.0004428210678,0.0002930035651,0.0002077851343,0.000154780147,0.0001196172249,9.512417407e-05,7.739735012e-05,6.416508393e-05,5.403303328e-05\0,0.0006219474969,0.001251526252,0.0003707893414,0.000245621753,0.0001743612425,0.0001299991432,0.0001005451663,8.001258001e-05,6.514127067e-05,5.403303328e-05,4.552211074e-05)
+		}
+		else if ("`kernel'"=="epanechnikov") {
+		Splus=(0,0,0,0,0,0,0,0,0,0,0,0\0,0.1,0.1875,0.0625,0.04285714286,0.03125,0.02380952381,0.01875,0.01515151515,0.0125,0.01048951049,0.008928571429\0,0.1875,0.5,0.1,0.0625,0.04285714286,0.03125,0.02380952381,0.01875,0.01515151515,0.0125,0.01048951049\0,0.0625,0.1,0.04285714286,0.03125,0.02380952381,0.01875,0.01515151515,0.0125,0.01048951049,0.008928571429,0.007692307692\0,0.04285714286,0.0625,0.03125,0.02380952381,0.01875,0.01515151515,0.0125,0.01048951049,0.008928571429,0.007692307692,0.006696428571\0,0.03125,0.04285714286,0.02380952381,0.01875,0.01515151515,0.0125,0.01048951049,0.008928571429,0.007692307692,0.006696428571,0.005882352941\0,0.02380952381,0.03125,0.01875,0.01515151515,0.0125,0.01048951049,0.008928571429,0.007692307692,0.006696428571,0.005882352941,0.005208333333\0,0.01875,0.02380952381,0.01515151515,0.0125,0.01048951049,0.008928571429,0.007692307692,0.006696428571,0.005882352941,0.005208333333,0.004643962848\0,0.01515151515,0.01875,0.0125,0.01048951049,0.008928571429,0.007692307692,0.006696428571,0.005882352941,0.005208333333,0.004643962848,0.004166666667\0,0.0125,0.01515151515,0.01048951049,0.008928571429,0.007692307692,0.006696428571,0.005882352941,0.005208333333,0.004643962848,0.004166666667,0.003759398496\0,0.01048951049,0.0125,0.008928571429,0.007692307692,0.006696428571,0.005882352941,0.005208333333,0.004643962848,0.004166666667,0.003759398496,0.003409090909\0,0.008928571429,0.01048951049,0.007692307692,0.006696428571,0.005882352941,0.005208333333,0.004643962848,0.004166666667,0.003759398496,0.003409090909,0.003105590062)
+		Gplus=(0,0,0,0,0,0,0,0,0,0,0,0\0,0.01428571429,0.028515625,0.008515625,0.005627705628,0.003984375,0.002963702964,0.002287946429,0.001818181818,0.001478794643,0.001225832991,0.001032366071\0,0.028515625,0.05892857143,0.01666666667,0.01088169643,0.007643398268,0.005654761905,0.004348776224,0.00344629329,0.002797202797,0.002315067745,0.001947317388\0,0.008515625,0.01666666667,0.005140692641,0.003426339286,0.002440268065,0.001822916667,0.001411713287,0.001124526515,0.0009162895928,0.0007606325966,0.0006413091552\0,0.005627705628,0.01088169643,0.003426339286,0.002297702298,0.001643813776,0.001232101232,0.0009566326531,0.0007635501753,0.000623139881,0.0005179340783,0.0004371279762\0,0.003984375,0.007643398268,0.002440268065,0.001643813776,0.00118006993,0.0008868781888,0.0006900452489,0.0005516943994,0.0004508513932,0.0003751456876,0.000316903077\0,0.002963702964,0.005654761905,0.001822916667,0.001232101232,0.0008868781888,0.0006679594915,0.0005206118906,0.0004168174447,0.0003410218254,0.0002840296958,0.0002401244589\0,0.002287946429,0.004348776224,0.001411713287,0.0009566326531,0.0006900452489,0.0005206118906,0.0004063467492,0.0003257181187,0.0002667514374,0.0002223557692,0.0001881158642\0,0.001818181818,0.00344629329,0.001124526515,0.0007635501753,0.0005516943994,0.0004168174447,0.0003257181187,0.0002613485586,0.0002142160239,0.0001786923984,0.0001512691854\0,0.001478794643,0.002797202797,0.0009162895928,0.000623139881,0.0004508513932,0.0003410218254,0.0002667514374,0.0002142160239,0.0001757110167,0.0001466644151,0.0001242236025\0,0.001225832991,0.002315067745,0.0007606325966,0.0005179340783,0.0003751456876,0.0002840296958,0.0002223557692,0.0001786923984,0.0001466644151,0.0001224862094,0.0001037942608\0,0.001032366071,0.001947317388,0.0006413091552,0.0004371279762,0.000316903077,0.0002401244589,0.0001881158642,0.0001512691854,0.0001242236025,0.0001037942608,8.799171843e-05)
+		}
+	}
+	Psi=(0,-1,0,0,0,0,0,0,0,0,0,0\-1,0,0,0,0,0,0,0,0,0,0,0\0,0,1,0,0,0,0,0,0,0,0,0\0,0,0,1,0,0,0,0,0,0,0,0\0,0,0,0,-1,0,0,0,0,0,0,0\0,0,0,0,0,1,0,0,0,0,0,0\0,0,0,0,0,0,-1,0,0,0,0,0\0,0,0,0,0,0,0,1,0,0,0,0\0,0,0,0,0,0,0,0,-1,0,0,0\0,0,0,0,0,0,0,0,0,1,0,0\0,0,0,0,0,0,0,0,0,0,-1,0\0,0,0,0,0,0,0,0,0,0,0,1)
+
+	****************************************************************************
+	** Select preliminary bandwidths.
+	****************************************************************************
+	mu = mean(X); sd = (variance(X))^(1/2)
+
+	fhatb = sd^(2*`p'+5) * normalden(-mu/sd) / (rddensity_h(-mu/sd,`p'+2) * normalden(-mu/sd))^2
+	C_b = (25884.444444494150957,3430865.4551236177795,845007948.04262602329,330631733667.03808594,187774809656037.3125,145729502641999264,146013502974449876992)
+	b = ((2*`p'+1)/4 * fhatb * C_b[`p']/`N')^(1/(2*`p'+5))
+	
+	fhatc = sd^(2*`p'+1) * normalden(-mu/sd) / (rddensity_h(-mu/sd,`p') * normalden(-mu/sd))^2
+	C_c = (4.8000000000000246914,548.57142857155463389,100800.00000020420703,29558225.458100609481,12896196859.612621307,7890871468221.609375,6467911284037581)
+	c = (1/(2*`p') * fhatc * C_c[`p']/`N')^(1/(2*`p'+1))
+	
+	// b is for higher-order derivative estimation
+    // c is for density estimation
+	
+	if (`regularize') {
+		
+		// bandwidth should not exceed the range of data
+		b = min( (b, max(abs(XUnique))) )
+		c = min( (c, max(abs(XUnique))) )
+
+		// nlocalmin check
+		
+		if (`nlocalmin' > 0) {
+			b = max((b, sort(abs(X[selectindex(X :< 0)]), 1)[min((20+`p'+2+1, `Nl'))], (X[selectindex(X :>= 0)])[min((20+`p'+2+1, `Nr'))]))
+			c = max((c, sort(abs(X[selectindex(X :< 0)]), 1)[min((20+`p'+  1, `Nl'))], (X[selectindex(X :>= 0)])[min((20+`p'  +1, `Nr'))]))
+		}
+
+		// nuniquemin check
+		if (`nuniquemin' > 0) {
+			b = max((b, sort(abs(XUnique[selectindex(XUnique :< 0)]), 1)[min((20+`p'+2+1, NlUnique))], (XUnique[selectindex(XUnique :>= 0)])[min((20+`p'+2+1, NrUnique))]))
+			c = max((c, sort(abs(XUnique[selectindex(XUnique :< 0)]), 1)[min((20+`p'  +1, NlUnique))], (XUnique[selectindex(XUnique :>= 0)])[min((20+`p'  +1, NrUnique))]))
+		}
+	}
+	
+	st_numscalar("BW_b", b)
+	st_numscalar("BW_c", c)
+
+	****************************************************************************
+	** Estimate main bandwidths.
+	****************************************************************************
+	Xb = select(X, -b:<=X :& X:<=b)
+	Nlb = sum(-b:<=X :& X:<0)
+	Nrb = rows(Xb) - Nlb
+	
+	Xc = select(X, -c:<=X :& X:<=c)
+	Nlc = sum(-c:<=X :& X:<0)
+	Nrc = rows(Xc) - Nlc
+	
+	Ytemp = (0..(`N'-1))' :/ (`N'-1)
+	if (`masspoints') {
+		Ytemp = rddensity_rep(Ytemp[indexUnique], freqUnique)
+	}
+	Yb = select(Ytemp, -b:<=X :& X:<=b)
+	Yc = select(Ytemp, -c:<=X :& X:<=c)
+
+	h = J(4,3,0)
+
+	fV_b = rddensity_fv(Yb, Xb, `Nl', `Nr', Nlb, Nrb, b, b, `p'+2 , `p'+1, "`kernel'", "`fitselect'", "`vce'", `masspoints')
+	fV_c = rddensity_fv(Yc, Xc, `Nl', `Nr', Nlc, Nrc, c, c, `p'   , 1    , "`kernel'", "`fitselect'", "`vce'", `masspoints')
+	
+
+	h[.,2] = `N'*c*fV_c[.,2]
+
+	if ("`fitselect'"=="unrestricted") {
+		h[1,3] = fV_b[1,3] * Bsq_p[`p']^(1/2) * (-1)^`p' * factorial(`p'+1)
+		h[2,3] = fV_b[2,3] * Bsq_p[`p']^(1/2) * factorial(`p'+1)
+	}
+	else if ("`fitselect'"=="restricted") {
+		Psi = Psi[1..`p'+2,1..`p'+2];
+		Gplus = Gplus[1..`p'+2,1..`p'+2]; Gminus = Psi*Gplus*Psi;
+		vplus = Splus[1..`p'+2,`p'+3]; vminus = Psi*vplus;
+		Splus = Splus[1..`p'+2,1..`p'+2]; Sminus = Psi*Splus*Psi;
+		S = invsym(fV_c[2,1] * Splus + fV_c[1,1] * Sminus);
+		B = fV_b[1,3] * S[1..2,] * (fV_c[1,1] * (-1)^(`p'+1) * vminus + fV_c[2,1] * vplus) 
+		h[1,3] = B[1,1]
+		h[2,3] = B[2,1]
+	}
+
+ 	h[3,3] = h[2,3] - h[1,3]; h[4,3] = h[2,3] + h[1,3]; h[.,3] = h[.,3]:^2;
+	h[.,1] = ((1/(2*`p')) * (h[.,2]:/h[.,3]) * (1/`N')):^(1/(2*`p'+1));
+	
+	if (`regularize') {
+		
+		for (i=1; i<=4; i++) {
+			if (h[i, 2] < 0) { 
+				h[i, 1] = 0
+				h[i, 2] = . 
+			}
+			if (h[i, 1] == .) { 
+				h[i, 1] = 0 
+			}
+		}
+	
+		// bandwidth should not exceed the range of data
+		h[1,1] = min((h[1,1], abs(XUnique[1])))
+		h[2,1] = min((h[2,1], XUnique[NUnique]))
+		h[3,1] = min((h[3,1], max((abs(XUnique[1]), XUnique[NUnique]))))
+		h[4,1] = min((h[4,1], max((abs(XUnique[1]), XUnique[NUnique]))))
+
+		// nlocalmin check
+		if (`nlocalmin' > 0) {
+			hlMin = sort(abs(X[selectindex(X :< 0)]), 1)[min((`Nl', `nlocalmin'))]
+			hrMin = (X[selectindex(X :>= 0)])[min((`Nr', `nlocalmin'))]
+			h[1,1] = max((h[1,1], hlMin))
+			h[2,1] = max((h[2,1], hrMin))
+			h[3,1] = max((h[3,1], hlMin, hrMin))
+			h[4,1] = max((h[4,1], hlMin, hrMin))
+		}
+
+		// nuniquemin check
+		if (`nuniquemin' > 0) {
+			hlMin = sort(abs(XUnique[selectindex(XUnique :< 0)]),1)[min((NlUnique, `nuniquemin'))]
+			hrMin = (XUnique[selectindex(XUnique :>= 0)])[min((NrUnique, `nuniquemin'))]
+			h[1,1] = max((h[1,1], hlMin))
+			h[2,1] = max((h[2,1], hrMin))
+			h[3,1] = max((h[3,1], hlMin, hrMin))
+			h[4,1] = max((h[4,1], hlMin, hrMin))
+		}
+	}
+	
+	st_matrix("h", h);
+
+	*display("Estimation completed.");
+	}
+	*** END MATA ESTIMATION **************************************************** 
+	****************************************************************************
+
+	****************************************************************************
+	*** BEGIN OUTPUT TABLE *****************************************************
+	if (masspoints_flag == 1) {
+		disp ""
+		disp "Point estimates and standard errors have been adjusted for repeated observations."
+		disp "(Use option {it:nomasspoints} to suppress this adjustment.)"
+	}
+	
+	disp ""
+	disp "Bandwidth selection for manipulation testing." 
+
+	disp ""
+	disp in smcl in gr "Cutoff " in ye "c = " %10.3f `c'  _col(22) " {c |} " _col(23) in gr "Left of " in ye "c" _col(36) in gr "Right of " in y "c"  _col(58) in gr "Number of obs = "  in ye %12.0f `N'
+	disp in smcl in gr "{hline 22}{c +}{hline 22}"                                                                                                    _col(58) in gr "Model         = "  in ye "{ralign 12:`fitselect'}"
+	disp in smcl in gr "{ralign 21:Number of obs}"        _col(22) " {c |} " _col(23) as result %9.0f `Nl'       _col(37) as result %9.0f  `Nr'       _col(58) in gr "Kernel        = "  in ye "{ralign 12:`kernel'}"
+	disp in smcl in gr "{ralign 21:Min Running var.}"     _col(22) " {c |} " _col(23) as result %9.3f `xl_min'   _col(37) as result %9.3f  `xr_min'   _col(58) in gr "VCE method    = "  in ye "{ralign 12:`vce'}"
+	disp in smcl in gr "{ralign 21:Max Running var.}"     _col(22) " {c |} " _col(23) as result %9.3f `xl_max'   _col(37) as result %9.3f  `xr_max'
+	disp in smcl in gr "{ralign 21:Order loc. poly. (p)}" _col(22) " {c |} " _col(23) as result %9.0f `p'        _col(37) as result %9.0f  `p'
+
+	disp ""
+	disp "Running variable: `x'."
+	disp in smcl in gr "{hline 22}{c TT}{hline 34}"
+	disp in smcl in gr "{ralign 21:Target}"              _col(22) " {c |} " _col(23) in gr "Bandwidth"          _col(37) " Variance"                 _col(49) "   Bias^2" 
+	disp in smcl in gr "{hline 22}{c +}{hline 34}"
+	disp in smcl in gr "{ralign 21:left density}"        _col(22) " {c |} " _col(23) as result %9.3f h[1,1]     _col(37) as result %9.3f h[1,2]      _col(49) as result %9.3f h[1,3]
+	disp in smcl in gr "{ralign 21:right density}"       _col(22) " {c |} " _col(23) as result %9.3f h[2,1]     _col(37) as result %9.3f h[2,2]      _col(49) as result %9.3f h[2,3]
+	disp in smcl in gr "{ralign 21:difference densities}" _col(22) " {c |} " _col(23) as result %9.3f h[3,1]     _col(37) as result %9.3f h[3,2]      _col(49) as result %9.3f h[3,3]
+	disp in smcl in gr "{ralign 21:sum densities}"      _col(22) " {c |} " _col(23) as result %9.3f h[4,1]     _col(37) as result %9.3f h[4,2]      _col(49) as result %9.3f h[4,3]
+	disp in smcl in gr "{hline 22}{c BT}{hline 34}"
+	disp ""
+	*** END OUTPUT TABLE ******************************************************* 
+	****************************************************************************
+
+	restore
+
+	ereturn clear
+	ereturn scalar c = `c'
+	ereturn scalar p = `p'
+	ereturn scalar N_l = `Nl'
+	ereturn scalar N_r = `Nr'
+	mat rown h = f_left f_right f_diff f_sum
+	mat coln h = bandwidth var bias2
+	ereturn matrix h = h
+	ereturn scalar BW_b = BW_b
+	ereturn scalar BW_c = BW_c
+	
+	ereturn local runningvar "`x'"
+	ereturn local kernel = "`kernel'"
+	ereturn local fitmethod = "`fitselect'"
+	ereturn local vce = "`vce'"
+
+	mata: mata clear
+	
+end
+	

30/replication_package/Adofiles/rd_2021/rdbwdensity.sthlp

@@ -0,0 +1,147 @@
+{smcl}
+{* *!version 2.3 2021-02-28}{...}
+{viewerjumpto "Syntax" "rdrobust##syntax"}{...}
+{viewerjumpto "Description" "rdrobust##description"}{...}
+{viewerjumpto "Options" "rdrobust##options"}{...}
+{viewerjumpto "Examples" "rdrobust##examples"}{...}
+{viewerjumpto "Saved results" "rdrobust##saved_results"}{...}
+
+{title:Title}
+
+{p 4 8}{cmd:rdbwdensity} {hline 2} Bandwidth Selection for Manipulation Testing Using Local Polynomial Density Estimation.{p_end}
+
+{marker syntax}{...}
+{title:Syntax}
+
+{p 4 8}{cmd:rdbwdensity} {it:Var} {ifin} 
+[{cmd:,} {p_end}
+{p 16 20}
+{cmd:c(}{it:#}{cmd:)} 
+{cmd:p(}{it:#}{cmd:)} 
+{cmd:kernel(}{it:KernelFn}{cmd:)}
+{cmd:fitselect(}{it:FitMethod}{cmd:)}
+{cmd:vce(}{it:VceMethod}{cmd:)}
+{cmd:nomasspoints}{p_end}
+{p 16 20}
+{cmd:nlocalmin(}{it:#}{cmd:)}
+{cmd:nuniquemin(}{it:#}{cmd:)}
+{cmd:noregularize}{p_end}
+{p 16 20}]{p_end}
+
+{marker description}{...}
+{title:Description}
+
+{p 4 8}{cmd:rdbwdensity} implements several data-driven bandwidth selection methods useful to construct manipulation testing procedures using the local polynomial density estimators proposed in
+{browse "https://rdpackages.github.io/references/Cattaneo-Jansson-Ma_2020_JASA.pdf":Cattaneo, Jansson and Ma (2020)}.{p_end}
+
+{p 4 8}A detailed introduction to this Stata command is given in {browse "https://rdpackages.github.io/references/Cattaneo-Jansson-Ma_2018_Stata.pdf":Cattaneo, Jansson and Ma (2018)}.{p_end}
+{p 8 8}Companion {browse "www.r-project.org":R} functions are also available {browse "https://rdpackages.github.io/rddensity":here}.{p_end}
+
+{p 4 8}Companion function is {help rddensity:rddensity}.
+See also the 
+{browse "https://nppackages.github.io/lpdensity":lpdensity}
+package for other related bandwidth selection methods.{p_end}
+
+{p 4 8}Related Stata and R packages useful for inference in regression discontinuity (RD) designs are described in the following website:{p_end}
+
+{p 8 8}{browse "https://rdpackages.github.io/":https://rdpackages.github.io/}{p_end}
+
+{marker options}{...}
+{title:Options}
+
+{dlgtab:Bandwidth Selection}
+
+{p 4 8}{opt c:}{cmd:(}{it:#}{cmd:)} specifies the threshold or cutoff value in the support of {it:Var}, which determines the two samples (e.g., control and treatment units in RD settings).
+Default is {cmd:c(0)}.{p_end}
+
+{p 4 8}{opt p:}{cmd:(}{it:#}{cmd:)} specifies the local polynomial order used to construct the density estimators.
+Default is {cmd:p(2)} (local quadratic approximation).{p_end}
+
+{p 4 8}{opt fit:select}{cmd:(}{it:FitMethod}{cmd:)} specifies the density estimation method.{p_end}
+{p 8 12}{opt unrestricted}{bind:} for density estimation without any restrictions (two-sample, unrestricted inference).
+This is the default option.{p_end}
+{p 8 12}{opt restricted}{bind:} for density estimation assuming equal distribution function and higher-order derivatives.{p_end}
+
+{p 4 8}{opt ker:nel}{cmd:(}{it:KernelFn}{cmd:)} specifies the kernel function used to construct the local polynomial estimators.{p_end}
+{p 8 12}{opt triangular}{bind:  } {it:K(u) = (1 - |u|) * (|u|<=1)}.
+This is the default option.{p_end}
+{p 8 12}{opt epanechnikov}{bind:}  {it:K(u) = 0.75 * (1 - u^2) * (|u|<=1)}.{p_end}
+{p 8 12}{opt uniform}{bind:     }  {it:K(u) = 0.5 * (|u|<=1)}.{p_end}
+
+{p 4 8}{opt vce:}{cmd:(}{it:VceMethod}{cmd:)} specifies the procedure used to compute the variance-covariance matrix estimator.{p_end}
+{p 8 12}{opt plugin}{bind:   } for asymptotic plug-in standard errors.{p_end}
+{p 8 12}{opt jackknife}{bind:} for jackknife standard errors.
+This is the default option.{p_end}
+
+{p 4 8}{opt nomass:points} will not adjust for mass points in the data.{p_end}
+
+{dlgtab:Local Sample Size Checking}
+
+{p 4 8}{opt nloc:almin}{cmd:(}{it:#}{cmd:)} specifies the minimum number of observations in each local neighborhood.
+This option will be ignored if set to 0, or if {cmd:noregularize} is used.
+The default value is {cmd:20+p(}{it:#}{cmd:)+1}.{p_end}
+
+{p 4 8}{opt nuni:quemin}{cmd:(}{it:#}{cmd:)} specifies the minimum number of unique observations in each local neighborhood.
+This option will be ignored if set to 0, or if {cmd:noregularize} is used.
+The default value is {cmd:20+p(}{it:#}{cmd:)+1}.{p_end}
+
+{p 4 8}{opt noreg:ularize} suppresses the local sample size checking feature.{p_end}
+
+		
+{marker examples}{...}
+{title:Example: Cattaneo, Frandsen and Titiunik (2015) Incumbency Data}.
+
+{p 4 8}Load dataset (cutoff is 0 in this dataset):{p_end}
+{p 8 8}{cmd:. use rddensity_senate.dta}{p_end}
+
+{p 4 8}Bandwidth selection for manipulation test using default options: {p_end}
+{p 8 8}{cmd:. rdbwdensity margin}{p_end}
+
+{p 4 8}Bandwidth selection for manipulation test using plug-in standard errors:{p_end}
+{p 8 8}{cmd:. rdbwdensity margin, vce(plugin)}{p_end}
+
+
+{marker saved_results}{...}
+{title:Saved results}
+
+{p 4 8}{cmd:rddensity} saves the following in {cmd:e()}:
+
+{synoptset 20 tabbed}{...}
+{p2col 5 20 24 2: Macros}{p_end}
+{synopt:{cmd:e(c)}}cutoff value{p_end}
+{synopt:{cmd:e(p)}}order of the polynomial used for density estimation{p_end}
+{synopt:{cmd:e(N_l)}}sample size to the left of the cutoff{p_end}
+{synopt:{cmd:e(N_r)}}sample size to the right of the cutoff{p_end}
+{synopt:{cmd:e(h)}}matrix of estimated bandwidth (including underlying estimated constants){p_end}
+{synopt:{cmd:e(runningvar)}}running variable used{p_end}
+{synopt:{cmd:e(kernel)}}kernel used{p_end}
+{synopt:{cmd:e(fitmethod)}}model used{p_end}
+{synopt:{cmd:e(vce)}}standard errors estimator used{p_end}
+
+
+{title:References}
+
+{p 4 8}Cattaneo, M. D., B. Frandsen, and R. Titiunik. 2015.
+{browse "https://rdpackages.github.io/references/Cattaneo-Frandsen-Titiunik_2015_JCI.pdf":Randomization Inference in the Regression Discontinuity Design: An Application to the Study of Party Advantages in the U.S. Senate}.{p_end}
+{p 8 8}{it:Journal of Causal Inference} 3(1): 1-24.{p_end}
+
+{p 4 8}Cattaneo, M. D., M. Jansson, and X. Ma. 2018.
+{browse "https://rdpackages.github.io/references/Cattaneo-Jansson-Ma_2018_Stata.pdf": Manipulation Testing based on Density Discontinuity}.{p_end}
+{p 8 8}{it:Stata Journal} 18(1): 234-261.{p_end}
+
+{p 4 8}Cattaneo, M. D., M. Jansson, and X. Ma. 2020.
+{browse "https://rdpackages.github.io/references/Cattaneo-Jansson-Ma_2020_JASA.pdf":Simple Local Polynomial Density Estimators}.{p_end}
+{p 8 8}{it:Journal of the American Statistical Association} 115(531): 1449-1455.{p_end}
+
+{title:Authors}
+
+{p 4 8}Matias D. Cattaneo, Princeton University, Princeton, NJ.
+{browse "mailto:[email protected]":[email protected]}.{p_end}
+
+{p 4 8}Michael Jansson, University of California Berkeley, Berkeley, CA.
+{browse "mailto:[email protected]":[email protected]}.{p_end}
+
+{p 4 8}Xinwei Ma, University of California San Diego, La Jolla, CA.
+{browse "mailto:[email protected]":[email protected]}.{p_end}
+
+

30/replication_package/Adofiles/rd_2021/rdbwselect.ado

@@ -0,0 +1,679 @@
+*!version 8.1.0  2021-02-22
+ 
+capture program drop rdbwselect
+program define rdbwselect, eclass
+	syntax anything [if] [in] [, c(real 0) fuzzy(string) deriv(real 0) p(real 1) q(real 0) covs(string) covs_drop(string) kernel(string) weights(string) bwselect(string) vce(string) scaleregul(real 1) all nochecks masspoints(string) bwcheck(real 0) bwrestrict(string) stdvars(string)]
+
+	marksample touse
+	preserve
+	qui keep if `touse'
+	tokenize "`anything'"
+	local y `1'
+	local x `2'
+	local kernel   = lower("`kernel'")
+	local bwselect = lower("`bwselect'")
+	
+	******************** Set VCE ***************************
+	local nnmatch = 3
+	tokenize `vce'	
+	local w : word count `vce' 
+	if `w' == 1 {
+		local vce_select `"`1'"'
+	}
+	if `w' == 2 {
+		local vce_select `"`1'"'
+		if ("`vce_select'"=="nn")      local nnmatch     `"`2'"'
+		if ("`vce_select'"=="cluster" | "`vce_select'"=="nncluster") local clustvar `"`2'"'	
+	}
+	if `w' == 3 {
+		local vce_select `"`1'"'
+		local clustvar   `"`2'"'
+		local nnmatch    `"`3'"'
+		if ("`vce_select'"!="cluster" & "`vce_select'"!="nncluster") di as error "{err}{cmd:vce()} incorrectly specified"  
+	}
+	if `w' > 3 {
+		di as error "{err}{cmd:vce()} incorrectly specified"  
+		exit 125
+	}
+	
+	local vce_type = "NN"
+	if ("`vce_select'"=="hc0")       local vce_type = "HC0"
+	if ("`vce_select'"=="hc1")       local vce_type = "HC1"
+	if ("`vce_select'"=="hc2")       local vce_type = "HC2"
+	if ("`vce_select'"=="hc3")       local vce_type = "HC3"
+	if ("`vce_select'"=="cluster")   local vce_type = "Cluster"
+	if ("`vce_select'"=="nncluster") local vce_type = "NNcluster"
+
+	if ("`vce_select'"=="cluster" | "`vce_select'"=="nncluster") local cluster = "cluster"
+	if ("`vce_select'"=="cluster")   local vce_select = "hc0"
+	if ("`vce_select'"=="nncluster") local vce_select = "nn"
+	if ("`vce_select'"=="")          local vce_select = "nn"
+	
+	******************** Set Fuzzy***************************
+	tokenize `fuzzy'	
+	local w : word count `fuzzy'
+	if `w' == 1 {
+		local fuzzyvar `"`1'"'
+	}
+	if `w' == 2 {
+		local fuzzyvar `"`1'"'
+		local sharpbw  `"`2'"'
+		if `"`2'"' != "sharpbw" {
+			di as error  "{err}fuzzy() only accepts sharpbw as a second input" 
+			exit 125
+		}
+	}
+	if `w' >= 3 {
+		di as error "{err}{cmd:fuzzy()} only accepts two inputs"  
+		exit 125
+	}
+	************************************************************
+
+	**** DROP MISSINGS ******************************************
+	qui drop if `y'==. | `x'==.
+	if ("`cluster'"!="") qui drop if `clustvar'==.
+	if ("`fuzzy'"~="") {
+		qui drop if `fuzzyvar'==.
+		qui su `fuzzyvar'
+		*qui replace `fuzzyvar' = `fuzzyvar'/r(sd)
+	}
+
+	if ("`covs'"~="") {
+		qui ds `covs', alpha
+		local covs_list = r(varlist)
+		local ncovs: word count `covs_list'	
+		foreach z in `covs_list' {
+			qui drop if `z'==.
+		}
+	}
+
+	
+	**** CHECK colinearity ******************************************
+	local covs_drop_coll = 0	
+	if ("`covs_drop'"=="") local covs_drop = "pinv"	
+	if ("`covs'"~="") {	
+		
+	if ("`covs_drop'"=="invsym")  local covs_drop_coll = 1
+	if ("`covs_drop'"=="pinv")    local covs_drop_coll = 2
+	
+		qui _rmcoll `covs_list'
+		local nocoll_controls_cat `r(varlist)'
+		local nocoll_controls ""
+		foreach myString of local nocoll_controls_cat {
+			if ~strpos("`myString'", "o."){
+				if ~strpos("`myString'", "MYRUNVAR"){
+					local nocoll_controls "`nocoll_controls' `myString'"
+				}
+				}
+			}			
+		local covs_new `nocoll_controls'
+		qui ds `covs_new', alpha
+		local covs_list_new = r(varlist)
+		local ncovs_new: word count `covs_list_new'
+		
+		if (`ncovs_new'<`ncovs') {
+			if ("`covs_drop'"=="off") {	
+				di as error  "{err}Multicollinearity issue detected in {cmd:covs}. Please rescale and/or remove redundant covariates, or add {cmd:covs_drop} option." 
+				exit 125
+			} 
+			else {
+				local ncovs = "`ncovs_new'"
+				local covs_list = "`covs_list_new'"
+				*local covs_drop_coll = 1
+			}	
+		}
+	}
+	
+	
+	
+	
+	
+	**** DEFAULTS ***************************************
+	if ("`masspoints'"=="") local masspoints = "adjust"
+	if ("`stdvars'"=="")    local stdvars    = "off"	
+	if ("`bwrestrict'"=="") local bwrestrict = "on"	
+	*****************************************************************
+	
+			qui su `x', d
+			local x_min = r(min)
+			local x_max = r(max)
+			local N = r(N)
+			local x_iq = r(p75)-r(p25)
+			local x_sd = r(sd)
+						
+			if ("`deriv'">"0" & "`p'"=="1" & "`q'"=="0") local p = (`deriv'+1)
+			if ("`q'"=="0")                              local q = (`p'+1)
+			
+			**************************** BEGIN ERROR CHECKING ************************************************
+			if ("`nochecks'"=="") {
+			
+			if (`c'<=`x_min' | `c'>=`x_max'){
+			 di as error "{err}{cmd:c()} should be set within the range of `x'"  
+			 exit 125
+			}
+			
+			if (`N'<20){
+			 di as error "{err}Not enough observations to perform bandwidth calculations"  
+			 exit 2001
+			}
+			
+			if ("`kernel'"~="uni" & "`kernel'"~="uniform" & "`kernel'"~="tri" & "`kernel'"~="triangular" & "`kernel'"~="epa" & "`kernel'"~="epanechnikov" & "`kernel'"~="" ){
+			 di as error "{err}{cmd:kernel()} incorrectly specified"  
+			 exit 7
+			}
+
+			if ("`bwselect'"=="CCT" | "`bwselect'"=="IK" | "`bwselect'"=="CV" |"`bwselect'"=="cct" | "`bwselect'"=="ik" | "`bwselect'"=="cv"){
+				di as error "{err}{cmd:bwselect()} options IK, CCT and CV have been depricated. Please see help for new options"  
+				exit 7
+			}
+					
+			if  ("`bwselect'"!="mserd" & "`bwselect'"!="msetwo" & "`bwselect'"!="msesum" & "`bwselect'"!="msecomb1" & "`bwselect'"!="msecomb2"  & "`bwselect'"!="cerrd" & "`bwselect'"!="certwo" & "`bwselect'"!="cersum" & "`bwselect'"!="cercomb1" & "`bwselect'"!="cercomb2" & "`bwselect'"~=""){
+				di as error  "{err}{cmd:bwselect()} incorrectly specified"  
+				exit 7
+			}
+
+			if ("`vce_select'"~="nn" & "`vce_select'"~="" & "`vce_select'"~="cluster" & "`vce_select'"~="nncluster" & "`vce_select'"~="hc1" & "`vce_select'"~="hc2" & "`vce_select'"~="hc3" & "`vce_select'"~="hc0"){ 
+			 di as error  "{err}{cmd:vce()} incorrectly specified"  
+			 exit 7
+			}
+
+			if ("`p'"<"0" | "`q'"<="0" | "`deriv'"<"0" | "`nnmatch'"<="0" ){
+			 di as error  "{err}{cmd:p()}, {cmd:q()}, {cmd:deriv()}, {cmd:nnmatch()} imson should be positive"  
+			 exit 411
+			}
+
+			if ("`p'">="`q'" & "`q'">"0"){
+			 di as error  "{err}{cmd:q()} should be higher than {cmd:p()}"  
+			 exit 125
+			}
+
+			if ("`deriv'">"`p'" & "`deriv'">"0" ){
+			 di as error  "{err}{cmd:deriv()} can not be higher than {cmd:p()}"  
+			 exit 125
+			}
+
+			if ("`p'">"0" ) {
+				local p_round = round(`p')/`p'
+				local q_round = round(`q')/`q'
+				local d_round = round(`deriv'+1)/(`deriv'+1)
+				local m_round = round(`nnmatch')/`nnmatch'
+
+				if (`p_round'!=1 | `q_round'!=1 |`d_round'!=1 |`m_round'!=1 ){
+				 di as error  "{err}{cmd:p()}, {cmd:q()}, {cmd:deriv()} and {cmd:nnmatch()} should be integers"  
+				 exit 126
+				}
+			}			
+		}
+			
+	if ("`kernel'"=="epanechnikov" | "`kernel'"=="epa") {
+		local kernel_type = "Epanechnikov"
+		local C_c = 2.34
+	}
+	else if ("`kernel'"=="uniform" | "`kernel'"=="uni") {
+		local kernel_type = "Uniform"
+		local C_c = 1.843
+	}
+	else {
+		local kernel_type = "Triangular"
+		local C_c = 2.576
+	}
+	
+	if ("`vce_select'"=="nn" | "`masspoints'"=="check" | "`masspoints'"=="adjust") {
+		sort `x', stable
+		if ("`vce_select'"=="nn") {
+			tempvar dups dupsid
+			by `x': gen dups = _N
+			by `x': gen dupsid = _n
+		}
+	}	
+	
+
+	mata{
+	c = `c'
+	p = `p'
+	q = `q'
+	covs_drop_coll = `covs_drop_coll'
+	nnmatch =  strtoreal("`nnmatch'")
+		
+	Y = st_data(.,("`y'"), 0);	X = st_data(.,("`x'"), 0)
+	
+	BWp = min((`x_sd',`x_iq'/1.349))
+	x_sd = y_sd = 1
+	if  ("`stdvars'"=="on")  {	
+		y_sd = sqrt(variance(Y))
+		x_sd = sqrt(variance(X))
+		Y = Y/y_sd
+		X = X/x_sd
+		c = c/x_sd
+		BWp = min((1, (`x_iq'/x_sd)/1.349))
+	}
+
+	ind_r = X:>=c
+	ind_l = abs(1:-ind_r)
+	
+	X_l = select(X,ind_l);	X_r = select(X,ind_r)
+	Y_l = select(Y,ind_l);	Y_r = select(Y,ind_r)
+	
+	N   = length(X);	N_l = length(X_l);	N_r = length(X_r)
+	
+	x_l_min = min(X_l);	x_l_max = max(X_l)
+	x_r_min = min(X_r);	x_r_max = max(X_r)
+	
+	range_l = c - x_l_min
+	range_r = x_r_max - c  
+	
+	dZ=Z_l=Z_r=T_l=T_r=Cind_l=Cind_r=g_l=g_r=dups_l=dups_r=dupsid_l=dupsid_r=0
+
+	if ("`vce_select'"=="nn") {
+		dups      = st_data(.,("dups"), 0); dupsid    = st_data(.,("dupsid"), 0)
+		dups_l    = select(dups,ind_l);    dups_r    = select(dups,ind_r)
+		dupsid_l  = select(dupsid,ind_l);  dupsid_r  = select(dupsid,ind_r)
+	}
+	
+	if ("`covs'"~="") {
+		Z   = st_data(.,tokens("`covs_list'"), 0)
+		dZ  = cols(Z)
+		Z_l = select(Z,ind_l);	Z_r = select(Z,ind_r)
+	}
+	
+	if ("`fuzzy'"~="") {
+		T   = st_data(.,("`fuzzyvar'"), 0)
+		T_l = select(T,ind_l);	T_r = select(T,ind_r)
+		if (variance(T_l)==0 | variance(T_r)==0){
+			T_l = T_r =0
+			st_local("perf_comp","perf_comp")
+		}
+		if ("`sharpbw'"!=""){
+			T_l = T_r =0
+			st_local("sharpbw","sharpbw")
+		}
+	}
+	
+	C_l=C_r=0
+	if ("`cluster'"!="") {
+		C  = st_data(.,("`clustvar'"), 0)
+		C_l  = select(C,ind_l); C_r  = select(C,ind_r)
+		indC_l = order(C_l,1);  indC_r = order(C_r,1) 
+		g_l = rows(panelsetup(C_l[indC_l],1));	g_r = rows(panelsetup(C_r[indC_r],1))
+		st_numscalar("g_l",  g_l);     st_numscalar("g_r",   g_r)
+	}
+	
+	fw_l = fw_r = 0
+	if ("`weights'"~="") {
+		fw = st_data(.,("`weights'"), 0)
+		fw_l = select(fw,ind_l);	fw_r = select(fw,ind_r)
+	}
+	
+	mN = N
+	bwcheck = `bwcheck'
+	masspoints_found = 0
+	if ("`masspoints'"=="check" | "`masspoints'"=="adjust") {
+		X_uniq_l = sort(uniqrows(X_l),-1)
+		X_uniq_r = uniqrows(X_r)
+		M_l = length(X_uniq_l)
+		M_r = length(X_uniq_r)
+		M = M_l + M_r
+		st_numscalar("M_l", M_l); st_numscalar("M_r", M_r)
+		mass_l = 1-M_l/N_l
+		mass_r = 1-M_r/N_r
+		if (mass_l>=0.1 | mass_r>=0.1){
+			masspoints_found = 1
+			display("{err}Mass points detected in the running variable.")
+			if ("`masspoints'"=="adjust" & "`bwcheck'"=="0") bwcheck = 10
+			if ("`masspoints'"=="check") display("{err}Try using option {cmd:masspoints(adjust)}")
+		}				
+	}
+	
+	*if ("`masspoints'"=="adjust") mN = M	
+	
+	
+	***********************************************************************
+	******** Computing bandwidth selector *********************************
+	***********************************************************************					
+	c_bw = `C_c'*BWp*mN^(-1/5)
+	if ("`masspoints'"=="adjust") c_bw = `C_c'*BWp*M^(-1/5)
+	
+	if  ("`bwrestrict'"=="on")  {	
+		bw_max = max((range_l,range_r))
+		c_bw = min((c_bw, bw_max))
+	}
+	
+	if (bwcheck > 0) {
+		bwcheck_l = min((bwcheck, M_l))
+		bwcheck_r = min((bwcheck, M_r))
+		bw_min_l = abs(X_uniq_l:-c)[bwcheck_l] + 1e-8
+		bw_min_r = abs(X_uniq_r:-c)[bwcheck_r] + 1e-8
+		c_bw = max((c_bw, bw_min_l, bw_min_r))
+	}	
+		
+	c_bw_l = c_bw_r = c_bw
+	
+	
+	*** Step 1: d_bw
+	C_d_l = rdrobust_bw(Y_l, X_l, T_l, Z_l, C_l, fw_l, c=c, o=q+1, nu=q+1, o_B=q+2, h_V=c_bw_l, h_B=range_l+1e-8, 0, "`vce_select'", nnmatch, "`kernel'", dups_l, dupsid_l, covs_drop_coll)
+	C_d_r = rdrobust_bw(Y_r, X_r, T_r, Z_r, C_r, fw_r, c=c, o=q+1, nu=q+1, o_B=q+2, h_V=c_bw_r, h_B=range_r+1e-8, 0, "`vce_select'", nnmatch, "`kernel'", dups_r, dupsid_r, covs_drop_coll)
+	
+	*printf("i=%g\n ",C_d_l[5])
+	*printf("i=%g\n ",C_d_r[5])
+		
+		
+	if (C_d_l[1]==. | C_d_l[2]==. | C_d_l[3]==. |C_d_r[1]==. | C_d_r[2]==. | C_d_r[3]==.) printf("{err}Invertibility problem in the computation of preliminary bandwidth. Try checking for mass points with option {cmd:masspoints(check)}.\n")  
+	if (C_d_l[1]==0 | C_d_l[2]==0 | C_d_r[1]==0 | C_d_r[2]==0)                            printf("{err}Not enough variability to compute the preliminary bandwidth. Try checking for mass points with option {cmd:masspoints(check)}.\n")  
+	
+
+		
+	*** TWO
+	if  ("`bwselect'"=="msetwo" |  "`bwselect'"=="certwo" | "`bwselect'"=="msecomb2" | "`bwselect'"=="cercomb2"  | "`all'"!="")  {		
+		d_bw_l = (  (C_d_l[1]              /   C_d_l[2]^2)    * (N/mN)         )^C_d_l[4] 
+		d_bw_r = (  (C_d_r[1]              /   C_d_r[2]^2)    * (N/mN)         )^C_d_l[4]
+		if  ("`bwrestrict'"=="on")  {		
+		d_bw_l = min((d_bw_l, range_l))
+		d_bw_r = min((d_bw_r, range_r))
+		}
+		if (bwcheck > 0) {
+			d_bw_l = max((d_bw_l, bw_min_l))
+			d_bw_r = max((d_bw_r, bw_min_r))
+		}
+		C_b_l  = rdrobust_bw(Y_l, X_l, T_l, Z_l, C_l, fw_l, c=c, o=q, nu=p+1, o_B=q+1, h_V=c_bw_l, h_B=d_bw_l, `scaleregul', "`vce_select'", nnmatch, "`kernel'", dups_l, dupsid_l, covs_drop_coll)
+		b_bw_l = (  (C_b_l[1]              /   (C_b_l[2]^2 + `scaleregul'*C_b_l[3]))  * (N/mN)     )^C_b_l[4]
+		C_b_r  = rdrobust_bw(Y_r, X_r, T_r, Z_r, C_r, fw_r, c=c, o=q, nu=p+1, o_B=q+1, h_V=c_bw_r, h_B=d_bw_r, `scaleregul', "`vce_select'", nnmatch, "`kernel'", dups_r, dupsid_r, covs_drop_coll)
+		b_bw_r = (  (C_b_r[1]              /   (C_b_r[2]^2 + `scaleregul'*C_b_r[3]))   * (N/mN)    )^C_b_l[4]
+		if  ("`bwrestrict'"=="on")  {	
+		b_bw_l = min((b_bw_l, range_l))
+		b_bw_r = min((b_bw_r, range_r))
+		}
+		*if ("`bwcheck'" != "0") {
+		*	b_bw_l = max((b_bw_l, bw_min_l))
+		*	b_bw_r = max((b_bw_r, bw_min_r))
+		*}
+		C_h_l  = rdrobust_bw(Y_l, X_l, T_l, Z_l, C_l, fw_l, c=c, o=p, nu=`deriv', o_B=q, h_V=c_bw_l, h_B=b_bw_l, `scaleregul', "`vce_select'", nnmatch, "`kernel'", dups_l, dupsid_l, covs_drop_coll)
+		h_bw_l = (  (C_h_l[1]              /   (C_h_l[2]^2 + `scaleregul'*C_h_l[3]))  * (N/mN)       )^C_h_l[4]
+		C_h_r  = rdrobust_bw(Y_r, X_r, T_r, Z_r, C_r, fw_r, c=c, o=p, nu=`deriv', o_B=q, h_V=c_bw_r, h_B=b_bw_r, `scaleregul', "`vce_select'", nnmatch, "`kernel'", dups_r, dupsid_r, covs_drop_coll)
+		h_bw_r = (  (C_h_r[1]              /   (C_h_r[2]^2 + `scaleregul'*C_h_r[3]))  * (N/mN)       )^C_h_l[4]
+		
+		if  ("`bwrestrict'"=="on")  {	
+		h_bw_l = min((h_bw_l, range_l))
+		h_bw_r = min((h_bw_r, range_r))
+		}
+		*if ("`bwcheck'" != "0") {
+		*	h_bw_l = max((h_bw_l, bw_min_l))
+		*	h_bw_r = max((h_bw_r, bw_min_r))
+		*}		
+	}
+	
+	*** SUM
+	if  ("`bwselect'"=="msesum" | "`bwselect'"=="cersum" |  "`bwselect'"=="msecomb1" | "`bwselect'"=="msecomb2" |  "`bwselect'"=="cercomb1" | "`bwselect'"=="cercomb2"  |  "`all'"!="")  {
+		d_bw_s = ( ((C_d_l[1] + C_d_r[1])  /  (C_d_r[2] + C_d_l[2])^2)  * (N/mN)  )^C_d_l[4]
+		if  ("`bwrestrict'"=="on")  d_bw_s = min((d_bw_s, bw_max))
+		if (bwcheck > 0) d_bw_s = max((d_bw_s, bw_min_l, bw_min_r))		
+		C_b_l  = rdrobust_bw(Y_l, X_l, T_l, Z_l, C_l, fw_l, c=c, o=q, nu=p+1, o_B=q+1, h_V=c_bw_l, h_B=d_bw_s, `scaleregul', "`vce_select'", nnmatch, "`kernel'", dups_l, dupsid_l, covs_drop_coll)
+		C_b_r  = rdrobust_bw(Y_r, X_r, T_r, Z_r, C_r, fw_r, c=c, o=q, nu=p+1, o_B=q+1, h_V=c_bw_r, h_B=d_bw_s, `scaleregul', "`vce_select'", nnmatch, "`kernel'", dups_r, dupsid_r, covs_drop_coll)
+		b_bw_s = ( ((C_b_l[1] + C_b_r[1])  /  ((C_b_r[2] + C_b_l[2])^2 + `scaleregul'*(C_b_r[3]+C_b_l[3])))  * (N/mN)  )^C_b_l[4]
+		if  ("`bwrestrict'"=="on")  b_bw_s = min((b_bw_s, bw_max))
+		*if ("`bwcheck'" != "0") b_bw_s = max((b_bw_s, bw_min_l, bw_min_r))		
+		C_h_l  = rdrobust_bw(Y_l, X_l, T_l, Z_l, C_l, fw_l, c=c, o=p, nu=`deriv', o_B=q, h_V=c_bw_l, h_B=b_bw_s, `scaleregul', "`vce_select'", nnmatch, "`kernel'", dups_l, dupsid_l, covs_drop_coll)
+		C_h_r  = rdrobust_bw(Y_r, X_r, T_r, Z_r, C_r, fw_r, c=c, o=p, nu=`deriv', o_B=q, h_V=c_bw_r, h_B=b_bw_s, `scaleregul', "`vce_select'", nnmatch, "`kernel'", dups_r, dupsid_r, covs_drop_coll)
+		h_bw_s = ( ((C_h_l[1] + C_h_r[1])  /  ((C_h_r[2] + C_h_l[2])^2 + `scaleregul'*(C_h_r[3] + C_h_l[3])))  * (N/mN)  )^C_h_l[4]
+		if  ("`bwrestrict'"=="on")  h_bw_s = min((h_bw_s, bw_max))
+		*if ("`bwcheck'" != "0") h_bw_s = max((h_bw_s, bw_min_l, bw_min_r))		
+	}
+	
+	*** RD
+	if  ("`bwselect'"=="mserd" | "`bwselect'"=="cerrd" | "`bwselect'"=="msecomb1" | "`bwselect'"=="msecomb2" | "`bwselect'"=="cercomb1" | "`bwselect'"=="cercomb2" | "`bwselect'"=="" | "`all'"!="" ) {
+		d_bw_d = ( ((C_d_l[1] + C_d_r[1])  /  (C_d_r[2] - C_d_l[2])^2)  * (N/mN)   )^C_d_l[4]
+		if  ("`bwrestrict'"=="on")  d_bw_d = min((d_bw_d, bw_max))
+		if (bwcheck > 0) d_bw_d = max((d_bw_d, bw_min_l, bw_min_r))		
+		C_b_l  = rdrobust_bw(Y_l, X_l, T_l, Z_l, C_l, fw_l, c=c, o=q, nu=p+1, o_B=q+1, h_V=c_bw_l, h_B=d_bw_d, `scaleregul', "`vce_select'", nnmatch, "`kernel'", dups_l, dupsid_l, covs_drop_coll)
+		C_b_r  = rdrobust_bw(Y_r, X_r, T_r, Z_r, C_r, fw_r, c=c, o=q, nu=p+1, o_B=q+1, h_V=c_bw_r, h_B=d_bw_d, `scaleregul', "`vce_select'", nnmatch, "`kernel'", dups_r, dupsid_r, covs_drop_coll)
+		b_bw_d = ( ((C_b_l[1] + C_b_r[1])  /  ((C_b_r[2] - C_b_l[2])^2 + `scaleregul'*(C_b_r[3] + C_b_l[3])))  * (N/mN)    )^C_b_l[4]
+		if  ("`bwrestrict'"=="on")  b_bw_d = min((b_bw_d, bw_max))
+		*if ("`bwcheck'" != "0") b_bw_d = max((b_bw_d, bw_min_l, bw_min_r))		
+		C_h_l  = rdrobust_bw(Y_l, X_l, T_l, Z_l, C_l, fw_l, c=c, o=p, nu=`deriv', o_B=q, h_V=c_bw_l, h_B=b_bw_d, `scaleregul', "`vce_select'", nnmatch, "`kernel'", dups_l, dupsid_l, covs_drop_coll)
+		C_h_r  = rdrobust_bw(Y_r, X_r, T_r, Z_r, C_r, fw_r, c=c, o=p, nu=`deriv', o_B=q, h_V=c_bw_r, h_B=b_bw_d, `scaleregul', "`vce_select'", nnmatch, "`kernel'", dups_r, dupsid_r, covs_drop_coll)
+		h_bw_d = ( ((C_h_l[1] + C_h_r[1])  /  ((C_h_r[2] - C_h_l[2])^2 + `scaleregul'*(C_h_r[3] + C_h_l[3])))  * (N/mN)   )^C_h_l[4]
+		if  ("`bwrestrict'"=="on")  h_bw_d = min((h_bw_d, bw_max))
+		
+		*if ("`bwcheck'" != "0") h_bw_d = max((h_bw_d, bw_min_l, bw_min_r))		
+	}	
+	
+	
+	
+	if (C_b_l[1]==0 | C_b_l[2]==0 | C_b_r[1]==0 | C_b_r[2]==0 |C_b_l[1]==. | C_b_l[2]==. | C_b_l[3]==. | C_b_r[1]==. | C_b_r[2]==. | C_b_r[3]==.) printf("{err}Not enough variability to compute the bias bandwidth (b). Try checking for mass points with option {cmd:masspoints(check)}. \n")  
+	if (C_h_l[1]==0 | C_h_l[2]==0 | C_h_r[1]==0 | C_h_r[2]==0 |C_h_l[1]==. | C_h_l[2]==. | C_h_l[3]==. | C_h_r[1]==. | C_h_r[2]==. | C_h_r[3]==.) printf("{err}Not enough variability to compute the loc. poly. bandwidth (h). Try checking for mass points with option {cmd:masspoints(check)}.\n") 
+			
+	st_numscalar("N", N)
+	st_numscalar("N_l", N_l)
+	st_numscalar("N_r", N_r)
+	st_numscalar("x_l_min", x_sd*x_l_min)
+	st_numscalar("x_l_max", x_sd*x_l_max)
+	st_numscalar("x_r_min", x_sd*x_r_min)
+	st_numscalar("x_r_max", x_sd*x_r_max)
+	st_numscalar("masspoints_found", masspoints_found)
+	
+	if  ("`bwselect'"=="mserd" | "`bwselect'"=="cerrd" | "`bwselect'"=="msecomb1" | "`bwselect'"=="msecomb2" | "`bwselect'"=="cercomb1" | "`bwselect'"=="cercomb2" | "`bwselect'"=="" | "`all'"!="" ) {
+		h_mserd = x_sd*h_bw_d
+		b_mserd = x_sd*b_bw_d
+		st_numscalar("h_mserd", h_mserd); st_numscalar("b_mserd", b_mserd)
+	}	
+	if  ("`bwselect'"=="msesum" | "`bwselect'"=="cersum" |  "`bwselect'"=="msecomb1" | "`bwselect'"=="msecomb2" |  "`bwselect'"=="cercomb1" | "`bwselect'"=="cercomb2"  |  "`all'"!="")  {
+		h_msesum = x_sd*h_bw_s
+		b_msesum = x_sd*b_bw_s
+		st_numscalar("h_msesum", h_msesum); st_numscalar("b_msesum", b_msesum)
+		}
+	if  ("`bwselect'"=="msetwo" |  "`bwselect'"=="certwo" | "`bwselect'"=="msecomb2" | "`bwselect'"=="cercomb2"  | "`all'"!="")  {		
+		h_msetwo_l = x_sd*h_bw_l
+		h_msetwo_r = x_sd*h_bw_r
+		b_msetwo_l = x_sd*b_bw_l
+		b_msetwo_r = x_sd*b_bw_r
+		st_numscalar("h_msetwo_l", h_msetwo_l); st_numscalar("h_msetwo_r", h_msetwo_r)
+		st_numscalar("b_msetwo_l", b_msetwo_l); st_numscalar("b_msetwo_r", b_msetwo_r)
+		}
+	if  ("`bwselect'"=="msecomb1" | "`bwselect'"=="cercomb1" | "`all'"!="" ) {
+		h_msecomb1 = min((h_mserd,h_msesum))
+		b_msecomb1 = min((b_mserd,b_msesum))
+		st_numscalar("h_msecomb1", h_msecomb1);  st_numscalar("b_msecomb1", b_msecomb1) 
+		}
+	if  ("`bwselect'"=="msecomb2" | "`bwselect'"=="cercomb2" |  "`all'"!="" ) {
+		h_msecomb2_l = (sort((h_mserd,h_msesum,h_msetwo_l)',1))[2]
+		h_msecomb2_r = (sort((h_mserd,h_msesum,h_msetwo_r)',1))[2]
+		b_msecomb2_l = (sort((b_mserd,b_msesum,b_msetwo_l)',1))[2]
+		b_msecomb2_r = (sort((b_mserd,b_msesum,b_msetwo_r)',1))[2]
+		st_numscalar("h_msecomb2_l", h_msecomb2_l); st_numscalar("h_msecomb2_r", h_msecomb2_r);
+		st_numscalar("b_msecomb2_l", b_msecomb2_l); st_numscalar("b_msecomb2_r", b_msecomb2_r);
+	}
+	
+	cer_h = N^(-(`p'/((3+`p')*(3+2*`p'))))
+	if ("`cluster'"!="") cer_h = (g_l+g_r)^(-(`p'/((3+`p')*(3+2*`p'))))
+	cer_b = 1
+	
+	if  ("`bwselect'"=="cerrd" | "`all'"!="" ){
+		h_cerrd = h_mserd*cer_h
+		b_cerrd = b_mserd*cer_b
+		st_numscalar("h_cerrd", h_cerrd); st_numscalar("b_cerrd", b_cerrd)
+		}
+	if  ("`bwselect'"=="cersum" | "`all'"!="" ){
+		h_cersum = h_msesum*cer_h
+		b_cersum=  b_msesum*cer_b
+		st_numscalar("h_cersum", h_cersum); st_numscalar("b_cersum", b_cersum)
+		}
+	if  ("`bwselect'"=="certwo" | "`all'"!="" ){
+		h_certwo_l   = h_msetwo_l*cer_h
+		h_certwo_r   = h_msetwo_r*cer_h
+		b_certwo_l   = b_msetwo_l*cer_b
+		b_certwo_r   = b_msetwo_r*cer_b
+		st_numscalar("h_certwo_l", h_certwo_l); st_numscalar("h_certwo_r", h_certwo_r);
+		st_numscalar("b_certwo_l", b_certwo_l); st_numscalar("b_certwo_r", b_certwo_r);
+		}
+	if  ("`bwselect'"=="cercomb1" | "`all'"!="" ){
+		h_cercomb1 = h_msecomb1*cer_h
+		b_cercomb1 = b_msecomb1*cer_b
+		st_numscalar("h_cercomb1", h_cercomb1);	st_numscalar("b_cercomb1", b_cercomb1)
+		}
+	if  ("`bwselect'"=="cercomb2" | "`all'"!="" ){
+		h_cercomb2_l = h_msecomb2_l*cer_h
+		h_cercomb2_r = h_msecomb2_r*cer_h
+		b_cercomb2_l = b_msecomb2_l*cer_b
+		b_cercomb2_r = b_msecomb2_r*cer_b
+		st_numscalar("h_cercomb2_l", h_cercomb2_l); st_numscalar("h_cercomb2_r", h_cercomb2_r);
+		st_numscalar("b_cercomb2_l", b_cercomb2_l); st_numscalar("b_cercomb2_r", b_cercomb2_r);
+	}	
+}
+
+	*******************************************************************************
+	disp ""
+	if ("`fuzzy'"=="") {
+		if ("`covs'"=="") {
+			if      ("`deriv'"=="0") disp in yellow "Bandwidth estimators for sharp RD local polynomial regression." 
+			else if ("`deriv'"=="1") disp in yellow "Bandwidth estimators for sharp kink RD local polynomial regression."	
+			else                     disp in yellow "Bandwidth estimators for sharp RD local polynomial regression. Derivative of order " `deriv' "."	
+		}
+		else {
+			if      ("`deriv'"=="0") disp in yellow "Bandwidth estimators for covariate-adjusted sharp RD local polynomial regression." 
+			else if ("`deriv'"=="1") disp in yellow "Bandwidth estimators for covariate-adjusted sharp kink RD local polynomial regression."	
+			else                     disp in yellow "Bandwidth estimators for covariate-adjusted sharp RD local polynomial regression. Derivative of order " `deriv' "."	
+		}
+	}
+	else {
+		if ("`covs'"=="") {
+			if      ("`deriv'"=="0") disp in yellow "Bandwidth estimators for fuzzy RD local polynomial regression." 
+			else if ("`deriv'"=="1") disp in yellow "Bandwidth estimators for fuzzy kink RD local polynomial regression."	
+			else                     disp in yellow "Bandwidth estimators for fuzzy RD local polynomial regression. Derivative of order " `deriv' "."	
+		}
+		else {
+			if      ("`deriv'"=="0") disp in yellow "Bandwidth estimators for covariate-adjusted fuzzy RD local polynomial regression." 
+			else if ("`deriv'"=="1") disp in yellow "Bandwidth estimators for covariate-adjusted fuzzy kink RD local polynomial regression."	
+			else                     disp in yellow "Bandwidth estimators for covariate-adjusted fuzzy RD local polynomial regression. Derivative of order " `deriv' "."	
+		}
+	}
+	disp ""
+
+	disp in smcl in gr "{ralign 18: Cutoff c = `c_orig'}"  _col(19) " {c |} " _col(21) in gr "Left of " in yellow "c"  _col(33) in gr "Right of " in yellow "c" _col(55) in gr "Number of obs = "  in yellow %10.0f scalar(N)
+	disp in smcl in gr "{hline 19}{c +}{hline 22}"                                                                                                              _col(55) in gr "Kernel        = "  in yellow "{ralign 10:`kernel_type'}" 
+	disp in smcl in gr "{ralign 18:Number of obs}"         _col(19) " {c |} " _col(21) as result %9.0f scalar(N_l)      _col(34) %9.0f  scalar(N_r)                         _col(55) in gr "VCE method    = "  in yellow "{ralign 10:`vce_type'}" 
+	disp in smcl in gr "{ralign 18:Min of `x'}"            _col(19) " {c |} " _col(21) as result %9.3f scalar(x_l_min)  _col(34) %9.3f  scalar(x_r_min)  
+	disp in smcl in gr "{ralign 18:Max of `x'}"            _col(19) " {c |} " _col(21) as result %9.3f scalar(x_l_max)  _col(34) %9.3f  scalar(x_r_max)  
+	disp in smcl in gr "{ralign 18:Order est. (p)}"        _col(19) " {c |} " _col(21) as result %9.0f `p'        _col(34) %9.0f  `p'                              
+	disp in smcl in gr "{ralign 18:Order bias (q)}"        _col(19) " {c |} " _col(21) as result %9.0f `q'        _col(34) %9.0f  `q'  
+	if ("`masspoints'"=="check" | masspoints_found==1) disp in smcl in gr "{ralign 18:Unique obs}"     _col(19) " {c |} " _col(21) as result %9.0f scalar(M_l)           _col(34) %9.0f  scalar(M_r)                    
+	if ("`cluster'"!="") disp in smcl in gr "{ralign 18:Number of clusters}" _col(19) " {c |} " _col(21) as result %9.0f scalar(g_l)       _col(34) %9.0f  scalar(g_r)                         
+				
+			
+	disp ""
+	if ("`fuzzy'"=="") disp           "Outcome: `y'. Running variable: `x'."
+	else               disp in yellow "Outcome: `y'. Running variable: `x'. Treatment Status: `fuzzyvar'."	
+	disp in smcl in gr "{hline 19}{c TT}{hline 30}{c TT}{hline 29}"
+	disp in smcl in gr _col(19) " {c |} "             _col(30) "BW est. (h)"    _col(50) " {c |} " _col(60) "BW bias (b)"  
+	disp in smcl in gr "{ralign 18:Method}"        _col(19) " {c |} " _col(22) "Left of " in yellow "c" _col(40) in green "Right of " in yellow "c"  in green _col(50) " {c |} " _col(53)  "Left of " in yellow "c" _col(70) in green "Right of " in yellow "c" 
+	disp in smcl in gr "{hline 19}{c +}{hline 30}{c +}{hline 29}" 
+		
+	if  ("`bwselect'"=="mserd" | "`bwselect'"=="" | "`all'"!="" ) {
+		disp in smcl in gr "{ralign 18:mserd}"    _col(19) " {c |} " _col(22) as result %9.3f scalar(h_mserd)  _col(41) %9.3f  scalar(h_mserd)  in green _col(50) " {c |} " _col(51) as result %9.3f scalar(b_mserd)  _col(71) %9.3f  scalar(b_mserd)                                
+	}
+	if  ("`bwselect'"=="msetwo"  | "`all'"!="")  {		
+		disp in smcl in gr "{ralign 18:msetwo}"   _col(19) " {c |} " _col(22) as result %9.3f scalar(h_msetwo_l) _col(41) %9.3f  scalar(h_msetwo_r) in green _col(50) " {c |} " _col(51) as result %9.3f scalar(b_msetwo_l)           _col(71) %9.3f  scalar(b_msetwo_r)                                
+	}
+	if  ("`bwselect'"=="msesum"  |  "`all'"!="")  {
+		disp in smcl in gr "{ralign 18:msesum}"   _col(19) " {c |} " _col(22) as result %9.3f scalar(h_msesum) _col(41) %9.3f  scalar(h_msesum)  in green _col(50) " {c |} " _col(51) as result %9.3f scalar(b_msesum)           _col(71) %9.3f  scalar(b_msesum)                             
+	}
+	if  ("`bwselect'"=="msecomb1" | "`all'"!="" ) {
+		disp in smcl in gr "{ralign 18:msecomb1}" _col(19) " {c |} " _col(22) as result %9.3f scalar(h_msecomb1) _col(41) %9.3f  scalar(h_msecomb1) in green _col(50) " {c |} " _col(51) as result %9.3f scalar(b_msecomb1)           _col(71) %9.3f  scalar(b_msecomb1)                                 
+	}
+	if  ("`bwselect'"=="msecomb2" |  "`all'"!="" ) {
+		disp in smcl in gr "{ralign 18:msecomb2}" _col(19) " {c |} " _col(22) as result %9.3f scalar(h_msecomb2_l) _col(41) %9.3f  scalar(h_msecomb2_r) in green _col(50) " {c |} " _col(51) as result %9.3f scalar(b_msecomb2_l)           _col(71) %9.3f  scalar(b_msecomb2_r)                                  
+	}
+	if  ("`all'"!="" ) disp in smcl in gr "{hline 19}{c +}{hline 30}{c +}{hline 29}"
+	if  ("`bwselect'"=="cerrd" | "`all'"!="" ){
+		disp in smcl in gr "{ralign 18:cerrd}"    _col(19) " {c |} " _col(22) as result %9.3f scalar(h_cerrd) _col(41) %9.3f  scalar(h_cerrd) in green _col(50) " {c |} " _col(51) as result %9.3f scalar(b_cerrd)           _col(71) %9.3f  scalar(b_cerrd)                                
+	}
+	if  ("`bwselect'"=="certwo" | "`all'"!="" ){
+		disp in smcl in gr "{ralign 18:certwo}"   _col(19) " {c |} " _col(22) as result %9.3f scalar(h_certwo_l) _col(41) %9.3f  scalar(h_certwo_r) in green _col(50) " {c |} " _col(51) as result %9.3f scalar(b_certwo_l)           _col(71) %9.3f  scalar(b_certwo_r)                                
+	}
+	if  ("`bwselect'"=="cersum" | "`all'"!="" ){
+		disp in smcl in gr "{ralign 18:cersum}"   _col(19) " {c |} " _col(22) as result %9.3f scalar(h_cersum) _col(41) %9.3f  scalar(h_cersum) in green _col(50) " {c |} " _col(51) as result %9.3f scalar(b_cersum)           _col(71) %9.3f  scalar(b_cersum)                                
+	}
+	if  ("`bwselect'"=="cercomb1" | "`all'"!="" ){
+		disp in smcl in gr "{ralign 18:cercomb1}" _col(19) " {c |} " _col(22) as result %9.3f scalar(h_cercomb1) _col(41) %9.3f  scalar(h_cercomb1) in green _col(50) " {c |} " _col(51) as result %9.3f scalar(b_cercomb1)           _col(71) %9.3f  scalar(b_cercomb1)                              
+	}
+	if  ("`bwselect'"=="cercomb2" | "`all'"!="" ){
+		disp in smcl in gr "{ralign 18:cercomb2}" _col(19) " {c |} " _col(22) as result %9.3f scalar(h_cercomb2_l) _col(41) %9.3f  scalar(h_cercomb2_r) in green _col(50) " {c |} " _col(51) as result %9.3f scalar(b_cercomb2_l)           _col(71) %9.3f  scalar(b_cercomb2_r)                              
+	}
+	disp in smcl in gr "{hline 19}{c BT}{hline 30}{c BT}{hline 29}" 
+   	if ("`covs'"!="")        di "Covariate-adjusted estimates. Additional covariates included: `ncovs'"
+*	if (`covs_drop_coll'>=1) di "Variables dropped due to multicollinearity."
+	if ("`masspoints'"=="check")  di "Running variable checked for mass points."  
+	if ("`masspoints'"=="adjust" &  masspoints_found==1) di "Estimates adjusted for mass points in the running variable."  	 	
+
+	if ("`cluster'"!="")     di "Std. Err. adjusted for clusters in " "`clustvar'"
+	if ("`scaleregul'"!="1") di "Scale regularization: " `scaleregul'
+	if ("`sharpbw'"~="")   	 di in red "WARNING: bandwidths automatically computed for sharp RD estimation."
+	if ("`perf_comp'"~="")   di in red "WARNING: bandwidths automatically computed for sharp RD estimation because perfect compliance was detected on at least one side of the threshold."
+
+	restore
+	ereturn clear
+	ereturn scalar N_l = scalar(N_l)
+	ereturn scalar N_r = scalar(N_r)
+	ereturn scalar c = `c'
+	ereturn scalar p = `p'
+	ereturn scalar q = `q'
+	ereturn local kernel = "`kernel_type'"
+	ereturn local bwselect = "`bwselect'"
+	ereturn local vce_select = "`vce_type'"
+	if ("`covs'"!="")    ereturn local covs "`covs'"
+	if ("`cluster'"!="") ereturn local clustvar "`clustvar'"
+	ereturn local outcomevar "`y'"
+	ereturn local runningvar "`x'"
+	ereturn local depvar "`y'"
+	ereturn local cmd "rdbwselect"
+
+	if  ("`bwselect'"=="mserd" | "`bwselect'"=="" | "`all'"!="" ) {
+		ereturn scalar h_mserd = scalar(h_mserd)
+		ereturn scalar b_mserd = scalar(b_mserd)
+		}
+	if  ("`bwselect'"=="msesum"  |  "`all'"!="")  {
+		ereturn scalar h_msesum = scalar(h_msesum)
+		ereturn scalar b_msesum = scalar(b_msesum)
+		}
+	if  ("`bwselect'"=="msetwo"  | "`all'"!="")  {	
+		ereturn scalar h_msetwo_l = scalar(h_msetwo_l)
+		ereturn scalar h_msetwo_r = scalar(h_msetwo_r)
+		ereturn scalar b_msetwo_l = scalar(b_msetwo_l)
+		ereturn scalar b_msetwo_r = scalar(b_msetwo_r)
+		}
+	if  ("`bwselect'"=="msecomb1" | "`all'"!="" ) {
+		ereturn scalar h_msecomb1 = scalar(h_msecomb1)
+		ereturn scalar b_msecomb1 = scalar(b_msecomb1)
+		}
+	if  ("`bwselect'"=="msecomb2" | "`all'"!="" ) {
+		ereturn scalar h_msecomb2_l = scalar(h_msecomb2_l)
+		ereturn scalar h_msecomb2_r = scalar(h_msecomb2_r)
+		ereturn scalar b_msecomb2_l = scalar(b_msecomb2_l)
+		ereturn scalar b_msecomb2_r = scalar(b_msecomb2_r)
+		}
+	if  ("`bwselect'"=="cerrd" | "`all'"!="") {
+		ereturn scalar h_cerrd = scalar(h_cerrd)
+		ereturn scalar b_cerrd = scalar(b_cerrd)
+		}
+	if  ("`bwselect'"=="cersum" | "`all'"!="") {
+		ereturn scalar h_cersum = scalar(h_cersum)
+		ereturn scalar b_cersum = scalar(b_cersum)
+		}
+	if  ("`bwselect'"=="certwo" | "`all'"!="") {
+		ereturn scalar h_certwo_l = scalar(h_certwo_l)
+		ereturn scalar h_certwo_r = scalar(h_certwo_r)
+		ereturn scalar b_certwo_l = scalar(b_certwo_l)
+		ereturn scalar b_certwo_r = scalar(b_certwo_r)
+		}
+	if  ("`bwselect'"=="cercomb1" | "`all'"!="") {
+		ereturn scalar h_cercomb1 = scalar(h_cercomb1)
+		ereturn scalar b_cercomb1 = scalar(b_cercomb1)
+		}
+	if  ("`bwselect'"=="cercomb2" | "`all'"!="") { 
+		ereturn scalar h_cercomb2_l = scalar(h_cercomb2_l)
+		ereturn scalar h_cercomb2_r = scalar(h_cercomb2_r)
+		ereturn scalar b_cercomb2_l = scalar(b_cercomb2_l)
+		ereturn scalar b_cercomb2_r = scalar(b_cercomb2_r)
+	}
+	
+	mata mata clear 
+
+end

30/replication_package/Adofiles/rd_2021/rdbwselect.sthlp

@@ -0,0 +1,275 @@
+{smcl}
+{* *!version 8.1.0  2021-02-22}{...}
+{viewerjumpto "Syntax" "rdbwselect##syntax"}{...}
+{viewerjumpto "Description" "rdbwselect##description"}{...}
+{viewerjumpto "Options" "rdbwselect##options"}{...}
+{viewerjumpto "Examples" "rdbwselect##examples"}{...}
+{viewerjumpto "Stored results" "rdbwselect##stored_results"}{...}
+{viewerjumpto "References" "rdbwselect##references"}{...}
+{viewerjumpto "Authors" "rdbwselect##authors"}{...}
+
+{title:Title}
+
+{p 4 8}{cmd:rdbwselect} {hline 2} Bandwidth Selection Procedures for Local Polynomial Regression Discontinuity Estimators.{p_end}
+
+{marker syntax}{...}
+{title:Syntax}
+
+{p 4 8}{cmd:rdbwselect } {it:depvar} {it:indepvar} {ifin} 
+[{cmd:,} 
+{cmd:c(}{it:#}{cmd:)} 
+{cmd:fuzzy(}{it:fuzzyvar [sharpbw]}{cmd:)}
+{cmd:deriv(}{it:#}{cmd:)}
+{cmd:p(}{it:#}{cmd:)}  
+{cmd:q(}{it:#}{cmd:)}
+{cmd:covs(}{it:covars}{cmd:)}
+{cmd:covs_drop(}{it:covsdropoption}{cmd:)}
+{cmd:kernel(}{it:kernelfn}{cmd:)}
+{cmd:weights(}{it:weightsvar}{cmd:)}
+{cmd:bwselect(}{it:bwmethod}{cmd:)}
+{cmd:all}
+{cmd:scaleregul(}{it:#}{cmd:)}
+{cmd:masspoints(}{it:masspointsoption}{cmd:)}
+{cmd:bwcheck(}{it:bwcheck}{cmd:)}
+{cmd:bwrestrict(}{it:bwropt}{cmd:)}
+{cmd:stdvars(}{it:stdopt}{cmd:)}
+{cmd:vce(}{it:vcetype [vceopt1 vceopt2]}{cmd:)}
+]{p_end}
+
+{synoptset 28 tabbed}{...}
+
+{marker description}{...}
+{title:Description}
+
+{p 4 8}{cmd:rdbwselect} implements bandwidth selectors for local polynomial Regression Discontinuity (RD) point estimators and inference procedures developed in
+{browse "https://rdpackages.github.io/references/Calonico-Cattaneo-Titiunik_2014_ECMA.pdf":Calonico, Cattaneo and Titiunik (2014a)},
+{browse "https://rdpackages.github.io/references/Calonico-Cattaneo-Farrell_2018_JASA.pdf":Calonico, Cattaneo and Farrell (2018)},
+{browse "https://rdpackages.github.io/references/Calonico-Cattaneo-Farrell-Titiunik_2019_RESTAT.pdf":Calonico, Cattaneo, Farrell and Titiunik (2019)},
+and {browse "https://rdpackages.github.io/references/Calonico-Cattaneo-Farrell_2020_ECTJ.pdf":Calonico, Cattaneo and Farrell (2020)}.{p_end}
+
+{p 8 8} Companion commands are: {help rdrobust:rdrobust} for point estimation and inference procedures, and {help rdplot:rdplot} for data-driven RD plots (see
+{browse "https://rdpackages.github.io/references/Calonico-Cattaneo-Titiunik_2015_JASA.pdf":Calonico, Cattaneo and Titiunik (2015a)} for details).{p_end}
+
+{p 8 8}A detailed introduction to this command is given in
+{browse "https://rdpackages.github.io/references/Calonico-Cattaneo-Titiunik_2014_Stata.pdf":Calonico, Cattaneo and Titiunik (2014b)},
+and {browse "https://rdpackages.github.io/references/Calonico-Cattaneo-Farrell-Titiunik_2017_Stata.pdf":Calonico, Cattaneo, Farrell and Titiunik (2017)}. A companion {browse "www.r-project.org":R} package is also described in
+{browse "https://rdpackages.github.io/references/Calonico-Cattaneo-Titiunik_2015_R.pdf":Calonico, Cattaneo and Titiunik (2015b)}.{p_end}
+
+{p 4 8}Related Stata and R packages useful for inference in RD designs are described in the following website:{p_end}
+
+{p 8 8}{browse "https://rdpackages.github.io/":https://rdpackages.github.io/}{p_end}
+
+
+{marker options}{...}
+{title:Options}
+
+{dlgtab:Estimand}
+
+{p 4 8}{cmd:c(}{it:#}{cmd:)} specifies the RD cutoff for {it:indepvar}.
+Default is {cmd:c(0)}.{p_end}
+
+{p 4 8}{cmd:fuzzy(}{it:fuzzyvar [sharpbw]}{cmd:)} specifies the treatment status variable used to implement fuzzy RD estimation (or Fuzzy Kink RD if {cmd:deriv(1)} is also specified).
+Default is Sharp RD design and hence this option is not used.
+If the option {it:sharpbw} is set, the fuzzy RD estimation is performed using a bandwidth selection procedure for the sharp RD model. This option is automatically selected if there is perfect compliance at either side of the threshold.
+{p_end}
+
+{p 4 8}{cmd:deriv(}{it:#}{cmd:)} specifies the order of the derivative of the regression functions to be estimated.
+Default is {cmd:deriv(0)} (for Sharp RD, or for Fuzzy RD if {cmd:fuzzy(.)} is also specified). Setting {cmd:deriv(1)} results in estimation of a Kink RD design (up to scale), or Fuzzy Kink RD if {cmd:fuzzy(.)} is also specified.{p_end}
+
+{dlgtab:Local Polynomial Regression}
+
+{p 4 8}{cmd:p(}{it:#}{cmd:)} specifies the order of the local polynomial used to construct the point estimator.
+Default is {cmd:p(1)} (local linear regression).{p_end}
+
+{p 4 8}{cmd:q(}{it:#}{cmd:)} specifies the order of the local polynomial used to construct the bias correction.
+Default is {cmd:q(2)} (local quadratic regression).{p_end}
+
+{p 4 8}{cmd:covs(}{it:covars}{cmd:)} specifies additional covariates to be used for estimation and inference.{p_end}
+
+{p 4 8}{cmd:covs_drop(}{it:covsdropoption}{cmd:)} assess collinearity in additional covariates used for estimation and inference. Options {opt pinv} (default choice) and {opt invsym} drops collinear additional covariates, differing only in the type of inverse function used. Option {opt off} only checks collinear additional covariates but does not drop them.{p_end}
+
+{p 4 8}{cmd:kernel(}{it:kernelfn}{cmd:)} specifies the kernel function used to construct the local-polynomial estimator(s). Options are: {opt tri:angular}, {opt epa:nechnikov}, and {opt uni:form}.
+Default is {cmd:kernel(triangular)}.{p_end}
+
+{p 4 8}{cmd:weights(}{it:weightsvar}{cmd:)} is the variable used for optional weighting of the estimation procedure. The unit-specific weights multiply the kernel function.{p_end}
+
+{dlgtab:Bandwidth Selection}
+
+{p 4 8}{cmd:bwselect(}{it:bwmethod}{cmd:)} specifies the bandwidth selection procedure to be used. 
+Options are:{p_end}
+{p 8 12}{opt mserd} one common MSE-optimal bandwidth selector for the RD treatment effect estimator.{p_end}
+{p 8 12}{opt msetwo} two different MSE-optimal bandwidth selectors (below and above the cutoff) for the RD treatment effect estimator.{p_end}
+{p 8 12}{opt msesum} one common MSE-optimal bandwidth selector for the sum of regression estimates (as opposed to difference thereof).{p_end}
+{p 8 12}{opt msecomb1} for min({opt mserd},{opt msesum}).{p_end}
+{p 8 12}{opt msecomb2} for median({opt msetwo},{opt mserd},{opt msesum}), for each side of the cutoff separately.{p_end}
+{p 8 12}{opt cerrd} one common CER-optimal bandwidth selector for the RD treatment effect estimator.{p_end}
+{p 8 12}{opt certwo} two different CER-optimal bandwidth selectors (below and above the cutoff) for the RD treatment effect estimator.{p_end}
+{p 8 12}{opt cersum} one common CER-optimal bandwidth selector for the sum of regression estimates (as opposed to difference thereof).{p_end}
+{p 8 12}{opt cercomb1} for min({opt cerrd},{opt cersum}).{p_end}
+{p 8 12}{opt cercomb2} for median({opt certwo},{opt cerrd},{opt cersum}), for each side of the cutoff separately.{p_end}
+{p 8 12}Note: MSE = Mean Square Error; CER = Coverage Error Rate.{p_end}
+{p 8 12}Default is {cmd:bwselect(mserd)}. For details on implementation see
+{browse "https://rdpackages.github.io/references/Calonico-Cattaneo-Titiunik_2014_ECMA.pdf":Calonico, Cattaneo and Titiunik (2014a)},
+{browse "https://rdpackages.github.io/references/Calonico-Cattaneo-Farrell_2018_JASA.pdf":Calonico, Cattaneo and Farrell (2018)},
+{browse "https://rdpackages.github.io/references/Calonico-Cattaneo-Farrell-Titiunik_2019_RESTAT.pdf":Calonico, Cattaneo, Farrell and Titiunik (2019)}, 
+and {browse "https://rdpackages.github.io/references/Calonico-Cattaneo-Farrell_2020_ECTJ.pdf":Calonico, Cattaneo and Farrell (2020)},
+and the companion software articles.{p_end}
+
+{p 4 8}{cmd:all} if specified, {cmd:rdbwselect} reports all available bandwidth selection procedures.{p_end}
+
+{p 4 8}{cmd:scaleregul(}{it:#}{cmd:)} specifies scaling factor for the regularization term added to the denominator of the bandwidth selectors. Setting {cmd:scaleregul(0)} removes the regularization term from the bandwidth selectors.
+Default is {cmd:scaleregul(1)}.{p_end}
+
+{p 4 8}{cmd:masspoints(}{it:masspointsoption}{cmd:)} checks and controls for repeated observations in the running variable. 
+Options are:{p_end}
+{p 8 12}{opt off}  ignores the presence of mass points. {p_end}
+{p 8 12}{opt check}  looks for and reports the number of unique observations at each side of the cutoff.   {p_end}
+{p 8 12}{opt adjust}  controls that the preliminary bandwidths used in the calculations contain a minimal number of unique observations. By default it uses 10 observations, but it can be manually adjusted with the option {cmd:bwcheck}.{p_end}
+{p 8 12} Default option is {cmd:masspoints(adjust)}.{p_end}
+
+{p 4 8}{cmd:bwcheck(}{it:bwcheck}{cmd:)} if a positive integer is provided, the preliminary bandwidth used in the calculations is enlarged so that at least {it:bwcheck} unique observations are used. {p_end}
+
+{p 4 8}{cmd:bwrestrict(}{it:bwropt}{cmd:)} if set {opt on}, computed bandwidths are restricted to lie within the range of {it:runvar}. Default is {opt on}.{p_end}
+
+{p 4 8}{cmd:stdvars(}{it:stdopt}{cmd:)} if set {opt on}, {it:depvar} and {it:runvar} are standardized before computing the bandwidths. Default is {opt off}.{p_end}
+
+{dlgtab:Variance-Covariance Estimation}
+
+{p 4 8}{cmd:vce(}{it:vcetype [vceopt1 vceopt2]}{cmd:)} specifies the procedure used to compute the variance-covariance matrix estimator.
+Options are:{p_end}
+{p 8 12}{cmd:vce(nn }{it:[nnmatch]}{cmd:)} for heteroskedasticity-robust nearest neighbor variance estimator with {it:nnmatch} indicating the minimum number of neighbors to be used.{p_end}
+{p 8 12}{cmd:vce(hc0)} for heteroskedasticity-robust plug-in residuals variance estimator without weights.{p_end}
+{p 8 12}{cmd:vce(hc1)} for heteroskedasticity-robust plug-in residuals variance estimator with {it:hc1} weights.{p_end}
+{p 8 12}{cmd:vce(hc2)} for heteroskedasticity-robust plug-in residuals variance estimator with {it:hc2} weights.{p_end}
+{p 8 12}{cmd:vce(hc3)} for heteroskedasticity-robust plug-in residuals variance estimator with {it:hc3} weights.{p_end}
+{p 8 12}{cmd:vce(nncluster }{it:clustervar [nnmatch]}{cmd:)} for cluster-robust nearest neighbor variance estimation using with {it:clustervar} indicating the cluster ID variable and {it: nnmatch} matches indicating the minimum number of neighbors to be used.{p_end}
+{p 8 12}{cmd:vce(cluster }{it:clustervar}{cmd:)} for cluster-robust plug-in residuals variance estimation with degrees-of-freedom weights and {it:clustervar} indicating the cluster ID variable.{p_end}
+{p 8 12}Default is {cmd:vce(nn 3)}.{p_end}
+
+    {hline}
+
+
+{marker examples}{...}
+{title:Example: Cattaneo, Frandsen and Titiunik (2015) Incumbency Data}
+
+    
+{p 4 8}Setup{p_end}
+{p 8 8}{cmd:. use rdrobust_senate.dta}{p_end}
+
+{p 4 8}MSE bandwidth selection procedure{p_end}
+{p 8 8}{cmd:. rdbwselect vote margin}{p_end}
+
+{p 4 8}All bandwidth bandwidth selection procedures{p_end}
+{p 8 8}{cmd:. rdbwselect vote margin, all}{p_end}
+
+
+{marker stored_results}{...}
+{title:Stored results}
+
+{p 4 8}{cmd:rdbwselect} stores the following in {cmd:e()}:
+
+{synoptset 20 tabbed}{...}
+{p2col 5 20 24 2: Scalars}{p_end}
+{synopt:{cmd:e(N_l)}}number of observations to the left of the cutoff{p_end}
+{synopt:{cmd:e(N_r)}}number of observations to the right of the cutoff{p_end}
+{synopt:{cmd:e(c)}}cutoff value{p_end}
+{synopt:{cmd:e(p)}}order of the polynomial used for estimation of the regression function{p_end}
+{synopt:{cmd:e(q)}}order of the polynomial used for estimation of the bias of the regression function estimator{p_end}
+
+{synopt:{cmd:e(h_mserd)}}     MSE-optimal bandwidth selector for the RD treatment effect estimator.{p_end}
+{synopt:{cmd:e(h_msetwo_l)}}  MSE-optimal bandwidth selectors below the cutoff for the RD treatment effect estimator.{p_end}
+{synopt:{cmd:e(h_msetwo_r)}}  MSE-optimal bandwidth selectors above the cutoff for the RD treatment effect estimator.{p_end}
+{synopt:{cmd:e(h_msesum)}}    MSE-optimal bandwidth selector for the sum of regression estimates.{p_end}
+{synopt:{cmd:e(h_msecomb1)}}   for min({opt mserd},{opt msesum}).{p_end}
+{synopt:{cmd:e(h_msecomb2_l)}} for median({opt msetwo},{opt mserd},{opt msesum}), below the cutoff.{p_end}
+{synopt:{cmd:e(h_msecomb2_r)}} for median({opt msetwo},{opt mserd},{opt msesum}), above the cutoff.{p_end}
+
+{synopt:{cmd:e(h_cerrd)}}     CER-optimal bandwidth selector for the RD treatment effect estimator.{p_end}
+{synopt:{cmd:e(h_certwo_l)}}  CER-optimal bandwidth selectors below the cutoff for the RD treatment effect estimator.{p_end}
+{synopt:{cmd:e(h_certwo_r)}}  CER-optimal bandwidth selectors above the cutoff for the RD treatment effect estimator.{p_end}
+{synopt:{cmd:e(h_cersum)}}    CER-optimal bandwidth selector for the sum of regression estimates.{p_end}
+{synopt:{cmd:e(h_cercomb1)}}   for min({opt cerrd},{opt cersum}).{p_end}
+{synopt:{cmd:e(h_cercomb2_l)}} for median({opt certwo_l},{opt cerrd},{opt cersum}), below the cutoff.{p_end}
+{synopt:{cmd:e(h_cercomb2_r)}} for median({opt certwo_r},{opt cerrd},{opt cersum}), above the cutoff.{p_end}
+
+{synopt:{cmd:e(b_mserd)}}     MSE-optimal bandwidth selector for the bias of the RD treatment effect estimator.{p_end}
+{synopt:{cmd:e(b_msetwo_l)}}  MSE-optimal bandwidth selectors below the cutoff for the bias of the RD treatment effect estimator.{p_end}
+{synopt:{cmd:e(b_msetwo_r)}}  MSE-optimal bandwidth selectors above the cutoff for the bias of the RD treatment effect estimator.{p_end}
+{synopt:{cmd:e(b_msesum)}}    MSE-optimal bandwidth selector for the sum of regression estimates for the bias of the RD treatment effect estimator.{p_end}
+{synopt:{cmd:e(b_msecomb1)}}   for min({opt mserd},{opt msesum}).{p_end}
+{synopt:{cmd:e(b_msecomb2_l)}} for median({opt msetwo},{opt mserd},{opt msesum}), below the cutoff.{p_end}
+{synopt:{cmd:e(b_msecomb2_r)}} for median({opt msetwo},{opt mserd},{opt msesum}), above the cutoff.{p_end}
+
+{synopt:{cmd:e(b_cerrd)}}     CER-optimal bandwidth selector for the bias of the RD treatment effect estimator.{p_end}
+{synopt:{cmd:e(b_certwo_l)}}  CER-optimal bandwidth selectors below the cutoff for the bias of the RD treatment effect estimator.{p_end}
+{synopt:{cmd:e(b_certwo_r)}}  CER-optimal bandwidth selectors above the cutoff for the bias of the RD treatment effect estimator.{p_end}
+{synopt:{cmd:e(b_cersum)}}    CER-optimal bandwidth selector for the sum of regression estimates for the bias of the RD treatment effect estimator.{p_end}
+{synopt:{cmd:e(b_cercomb1)}}   for min({opt cerrd},{opt cersum}).{p_end}
+{synopt:{cmd:e(b_cercomb2_l)}} for median({opt certwo_l},{opt cerrd},{opt cersum}), below the cutoff.{p_end}
+{synopt:{cmd:e(b_cercomb2_r)}} for median({opt certwo_r},{opt cerrd},{opt cersum}), above the cutoff.{p_end}
+
+{p2col 5 20 24 2: Macros}{p_end}
+{synopt:{cmd:e(runningvar)}}name of running variable{p_end}
+{synopt:{cmd:e(outcomevar)}}name of outcome variable{p_end}
+{synopt:{cmd:e(clustvar)}}name of cluster variable{p_end}
+{synopt:{cmd:e(covs)}}name of covariates{p_end}
+{synopt:{cmd:e(vce_select)}}vcetype specified in vce(){p_end}
+{synopt:{cmd:e(bwselect)}}bandwidth selection choice{p_end}
+{synopt:{cmd:e(kernel)}}kernel choice{p_end}
+
+
+{marker references}{...}
+{title:References}
+
+{p 4 8}Calonico, S., M. D. Cattaneo, and M. H. Farrell. 2020.
+{browse "https://rdpackages.github.io/references/Calonico-Cattaneo-Farrell_2020_ECTJ.pdf":Optimal Bandwidth Choice for Robust Bias Corrected Inference in Regression Discontinuity Designs}.
+{it:Econometrics Journal} 23(2): 192-210.{p_end}
+
+{p 4 8}Calonico, S., M. D. Cattaneo, and M. H. Farrell. 2018.
+{browse "https://rdpackages.github.io/references/Calonico-Cattaneo-Farrell_2018_JASA.pdf":On the Effect of Bias Estimation on Coverage Accuracy in Nonparametric Inference}.
+{it:Journal of the American Statistical Association} 113(522): 767-779.{p_end}
+
+{p 4 8}Calonico, S., M. D. Cattaneo, M. H. Farrell, and R. Titiunik. 2019.
+{browse "https://rdpackages.github.io/references/Calonico-Cattaneo-Farrell-Titiunik_2019_RESTAT.pdf":Regression Discontinuity Designs using Covariates}.
+{it:Review of Economics and Statistics}, 101(3): 442-451.{p_end}
+
+{p 4 8}Calonico, S., M. D. Cattaneo, M. H. Farrell, and R. Titiunik. 2017.
+{browse "https://rdpackages.github.io/references/Calonico-Cattaneo-Farrell-Titiunik_2017_Stata.pdf":rdrobust: Software for Regression Discontinuity Designs}.
+{it:Stata Journal} 17(2): 372-404.{p_end}
+
+{p 4 8}Calonico, S., M. D. Cattaneo, and R. Titiunik. 2014a.
+{browse "https://rdpackages.github.io/references/Calonico-Cattaneo-Titiunik_2014_ECMA.pdf":Robust Nonparametric Confidence Intervals for Regression-Discontinuity Designs}.
+{it:Econometrica} 82(6): 2295-2326.{p_end}
+
+{p 4 8}Calonico, S., M. D. Cattaneo, and R. Titiunik. 2014b.
+{browse "https://rdpackages.github.io/references/Calonico-Cattaneo-Titiunik_2014_Stata.pdf":Robust Data-Driven Inference in the Regression-Discontinuity Design}.
+{it:Stata Journal} 14(4): 909-946.{p_end}
+
+{p 4 8}Calonico, S., M. D. Cattaneo, and R. Titiunik. 2015a.
+{browse "https://rdpackages.github.io/references/Calonico-Cattaneo-Titiunik_2015_JASA.pdf":Optimal Data-Driven Regression Discontinuity Plots}.
+{it:Journal of the American Statistical Association} 110(512): 1753-1769.{p_end}
+
+{p 4 8}Calonico, S., M. D. Cattaneo, and R. Titiunik. 2015b.
+{browse "https://rdpackages.github.io/references/Calonico-Cattaneo-Titiunik_2015_R.pdf":rdrobust: An R Package for Robust Nonparametric Inference in Regression-Discontinuity Designs}.
+{it:R Journal} 7(1): 38-51.{p_end}
+
+{p 4 8}Cattaneo, M. D., B. Frandsen, and R. Titiunik. 2015.
+{browse "https://rdpackages.github.io/references/Cattaneo-Frandsen-Titiunik_2015_JCI.pdf":Randomization Inference in the Regression Discontinuity Design: An Application to Party Advantages in the U.S. Senate}.
+{it:Journal of Causal Inference} 3(1): 1-24.{p_end}
+
+{marker authors}{...}
+{title:Authors}
+
+{p 4 8}Sebastian Calonico, Columbia University, New York, NY.
+{browse "mailto:[email protected]":[email protected]}.{p_end}
+
+{p 4 8}Matias D. Cattaneo, Princeton University, Princeton, NJ.
+{browse "mailto:[email protected]":[email protected]}.{p_end}
+
+{p 4 8}Max H. Farrell, University of Chicago, Chicago, IL.
+{browse "mailto:[email protected]":[email protected]}.{p_end}
+
+{p 4 8}Rocio Titiunik, Princeton University, Princeton, NJ.
+{browse "mailto:[email protected]":[email protected]}.{p_end}
+
+

30/replication_package/Adofiles/rd_2021/rdbwselect_2014.ado

@@ -0,0 +1,596 @@
+*!version 6.0  2014-10-14
+
+capture program drop rdbwselect_2014
+program define rdbwselect_2014, eclass
+	syntax anything [if] [in] [, c(real 0) deriv(real 0) p(real 1) q(real 0) kernel(string) bwselect(string) rho(real 0) vce(string) matches(real 3) delta(real 0.5) cvgrid_min(real 0) cvgrid_max(real 0) cvgrid_length(real 0) cvplot all precalc scaleregul(real 1) ]
+
+	local kernel = lower("`kernel'")
+	local bwselect = upper("`bwselect'")
+	local vce = lower("`vce'")
+
+	marksample touse
+	preserve
+	qui keep if `touse'
+	tokenize "`anything'"
+	local y `1'
+	local x `2'
+	qui drop if `y'==. | `x'==.
+	tempvar x_l x_r y_l y_r  
+	local b_calc = 0
+	
+	if (`rho'==0){
+		local b_calc = 1
+		local rho = 1
+	}
+	
+		qui su `x'  if `x'<`c', d
+		local medX_l = r(p50)
+		qui su `x'  if `x'>=`c', d
+		local medX_r = r(p50)
+		
+	if ("`precalc'"==""){
+		qui gen `x_l' = `x' if `x'<`c'
+		qui gen `x_r' = `x' if `x'>=`c'
+		qui gen `y_l' = `y' if `x'<`c'
+		qui gen `y_r' = `y' if `x'>=`c'
+
+		qui su `x'
+		local x_min = r(min)
+		local x_max = r(max)
+		qui su `x_l',d
+		local N_l = r(N)
+		local range_l = abs(r(max)-r(min))
+		qui su `x_r',d 
+		local N_r = r(N)
+		local range_r = abs(r(max)-r(min))
+		local N = `N_r' + `N_l'
+
+	if ("`deriv'">"0" & "`p'"=="1" & "`q'"=="0"){
+		local p = `deriv'+1
+	}
+
+		if ("`q'"=="0") {
+			local q = `p'+1
+		}
+
+		
+		**************************** ERRORS
+	if (`c'<=`x_min' | `c'>=`x_max'){
+	 di "{err}{cmd:c()} should be set within the range of `x'"  
+	 exit 125
+	}
+	
+	if (`N_l'<20 | `N_r'<20){
+	 di "{err}Not enough observations to perform calculations"  
+	 exit 2001
+	}
+	
+	if ("`p'">"8"){
+	 di "{err}{cmd:p()} should be less or equal than 8 for this version of the software package"  
+	 exit 125
+	}
+	
+	
+	if ("`kernel'"~="uni" & "`kernel'"~="uniform" & "`kernel'"~="tri" & "`kernel'"~="triangular" & "`kernel'"~="epa" & "`kernel'"~="epanechnikov" & "`kernel'"~="" ){
+	 di "{err}{cmd:kernel()} incorrectly specified"  
+	 exit 7
+	}
+
+	if ("`bwselect'"~="CCT" & "`bwselect'"~="IK" & "`bwselect'"~="CV" & "`bwselect'"~=""){
+	 di "{err}{cmd:bwselect()} incorrectly specified"  
+	 exit 7
+	}
+
+	if ("`vce'"~="resid" & "`vce'"~="nn" & "`vce'"~=""){ 
+	 di "{err}{cmd:vce()} incorrectly specified"  
+	 exit 7
+	}
+
+	if ("`p'"<"0" | "`q'"<="0" | "`deriv'"<"0" | "`matches'"<="0" | `scaleregul'<0){
+	 di "{err}{cmd:p()}, {cmd:q()}, {cmd:deriv()}, {cmd:matches()} and {cmd:scaleregul()} should be positive"  
+	 exit 411
+	}
+
+	if ("`p'">="`q'" & "`q'">"0"){
+	 di "{err}{cmd:q()} should be higher than {cmd:p()}"  
+	 exit 125
+	}
+
+	if ("`deriv'">"`p'" & "`deriv'">"0" ){
+	 di "{err}{cmd:deriv()} can not be higher than {cmd:p()}"  
+	 exit 125
+	}
+
+	if ("`p'">"0" ) {
+		local p_round = round(`p')/`p'
+		local q_round = round(`q')/`q'
+		local d_round = round(`deriv'+1)/(`deriv'+1)
+		local m_round = round(`matches')/`matches'
+
+	if (`p_round'!=1 | `q_round'!=1 |`d_round'!=1 |`m_round'!=1 ){
+	 di "{err}{cmd:p()}, {cmd:q()}, {cmd:deriv()} and {cmd:matches()} should be integers"  
+	 exit 126
+	}
+	}
+	
+	if (`delta'>1 | `delta'<=0){
+	 di "{err}{cmd:delta()}should be set between 0 and 1"  
+	 exit 125
+	}
+
+	if (`rho'>1 | `rho'<0){
+	 di "{err}{cmd:rho()}should be set between 0 and 1"  
+	 exit 125
+	}
+
+	if (`cvgrid_min'<0 | `cvgrid_max'<0 | `cvgrid_length'<0 ){
+	 di "{err}{cmd:cvgrid_min()}, {cmd:cvgrid_max()} and {cmd:cvgrid_length()} should be positive numbers"
+	 exit 126
+	}
+
+	if (`cvgrid_min'>`cvgrid_max' ){
+		di "{err}{cmd:cvgrid_min()} should be lower than {cmd:cvgrid_max()}"
+		exit 125
+	}
+
+	if (`deriv'>0 & ("`bwselect'"=="IK" | "`bwselect'"=="CV" | "`all'"!="")) {
+		di "{err}{cmd:IK} and {cmd:CV} implementations are not availale for {cmd:deriv}>0; use CCT instead"
+		exit 125
+	}
+	
+		if ("`exit'">"0") {
+			exit
+		}
+
+	if ("`kernel'"=="epanechnikov" | "`kernel'"=="epa") {
+			local kernel_type = "Epanechnikov"
+		}
+	else if ("`kernel'"=="uniform" | "`kernel'"=="uni") {
+			local kernel_type = "Uniform"
+		}
+	else  {
+			local kernel_type = "Triangular"
+		}
+	}	
+
+	local p1 = `p' + 1
+	local p2 = `p' + 2
+	local q1 = `q' + 1
+	local q2 = `q' + 2
+	local q3 = `q' + 3
+	quietly count if `x'<`c' 
+	local N_l = r(N)
+	quietly count if `c'<=`x' 
+	local N_r = r(N)
+	local N = `N_r' + `N_l'
+	local m = `matches' + 1
+
+	if ("`kernel'"=="epanechnikov" | "`kernel'"=="epa") {
+			local kid=3
+			local C_pilot=2.34
+	}
+	else if ("`kernel'"=="uniform" | "`kernel'"=="uni") {
+			local kid=2
+			local C_pilot=1.84
+	}
+	else  {
+			local kid=1
+			local C_pilot=2.58
+	}
+	
+	rdbwselect_2014_kconst `p' `deriv' `kid'
+	local C1_h = e(C1)
+	local C2_h = e(C2)
+	rdbwselect_2014_kconst `q' `q' `kid'
+	local C1_b = e(C1)
+	local C2_b = e(C2)
+	rdbwselect_2014_kconst `q1' `q1' `kid'
+	local C1_q = e(C1)
+	local C2_q = e(C2)
+		
+	rdbwselect_2014_kconst `q' `q' 2
+	local C1_b_uni = e(C1)
+	local C2_b_uni = e(C2)
+	rdbwselect_2014_kconst `q1' `q1' 2
+	local C1_q_uni = e(C1)
+	local C2_q_uni = e(C2)
+		
+	***********************************************************************
+	**************************** CCT Approach
+	***********************************************************************
+	qui su `x', d
+	local h_pilot_CCT = `C_pilot'*min(r(sd),(r(p75)-r(p25))/1.349)*r(N)^(-1/5)
+		
+	mata{
+	h_pilot_CCT=`h_pilot_CCT'
+	N_l = `N_l'
+	N_r = `N_r'
+	p = `p'
+	q = `q'
+	c = `c'
+	C1_h=`C1_h'
+	C2_h=`C2_h'
+	C1_b=`C1_b'
+	C2_b=`C2_b'
+	C1_q=`C1_q'
+	C2_q=`C2_q'
+
+	C1_b_uni=`C1_b_uni'
+	C2_b_uni=`C2_b_uni'
+	C1_q_uni=`C1_q_uni'
+	C2_q_uni=`C2_q_uni'
+	
+	deriv = `deriv'
+	p1 = p+1;	q1 = q+1;	p2 = p+2;	q2 = q+2;	p3 = p+3;	q3 = q+3
+	Y = st_data(.,("`y'"), 0);	X = st_data(.,("`x'"), 0)
+	X_l = select(X,X:<c);	X_r = select(X,X:>=c)
+	Y_l = select(Y,X:<c);	Y_r = select(Y,X:>=c)
+	X_lq2 = J(N_l, q+3, .);	X_rq2 = J(N_r, q+3, .)
+	for (j=1; j<=q3; j++) {
+		X_lq2[.,j] = (X_l:-c):^(j-1)
+		X_rq2[.,j] = (X_r:-c):^(j-1)
+	}
+	
+	X_lq1 = X_lq2[.,1::q2];X_rq1 = X_rq2[.,1::q2]
+	X_lq  = X_lq2[.,1::q1];X_rq  = X_rq2[.,1::q1]
+	X_lp  = X_lq2[.,1::p1];X_rp  = X_rq2[.,1::p1]
+
+	if ("`bwselect'"=="CCT" | "`bwselect'"=="" | "`all'"!="") {
+
+	display("Computing CCT bandwidth selector.")
+
+	*** Step 1: q_CCT
+	* Variances for all CCT estimators
+	w_pilot_l = rdbwselect_2014_kweight(X_l,c,h_pilot_CCT,"`kernel'")
+	w_pilot_r = rdbwselect_2014_kweight(X_r,c,h_pilot_CCT,"`kernel'")
+	Gamma_pilot_lq1 = cross(X_lq1, w_pilot_l, X_lq1);	Gamma_pilot_rq1 = cross(X_rq1, w_pilot_r, X_rq1)
+	Gamma_pilot_lq = Gamma_pilot_lq1[1::`q1',1::`q1'];	Gamma_pilot_rq = Gamma_pilot_rq1[1::`q1',1::`q1']
+	Gamma_pilot_lp = Gamma_pilot_lq1[1::`p1',1::`p1'];	Gamma_pilot_rp = Gamma_pilot_rq1[1::`p1',1::`p1']
+	invGamma_pilot_lq1 = invsym(Gamma_pilot_lq1);	invGamma_pilot_rq1 = invsym(Gamma_pilot_rq1)
+	invGamma_pilot_lq  = invsym(Gamma_pilot_lq);	invGamma_pilot_rq  = invsym(Gamma_pilot_rq)
+	invGamma_pilot_lp  = invsym(Gamma_pilot_lp);	invGamma_pilot_rp  = invsym(Gamma_pilot_rp)
+	sigma_l_pilot = rdbwselect_2014_rdvce(X_l, Y_l, Y_l, `p', `h_pilot_CCT', `matches', "`vce'", "`kernel'")
+	sigma_r_pilot = rdbwselect_2014_rdvce(X_r, Y_r, Y_r, `p', `h_pilot_CCT', `matches', "`vce'", "`kernel'")
+	Psi_pilot_lq1 = cross(X_lq1, w_pilot_l:*sigma_l_pilot:*w_pilot_l, X_lq1)
+	Psi_pilot_rq1 = cross(X_rq1, w_pilot_r:*sigma_r_pilot:*w_pilot_r, X_rq1)
+	Psi_pilot_lq  = Psi_pilot_lq1[1::`q1',1::`q1'];	Psi_pilot_rq  = Psi_pilot_rq1[1::`q1',1::`q1']
+	Psi_pilot_lp  = Psi_pilot_lq1[1::`p1',1::`p1'];	Psi_pilot_rp  = Psi_pilot_rq1[1::`p1',1::`p1']
+	V_m3_pilot_CCT = (invGamma_pilot_lq1*Psi_pilot_lq1*invGamma_pilot_lq1)[`q'+2,`q'+2]      + (invGamma_pilot_rq1*Psi_pilot_rq1*invGamma_pilot_rq1)[`q'+2,`q'+2]
+	V_m2_pilot_CCT = (invGamma_pilot_lq*Psi_pilot_lq*invGamma_pilot_lq)[`q'+1,`q'+1]         + (invGamma_pilot_rq*Psi_pilot_rq*invGamma_pilot_rq)[`q'+1,`q'+1]
+	V_m0_pilot_CCT = (invGamma_pilot_lp*Psi_pilot_lp*invGamma_pilot_lp)[`deriv'+1,`deriv'+1] + (invGamma_pilot_rp*Psi_pilot_rp*invGamma_pilot_rp)[`deriv'+1,`deriv'+1]
+	* Numerator
+	N_q_CCT=(2*q+3)*`N'*`h_pilot_CCT'^(2*q+3)*V_m3_pilot_CCT
+	* Denominator
+	m4_l_pilot_CCT = (invsym(cross(X_lq2,X_lq2))*cross(X_lq2,Y_l))[`q3',1]
+	m4_r_pilot_CCT = (invsym(cross(X_rq2,X_rq2))*cross(X_rq2,Y_r))[`q3',1]
+	D_q_CCT = 2*(C1_q*(m4_r_pilot_CCT-(-1)^(deriv+q)*m4_l_pilot_CCT))^2
+	* Final
+	q_CCT = (N_q_CCT/(`N'*D_q_CCT))^(1/(2*q+5))
+
+	*** Step 2: b_CCT
+	* Numerator
+	N_b_CCT = (2*p+3)*`N'*`h_pilot_CCT'^(2*p+3)*V_m2_pilot_CCT
+	* Denominator
+	w_q_l=rdbwselect_2014_kweight(X_l,c,q_CCT,"`kernel'")
+	w_q_r=rdbwselect_2014_kweight(X_r,c,q_CCT,"`kernel'")
+	m3_l_CCT = (invsym(cross(X_lq1, w_q_l, X_lq1))*cross(X_lq1, w_q_l, Y_l))[q2,1]
+	m3_r_CCT = (invsym(cross(X_rq1, w_q_r, X_rq1))*cross(X_rq1, w_q_r, Y_r))[q2,1]
+	D_b_CCT = 2*(q-p)*(C1_b*(m3_r_CCT - (-1)^(deriv+q+1)*m3_l_CCT))^2
+	* Regul
+	invGamma_q_lq1_CCT = invsym(cross(X_lq1, w_q_l, X_lq1))
+	invGamma_q_rq1_CCT = invsym(cross(X_rq1, w_q_r, X_rq1))
+	Psi_q_lq1_CCT = cross(X_lq1, w_q_l:*sigma_l_pilot:*w_q_l, X_lq1)
+	Psi_q_rq1_CCT = cross(X_rq1, w_q_r:*sigma_r_pilot:*w_q_r, X_rq1)
+	V_m3_q_CCT = (invGamma_q_lq1_CCT*Psi_q_lq1_CCT*invGamma_q_lq1_CCT)[`q'+2,`q'+2] + (invGamma_q_rq1_CCT*Psi_q_rq1_CCT*invGamma_q_rq1_CCT)[`q'+2,`q'+2]
+	R_b_CCT = `scaleregul'*2*(q-p)*C1_b^2*3*V_m3_q_CCT
+	* Final
+	b_CCT = (N_b_CCT / (`N'*(D_b_CCT + R_b_CCT)))^(1/(2*q+3))
+		
+	*** Step 3: h_CCT
+	* Numerator
+	N_h_CCT = (2*`deriv'+1)*`N'*`h_pilot_CCT'^(2*`deriv'+1)*V_m0_pilot_CCT
+	* Denominator
+	w_b_l=rdbwselect_2014_kweight(X_l,`c',b_CCT,"`kernel'")
+	w_b_r=rdbwselect_2014_kweight(X_r,`c',b_CCT,"`kernel'")
+	m2_l_CCT = (invsym(cross(X_lq, w_b_l, X_lq))*cross(X_lq, w_b_l, Y_l))[`p2',1]
+	m2_r_CCT = (invsym(cross(X_rq, w_b_r, X_rq))*cross(X_rq, w_b_r, Y_r))[`p2',1]
+	D_h_CCT = 2*(p+1-`deriv')*(C1_h*(m2_r_CCT - (-1)^(`deriv'+p+1)*m2_l_CCT))^2
+	* Regul
+	invGamma_b_lq_CCT = invsym(cross(X_lq, w_b_l, X_lq))
+	invGamma_b_rq_CCT = invsym(cross(X_rq, w_b_r, X_rq))
+	Psi_b_lq_CCT = cross(X_lq, w_b_l:*sigma_l_pilot:*w_b_l, X_lq)
+	Psi_b_rq_CCT = cross(X_rq, w_b_r:*sigma_r_pilot:*w_b_r, X_rq)
+	V_m2_b_CCT = (invGamma_b_lq_CCT*Psi_b_lq_CCT*invGamma_b_lq_CCT)[`p2',`p2'] + (invGamma_b_rq_CCT*Psi_b_rq_CCT*invGamma_b_rq_CCT)[`p2',`p2']
+	R_h_CCT = `scaleregul'*2*(`p'+1-`deriv')*C1_h^2*3*V_m2_b_CCT
+	* Final
+	h_CCT = (N_h_CCT / (`N'*(D_h_CCT+R_h_CCT)))^(1/(2*p+3))
+
+	st_numscalar("h_CCT",h_CCT)
+	st_numscalar("q_CCT",q_CCT)
+	
+	if (`b_calc'==0) {
+		b_CCT = h_CCT/`rho'
+	}
+	st_numscalar("b_CCT",b_CCT)
+	}
+
+	***************************************************************************************************
+	******************** IK
+	**************************************************************************************************
+	if ("`bwselect'"=="IK" | "`all'"~="") {
+
+	display("Computing IK bandwidth selector.")
+	h_pilot_IK = 1.84*sqrt(variance(X))*length(X)^(-1/5)
+	n_l_h1 = length(select(X_l,X_l:>=`c'-h_pilot_IK))
+	n_r_h1 = length(select(X_r,X_r:<=`c'+h_pilot_IK))
+	f0_pilot=(n_r_h1+n_l_h1)/(2*`N'*h_pilot_IK)
+	s2_l_pilot = variance(select(Y_l,X_l:>=`c'-h_pilot_IK))
+	s2_r_pilot = variance(select(Y_r,X_r:<=`c'+h_pilot_IK))
+
+	if (s2_l_pilot==0){
+		s2_l_pilot=variance(select(Y_l,X_l:>=`c'-2*h_pilot_IK))
+	}
+	
+	if (s2_r_pilot==0){
+		s2_r_pilot=variance(select(Y_r,X_r:<=`c'+2*h_pilot_IK))
+	}
+	
+	V_IK_pilot = (s2_r_pilot+s2_l_pilot)/f0_pilot
+	Vm0_pilot_IK = C2_h*V_IK_pilot
+	Vm2_pilot_IK = C2_b*V_IK_pilot
+	Vm3_pilot_IK = C2_q*V_IK_pilot
+	
+	* Select Median Sample to compute derivative (as in IK code)
+	x_IK_med_l = select(X_l,X_l:>=`medX_l'); y_IK_med_l = select(Y_l,X_l:>=`medX_l')
+	x_IK_med_r = select(X_r,X_r:<=`medX_r'); y_IK_med_r = select(Y_r,X_r:<=`medX_r')
+	x_IK_med = x_IK_med_r \ x_IK_med_l
+	y_IK_med = y_IK_med_r \ y_IK_med_l
+	sample_IK = length(x_IK_med)
+	X_IK_med_q2 = J(sample_IK, `q3', .)
+	for (j=1; j<= `q3' ; j++) {
+			X_IK_med_q2[.,j] = (x_IK_med:-`c'):^(j-1)
+	}
+	X_IK_med_q1 = X_IK_med_q2[.,1::`q2']
+	* Add cutoff dummy
+	X_IK_med_q2 = (X_IK_med_q2, x_IK_med:>=c)
+	X_IK_med_q1 = (X_IK_med_q1, x_IK_med:>=c)
+	
+	*** Compute b_IK
+	* Pilot Bandwidth
+		N_q_r_pilot_IK = (2*q+3)*C2_q_uni*(s2_r_pilot/f0_pilot)
+		N_q_l_pilot_IK = (2*q+3)*C2_q_uni*(s2_l_pilot/f0_pilot)
+		m4_pilot_IK = (invsym(cross(X_IK_med_q2, X_IK_med_q2))*cross(X_IK_med_q2, y_IK_med))[q+3,1]
+		D_q_pilot_IK = 2*(C1_q_uni*m4_pilot_IK)^2
+		h3_r_pilot_IK = (N_q_r_pilot_IK / (N_r*D_q_pilot_IK))^(1/(2*q+5))
+		h3_l_pilot_IK = (N_q_l_pilot_IK / (N_l*D_q_pilot_IK))^(1/(2*q+5))
+	* Data for derivative
+		X_lq_IK_h3=select(X_lq1,X_l:>=c-h3_l_pilot_IK); Y_l_IK_h3 =select(Y_l,X_l:>=c-h3_l_pilot_IK)
+		X_rq_IK_h3=select(X_rq1,X_r:<=c+h3_r_pilot_IK);	Y_r_IK_h3 =select(Y_r,X_r:<=c+h3_r_pilot_IK)
+		m3_l_IK = (invsym(cross(X_lq_IK_h3, X_lq_IK_h3))*cross(X_lq_IK_h3, Y_l_IK_h3))[q+2,1]
+		m3_r_IK = (invsym(cross(X_rq_IK_h3, X_rq_IK_h3))*cross(X_rq_IK_h3, Y_r_IK_h3))[q+2,1]
+		D_b_IK = 2*(q-p)*(C1_b*(m3_r_IK - (-1)^(`deriv'+`q'+1)*m3_l_IK))^2
+		N_b_IK = (2*p+3)*Vm2_pilot_IK
+	* Regularization
+		temp = rdbwselect_2014_regconst(`q1',1)
+		con = temp[`q2',`q2']
+		n_l_h3 = length(Y_l_IK_h3);	n_r_h3 = length(Y_r_IK_h3)
+		r_l_b = (con*s2_l_pilot)/(n_l_h3*h3_l_pilot_IK^(2*`q1'))
+		r_r_b = (con*s2_r_pilot)/(n_r_h3*h3_r_pilot_IK^(2*`q1'))
+		R_b_IK = `scaleregul'*2*(q-p)*C1_b^2*3*(r_l_b + r_r_b)
+	* Final bandwidth:
+		b_IK   = (N_b_IK / (`N'*(D_b_IK + R_b_IK)))^(1/(2*q+3))
+	
+	*** Compute h_IK
+	* Pilot Bandwidth
+		N_b_r_pilot_IK = (2*p+3)*C2_b_uni*(s2_r_pilot/f0_pilot)
+		N_b_l_pilot_IK = (2*p+3)*C2_b_uni*(s2_l_pilot/f0_pilot)
+		m3_pilot_IK = (invsym(cross(X_IK_med_q1, X_IK_med_q1))*cross(X_IK_med_q1, y_IK_med))[q+2,1]
+		D_b_pilot_IK = 2*(q-p)*(C1_b_uni*m3_pilot_IK)^2
+		h2_l_pilot_IK  = (N_b_l_pilot_IK / (N_l*D_b_pilot_IK))^(1/(2*q+3))
+		h2_r_pilot_IK  = (N_b_r_pilot_IK / (N_r*D_b_pilot_IK))^(1/(2*q+3))
+	* Data for derivative
+		X_lq_IK_h2=select(X_lq,X_l:>=c-h2_l_pilot_IK); Y_l_IK_h2 =select(Y_l,X_l:>=c-h2_l_pilot_IK)
+		X_rq_IK_h2=select(X_rq,X_r:<=c+h2_r_pilot_IK); Y_r_IK_h2 =select(Y_r,X_r:<=c+h2_r_pilot_IK)
+		m2_l_IK = (invsym(cross(X_lq_IK_h2, X_lq_IK_h2))*cross(X_lq_IK_h2, Y_l_IK_h2))[p+2,1]
+		m2_r_IK = (invsym(cross(X_rq_IK_h2, X_rq_IK_h2))*cross(X_rq_IK_h2, Y_r_IK_h2))[p+2,1]
+		D_h_IK = 2*(`p'+1-`deriv')*(C1_h*(m2_r_IK - (-1)^(`deriv'+`p'+1)*m2_l_IK))^2
+		N_h_IK = (2*`deriv'+1)*Vm0_pilot_IK
+	* Regularization
+		temp = rdbwselect_2014_regconst(`p1',1)
+		con = temp[`p2',`p2']
+		n_l_h2 = length(Y_l_IK_h2);	n_r_h2 = length(Y_r_IK_h2)
+		r_l_h = (con*s2_l_pilot)/(n_l_h2*h2_l_pilot_IK^(2*`p1'))
+		r_r_h = (con*s2_r_pilot)/(n_r_h2*h2_r_pilot_IK^(2*`p1'))
+		R_h_IK = `scaleregul'*2*(`p'+1-`deriv')*C1_h^2*3*(r_l_h + r_r_h)
+	* Final bandwidth
+		h_IK  = (N_h_IK / (`N'*(D_h_IK + R_h_IK)))^(1/(2*p+3))
+
+	*** DJMC (not documented)
+		D_h_DM  = 2*(`p'+1-`deriv')*C1_h^2*(m2_r_IK^2 + m2_l_IK^2)
+		D_b_DM  =       2*(`q'-`p')*C1_b^2*(m3_r_IK^2 + m3_l_IK^2)
+		h_DM = (N_h_IK / (`N'*D_h_DM))^(1/(2*`p'+3))
+		b_DM = (N_b_IK / (`N'*D_b_DM))^(1/(2*`q'+3))
+
+	st_numscalar("h_IK", h_IK)
+	st_numscalar("b_IK", b_IK)
+	
+	if (`b_calc'==0) {
+		b_IK = h_IK/`rho'
+	}
+	st_numscalar("b_IK",b_IK)
+	}
+
+	*********************************************************************
+	********************************** C-V  *****************************
+	*********************************************************************
+	if ("`bwselect'"=="CV" | "`all'"~="") {
+
+	display("Computing CV bandwidth selector.")
+	v_CV_l = 0;w_CV_l = 0
+	minindex(X_l, `N_l', v_CV_l, w_CV_l)
+	x_sort_l = X_l[v_CV_l];y_sort_l = Y_l[v_CV_l]
+	v_CV_r = 0;w_CV_r = 0
+	maxindex(X_r, `N_r', v_CV_r, w_CV_r)
+	x_sort_r = X_r[v_CV_r];y_sort_r = Y_r[v_CV_r]
+	h_CV_min = 0
+	if (`N_r'>20 & `N_l'>20){
+	h_CV_min  = min((abs(x_sort_r[`N_r']-x_sort_r[`N_r'-20]),abs(x_sort_l[`N_l']-x_sort_l[`N_l'-20])))
+	}
+	h_CV_max  = min((abs(x_sort_r[1]-x_sort_r[`N_r']),abs(x_sort_l[1]-x_sort_l[`N_l'])))
+	h_CV_jump = min((abs(x_sort_r[1]-x_sort_r[`N_r'])/10,abs(x_sort_l[1]-x_sort_l[`N_l']))/10)
+	st_numscalar("h_CV_min", h_CV_min[1,1])
+	st_numscalar("h_CV_max", h_CV_max[1,1])
+	st_numscalar("h_CV_jump", h_CV_jump[1,1])
+	if ("`cvgrid_min'"=="0") {
+		cvgrid_min = h_CV_min
+	}
+	else if ("`cvgrid_min'"!="0") {
+		cvgrid_min = `cvgrid_min'
+	}
+	if ("`cvgrid_max'"=="0") {
+		cvgrid_max = h_CV_max
+	}
+	else if ("`cvgrid_max'"!="0") {
+		cvgrid_max = `cvgrid_max'
+	}
+	if ("`cvgrid_length'"=="0") {
+		cvgrid_length = abs(cvgrid_max-cvgrid_min)/20
+	}
+	else if ("`cvgrid_length'"!="0") {
+		cvgrid_length = `cvgrid_length'
+	}
+	if (cvgrid_min>=cvgrid_max){
+		cvgrid_min = 0
+	}
+	st_numscalar("cvgrid_min",    cvgrid_min)
+	st_numscalar("cvgrid_max",    cvgrid_max)
+	st_numscalar("cvgrid_length", cvgrid_length)
+	h_CV_seq  = range(cvgrid_min, cvgrid_max, cvgrid_length)
+	s_CV = length(h_CV_seq)
+	CV_l = CV_r = J(1, s_CV, 0)
+	n_CV_l = round(`delta'*`N_l')-3
+	n_CV_r = round(`delta'*`N_r')-3
+
+	for (v=1; v<=s_CV; v++) {
+	for (k=0; k<=n_CV_l; k++) {
+		ind_l = `N_l'-k-1
+		x_CV_sort_l = x_sort_l[1::ind_l] 
+		y_CV_sort_l = y_sort_l[1::ind_l] 
+		w_CV_sort_l = rdbwselect_2014_kweight(x_CV_sort_l,x_sort_l[ind_l+1],h_CV_seq[v],"`kernel'")
+		x_CV_l = select(x_CV_sort_l,w_CV_sort_l:>0)
+		y_CV_l = select(y_CV_sort_l,w_CV_sort_l:>0)
+		w_CV_l = select(w_CV_sort_l,w_CV_sort_l:>0)
+		XX_CV_l = J(length(w_CV_l),`p1',.)
+	for (j=1; j<=`p1'; j++) {
+		XX_CV_l[.,j] = (x_CV_l :- x_sort_l[ind_l+1]):^(j-1)
+		}
+	y_CV_hat_l = (invsym(cross(XX_CV_l,w_CV_l,XX_CV_l))*cross(XX_CV_l,w_CV_l,y_CV_l))[1]
+	mse_CV_l = (y_sort_l[ind_l+1] - y_CV_hat_l)^2
+	CV_l[v] = CV_l[v] + mse_CV_l
+	}
+	for (k=0; k<=n_CV_r; k++) {
+		ind_r = `N_r'-k-1
+		x_CV_sort_r = x_sort_r[1::ind_r] 
+		y_CV_sort_r = y_sort_r[1::ind_r] 
+		w_CV_sort_r = rdbwselect_2014_kweight(x_CV_sort_r,x_sort_r[ind_r+1],h_CV_seq[v],"`kernel'")
+		x_CV_r = select(x_CV_sort_r,w_CV_sort_r:>0)
+		y_CV_r = select(y_CV_sort_r,w_CV_sort_r:>0)
+		w_CV_r = select(w_CV_sort_r,w_CV_sort_r:>0)
+		XX_CV_r = J(length(w_CV_r),`p1',.)
+		
+		for (j=1; j<= `p1' ; j++) {
+			XX_CV_r[.,j] = (x_CV_r :- x_sort_r[ind_r+1]):^(j-1)
+		}
+		
+		y_CV_hat_r = (invsym(cross(XX_CV_r,w_CV_r,XX_CV_r))*cross(XX_CV_r,w_CV_r,y_CV_r))[1]
+		mse_CV_r = (y_sort_r[ind_r+1] - y_CV_hat_r)^2
+		CV_r[v] = CV_r[v] + mse_CV_r
+	}
+	}
+
+	CV_sum = CV_l + CV_r
+	CV_sum_order = order(abs(CV_sum'),1)
+	h_CV = h_CV_seq[CV_sum_order] 
+	h_CV = h_CV[1,1]
+
+	if (`b_calc'==0) {
+		b_CV = h_CV/`rho'
+	}
+	st_numscalar("h_CV", h_CV)
+	st_numscalar("b_CV", b_CV)
+	}
+	}
+
+	*******************************************************************************
+
+	disp ""
+	disp in smcl in gr "Bandwidth estimators for RD local polynomial regression" 
+	disp ""
+	disp ""
+	disp in smcl in gr "{ralign 21: Cutoff c = `c'}"      _col(22) " {c |} " _col(23) in gr "Left of " in yellow "c"  _col(36) in gr "Right of " in yellow "c" _col(61) in gr "Number of obs  = "  in yellow %10.0f `N_l'+`N_r'
+	disp in smcl in gr "{hline 22}{c +}{hline 22}"                                                                                                             _col(61) in gr "NN matches     = "  in yellow %10.0f `matches'
+	disp in smcl in gr "{ralign 21:Number of obs}"        _col(22) " {c |} " _col(23) as result %9.0f `N_l'   _col(37) %9.0f  `N_r'                            _col(61) in gr "Kernel type    = "  in yellow "{ralign 10:`kernel_type'}" 
+	if ("`all'"=="" & "`bwselect'"!="CV")  {  
+	disp in smcl in gr "{ralign 21:Order loc. poly. (p)}" _col(22) " {c |} " _col(23) as result %9.0f `p'        _col(37) %9.0f  `p'                              
+	disp in smcl in gr "{ralign 21:Order bias (q)}"       _col(22) " {c |} " _col(23) as result %9.0f `q'        _col(37) %9.0f  `q'  
+	disp in smcl in gr "{ralign 21:Range of `x'}"         _col(22) " {c |} " _col(23) as result %9.3f `range_l'  _col(37) %9.3f  `range_r'                               
+	}
+	if ("`bwselect'"=="CV" | "`all'"!="")  {  
+	disp in smcl in gr "{ralign 21:Order loc. poly. (p)}" _col(22) " {c |} " _col(23) as result %9.0f `p'        _col(37) %9.0f  `p'       _col(61) in gr "Min BW grid    = " in yellow %10.5f cvgrid_min
+	disp in smcl in gr "{ralign 21:Order bias (q)}"       _col(22) " {c |} " _col(23) as result %9.0f `q'        _col(37) %9.0f  `q'       _col(61) in gr "Max BW grid    = " in yellow %10.5f cvgrid_max
+	disp in smcl in gr "{ralign 21:Range of `x'}"         _col(22) " {c |} " _col(23) as result %9.3f `range_l'  _col(37) %9.3f  `range_r' _col(61) in gr "Length BW grid = " in yellow %10.5f cvgrid_length
+	}   
+
+	disp ""
+	disp in smcl in gr "{hline 10}{c TT}{hline 35}" 
+	disp in smcl in gr "{ralign 9:Method}"   _col(10) " {c |} " _col(18) "h" _col(30) "b" _col(41) "rho" _n  "{hline 10}{c +}{hline 35}"
+	if ("`bwselect'"=="IK")  {
+	disp in smcl in gr "{ralign 9:IK }"      _col(10) " {c |} " _col(11) in ye %9.0g h_IK  _col(25) in ye %9.0g b_IK  _col(38) in ye %9.0g h_IK/b_IK
+	}
+	if ("`bwselect'"=="CV")  {
+	disp in smcl in gr "{ralign 9:CV }"      _col(10) " {c |} " _col(11) in ye %9.0g h_CV  _col(30) in ye "NA"  _col(42) in ye %9.0g "NA"
+	}	
+	if ("`all'"~="") {
+	disp in smcl in gr "{ralign 9:CCT}"     _col(10) " {c |} " _col(11) in ye %9.0g h_CCT _col(25) in ye %9.0g b_CCT _col(38) in ye %9.0g h_CCT/b_CCT
+	disp in smcl in gr "{ralign 9:IK}"      _col(10) " {c |} " _col(11) in ye %9.0g h_IK  _col(25) in ye %9.0g b_IK  _col(38) in ye %9.0g h_IK/b_IK
+	disp in smcl in gr "{ralign 9:CV}"      _col(10) " {c |} " _col(11) in ye %9.0g h_CV  _col(30) in ye  "NA"         _col(42) in ye  "NA"
+	}
+	if ("`bwselect'"=="" & "`all'"=="") | ("`bwselect'"=="CCT" & "`all'"=="") {
+		disp in smcl in gr "{ralign 9:CCT}"      _col(10) " {c |} " _col(11) in ye %9.0g h_CCT _col(25) in ye %9.0g b_CCT _col(38) in ye %9.0g h_CCT/b_CCT
+	}
+	disp in smcl in gr "{hline 10}{c BT}{hline 35}"
+
+	if ("`bwselect'"=="CV" & "`cvplot'"!="" | "`all'"!="" & "`cvplot'"!="")  {  
+		local h_CV= h_CV
+		mata rdbwselect_2014_cvplot(CV_sum', h_CV_seq, "xtitle(Grid of bandwidth (h)) ytitle(Cross-Validation objective function) c(l) ylabel(none) xline(`h_CV') title(Cross-Validation objective function)")
+	}
+
+	restore
+	ereturn clear
+	ereturn scalar N_l = `N_l'
+	ereturn scalar N_r = `N_r'
+	ereturn scalar c = `c'
+	ereturn scalar p = `p'
+	ereturn scalar q = `q'
+	
+	if ("`bwselect'"=="CCT" | "`bwselect'"=="" | "`all'"~="") {
+	ereturn scalar h_CCT = h_CCT
+	ereturn scalar b_CCT = b_CCT
+	*ereturn scalar q_CCT = q_CCT
+	}
+	if ("`bwselect'"=="IK" | "`all'"~="") {
+	ereturn scalar h_IK   = h_IK
+	ereturn scalar b_IK   = b_IK
+	*ereturn scalar h_djmc = `h_DJMC'
+	*ereturn scalar b_djmc = `b_DJMC'
+	}
+	if ("`bwselect'"=="CV" | "`all'"~="") {
+	ereturn scalar h_CV   = h_CV
+	*ereturn scalar b_CV   = b_cv
+	}
+	
+	mata mata clear
+
+end
+
+

30/replication_package/Adofiles/rd_2021/rdbwselect_2014.sthlp

@@ -0,0 +1,135 @@
+{smcl}
+{* *! version 6.0  2014-10-14}{...}
+{viewerjumpto "Syntax" "rdbwselect##syntax"}{...}
+{viewerjumpto "Description" "rdbwselect##description"}{...}
+{viewerjumpto "Options" "rdbwselect##options"}{...}
+{viewerjumpto "Examples" "rdbwselect##examples"}{...}
+{viewerjumpto "Saved results" "rdbwselect##saved_results"}{...}
+
+{title:Title}
+
+{p 4 8}{cmd:rdbwselect_2014} {hline 2} Deprecated Bandwidth Selection Procedures for Local-Polynomial Regression-Discontinuity Estimators.{p_end}
+
+{p 4 8}{ul:Important}: this command is no longer supported or updated, and it is made available only for backward compatibility purposes. Please use {help rdbwselect:rdbwselect} instead.{p_end}
+
+
+{marker syntax}{...} 
+{title:Syntax}
+
+{p 4 8}{cmd:rdbwselect_2014} {it:depvar} {it:indepvar} {ifin} 
+[{cmd:,} 
+{cmd:c(}{it:#}{cmd:)} 
+{cmd:p(}{it:#}{cmd:)} 
+{cmd:q(}{it:#}{cmd:)}
+{cmd:deriv(}{it:#}{cmd:)}
+{cmd:rho(}{it:#}{cmd:)}
+{cmd:kernel(}{it:kernelfn}{cmd:)}
+{cmd:bwselect(}{it:bwmethod}{cmd:)}
+{cmd:scaleregul(}{it:#}{cmd:)}
+{cmd:delta(}{it:#}{cmd:)}
+{cmd:cvgrid_min(}{it:#}{cmd:)}
+{cmd:cvgrid_max(}{it:#}{cmd:)}
+{cmd:cvgrid_length(}{it:#}{cmd:)}
+{cmd:cvplot}
+{cmd:vce(}{it:vcemethod}{cmd:)}
+{cmd:matches(}{it:#}{cmd:)}
+{cmd:all}
+]{p_end}
+
+{synoptset 28 tabbed}{...}
+
+{marker description}{...}
+{title:Description}
+
+{p 4 8}{cmd:rdbwselect_2014} is a deprecated command implementing three bandwidth selectors for local polynomial Regression Discontinuity (RD) point estimators and inference procedures, as described in
+{browse "https://sites.google.com/site/rdpackages/rdrobust/Calonico-Cattaneo-Titiunik_2014_Stata.pdf":Calonico, Cattaneo and Titiunik (2014)}.
+This command is no longer supported or updated, and it is made available only for backward compatibility purposes.{p_end}
+{p 8 8}This command uses compiled MATA functions given in
+{it:rdbwselect_2014_functions.do}.{p_end}
+
+{p 4 8}The latest version of the {cmd:rdrobust} package includes the following commands:{p_end}
+{p 8 8}{help rdrobust:rdrobust} for point estimation and inference procedures.{p_end}
+{p 8 8}{help rdbwselect:rdbwselect} for data-driven bandwidth selection.{p_end}
+{p 8 8}{help rdplot:rdplot} for data-driven RD plots.{p_end}
+
+{p 4 8}For more details, and related Stata and R packages useful for analysis of RD designs, visit:
+{browse "https://sites.google.com/site/rdpackages/"}{p_end}
+
+
+{marker options}{...}
+{title:Options}
+
+{p 4 8}{cmd:c(}{it:#}{cmd:)} specifies the RD cutoff in {it:indepvar}.
+Default is {cmd:c(0)}.
+
+{p 4 8}{cmd:p(}{it:#}{cmd:)} specifies the order of the local-polynomial used to construct the point estimator.
+Default is {cmd:p(1)} (local linear regression).
+
+{p 4 8}{cmd:q(}{it:#}{cmd:)} specifies the order of the local-polynomial used to construct the bias-correction.
+Default is {cmd:q(2)} (local quadratic regression).
+
+{p 4 8}{cmd:deriv(}{it:#}{cmd:)} specifies the order of the derivative of the regression functions to be estimated.
+Default is {cmd:deriv(0)} (Sharp RD, or Fuzzy RD if {cmd:fuzzy(.)} is also specified). Setting {cmd:deriv(1)} results in estimation of a Kink RD design (up to scale), or Fuzzy Kink RD if {cmd:fuzzy(.)} is also specified.
+
+{p 4 8}{cmd:rho(}{it:#}{cmd:)} if specified, sets the pilot bandwidth {it:b} equal to {it:h}/{it:rho}, where {it:h} is computed using the method and options chosen below.
+
+{p 4 8}{cmd:kernel(}{it:kernelfn}{cmd:)} specifies the kernel function used to construct the local-polynomial estimator(s). Options are: {opt tri:angular}, {opt epa:nechnikov}, and {opt uni:form}.
+Default is {opt triangular}.
+
+{p 4 8}{cmd:bwselect(}{it:bwmethod}{cmd:)} specifies the bandwidth selection procedure to be used. By default it computes both {it:h} and {it:b}, unless {it:rho} is specified, in which case it only computes {it:h} and sets {it:b}={it:h}/{it:rho}.
+Options are:{p_end}
+{p 8 12}{opt CCT} for bandwidth selector proposed by Calonico, Cattaneo and Titiunik (2014a). This is the default option.{p_end}
+{p 8 12}{opt IK} for bandwidth selector proposed by Imbens and Kalyanaraman (2012) (only available for Sharp RD design).{p_end}
+{p 8 12}{opt CV} for cross-validation method proposed by Ludwig and Miller (2007) (only available for Sharp RD design).{p_end}
+
+{p 4 8}{cmd:scaleregul(}{it:#}{cmd:)} specifies scaling factor for the regularization terms of {opt CCT} and {opt IK} bandwidth selectors. Setting {cmd:scaleregul(0)} removes the regularization term from the bandwidth selectors.
+Default is {cmd:scaleregul(1)}.
+
+{p 4 8}{cmd:delta(}{it:#}{cmd:)} specifies the quantile that defines the sample used in the cross-validation procedure. This option is used only if {cmd:bwselect(}{opt CV}{cmd:)} is specified.
+Default is {cmd:delta(0.5)}, that is, the median of the control and treated subsamples.
+
+{p 4 8}{cmd:cvgrid_min(}{it:#}{cmd:)} specifies the minimum value of the bandwidth grid used in the cross-validation procedure. This option is used only if {cmd:bwselect(}{opt CV}{cmd:)} is specified.
+
+{p 4 8}{cmd:cvgrid_max(}{it:#}{cmd:)} specifies the maximum value of the bandwidth grid used in the cross-validation procedure. This option is used only if {cmd:bwselect(}{opt CV}{cmd:)} is specified.
+
+{p 4 8}{cmd:cvgrid_length(}{it:#}{cmd:)} specifies the bin length of the (evenly-spaced) bandwidth grid used in the cross-validation procedure. This option is used only if {cmd:bwselect(}{opt CV}{cmd:)} is specified.
+
+{p 4 8}{cmd:cvplot} if specified, {cmd:rdbwselect} also reports a graph of the CV objective function. This option is used only if {cmd:bwselect(}{opt CV}{cmd:)} is specified.
+
+{p 4 8}{cmd:vce(}{it:vcemethod}{cmd:)} specifies the procedure used to compute the variance-covariance matrix estimator. This option is used only if {opt CCT} or {opt IK} bandwidth procedures are used.
+Options are:{p_end}
+{p 8 12}{opt nn} for nearest-neighbor matches residuals using {cmd:matches(}{it:#}{cmd:)} matches. This is the default option (with {cmd:matches(3)}, see below).{p_end}
+{p 8 12}{opt resid} for estimated plug-in residuals using {it:h} bandwidth.{p_end}
+
+{p 4 8}{cmd:matches(}{it:#}{cmd:)} specifies the number of matches in the nearest-neighbor based variance-covariance matrix estimator. This option is used only when nearest-neighbor matches residuals are employed.
+Default is {cmd:matches(3)}.
+
+{p 4 8}{cmd:all} if specified, {cmd:rdbwselect} reports three different procedures:{p_end}
+{p 8 12}{opt CCT} for bandwidth selector proposed by Calonico, Cattaneo and Titiunik (2014).{p_end}
+{p 8 12}{opt IK} for bandwidth selector proposed by Imbens and Kalyanaraman (2012).{p_end}
+{p 8 12}{opt CV} for cross-validation method proposed by Ludwig and Miller (2007).{p_end}
+	
+    {hline}
+
+	
+{title:References}
+
+{p 4 8}Calonico, S., Cattaneo, M. D., and R. Titiunik. 2014. Robust Data-Driven Inference in the Regression-Discontinuity Design. {it:Stata Journal} 14(4): 909-946. 
+{browse "https://sites.google.com/site/rdpackages/rdrobust/Calonico-Cattaneo-Titiunik_2014_Stata.pdf"}.
+
+
+{title:Authors}
+
+{p 4 8}Sebastian Calonico, Columbia University, New York, NY.
+{browse "mailto:[email protected]":[email protected]}.{p_end}
+
+{p 4 8}Matias D. Cattaneo, Princeton University, Princeton, NJ.
+{browse "mailto:[email protected]":[email protected]}.{p_end}
+
+{p 4 8}Max H. Farrell, University of Chicago, Chicago, IL.
+{browse "mailto:[email protected]":[email protected]}.{p_end}
+
+{p 4 8}Rocio Titiunik, Princeton University, Princeton, NJ.
+{browse "mailto:[email protected]":[email protected]}.{p_end}
+
+

30/replication_package/Adofiles/rd_2021/rdbwselect_2014_kconst.ado

@@ -0,0 +1,885 @@
+*!version 6.0  2014-10-14
+
+capture program drop rdbwselect_2014_kconst
+program define rdbwselect_2014_kconst, eclass
+	syntax anything
+	
+	tokenize "`anything'"
+	local p1  `1'
+	local p2  `2'
+	local kid `3'
+	
+	
+ if (`kid'==1) {
+ if (`p1'==0){
+ if (`p2'==0) {
+ local C1=0.333333333333333
+ local C2=1.33333333333333
+ }
+ }
+ if (`p1'==1){
+ if (`p2'==0) {
+ local C1=-0.1
+ local C2=4.8
+ }
+ if (`p2'==1) {
+ local C1=0.8
+ local C2=19.2
+ }
+ }
+ if (`p1'==2){
+ if (`p2'==0) {
+ local C1=0.0285714285714287
+ local C2=10.2857142857143
+ }
+ if (`p2'==1) {
+ local C1=-0.428571428571427
+ local C2=274.285714285714
+ }
+ if (`p2'==2) {
+ local C1=1.28571428571428
+ local C2=308.571428571429
+ }
+ }
+ if (`p1'==3){
+ if (`p2'==0) {
+ local C1=-0.00793650793649814
+ local C2=17.7777777777783
+ }
+ if (`p2'==1) {
+ local C1=0.190476190476176
+ local C2=1600.00000000012
+ }
+ if (`p2'==2) {
+ local C1=-1.00000000000003
+ local C2=10080.0000000008
+ }
+ if (`p2'==3) {
+ local C1=1.77777777777777
+ local C2=4977.77777777821
+ }
+ }
+ if (`p1'==4){
+ if (`p2'==0) {
+ local C1=0.00216450216449893
+ local C2=27.2727272727347
+ }
+ if (`p2'==1) {
+ local C1=-0.0757575757576774
+ local C2=6109.0909090921
+ }
+ if (`p2'==2) {
+ local C1=0.606060606059373
+ local C2=115461.818181807
+ }
+ if (`p2'==3) {
+ local C1=-1.81818181818016
+ local C2=293236.363636312
+ }
+ if (`p2'==4) {
+ local C1=2.27272727272634
+ local C2=80181.8181817951
+ }
+ }
+ if (`p1'==5){
+ if (`p2'==0) {
+ local C1=-0.000582750584072755
+ local C2=38.7692307691143
+ }
+ if (`p2'==1) {
+ local C1=0.0279720279806952
+ local C2=18092.3076921598
+ }
+ if (`p2'==2) {
+ local C1=-0.314685314702729
+ local C2=781587.692308313
+ }
+ if (`p2'==3) {
+ local C1=1.39860139862503
+ local C2=5582769.23070759
+ }
+ if (`p2'==4) {
+ local C1=-2.88461538463889
+ local C2=7463076.92303863
+ }
+ if (`p2'==5) {
+ local C1=2.76923076923777
+ local C2=1289619.69231728
+ }
+ }
+ if (`p1'==6){
+ if (`p2'==0) {
+ local C1=0.000155400158703856
+ local C2=52.2666666813375
+ }
+ if (`p2'==1) {
+ local C1=-0.00979020967770339
+ local C2=45158.4000232623
+ }
+ if (`p2'==2) {
+ local C1=0.146853146718058
+ local C2=3810240.00305634
+ }
+ if (`p2'==3) {
+ local C1=-0.897435898077674
+ local C2=59136000.0516687
+ }
+ if (`p2'==4) {
+ local C1=2.69230769423302
+ local C2=213444000.281064
+ }
+ if (`p2'==5) {
+ local C1=-4.20000000228174
+ local C2=174356582.583545
+ }
+ if (`p2'==6) {
+ local C1=3.266666667565
+ local C2=20718297.6275418
+ }
+ }
+ if (`p1'==7){
+ if (`p2'==0) {
+ local C1=-4.11365348327308e-05
+ local C2=67.7647062980167
+ }
+ if (`p2'==1) {
+ local C1=0.00329083788165008
+ local C2=99614.1186678147
+ }
+ if (`p2'==2) {
+ local C1=-0.0633484429563396
+ local C2=14792696.6380086
+ }
+ if (`p2'==3) {
+ local C1=0.506787375546992
+ local C2=430475298.36917
+ }
+ if (`p2'==4) {
+ local C1=-2.05882356315851
+ local C2=3264437686.45156
+ }
+ if (`p2'==5) {
+ local C1=4.61176469177008
+ local C2=6999904063.30826
+ }
+ if (`p2'==6) {
+ local C1=-5.76470586378127
+ local C2=3838978717.71456
+ }
+ if (`p2'==7) {
+ local C1=3.76470587169752
+ local C2=332572914.642903
+ }
+ }
+ if (`p1'==8){
+ if (`p2'==0) {
+ local C1=1.07820976609219e-05
+ local C2=85.2631303268003
+ }
+ if (`p2'==1) {
+ local C1=-0.0010711795912357
+ local C2=200084.040818939
+ }
+ if (`p2'==2) {
+ local C1=0.0257188626565039
+ local C2=48530367.293081
+ }
+ if (`p2'==3) {
+ local C1=-0.260059123858809
+ local C2=2403408146.73831
+ }
+ if (`p2'==4) {
+ local C1=1.36532014608383
+ local C2=33224189297.6117
+ }
+ if (`p2'==5) {
+ local C1=-4.09596675634384
+ local C2=146138075172.791
+ }
+ if (`p2'==6) {
+ local C1=7.2817234992981
+ local C2=206092142381.58
+ }
+ if (`p2'==7) {
+ local C1=-7.57894077897072
+ local C2=80937582484.7007
+ }
+ if (`p2'==8) {
+ local C1=4.2631561756134
+ local C2=5335240470.92272
+ }
+ }
+ if (`p1'==9){
+ if (`p2'==0) {
+ local C1=-4.34125468018465e-06
+ local C2=104.759683619607
+ }
+ if (`p2'==1) {
+ local C1=0.000359364319592714
+ local C2=373351.594641908
+ }
+ if (`p2'==2) {
+ local C1=-0.0100117437541485
+ local C2=139779902.485658
+ }
+ if (`p2'==3) {
+ local C1=0.123909175395966
+ local C2=10992402108.5829
+ }
+ if (`p2'==4) {
+ local C1=-0.812669515609741
+ local C2=252479011669.66
+ }
+ if (`p2'==5) {
+ local C1=3.12047624588013
+ local C2=1983097707753.03
+ }
+ if (`p2'==6) {
+ local C1=-7.36788511276245
+ local C2=5634749358454.49
+ }
+ if (`p2'==7) {
+ local C1=10.8265118598938
+ local C2=5601398362056.87
+ }
+ if (`p2'==8) {
+ local C1=-9.64254522323608
+ local C2=1650683628680.73
+ }
+ if (`p2'==9) {
+ local C1=4.76183295249939
+ local C2=85540403080.8251
+ }
+ }
+ if (`p1'==10){
+ if (`p2'==0) {
+ local C1=-5.92561264056712e-07
+ local C2=126.173458124805
+ }
+ if (`p2'==1) {
+ local C1=2.24271789193153e-05
+ local C2=655457.487684009
+ }
+ if (`p2'==2) {
+ local C1=0.00358942896127701
+ local C2=362125556.143413
+ }
+ if (`p2'==3) {
+ local C1=-0.057509183883667
+ local C2=42895674678.736
+ }
+ if (`p2'==4) {
+ local C1=0.448391914367676
+ local C2=1532214531495.65
+ }
+ if (`p2'==5) {
+ local C1=-2.11321067810059
+ local C2=19636178554116.5
+ }
+ if (`p2'==6) {
+ local C1=6.33000183105469
+ local C2=98056668493842
+ }
+ if (`p2'==7) {
+ local C1=-12.2766418457031
+ local C2=193660165481737
+ }
+ if (`p2'==8) {
+ local C1=15.3532409667969
+ local C2=142664371644737
+ }
+ if (`p2'==9) {
+ local C1=-11.9469718933105
+ local C2=32680235535116.8
+ }
+ if (`p2'==10) {
+ local C1=5.25889778137207
+ local C2=1366106680644.88
+ }
+ }
+ }
+ if (`kid'==2) {
+ if (`p1'==0){
+ if (`p2'==0) {
+ local C1=0.5
+ local C2=1
+ }
+ }
+ if (`p1'==1){
+ if (`p2'==0) {
+ local C1=-0.166666666666666
+ local C2=4
+ }
+ if (`p2'==1) {
+ local C1=0.999999999999999
+ local C2=12
+ }
+ }
+ if (`p1'==2){
+ if (`p2'==0) {
+ local C1=0.0499999999999927
+ local C2=8.99999999999989
+ }
+ if (`p2'==1) {
+ local C1=-0.599999999999969
+ local C2=191.999999999998
+ }
+ if (`p2'==2) {
+ local C1=1.49999999999998
+ local C2=179.999999999997
+ }
+ }
+ if (`p1'==3){
+ if (`p2'==0) {
+ local C1=-0.0142857142856023
+ local C2=15.9999999999967
+ }
+ if (`p2'==1) {
+ local C1=0.285714285713908
+ local C2=1199.99999999958
+ }
+ if (`p2'==2) {
+ local C1=-1.28571428571377
+ local C2=6479.99999999822
+ }
+ if (`p2'==3) {
+ local C1=1.99999999999972
+ local C2=2799.99999999933
+ }
+ }
+ if (`p1'==4){
+ if (`p2'==0) {
+ local C1=0.00396825396776279
+ local C2=24.999999999904
+ }
+ if (`p2'==1) {
+ local C1=-0.119047619048388
+ local C2=4799.99999999096
+ }
+ if (`p2'==2) {
+ local C1=0.83333333333394
+ local C2=79379.9999999445
+ }
+ if (`p2'==3) {
+ local C1=-2.22222222222626
+ local C2=179199.999999687
+ }
+ if (`p2'==4) {
+ local C1=2.50000000000273
+ local C2=44099.9999998837
+ }
+ }
+ if (`p1'==5){
+ if (`p2'==0) {
+ local C1=-0.00108225108795068
+ local C2=36.0000000009544
+ }
+ if (`p2'==1) {
+ local C1=0.0454545455922926
+ local C2=14700.0000007333
+ }
+ if (`p2'==2) {
+ local C1=-0.454545454842446
+ local C2=564480.000082575
+ }
+ if (`p2'==3) {
+ local C1=1.81818181864219
+ local C2=3628800.00023153
+ }
+ if (`p2'==4) {
+ local C1=-3.40909090952482
+ local C2=4410000.00041152
+ }
+ if (`p2'==5) {
+ local C1=3.00000000013097
+ local C2=698544.000095851
+ }
+ }
+ if (`p1'==6){
+ if (`p2'==0) {
+ local C1=0.000291375558163054
+ local C2=49.0000000807229
+ }
+ if (`p2'==1) {
+ local C1=-0.0163170211235411
+ local C2=37632.0000808351
+ }
+ if (`p2'==2) {
+ local C1=0.2202797360369
+ local C2=2857680.00223594
+ }
+ if (`p2'==3) {
+ local C1=-1.22377624921501
+ local C2=40320000.092693
+ }
+ if (`p2'==4) {
+ local C1=3.36538464389741
+ local C2=133402500.284745
+ }
+ if (`p2'==5) {
+ local C1=-4.84615386696532
+ local C2=100590336.250403
+ }
+ if (`p2'==6) {
+ local C1=3.5000000068685
+ local C2=11099088.0082191
+ }
+ }
+ if (`p1'==7){
+ if (`p2'==0) {
+ local C1=-7.77092654971057e-05
+ local C2=64.0000038038176
+ }
+ if (`p2'==1) {
+ local C1=0.0055944790947251
+ local C2=84672.0058301801
+ }
+ if (`p2'==2) {
+ local C1=-0.0979024390690029
+ local C2=11430721.0463556
+ }
+ if (`p2'==3) {
+ local C1=0.717949407175183
+ local C2=304920057.289328
+ }
+ if (`p2'==4) {
+ local C1=-2.69230864942074
+ local C2=2134440363.92093
+ }
+ if (`p2'==5) {
+ local C1=5.60000113397837
+ local C2=4249942482.73742
+ }
+ if (`p2'==6) {
+ local C1=-6.53333409875631
+ local C2=2175421444.25063
+ }
+ if (`p2'==7) {
+ local C1=4.00000020302832
+ local C2=176679380.680557
+ }
+ }
+ if (`p1'==8){
+ if (`p2'==0) {
+ local C1=2.18183413380757e-05
+ local C2=81.0000794511867
+ }
+ if (`p2'==1) {
+ local C1=-0.00185953138861805
+ local C2=172800.541412919
+ }
+ if (`p2'==2) {
+ local C1=0.0407402217388153
+ local C2=38420009.7178256
+ }
+ if (`p2'==3) {
+ local C1=-0.380106568336487
+ local C2=1756346185.84028
+ }
+ if (`p2'==4) {
+ local C1=1.85295575857162
+ local C2=22545053348.8166
+ }
+ if (`p2'==5) {
+ local C1=-5.1882472038269
+ local C2=92554313087.018
+ }
+ if (`p2'==6) {
+ local C1=8.64706671237946
+ local C2=122367438459.692
+ }
+ if (`p2'==7) {
+ local C1=-8.47059142589569
+ local C2=45230142568.556
+ }
+ if (`p2'==8) {
+ local C1=4.50000092387199
+ local C2=2815835708.811
+ }
+ }
+ if (`p1'==9){
+ if (`p2'==0) {
+ local C1=4.68557118438184e-06
+ local C2=100.001152185784
+ }
+ if (`p2'==1) {
+ local C1=0.000529960263520479
+ local C2=326698.901377387
+ }
+ if (`p2'==2) {
+ local C1=-0.0157094746828079
+ local C2=112913004.163799
+ }
+ if (`p2'==3) {
+ local C1=0.18475353717804
+ local C2=8245154393.28242
+ }
+ if (`p2'==4) {
+ local C1=-1.13636112213135
+ local C2=176755900163.269
+ }
+ if (`p2'==5) {
+ local C1=4.09473609924316
+ local C2=1301601790390.11
+ }
+ if (`p2'==6) {
+ local C1=-9.10118865966797
+ local C2=3480802183163.29
+ }
+ if (`p2'==7) {
+ local C1=12.6308746337891
+ local C2=3267931174533.81
+ }
+ if (`p2'==8) {
+ local C1=-10.6575126647949
+ local C2=912326437703.479
+ }
+ if (`p2'==9) {
+ local C1=4.99992036819458
+ local C2=44916975840.9114
+ }
+ }
+ if (`p1'==10){
+ if (`p2'==0) {
+ local C1=0.000199975620489568
+ local C2=120.969780523265
+ }
+ if (`p2'==1) {
+ local C1=-0.0060248076915741
+ local C2=580633.742406933
+ }
+ if (`p2'==2) {
+ local C1=0.0271593332290649
+ local C2=298292189.248646
+ }
+ if (`p2'==3) {
+ local C1=-0.118029594421387
+ local C2=32946394271.3983
+ }
+ if (`p2'==4) {
+ local C1=0.678001403808594
+ local C2=1103315909981.8
+ }
+ if (`p2'==5) {
+ local C1=-2.8924560546875
+ local C2=13331592042473
+ }
+ if (`p2'==6) {
+ local C1=8.1068115234375
+ local C2=62878798430702.7
+ }
+ if (`p2'==7) {
+ local C1=-14.8649291992188
+ local C2=117374454020910
+ }
+ if (`p2'==8) {
+ local C1=17.6541748046875
+ local C2=82487887927301
+ }
+ if (`p2'==9) {
+ local C1=-13.0838928222656
+ local C2=17947030260316.1
+ }
+ if (`p2'==10) {
+ local C1=5.49765396118164
+ local C2=715867764128.387
+ }
+ }
+ }
+ if (`kid'==3) {
+ if (`p1'==0){
+ if (`p2'==0) {
+ local C1=0.375
+ local C2=1.2
+ }
+ }
+ if (`p1'==1){
+ if (`p2'==0) {
+ local C1=-0.115789473684211
+ local C2=4.49798179659677
+ }
+ if (`p2'==1) {
+ local C1=0.842105263157895
+ local C2=16.7154728927583
+ }
+ }
+ if (`p1'==2){
+ if (`p2'==0) {
+ local C1=0.033482142857143
+ local C2=9.81646825396846
+ }
+ if (`p2'==1) {
+ local C1=-0.464285714285726
+ local C2=246.349206349214
+ }
+ if (`p2'==2) {
+ local C1=1.32812500000002
+ local C2=266.631944444454
+ }
+ }
+ if (`p1'==3){
+ if (`p2'==0) {
+ local C1=-0.00936222792511199
+ local C2=17.1423583607642
+ }
+ if (`p2'==1) {
+ local C1=0.2102461743182
+ local C2=1465.2713806652
+ }
+ if (`p2'==2) {
+ local C1=-1.05655355954787
+ local C2=8911.29621722357
+ }
+ if (`p2'==3) {
+ local C1=1.82035928143731
+ local C2=4288.56473226901
+ }
+ }
+ if (`p1'==4){
+ if (`p2'==0) {
+ local C1=0.00256405887983036
+ local C2=26.471726419711
+ }
+ if (`p2'==1) {
+ local C1=-0.0847303620927278
+ local C2=5670.24522674757
+ }
+ if (`p2'==2) {
+ local C1=0.651151696880333
+ local C2=103766.558129494
+ }
+ if (`p2'==3) {
+ local C1=-1.89587024669527
+ local C2=257166.288749527
+ }
+ if (`p2'==4) {
+ local C1=2.31540479760156
+ local C2=68979.7265596946
+ }
+ }
+ if (`p1'==5){
+ if (`p2'==0) {
+ local C1=-0.000692327266378356
+ local C2=37.8030101065867
+ }
+ if (`p2'==1) {
+ local C1=0.0315930338813359
+ local C2=16958.7194854538
+ }
+ if (`p2'==2) {
+ local C1=-0.342512696563062
+ local C2=711237.176273326
+ }
+ if (`p2'==3) {
+ local C1=1.47962261931389
+ local C2=4964148.04675615
+ }
+ if (`p2'==4) {
+ local C1=-2.98356568117015
+ local C2=6513914.18146154
+ }
+ if (`p2'==5) {
+ local C1=2.8119664051992
+ local C2=1108538.27359325
+ }
+ }
+ if (`p1'==6){
+ if (`p2'==0) {
+ local C1=0.000185013186126071
+ local C2=51.1354623094499
+ }
+ if (`p2'==1) {
+ local C1=-0.0111415456649411
+ local C2=42649.1227734126
+ }
+ if (`p2'==2) {
+ local C1=0.161503519528196
+ local C2=3501503.85604356
+ }
+ if (`p2'==3) {
+ local C1=-0.960724128526635
+ local C2=53169992.4514926
+ }
+ if (`p2'==4) {
+ local C1=2.81992441765033
+ local C2=188508235.652391
+ }
+ if (`p2'==5) {
+ local C1=-4.32027687039226
+ local C2=151705648.524794
+ }
+ if (`p2'==6) {
+ local C1=3.30943989104708
+ local C2=17800087.7625795
+ }
+ }
+ if (`p1'==7){
+ if (`p2'==0) {
+ local C1=-4.90504635308753e-05
+ local C2=66.4686791385977
+ }
+ if (`p2'==1) {
+ local C1=0.00376765715918737
+ local C2=94641.1544249395
+ }
+ if (`p2'==2) {
+ local C1=-0.0702605819096789
+ local C2=13702534.6421256
+ }
+ if (`p2'==3) {
+ local C1=0.547905247658491
+ local C2=390598570.447533
+ }
+ if (`p2'==4) {
+ local C1=-2.17951306328177
+ local C2=2911582861.44089
+ }
+ if (`p2'==5) {
+ local C1=4.79666758701205
+ local C2=6153252223.55684
+ }
+ if (`p2'==6) {
+ local C1=-5.90634610503912
+ local C2=3332903726.62978
+ }
+ if (`p2'==7) {
+ local C1=3.80750473635271
+ local C2=285633131.714089
+ }
+ }
+ if (`p1'==8){
+ if (`p2'==0) {
+ local C1=1.28009644413396e-05
+ local C2=83.8024160962497
+ }
+ if (`p2'==1) {
+ local C1=-0.0012318922963459
+ local C2=191016.021735915
+ }
+ if (`p2'==2) {
+ local C1=0.0287254140712321
+ local C2=45250162.0718378
+ }
+ if (`p2'==3) {
+ local C1=-0.283516984432936
+ local C2=2197551933.29091
+ }
+ if (`p2'==4) {
+ local C1=1.4586429297924
+ local C2=29881663369.7835
+ }
+ if (`p2'==5) {
+ local C1=-4.30135545134544
+ local C2=129595889329.345
+ }
+ if (`p2'==6) {
+ local C1=7.53462833166122
+ local C2=180547839391.581
+ }
+ if (`p2'==7) {
+ local C1=-7.74197471141815
+ local C2=70153904195.6161
+ }
+ if (`p2'==8) {
+ local C1=4.30597522854805
+ local C2=4581150539.5851
+ }
+ }
+ if (`p1'==9){
+ if (`p2'==0) {
+ local C1=-2.56981365964748e-06
+ local C2=103.136967120782
+ }
+ if (`p2'==1) {
+ local C1=0.000382994418032467
+ local C2=357882.128373971
+ }
+ if (`p2'==2) {
+ local C1=-0.0111749973148108
+ local C2=131065694.25377
+ }
+ if (`p2'==3) {
+ local C1=0.136033833026886
+ local C2=10117813548.0377
+ }
+ if (`p2'==4) {
+ local C1=-0.875308513641357
+ local C2=228745243443.724
+ }
+ if (`p2'==5) {
+ local C1=3.30519819259644
+ local C2=1772311718505.28
+ }
+ if (`p2'==6) {
+ local C1=-7.69141054153442
+ local C2=4976168741761.24
+ }
+ if (`p2'==7) {
+ local C1=11.1589169502258
+ local C2=4895118462920.4
+ }
+ if (`p2'==8) {
+ local C1=-9.82742595672607
+ local C2=1429179266718.81
+ }
+ if (`p2'==9) {
+ local C1=4.80476921796799
+ local C2=73448661555.592
+ }
+ }
+ if (`p1'==10){
+ if (`p2'==0) {
+ local C1=0.000106673240225064
+ local C2=124.520672499749
+ }
+ if (`p2'==1) {
+ local C1=-0.00113465404137969
+ local C2=632044.740476285
+ }
+ if (`p2'==2) {
+ local C1=0.00709155201911926
+ local C2=342376453.533928
+ }
+ if (`p2'==3) {
+ local C1=-0.0642940998077393
+ local C2=39880130461.1472
+ }
+ if (`p2'==4) {
+ local C1=0.481655120849609
+ local C2=1403708230458.23
+ }
+ if (`p2'==5) {
+ local C1=-2.25773620605469
+ local C2=17759178822082.7
+ }
+ if (`p2'==6) {
+ local C1=6.68578338623047
+ local C2=87680850871448.7
+ }
+ if (`p2'==7) {
+ local C1=-12.7984313964844
+ local C2=171433376795336
+ }
+ if (`p2'==8) {
+ local C1=15.8130035400391
+ local C2=125143858240646
+ }
+ if (`p2'==9) {
+ local C1=-12.1715126037598
+ local C2=28437327354854.3
+ }
+ if (`p2'==10) {
+ local C1=5.30557250976562
+ local C2=1179682266812.88
+ }
+ }
+ }
+
+ 
+ ereturn scalar C1=`C1'
+ ereturn scalar C2=`C2'
+ 
+ 
+ 
+ end 
+ 

30/replication_package/Adofiles/rd_2021/rddensity.ado

@@ -0,0 +1,1406 @@
+********************************************************************************
+* RDDENSITY STATA PACKAGE -- rddensity
+* Authors: Matias D. Cattaneo, Michael Jansson, Xinwei Ma
+********************************************************************************
+*!version 2.3 2021-02-28
+
+capture program drop rddensityEST
+
+program define rddensityEST, eclass
+syntax varlist(max=1) [if] [in] [, 	///
+c(real 0) 							///
+p(integer 2) 						///
+q(integer 0) 						///
+fitselect(string) 					///
+kernel(string) 						///
+h(string) 							///
+bwselect(string) 					///
+vce(string) 						///
+all									///
+noMASSpoints						///
+noREGularize 			    		///
+NLOCalmin (integer -1)				///
+NUNIquemin (integer -1)				///
+]
+
+	marksample touse
+
+	if (`q'==0) local q = `p' + 1
+	if ("`fitselect'"=="") local fitselect = "unrestricted"
+	local fitselect = lower("`fitselect'")
+	if ("`kernel'"=="") local kernel = "triangular"
+	local kernel = lower("`kernel'")
+	if ("`bwselect'"=="") local bwselect = "comb"
+	local bwselect = lower("`bwselect'")
+	if ("`vce'"=="") local vce = "jackknife"
+	local vce = lower("`vce'")
+	
+	tokenize `h'	
+	local w : word count `h'
+	if `w' == 0 {
+		local hl 0
+		local hr 0
+	}
+	if `w' == 1 {
+		local hl `"`1'"'
+		local hr `"`1'"'
+	}
+	if `w' == 2 {
+		local hl `"`1'"'
+		local hr `"`2'"'
+	}
+	if `w' >= 3 {
+		di as error  "{err}{cmd:h()} only accepts two inputs."  
+		exit 125
+	}
+
+	preserve
+	qui keep if `touse'
+
+	local x "`varlist'"
+
+	qui drop if `x'==.
+	
+	qui su `x'
+	local x_min = r(min)
+	local x_max = r(max)
+	local N = r(N)
+
+	qui count if `x'<`c'
+	local Nl = r(N)
+	qui count if `x'>=`c'
+	local Nr = r(N)
+
+	****************************************************************************
+	*** BEGIN ERROR HANDLING *************************************************** 
+	if (`c'<=`x_min' | `c'>=`x_max'){
+		di "{err}{cmd:c()} should be set within the range of `x'."  
+		exit 125
+	}
+	
+	if (`Nl'<10 | `Nr'<10){
+		di "{err}Not enough observations to perform calculations."  
+		exit 2001
+	}
+	
+	if (`p'!=1 & `p'!=2 & `p'!=3 & `p'!=4 & `p'!=5 & `p'!=6 & `p'!=7){
+		di "{err}{cmd:p()} should be an integer value less or equal than 7."  
+		exit 125
+	}
+	
+	if (`p'>`q'){
+		di "{err}{cmd:p()} should be an integer value no larger than {cmd:q()}."  
+		exit 125
+	}
+
+	if ("`kernel'"!="uniform" & "`kernel'"!="triangular" & "`kernel'"!="epanechnikov"){
+		di "{err}{cmd:kernel()} incorrectly specified."  
+		exit 7
+	}
+
+	if ("`fitselect'"!="restricted" & "`fitselect'"!="unrestricted"){
+		di "{err}{cmd:fitselect()} incorrectly specified."  
+		exit 7
+	}
+
+	if (`hl'<0){
+		di "{err}{cmd:hl()} must be a positive real number."  
+		exit 411
+	}
+
+	if (`hr'<0){
+		di "{err}{cmd:hr()} must be a positive real number."  
+		exit 411
+	}
+
+	if ("`fitselect'"=="restricted" & `hl'!=`hr'){
+		di "{err}{{cmd:hl()} and {cmd:hr()} must be equal in the restricted model."  
+		exit 7
+	}
+
+	if ("`bwselect'"!="each" & "`bwselect'"!="diff" & "`bwselect'"!="sum" & "`bwselect'"!="comb"){
+		di "{err}{cmd:bwselect()} incorrectly specified."  
+		exit 7
+	}
+
+	if ("`fitselect'"=="restricted" & "`bwselect'"=="each"){
+		di "{err}{cmd:bwselect(each)} is not available in the restricted model."  
+		exit 7
+	}
+
+	if ("`vce'"!="jackknife" & "`vce'"!="plugin"){ 
+		di "{err}{cmd:vce()} incorrectly specified."  
+		exit 7
+	}
+	
+	if ("`regularize'" == "") {
+		local regularize = 1
+		local Tempregularize = "regularize"
+	}
+	else {
+		local regularize = 0
+		local Tempregularize = "noregularize"
+	}
+
+	if ("`masspoints'" == "") {
+		local masspoints = 1
+		local Tempmasspoints = "masspoints"
+	}
+	else {
+		local masspoints = 0
+		local Tempmasspoints = "nomasspoints"
+	}
+
+	if (`nlocalmin' < 0) {
+		local nlocalmin = 20 + `p' + 1
+	}
+
+	if (`nuniquemin' < 0) {
+		local nuniquemin = 20 + `p' + 1
+	}
+	*** END ERROR HANDLING ***************************************************** 
+	****************************************************************************
+
+	****************************************************************************
+	*** BEGIN BANDWIDTH SELECTION ********************************************** 
+	if ("`h'"!="") {
+        local bwmethod = "manual"
+	}
+		
+	if (`hl'==0 | `hr'==0) {
+	    local bwmethod = "`bwselect'"
+		disp in ye "Computing data-driven bandwidth selectors."
+		qui rdbwdensity `x', c(`c') p(`p') kernel(`kernel') fitselect(`fitselect') vce(`vce') ///
+			nlocalmin(`nlocalmin') nuniquemin(`nuniquemin') `Tempregularize' `Tempmasspoints'
+		mat out = e(h)
+		if ("`fitselect'"=="unrestricted" & "`bwselect'"=="each" & `hl'==0) local hl = out[1,1]
+		if ("`fitselect'"=="unrestricted" & "`bwselect'"=="each" & `hr'==0) local hr = out[2,1]
+		if ("`fitselect'"=="unrestricted" & "`bwselect'"=="diff" & `hl'==0) local hl = out[3,1]
+		if ("`fitselect'"=="unrestricted" & "`bwselect'"=="diff" & `hr'==0) local hr = out[3,1]
+		if ("`fitselect'"=="unrestricted" & "`bwselect'"=="sum"  & `hl'==0) local hl = out[4,1]
+		if ("`fitselect'"=="unrestricted" & "`bwselect'"=="sum"  & `hr'==0) local hr = out[4,1]
+		if ("`fitselect'"=="unrestricted" & "`bwselect'"=="comb" & `hl'==0) local hl = out[1,1]+out[3,1]+out[4,1] - min(out[1,1],out[3,1],out[4,1]) - max(out[1,1],out[3,1],out[4,1])
+		if ("`fitselect'"=="unrestricted" & "`bwselect'"=="comb" & `hr'==0) local hr = out[2,1]+out[3,1]+out[4,1] - min(out[2,1],out[3,1],out[4,1]) - max(out[2,1],out[3,1],out[4,1])
+
+		if ("`fitselect'"=="restricted" & "`bwselect'"=="diff" & `hl'==0) local hl = out[3,1]
+		if ("`fitselect'"=="restricted" & "`bwselect'"=="diff" & `hr'==0) local hr = out[3,1]
+		if ("`fitselect'"=="restricted" & "`bwselect'"=="sum"  & `hl'==0) local hl = out[4,1]
+		if ("`fitselect'"=="restricted" & "`bwselect'"=="sum"  & `hr'==0) local hr = out[4,1]
+		if ("`fitselect'"=="restricted" & "`bwselect'"=="comb" & `hl'==0) local hl = min(out[3,1],out[4,1])
+		if ("`fitselect'"=="restricted" & "`bwselect'"=="comb" & `hr'==0) local hr = min(out[3,1],out[4,1])
+	}
+	*** END BANDWIDTH SELECTION ************************************************ 
+	****************************************************************************
+	qui replace `x' = `x'-`c'
+	
+	qui count if `x'<0 & `x'>= -`hl'
+	if (`r(N)'<5){
+	 display("{err}Not enough observations on the left to perform calculations.")
+	 exit(1)
+	}
+	local Nlh = r(N)
+
+	qui count if `x'>=0 & `x'<=`hr'
+	if (`r(N)'<5){
+	 display("{err}Not enough observations on the right to perform calculations.")
+	 exit(1)
+	}
+	local Nrh = r(N)
+	local Nh = `Nlh' + `Nrh'
+
+	qui sort `x'
+
+	****************************************************************************
+	*** BEGIN MATA ESTIMATION ************************************************** 
+	mata{
+	X = st_data(.,("`x'"), 0)
+	
+	XUnique   	= rddensity_unique(X)
+	freqUnique  = XUnique[., 2]
+	indexUnique = XUnique[., 4]
+	XUnique     = XUnique[., 1]
+	NUnique     = length(XUnique)
+	NlUnique    = sum(XUnique :<  0)
+	NrUnique    = sum(XUnique :>= 0)
+	
+	Y = (0..(`N'-1))' :/ (`N'-1)
+	if (`masspoints') {
+		Y = rddensity_rep(Y[indexUnique], freqUnique)
+	}
+	masspoints_flag = sum(freqUnique :!= 1) > 0 & `masspoints'
+
+	Y = select(Y, X :>= -`hl' :& X :<= `hr')
+	X = select(X, X :>= -`hl' :& X :<= `hr')
+	fV_q = rddensity_fv(Y, X, `Nl', `Nr', `Nlh', `Nrh', `hl', `hr', `q', 1, "`kernel'", "`fitselect'", "`vce'", `masspoints')
+	T_q  = fV_q[3,1] / sqrt(fV_q[3,2])
+	st_numscalar("f_ql", fV_q[1,1]); st_numscalar("f_qr", fV_q[2,1])
+	st_numscalar("se_ql", sqrt(fV_q[1,2])); st_numscalar("se_qr", sqrt(fV_q[2,2]))
+	st_numscalar("se_q", sqrt(fV_q[3,2]))
+	st_numscalar("T_q", T_q); st_numscalar("pval_q", 2*normal(-abs(T_q)))
+
+	if ("`all'"!=""){
+		fV_p = rddensity_fv(Y, X, `Nl', `Nr', `Nlh', `Nrh', `hl', `hr', `p', 1, "`kernel'", "`fitselect'", "`vce'", `masspoints')
+		T_p  = fV_p[3,1] / sqrt(fV_p[3,2])
+		st_numscalar("f_pl", fV_p[1,1]); st_numscalar("f_pr", fV_p[2,1])
+		st_numscalar("se_pl", sqrt(fV_p[1,2])); st_numscalar("se_pr", sqrt(fV_p[2,2]))
+		st_numscalar("se_p", sqrt(fV_p[3,2]))
+		st_numscalar("T_p", T_p); st_numscalar("pval_p", 2*normal(-abs(T_p)))
+	}
+	st_numscalar("masspoints_flag", masspoints_flag)
+	*display("Estimation completed.") 
+	}
+	*** END MATA ESTIMATION **************************************************** 
+	****************************************************************************
+
+	****************************************************************************
+	*** BEGIN OUTPUT TABLE ***************************************************** 
+	
+	if (`hl' > `c'-`x_min') {
+		disp ""
+		disp "Bandwidth {it:hl} greater than the range of the data."
+	} 
+	if (`hr' > `x_max'-`c') {
+		disp ""
+		disp "Bandwidth {it:hr} greater than the range of the data."
+	}
+	if (`Nlh'<20 | `Nrh'<20) disp in red "Bandwidth {it:h} may be too small."
+	if (masspoints_flag == 1) {
+		disp ""
+		disp "Point estimates and standard errors have been adjusted for repeated observations."
+		disp "(Use option {it:nomasspoints} to suppress this adjustment.)"
+	}
+	
+	disp ""
+	disp "RD Manipulation test using local polynomial density estimation." 
+
+	disp ""
+	disp in smcl in gr "{ralign 9: c = }" in ye %9.3f `c'			_col(19) " {c |}" 	_col(22) in gr "Left of c"  		_col(33) in gr "Right of c" 	_col(53) in gr "Number of obs = "  in ye %12.0f `N'
+	disp in smcl in gr "{hline 19}{c +}{hline 22}"                                                                                                     					_col(53) in gr "Model         = "  in ye "{ralign 12:`fitselect'}"
+	disp in smcl in gr "{ralign 18:Number of obs}"        		_col(19) " {c |} " 	_col(21) as result %9.0f `Nl'      			_col(34) %9.0f  `Nr'                   	_col(53) in gr "BW method     = "  in ye "{ralign 12:`bwmethod'}" 
+	disp in smcl in gr "{ralign 18:Eff. Number of obs}"   		_col(19) " {c |} " 	_col(21) as result %9.0f `Nlh'     			_col(34) %9.0f  `Nrh'                  	_col(53) in gr "Kernel        = "  in ye "{ralign 12:`kernel'}"
+	disp in smcl in gr "{ralign 18:Order est. (p)}" 			_col(19) " {c |} " 	_col(21) as result %9.0f `p'       			_col(34) %9.0f  `p'                    	_col(53) in gr "VCE method    = "  in ye "{ralign 12:`vce'}"
+	disp in smcl in gr "{ralign 18:Order bias (q)}"         	_col(19) " {c |} " 	_col(21) as result %9.0f `q'       			_col(34) %9.0f  `q'                             
+	disp in smcl in gr "{ralign 18:BW est. (h)}"				_col(19) " {c |} " 	_col(21) as result %9.3f `hl'      			_col(34) %9.3f  `hr'
+
+	disp ""
+	disp "Running variable: `x'."
+	disp in smcl in gr "{hline 19}{c TT}{hline 22}"
+	disp in smcl in gr "{ralign 18:Method}"                		_col(19) " {c |} " _col(23) "    T"          _col(38) "P>|T|" 
+	disp in smcl in gr "{hline 19}{c +}{hline 22}"
+	if ("`all'"!="" & `q'>`p'){
+		disp in smcl in gr "{ralign 18:Conventional}"      		_col(19) " {c |} " _col(21) in ye %9.4f T_p  _col(34) %9.4f pval_p
+	}
+	if (`q'>`p') {
+		disp in smcl in gr "{ralign 18:Robust}" 			    _col(19) " {c |} " _col(21) in ye %9.4f T_q  _col(34) %9.4f pval_q
+	}
+	else {
+		disp in smcl in gr "{ralign 18:Conventional}" 			_col(19) " {c |} " _col(21) in ye %9.4f T_q  _col(34) %9.4f pval_q
+	}
+	
+
+	disp in smcl in gr "{hline 19}{c BT}{hline 22}"
+	disp ""
+
+	*** END OUTPUT TABLE ******************************************************* 
+	****************************************************************************
+
+	restore
+
+	ereturn clear
+	ereturn scalar c = `c'
+	ereturn scalar p = `p'
+	ereturn scalar q = `q'
+	ereturn scalar N_l = `Nl'
+	ereturn scalar N_r = `Nr'
+	ereturn scalar N_h_l = `Nlh'
+	ereturn scalar N_h_r = `Nrh'
+	ereturn scalar h_l = `hl'
+	ereturn scalar h_r = `hr'
+	ereturn scalar f_ql = f_ql
+	ereturn scalar f_qr = f_qr
+	ereturn scalar se_ql = se_ql
+	ereturn scalar se_qr = se_qr
+	ereturn scalar se_q = se_q
+	ereturn scalar pv_q = pval_q
+	ereturn scalar T_q = T_q
+
+	if ("`all'"!=""){
+		ereturn scalar f_pl = f_pl
+		ereturn scalar f_pr = f_pr
+		ereturn scalar se_pl = se_pl
+		ereturn scalar se_pr = se_pr
+		ereturn scalar se_p = se_p
+		ereturn scalar pv_p = pval_p
+		ereturn scalar T_p = T_p
+	}
+	
+	ereturn local runningvar "`x'"
+	ereturn local kernel = "`kernel'"
+	ereturn local bwmethod = "`bwmethod'"
+	ereturn local vce = "`vce'"
+
+	mata: mata clear
+	
+end
+	
+********************************************************************************
+* MAIN PROGRAM
+********************************************************************************
+
+capture program drop rddensity
+
+program define rddensity, eclass
+	syntax 	varlist(max=1) 					///
+			[if] [in] [, 					///
+			/* Estimation */				///
+			C(real 0) 						///
+			P(integer 2) 					///
+			Q(integer 0) 					///
+			FITselect(string) 				///
+			KERnel(string) 					///
+			VCE(string) 					///
+			noMASSpoints					///
+			/* Bandwidth selection */		///
+			H(string) 						///
+			BWselect(string) 				///
+			noREGularize 			    	///
+			  NLOCalmin (integer -1)		///
+			  NUNIquemin (integer -1)		///
+			/* Binomial test */				///
+			noBINOmial 						///
+			bino_n(integer 0)				///
+			bino_nstep(integer 0)  			///
+			bino_w(string)					///
+			bino_wstep(string)				///
+			bino_nw(integer 10)				///
+			bino_p(real 0.5)				///
+			/* Plot */						///
+			PLot							///
+			plot_range(string)				///
+			plot_n(string)					///
+			plot_grid(string)				///
+			plot_bwselect(string) 			///
+			plot_ciuniform					///
+			  plot_cisimul(integer 2000)	///
+			plotl_estype(string)			///
+			  esll_opt(string)				///
+			  espl_opt(string)				///
+			plotr_estype(string)			///
+			  eslr_opt(string)				///
+			  espr_opt(string)				///
+			plotl_citype(string)			///
+			  cirl_opt(string)				///
+			  cill_opt(string)				///
+			  cibl_opt(string)				///
+			plotr_citype(string)			///
+			  cirr_opt(string)				///
+			  cilr_opt(string)				///
+			  cibr_opt(string)				///
+			/* Histogram */					///
+			noHISTogram		 				///
+			hist_range(string)				///
+			hist_n(string)					///
+			hist_width(string)				///
+			  histl_opt(string)				///
+			  histr_opt(string)				///
+			/* Additional grph options */	///
+			graph_opt(string)				///
+			GENVars(string)					///
+			/* Reporting */					///
+			LEVel(real 95) 					///
+			ALL 							///
+			]
+
+	marksample touse
+	
+	local x "`varlist'"
+	
+	****************************************************************************
+	*** CALL: RDDENSITYEST ********************************************************
+
+	if ("`regularize'" == "") {
+		local regularize = "regularize"
+	}
+	else {
+		local regularize = "noregularize"
+	}
+
+	if ("`masspoints'" == "") {
+		local masspoints = "masspoints"
+	}
+	else {
+		local masspoints = "nomasspoints"
+	}
+	
+	if ("`all'" != "") {
+		local all = "all"
+	}
+	else {
+		local all = ""
+	}
+	
+	rddensityEST `x' if `touse', ///
+			c(`c') p(`p') q(`q') fitselect(`fitselect') kernel(`kernel') h(`h') bwselect(`bwselect') vce(`vce') ///
+			`regularize' `masspoints' `all' nlocalmin(`nlocalmin') nuniquemin(`nuniquemin')
+	
+	/// save ereturn results
+	local c 			= e(c)
+    local p 			= e(p)
+	local q 			= e(q)
+	local N_l 			= e(N_l)
+	local N_r 			= e(N_r)
+    local N_h_l 		= e(N_h_l)
+    local N_h_r 		= e(N_h_r)
+    local h_l 			= e(h_l)
+    local h_r 			= e(h_r)
+    local f_ql 			= e(f_ql)
+    local f_qr 			= e(f_qr)
+    local se_ql 		= e(se_ql)
+    local se_qr 		= e(se_qr)
+    local se_q 			= e(se_q)
+    local pv_q 			= e(pv_q)
+	local T_q 			= e(T_q)
+	
+	if ("`all'" != ""){
+    local f_pl 			= e(f_pl)
+    local f_pr 			= e(f_pr)
+	local se_pl 		= e(se_pl)
+    local se_pr 		= e(se_pr)
+    local se_p 			= e(se_p)
+    local pv_p 			= e(pv_p)
+	local T_p 			= e(T_p)
+	}
+	
+	local vce 			= e(vce)
+	local bwmethod 		= e(bwmethod)
+    local kernel 		= e(kernel)
+    local runningvar 	= e(runningvar)
+	
+	****************************************************************************
+	*** BINOMIAL TEST **********************************************************
+	
+	// determine initial window width
+	if ("`bino_w'" != "") {
+		local flag_ini_window = "w_provided"
+	} 
+	else if (`bino_n' != 0) {
+		local flag_ini_window = "n_provided"
+	}
+	else {
+		local flag_ini_window = "automatic"
+	}
+	
+	// determine window increment
+	if ("`bino_wstep'" != "") {
+		local flag_step_window = "w_provided"
+	}
+	else if (`bino_nstep' != 0) {
+		local flag_step_window = "n_provided"
+	}
+	else {
+		local flag_step_window = "automatic"
+	}
+	
+	// bino_w check
+	tokenize `bino_w'	
+	local w : word count `bino_w'
+	if (`w' == 0) {
+		local bino_w_l = 0
+		local bino_w_r = 0
+	}
+	else if (`w' == 1) {
+		local bino_w_l `"`1'"'
+		local bino_w_r `"`1'"'
+		if (`bino_w_l' <= 0) {
+			di as err `"{err}{cmd:bino_w()}: incorrectly specified (should be a positive number)"'
+			exit 198
+		} 
+	}
+	else if (`w' == 2) {
+		local bino_w_l `"`1'"'
+		local bino_w_r `"`2'"'
+		if (`bino_w_l' <= 0 | `bino_w_r' <= 0) {
+			di as err `"{err}{cmd:bino_w()}: incorrectly specified (should be positive numbers)"'
+			exit 198
+		}
+	}
+	else {
+		di as error  "{err}{cmd:bino_w()} takes at most two inputs."  
+		exit 125
+	}
+	
+	// bino_n check
+	if (`bino_n' > 0) {
+		// do nothing
+	}
+	else if (`bino_n' < 0) {
+		di as err `"{err}{cmd:bino_n()}: incorrectly specified (should be a positive integer)"'
+		exit 198
+	}
+	else {
+		local bino_n = 20
+	}
+	
+	// bino_wstep check
+	tokenize `bino_wstep'	
+	local w : word count `bino_wstep'
+	if (`w' == 0) {
+		local bino_wstep_l = 0
+		local bino_wstep_r = 0
+	}
+	else if (`w' == 1) {
+		local bino_wstep_l `"`1'"'
+		local bino_wstep_r `"`1'"'
+		if (`bino_wstep_l' <= 0) {
+			di as err `"{err}{cmd:bino_wstep()}: incorrectly specified (should be a positive number)"'
+			exit 198
+		} 
+	}
+	else if (`w' == 2) {
+		local bino_wstep_l `"`1'"'
+		local bino_wstep_r `"`2'"'
+		if (`bino_wstep_l' <= 0 | `bino_wstep_r' <= 0) {
+			di as err `"{err}{cmd:bino_wstep()}: incorrectly specified (should be positive numbers)"'
+			exit 198
+		}
+	}
+	else {
+		di as error  "{err}{cmd:bino_wstep()} takes at most two inputs."  
+		exit 125
+	}
+	
+	// bino_nstep check
+	if (`bino_nstep' > 0) {
+		// do nothing
+	}
+	else if (`bino_nstep' < 0) {
+		di as err `"{err}{cmd:bino_nstep()}: incorrectly specified (should be a positive integer)"'
+		exit 198
+	}
+	else {
+		// do nothing
+	}
+	
+	// bino_nw check
+	if (`bino_nw' <= 0) {
+		di as err `"{err}{cmd:bino_nw()}: incorrectly specified (should be a positive integer)"'
+		exit 198
+	}
+	
+	// bino_p check
+	if (`bino_p'<=0 | `bino_p'>=1) {
+		di as err `"{err}{cmd:bino_p()}: incorrectly specified (should be between 0 and 1)"'
+		exit 198
+	}
+
+	// calculate windows
+	mata {
+	if ("`binomial'" == "") {
+
+	X = st_data(.,("`x'"), 0)
+	XL = sort(abs(select(X, X :< `c') :- `c'), 1)
+	XR = sort(select(X, X :>= `c') :- `c', 1)
+	Y = sort(abs(X :- `c'), 1)
+	binomTempLWindow = J(`bino_nw', 1, .)
+	binomTempRWindow = J(`bino_nw', 1, .)
+
+	// initial window width
+	if ("`flag_ini_window'" == "w_provided") {
+		binomTempLWindow[1] = `bino_w_l'
+		binomTempRWindow[1] = `bino_w_r'
+	} 
+	else {
+		binomTempLWindow[1] = Y[min((`bino_n', `N_l'+`N_r'))]
+		binomTempRWindow[1] = binomTempLWindow[1]
+	}
+	
+	// window increment
+	if (`bino_nw' > 1) {
+	if ("`flag_step_window'" == "w_provided") {
+		binomTempLWindow[2..`bino_nw', 1] = (1..(`bino_nw'-1))' :* `bino_wstep_l' :+ binomTempLWindow[1]
+		binomTempRWindow[2..`bino_nw', 1] = (1..(`bino_nw'-1))' :* `bino_wstep_r' :+ binomTempRWindow[1]
+	}
+	else if ("`flag_step_window'" == "n_provided") {
+		for (jj=2; jj<=`bino_nw'; jj++) {
+			if ("`flag_ini_window'" == "w_provided") {
+				binomTempLWindow[jj] = Y[min((sum(XL :<= binomTempLWindow[1]) + sum(XR :<= binomTempRWindow[1]) + (jj-1) * `bino_nstep', `N_l'+`N_r'))]
+				binomTempRWindow[jj] = binomTempLWindow[jj]
+			}
+			else {
+				binomTempLWindow[jj] = Y[min((`bino_n' + (jj-1) * `bino_nstep', `N_l'+`N_r'))]
+				binomTempRWindow[jj] = binomTempLWindow[jj]
+			}
+		}
+	}
+	else {
+		if (binomTempLWindow[1] >= `h_l' | binomTempRWindow[1] >= `h_r') {
+			// exceed bandwidth on either side
+			binomTempLWindow = binomTempLWindow[1]
+			binomTempRWindow = binomTempRWindow[1]
+		}
+		else {
+			if (binomTempLWindow[1]*`bino_nw' > `h_l') {
+				binomTempLWindow[2..`bino_nw', 1] = (1..(`bino_nw'-1))' :* ((`h_l'-binomTempLWindow[1])/(`bino_nw'-1)) :+ binomTempLWindow[1]
+			}
+			else {
+				binomTempLWindow[2..`bino_nw', 1] = (1..(`bino_nw'-1))' :* binomTempLWindow[1] :+ binomTempLWindow[1]
+			}
+			
+			if (binomTempRWindow[1]*`bino_nw' > `h_r') {
+				binomTempRWindow[2..`bino_nw', 1] = (1..(`bino_nw'-1))' :* ((`h_r'-binomTempRWindow[1])/(`bino_nw'-1)) :+ binomTempRWindow[1]
+			}
+			else {
+				binomTempRWindow[2..`bino_nw', 1] = (1..(`bino_nw'-1))' :* binomTempRWindow[1] :+ binomTempRWindow[1]
+			}
+		}
+	}
+	}
+	
+	// window sample size
+	binomTempLN	     = J(rows(binomTempLWindow), 1, .)
+	binomTempRN      = J(rows(binomTempLWindow), 1, .)
+	
+	for (jj=1; jj<=rows(binomTempLWindow); jj++) {
+		binomTempLN[jj] = sum(XL :<= binomTempLWindow[jj])
+		binomTempRN[jj] = sum(XR :<= binomTempRWindow[jj])
+	}
+	
+	// binomTempLWindow
+	// binomTempRWindow
+	// binomTempLN
+	// binomTempRN
+	// rows(binomTempLWindow)
+
+	st_matrix("binomTempLeftWindow" , binomTempLWindow)
+	st_matrix("binomTempRightWindow", binomTempRWindow)
+	st_matrix("binomTempLeftN" , binomTempLN)
+	st_matrix("binomTempRightN", binomTempRN)
+	st_matrix("binomTempNumber", rows(binomTempLWindow))
+	st_matrix("binomTempEqualWindow", sum(binomTempLWindow != binomTempRWindow) == 0)
+
+	}
+	}
+
+	local binomTempNumber = binomTempNumber[1,1]
+	local binomTempEqualWindow = binomTempEqualWindow[1,1]
+
+	if ("`binomial'" == "") {
+		disp in ye "P-values of binomial tests." in gr " (H0: prob = `bino_p')"
+		disp in smcl in gr "{hline 19}{c TT}{hline 22}{c TT}{hline 10}"
+		
+		
+
+	if (`binomTempEqualWindow' == 1) {
+		disp in smcl in gr "{ralign 18: Window Length / 2}"            			_col(20) "{c |}"  "{ralign 9: <c}" 		_col(33)	"{ralign 9: >=c}"		_col(43) "{c |}" _col(49) "P>|T|"
+	}
+	else {
+		disp in smcl in gr "{ralign 18: Window Length}"            				_col(20) "{c |}"  "{ralign 9: <c}" 		_col(33)	"{ralign 9: >=c}"		_col(43) "{c |}" _col(49) "P>|T|"
+	}
+	
+	disp in smcl in gr "{hline 19}{c +}{hline 22}{c +}{hline 10}"
+	
+	forvalues i = 1(1)`binomTempNumber' {
+			local binomTempTotal   = binomTempLeftN[`i', 1] + binomTempRightN[`i', 1]
+			local binomTempSuccess = binomTempLeftN[`i', 1]
+			if (`binomTempTotal' > 0) {
+				qui bitesti `binomTempTotal' `binomTempSuccess' `bino_p'
+				if (`binomTempEqualWindow' == 1) {
+					disp in smcl in ye _col(10) %9.3f binomTempLeftWindow[`i',1] 	_col(20) "{c |}"  %9.0f binomTempLeftN[`i',1] 	_col(33) %9.0f binomTempRightN[`i',1] 	_col(43) "{c |}" _col(45) %9.4f r(p)
+				}
+				else {
+					disp in smcl in ye %8.3f binomTempLeftWindow[`i',1] _col(10) "+" %8.3f binomTempRightWindow[`i',1] _col(20) "{c |}"  %9.0f binomTempLeftN[`i',1] _col(33) %9.0f binomTempRightN[`i',1] _col(43) "{c |}" _col(45) %9.4f r(p)
+				}
+			}
+			else {
+				if (`binomTempEqualWindow' == 1) {
+					disp in smcl in ye _col(10) %9.3f binomTempLeftWindow[`i',1] 	_col(20) "{c |}"  %9.0f 0 						_col(33) %9.0f  0 						_col(43) "{c |}" _col(45) %9.4f 1.0000
+				}
+				else {
+					disp in smcl in ye %8.3f binomTempLeftWindow[`i',1] _col(10) "+" %8.3f binomTempRightWindow[`i',1] _col(20) "{c |}"  %9.0f 0 _col(33) %9.0f 0 _col(43) "{c |}" _col(45) %9.4f 1.0000
+				}
+			}
+	}
+	
+	disp in smcl in gr "{hline 19}{c BT}{hline 22}{c BT}{hline 10}"
+	
+	}
+	
+	****************************************************************************
+	*** LPDENSITY **************************************************************
+	
+	// plot_range
+	tokenize `plot_range'	
+	local w : word count `plot_range'
+	if `w' == 0 {
+		qui sum `x'
+		if (`c' - 3 * `h_l' < r(min)) {
+			local plot_range_l = r(min)
+		} 
+		else {
+			local plot_range_l = `c' - 3 * `h_l'
+		}
+		if (`c' + 3 * `h_r' > r(max)) {
+			local plot_range_r = r(max)
+		} 
+		else {
+			local plot_range_r = `c' + 3 * `h_r'
+		}
+	}
+	if `w' == 1 {
+		di as error  "{err}{cmd:plot_range()} takes two inputs."  
+		exit 125
+	}
+	if `w' == 2 {
+		local plot_range_l `"`1'"'
+		local plot_range_r `"`2'"'
+	}
+	if `w' >= 3 {
+		di as error  "{err}{cmd:plot_range()} takes two inputs."  
+		exit 125
+	}
+	
+	// plot_n
+	tokenize `plot_n'	
+	local w : word count `plot_n'
+	if `w' == 0 {
+		local plot_n_l = 10
+		local plot_n_r = 10
+	}
+	if `w' == 1 {
+		local plot_n_l `"`1'"'
+		local plot_n_r `"`1'"'
+		if (`plot_n_l' <= 0) {
+			di as err `"{err}{cmd:plot_n()}: incorrectly specified (should be a positive integer)"'
+			exit 198
+		}
+	}
+	if `w' == 2 {
+		local plot_n_l `"`1'"'
+		local plot_n_r `"`2'"'
+		if (`plot_n_l' <= 0 | `plot_n_r' <= 0) {
+			di as err `"{err}{cmd:plot_n()}: incorrectly specified (should be positive integers)"'
+			exit 198
+		}
+	}
+	if `w' >= 3 {
+		di as error  "{err}{cmd:plot_n()} takes two inputs."  
+		exit 125
+	}
+	
+	// plot_grid
+	if ("`plot_grid'" == "") {
+		local plot_grid "es"
+	}
+	else {
+		if ("`plot_grid'" != "es" & "`plot_grid'" != "qs") {
+			di as error  "{err}{cmd:plot_grid()} incorrectly specified."  
+			exit 125
+		}
+	}
+	
+	// level
+	if (`level' <= 0 | `level' >= 100) {
+	di as err `"{err}{cmd:level()}: incorrectly specified"'
+	exit 198
+	}
+	
+	// plot
+	if ("`plot'" != "") {
+		local plot = 1
+		capture which lpdensity
+		if (_rc == 111) {
+			di as error  `"{err}plotting feature requires command {cmd:lpdensity}, install with"'
+			di as error  `"{err}net install lpdensity, from(https://raw.githubusercontent.com/nppackages/lpdensity/master/stata) replace"'
+			exit 111
+		}
+	}
+	else {
+		local plot = 0
+	}
+
+	if (`plot' == 1) {
+		
+		if (`plot_n_l' + `plot_n_r' > _N) {
+			local newN = `plot_n_l' + `plot_n_r'
+			set obs `newN'
+		}
+		tempvar temp_grid
+		qui gen `temp_grid' = .
+		tempvar temp_bw
+		qui gen `temp_bw' = .
+		tempvar temp_f
+		qui gen `temp_f' = .
+		tempvar temp_cil
+		qui gen `temp_cil' = .
+		tempvar temp_cir
+		qui gen `temp_cir' = .
+		tempvar temp_group
+		qui gen `temp_group' = .
+		
+	}
+
+	// MATA
+	mata{	
+	ng = `plot_n_l' + `plot_n_r'
+	if (`plot' == 1) {
+		// generate grid
+		if ("`plot_grid'" == "es") {
+			grid = ( rangen(`plot_range_l', `c' - ( (`c' - `plot_range_l') / (`plot_n_l' - 1) ), `plot_n_l' - 1) \ `c' \ `c' \ rangen(`c' + ( (`plot_range_r' - `c') / (`plot_n_r' - 1) ), `plot_range_r', `plot_n_r' - 1) )
+		} else {
+			x = st_data(., "`x'", "`touse'")
+			temp1 = mean(x :<= `plot_range_l')
+			temp2 = mean(x :<= `c')
+			temp3 = mean(x :<= `plot_range_r')
+			grid = ( rangen(temp1, temp2 - ( (temp2 - temp1) / (`plot_n_l' - 1) ), `plot_n_l' - 1) \ temp2 \ temp2 \ rangen(temp2 + ( (temp3 - temp2) / (`plot_n_r' - 1) ), temp3, `plot_n_r' - 1) )
+			for (j=1; j<=length(grid); j++) {
+				grid[j] = rddensity_quantile(x, grid[j])
+			}
+			grid[`plot_n_l'] = `c'
+			grid[`plot_n_l' + 1] = `c'
+		}
+		
+		// generate group
+		group = ( J(`plot_n_l', 1, 0) \ J(`plot_n_r', 1, 1) )
+		// generate bandwidth
+		bw = ( J(`plot_n_l', 1, `h_l') \ J(`plot_n_r', 1, `h_r') )
+
+		st_store((1..ng)', "`temp_grid'", grid)
+		st_store((1..ng)', "`temp_group'", group)
+		st_store((1..ng)', "`temp_bw'", bw)
+	}
+	}
+	
+	if (`plot' == 1) {
+	local scale_l = (`N_l' - 1) / (`N_l' + `N_r' - 1)
+	local scale_r = (`N_r' - 1) / (`N_l' + `N_r' - 1)
+	
+	// left estimation
+	tempvar temp_grid_l
+		qui gen `temp_grid_l' = `temp_grid' if `temp_group' == 0
+	tempvar temp_bw_l
+		qui gen `temp_bw_l' = `temp_bw' if `temp_group' == 0
+	
+	// bandwidth selection
+	if ("`plot_bwselect'" == "") {
+		local plot_bwselect_l = `"bw(`temp_bw_l')"'
+	}
+	else {
+		local plot_bwselect_l = `"bwselect(`plot_bwselect')"'
+	}
+
+	// uniform confidence band
+	if ("`plot_ciuniform'" != "") {
+		local plot_ciuniform = `"ciuniform cisimul(`plot_cisimul')"'
+	}
+	else {
+		local plot_ciuniform = ""
+	}
+
+	capture lpdensity `x' if `touse' & `x' <= `c', /// 
+		grid(`temp_grid_l') `plot_bwselect_l' p(`p') q(`q') v(1) kernel(`kernel') scale(`scale_l') level(`level') ///
+		`regularize' `masspoints' nlocalmin(`nlocalmin') nuniquemin(`nuniquemin') ///
+		`plot_ciuniform' 
+	if (_rc != 0) {
+		di as error  `"{err}{cmd:lpdensity} failed. Please try to install the latest version using"'
+		di as error  `"{err}net install lpdensity, from(https://raw.githubusercontent.com/nppackages/lpdensity/master/stata) replace"'
+		di as error  `"{err}If error persists, please contact the authors."'
+		di as error  `"{err}{cmd:lpdensity} error message:"'
+		lpdensity `x' if `touse' & `x' <= `c', /// 
+			grid(`temp_grid_l') `plot_bwselect_l' p(`p') q(`q') v(1) kernel(`kernel') scale(`scale_l') level(`level') ///
+			`regularize' `masspoints' nlocalmin(`nlocalmin') nuniquemin(`nuniquemin') ///
+			`plot_ciuniform' 
+		exit 111
+	}
+	}
+		
+	mata{
+	if (`plot' == 1) {
+		left = st_matrix("e(result)")
+		st_store((1..`plot_n_l')', "`temp_bw'",  left[., 2])
+		st_store((1..`plot_n_l')', "`temp_f'", 	 left[., 4])
+		st_store((1..`plot_n_l')', "`temp_cil'", left[., 8])
+		st_store((1..`plot_n_l')', "`temp_cir'", left[., 9])
+	}
+	}
+	
+	if (`plot' == 1) {
+	// right estimation
+	tempvar temp_grid_r
+		qui gen `temp_grid_r' = `temp_grid' if `temp_group' == 1
+	tempvar temp_bw_r
+		qui gen `temp_bw_r' = `temp_bw' if `temp_group' == 1
+		
+	if ("`plot_bwselect'" == "") {
+		local plot_bwselect_r = `"bw(`temp_bw_r')"'
+	}
+	else {
+		local plot_bwselect_r = `"bwselect(`plot_bwselect')"'
+	}
+
+	capture lpdensity `x' if `touse' & `x' >= `c', /// 
+		grid(`temp_grid_r') `plot_bwselect_r' p(`p') q(`q') v(1) kernel(`kernel') scale(`scale_r') level(`level') ///
+		`regularize' `masspoints' nlocalmin(`nlocalmin') nuniquemin(`nuniquemin') ///
+		`plot_ciuniform'
+	if (_rc != 0) {
+		di as error  `"{err}{cmd:lpdensity} failed. Please try to install the latest version using"'
+		di as error  `"{err}net install lpdensity, from(https://raw.githubusercontent.com/nppackages/lpdensity/master/stata) replace"'
+		di as error  `"{err}If error persists, please contact the authors."'
+		di as error  `"{err}{cmd:lpdensity} error message:"'
+		lpdensity `x' if `touse' & `x' >= `c', /// 
+			grid(`temp_grid_r') `plot_bwselect_r' p(`p') q(`q') v(1) kernel(`kernel') scale(`scale_r') level(`level') ///
+			`regularize' `masspoints' nlocalmin(`nlocalmin') nuniquemin(`nuniquemin') ///
+			`plot_ciuniform'
+		exit 111
+	}
+	}
+	
+	mata{
+	if (`plot' == 1) {
+		right = st_matrix("e(result)")
+		st_store(((`plot_n_l'+1)..(`plot_n_l'+`plot_n_r'))', "`temp_bw'",  right[., 2])
+		st_store(((`plot_n_l'+1)..(`plot_n_l'+`plot_n_r'))', "`temp_f'",   right[., 4])
+		st_store(((`plot_n_l'+1)..(`plot_n_l'+`plot_n_r'))', "`temp_cil'", right[., 8])
+		st_store(((`plot_n_l'+1)..(`plot_n_l'+`plot_n_r'))', "`temp_cir'", right[., 9])
+	}
+	}
+		
+	if ("`genvars'" != "" & `plot' == 1) {
+		qui gen `genvars'_grid 	= `temp_grid'
+		qui gen `genvars'_bw 	= `temp_bw'
+		qui gen `genvars'_f 	= `temp_f'
+		qui gen `genvars'_cil 	= `temp_cil'
+		qui gen `genvars'_cir 	= `temp_cir'
+		qui gen `genvars'_group = `temp_group'
+		label variable `genvars'_grid	"rddensity plot: grid"
+		label variable `genvars'_bw		"rddensity plot: bandwidth"
+		label variable `genvars'_f		"rddensity plot: point estimate"
+		label variable `genvars'_cil	"rddensity plot: `level'% CI, left"
+		label variable `genvars'_cir	"rddensity plot: `level'% CI, right"
+		label variable `genvars'_group	"rddensity plot: =1 if grid >= `c'"
+	}
+	
+	
+	****************************************************************************
+	*** DEFAULT OPTIONS: HISTOGRAM *********************************************
+	
+	// hist_range
+	tokenize `hist_range'	
+	local w : word count `hist_range'
+	if `w' == 0 {
+		qui sum `x'
+		if (`c' - 3 * `h_l' < r(min)) {
+			local hist_range_l = r(min)
+		} 
+		else {
+			local hist_range_l = `c' - 3 * `h_l'
+		}
+		if (`c' + 3 * `h_r' > r(max)) {
+			local hist_range_r = r(max)
+		} 
+		else {
+			local hist_range_r = `c' + 3 * `h_r'
+		}
+	}
+	if `w' == 1 {
+		di as error  "{err}{cmd:hist_range()} takes two inputs."  
+		exit 125
+	}
+	if `w' == 2 {
+		local hist_range_l `"`1'"'
+		local hist_range_r `"`2'"'
+	}
+	if `w' >= 3 {
+		di as error  "{err}{cmd:hist_range()} takes two inputs."  
+		exit 125
+	}
+	
+	// hist_n
+	tokenize `hist_n'
+	local w : word count `hist_n'
+	if `w' == 0 {
+		// check if hist_width is provided
+		if ("`hist_width'" == "") {
+			// do shonething
+			qui count if `x' < `c' & `x' >= `hist_range_l'
+			local hist_n_l = ceil(min( sqrt(r(N)) , 10 * log(r(N)) / log(10) ))
+			qui count if `x' >= `c' & `x' <= `hist_range_r'
+			local hist_n_r = ceil(min( sqrt(r(N)) , 10 * log(r(N)) / log(10) ))
+		}
+		else {
+			// do nothing. wait until hist_width
+		}
+		
+	}
+	if `w' == 1 {
+		local hist_n_l `"`1'"'
+		local hist_n_r `"`1'"'
+		if (`hist_n_l' <= 0) {
+			di as err `"{err}{cmd:hist_n()}: incorrectly specified (should be a positive integer)"'
+			exit 198
+		}
+	}
+	if `w' == 2 {
+		local hist_n_l `"`1'"'
+		local hist_n_r `"`2'"'
+		if (`hist_n_l' <= 0 | `hist_n_r' <= 0) {
+			di as err `"{err}{cmd:hist_n()}: incorrectly specified (should be positive integers)"'
+			exit 198
+		}
+	}
+	if `w' >= 3 {
+		di as error  "{err}{cmd:hist_n()} takes at most two inputs."  
+		exit 125
+	}
+	
+	// hist_width
+	tokenize `hist_width'
+	local w : word count `hist_width'
+	if `w' == 0 {
+		local hist_width_l = (`c' - `hist_range_l') / `hist_n_l'
+		local hist_width_r = (`hist_range_r' - `c') / `hist_n_r'
+	}
+	if `w' == 1 {
+		if ("`hist_n'" == "") {
+			// only hist_width is provided
+			local hist_width_l `"`1'"'
+			local hist_width_r `"`1'"'
+			if (`hist_width_l' <= 0) {
+				di as err `"{err}{cmd:hist_width()}: incorrectly specified (should be a positive number)"'
+				exit 198
+			}
+			local hist_n_l = ceil((`c' - `hist_range_l') / `hist_width_l')
+			local hist_n_r = ceil((`hist_range_r' - `c') / `hist_width_r')
+		}
+		else {
+			// ignore hist_width input, because hist_n is provided
+			local hist_width_l = (`c' - `hist_range_l') / `hist_n_l'
+			local hist_width_r = (`hist_range_r' - `c') / `hist_n_r'
+		}
+	}
+	if `w' == 2 {
+		if ("`hist_n'" == "") {
+			// only hist_width is provided
+			local hist_width_l `"`1'"'
+			local hist_width_r `"`2'"'
+			if (`hist_width_l' <= 0 | `hist_width_r' <= 0) {
+				di as err `"{err}{cmd:hist_width()}: incorrectly specified (should be positive numbers)"'
+				exit 198
+			}
+			local hist_n_l = ceil((`c' - `hist_range_l') / `hist_width_l')
+			local hist_n_r = ceil((`hist_range_r' - `c') / `hist_width_r')
+		}
+		else {
+			// ignore hist_width input, because hist_n is provided
+			local hist_width_l = (`c' - `hist_range_l') / `hist_n_l'
+			local hist_width_r = (`hist_range_r' - `c') / `hist_n_r'
+		}
+	}
+	if `w' >= 3 {
+		di as error  "{err}{cmd:hist_width()} takes two inputs."  
+		exit 125
+	}
+
+	// histogram
+	if ("`histogram'" != "") {
+		local histogram = 0
+	}
+	else {
+		local histogram = 1
+	}
+	
+	if (`histogram' == 1) {
+		if (`hist_n_l' + `hist_n_r' > _N) {
+			local newN = `hist_n_l' + `hist_n_r'
+			set obs `newN'
+		}
+		
+		tempvar temp_hist_center
+		qui gen `temp_hist_center' = .
+		tempvar temp_hist_end_l
+		qui gen `temp_hist_end_l' = .
+		tempvar temp_hist_end_r
+		qui gen `temp_hist_end_r' = .
+		tempvar temp_hist_width
+		qui gen `temp_hist_width' = .
+		tempvar temp_hist_height
+		qui gen `temp_hist_height' = .	
+		tempvar temp_hist_group
+		qui gen `temp_hist_group' = .
+	}
+	
+	// MATA
+	mata{	
+		
+	if (`histogram' == 1) {
+		ng = `hist_n_l' + `hist_n_r'
+		temp_hist_width = (J(`hist_n_l', 1, `hist_width_l') \ J(`hist_n_r', 1, `hist_width_r'))
+		temp_hist_center = (`c' :- (((`hist_n_l'..1) :- 0.5)' :* `hist_width_l') \ `c' :+ (((1..`hist_n_r') :- 0.5)' :* `hist_width_r'))
+		temp_hist_end_l = (`c' :- (((`hist_n_l'..1))' :* `hist_width_l') \ `c' :+ (((1..`hist_n_r') :- 1)' :* `hist_width_r'))
+		temp_hist_end_r = (`c' :- (((`hist_n_l'..1) :- 1)' :* `hist_width_l') \ `c' :+ (((1..`hist_n_r'))' :* `hist_width_r'))
+		temp_hist_group = (J(`hist_n_l', 1, 0) \ J(`hist_n_r', 1, 1))
+		temp_hist_height = J(ng, 1, .)
+	
+		x = st_data(., "`x'", "`touse'")
+	
+		for (jj=1; jj<=ng; jj++) {
+			temp_hist_height[jj] = sum(x :>= temp_hist_end_l[jj] :& x :< temp_hist_end_r[jj]) / (`N_l' + `N_r') / temp_hist_width[jj]
+		}
+	
+		st_store((1..ng)', "`temp_hist_width'",  temp_hist_width)
+		st_store((1..ng)', "`temp_hist_center'", temp_hist_center)
+		st_store((1..ng)', "`temp_hist_end_l'", temp_hist_end_l)
+		st_store((1..ng)', "`temp_hist_end_r'", temp_hist_end_r)
+		st_store((1..ng)', "`temp_hist_height'", temp_hist_height)
+		st_store((1..ng)', "`temp_hist_group'", temp_hist_group)
+	}
+	}
+	
+	if ("`genvars'" != "" & `plot' == 1 & `histogram' == 1) {
+		qui gen `genvars'_hist_width 	= `temp_hist_width'
+		qui gen `genvars'_hist_center 	= `temp_hist_center'
+		qui gen `genvars'_hist_height 	= `temp_hist_height'
+		qui gen `genvars'_hist_group 	= `temp_hist_group'
+		qui gen `genvars'_hist_endl 	= `temp_hist_end_l'
+		qui gen `genvars'_hist_endr 	= `temp_hist_end_r'
+		label variable `genvars'_hist_width		"histogram plot: histogram bar width"
+		label variable `genvars'_hist_center	"histogram plot: histogram bar center"
+		label variable `genvars'_hist_endl		"histogram plot: histogram bar left end"
+		label variable `genvars'_hist_endr		"histogram plot: histogram bar right end"
+		label variable `genvars'_hist_height	"histogram plot: histogram bar height"
+		label variable `genvars'_hist_group		"histogram plot: =1 if cell center > `c'"
+	}
+	
+	****************************************************************************
+	*** PLOT *******************************************************************
+
+	if (`plot' == 1) {
+		
+		// ci type check, left
+		if ("`plotl_citype'" == "") {
+			local plotl_citype = "region"
+		}
+		else if ("`plotl_citype'" != "all" & "`plotl_citype'" != "region" & "`plotl_citype'" != "line" & "`plotl_citype'" != "ebar" & "`plotl_citype'" != "none") {
+			di as err `"plotl_citype(): incorrectly specified: options(region, line, ebar, all, none)"'
+			exit 198
+		}
+
+		if ("`plotl_citype'" == "region" | "`plotl_citype'" == "all") {
+			if ("`cirl_opt'" == "") {
+				local ci_plot_region_l = `"(rarea `temp_cil' `temp_cir' `temp_grid' if `temp_group' == 0, sort lcolor(white%0) color(red%30))"'
+			} 
+			else {
+				local ci_plot_region_l = `"(rarea `temp_cil' `temp_cir' `temp_grid' if `temp_group' == 0, sort `cirl_opt')"'
+			}
+		} 
+		else {
+			local ci_plot_region_l = `""'
+		}
+		if ("`plotl_citype'" == "line" | "`plotl_citype'" == "all") {
+			if ("`cill_opt'" == "") {
+				local ci_plot_line_l = `"(rline `temp_cil' `temp_cir' `temp_grid' if `temp_group' == 0, sort color(red%70))"'
+			} 
+			else {
+				local ci_plot_line_l = `"(rline `temp_cil' `temp_cir' `temp_grid' if `temp_group' == 0, sort `cill_opt')"'
+			}
+		}
+		else {
+			local ci_plot_line_l = `""'
+		}
+		if ("`plotl_citype'" == "ebar" | "`plotl_citype'" == "all") {
+			if ("`cibl_opt'" == "") {
+				local ci_plot_ebar_l = `"(rcap `temp_cil' `temp_cir' `temp_grid' if `temp_group' == 0, sort color(red%70))"'
+			} 
+			else {
+				local ci_plot_ebar_l = `"(rcap `temp_cil' `temp_cir' `temp_grid' if `temp_group' == 0, sort `cibl_opt')"'
+			}
+		}
+		else {
+			local ci_plot_ebar_l = `""'
+		}
+		
+		// ci type check, right
+		if ("`plotr_citype'" == "") {
+			local plotr_citype = "region"
+		}
+		else if ("`plotr_citype'" != "all" & "`plotr_citype'" != "region" & "`plotr_citype'" != "line" & "`plotr_citype'" != "ebar" & "`plotr_citype'" != "none") {
+			di as err `"plotr_citype(): incorrectly specified: options(region, line, ebar, all, none)"'
+			exit 198
+		}
+
+		if ("`plotr_citype'" == "region" | "`plotr_citype'" == "all") {
+			if ("`cirr_opt'" == "") {
+				local ci_plot_region_r = `"(rarea `temp_cil' `temp_cir' `temp_grid' if `temp_group' == 1, sort lcolor(white%0) color(blue%30))"'
+			} 
+			else {
+				local ci_plot_region_r = `"(rarea `temp_cil' `temp_cir' `temp_grid' if `temp_group' == 1, sort `cirr_opt')"'
+			}
+		} 
+		else {
+			local ci_plot_region_r = `""'
+		}
+		if ("`plotr_citype'" == "line" | "`plotr_citype'" == "all") {
+			if ("`cilr_opt'" == "") {
+				local ci_plot_line_r = `"(rline `temp_cil' `temp_cir' `temp_grid' if `temp_group' == 1, sort color(blue%70))"'
+			} 
+			else {
+				local ci_plot_line_r = `"(rline `temp_cil' `temp_cir' `temp_grid' if `temp_group' == 1, sort `cilr_opt')"'
+			}
+		}
+		else {
+			local ci_plot_line_r = `""'
+		}
+		if ("`plotr_citype'" == "ebar" | "`plotr_citype'" == "all") {
+			if ("`cibr_opt'" == "") {
+				local ci_plot_ebar_r = `"(rcap `temp_cil' `temp_cir' `temp_grid' if `temp_group' == 1, sort color(blue%70))"'
+			} 
+			else {
+				local ci_plot_ebar_r = `"(rcap `temp_cil' `temp_cir' `temp_grid' if `temp_group' == 1, sort `cibr_opt')"'
+			}
+		}
+		else {
+			local ci_plot_ebar_r = `""'
+		}
+		
+		// point est type check, left
+		
+		if ("`plotl_estype'" == "") {
+			local plotl_estype = "line"
+		}
+		else if ("`plotl_estype'" != "both" & "`plotl_estype'" != "line" & "`plotl_estype'" != "point" & "`plotl_estype'" != "none") {
+			di as err `"plotl_estype(): incorrectly specified: options(line, point, both, none)"'
+			exit 198
+		}
+
+		if ("`plotl_estype'" == "line" | "`plotl_estype'" == "both") {
+			if ("`esll_opt'" == "") {
+				local es_plot_line_l = `"(line `temp_f' `temp_grid' if `temp_group' == 0, sort lcolor(red) lwidth("medthin") lpattern(solid))"'
+			} 
+			else {
+				local es_plot_line_l = `"(line `temp_f' `temp_grid' if `temp_group' == 0, sort `esll_opt')"'
+			}
+		} 
+		else {
+			local es_plot_line_l = `""'
+		}
+		if ("`plotl_estype'" == "point" | "`plotl_estype'" == "both") {
+			if ("`espl_opt'" == "") {
+				local es_plot_point_l = `"(scatter `temp_f' `temp_grid' if `temp_group' == 0, sort color(red))"'
+			} 
+			else {
+				local es_plot_point_l = `"(scatter `temp_f' `temp_grid' if `temp_group' == 0, sort `espl_opt')"'
+			}
+		} 
+		else {
+			local es_plot_point_l = `""'
+		}
+		
+		// point est type check, right
+		
+		if ("`plotr_estype'" == "") {
+			local plotr_estype = "line"
+		}
+		else if ("`plotr_estype'" != "both" & "`plotr_estype'" != "line" & "`plotr_estype'" != "point" & "`plotr_estype'" != "none") {
+			di as err `"plotr_estype(): incorrectly specified: options(line, point, both, none)"'
+			exit 198
+		}
+
+		if ("`plotr_estype'" == "line" | "`plotr_estype'" == "both") {
+			if ("`eslr_opt'" == "") {
+				local es_plot_line_r = `"(line `temp_f' `temp_grid' if `temp_group' == 1, sort lcolor(blue) lwidth("medthin") lpattern(solid))"'
+			} 
+			else {
+				local es_plot_line_r = `"(line `temp_f' `temp_grid' if `temp_group' == 1, sort `eslr_opt')"'
+			}
+		} 
+		else {
+			local es_plot_line_r = `""'
+		}
+		if ("`plotr_estype'" == "point" | "`plotr_estype'" == "both") {
+			if ("`espr_opt'" == "") {
+				local es_plot_point_r = `"(scatter `temp_f' `temp_grid' if `temp_group' == 1, sort color(blue))"'
+			} 
+			else {
+				local es_plot_point_r = `"(scatter `temp_f' `temp_grid' if `temp_group' == 1, sort `espr_opt')"'
+			}
+		} 
+		else {
+			local es_plot_point_r = `""'
+		}
+	
+		if (`histogram' == 1) {
+			if ("`histl_opt'" == "") {
+				local plot_histogram_l = `"(bar `temp_hist_height' `temp_hist_center' if `temp_hist_center' < `c', barwidth(`hist_width_l') color(red%20))"'
+			} 
+			else {
+				local plot_histogram_l = `"(bar `temp_hist_height' `temp_hist_center' if `temp_hist_center' < `c', `histl_opt')"'
+			}
+			if ("`histr_opt'" == "") {
+				local plot_histogram_r = `"(bar `temp_hist_height' `temp_hist_center' if `temp_hist_center' >= `c', barwidth(`hist_width_r') color(blue%20))"'
+			} 
+			else {
+				local plot_histogram_r = `"(bar `temp_hist_height' `temp_hist_center' if `temp_hist_center' >= `c', `histr_opt')"'
+			}
+		}
+		else {
+			local plot_histogram_l = ""
+			local plot_histogram_r = ""
+		}
+		
+		// graph option check
+		if (`"`graph_opt'"' == "" ) {
+			local graph_opt = `"xline(`c', lcolor(black) lwidth(medthin) lpattern(solid)) legend(off) title("Manipulation Testing Plot", color(gs0)) xtitle("`x'") ytitle("")"'
+		}
+		
+		twoway 	`plot_histogram_l' 	/// 
+				`plot_histogram_r' 	/// 
+				`ci_plot_region_l' 	///
+				`ci_plot_line_l'   	///
+				`ci_plot_ebar_l'   	///
+				`ci_plot_region_r' 	///
+				`ci_plot_line_r'   	///
+				`ci_plot_ebar_r'   	///
+				`es_plot_line_l' 	///
+				`es_plot_point_l' 	///
+				`es_plot_line_r' 	///
+				`es_plot_point_r' 	///
+				,					///
+				`graph_opt'
+	}
+	
+	ereturn clear 
+	ereturn scalar c = `c' 
+	ereturn scalar p = `p' 
+	ereturn scalar q = `q' 
+	ereturn scalar N_l = `N_l' 
+	ereturn scalar N_r = `N_r'
+	ereturn scalar N_h_l = `N_h_l' 
+	ereturn scalar N_h_r = `N_h_r'
+	ereturn scalar h_l = `h_l'
+	ereturn scalar h_r = `h_r'
+	ereturn scalar f_ql = `f_ql'
+	ereturn scalar f_qr = `f_qr'
+	ereturn scalar se_ql = `se_ql'
+	ereturn scalar se_qr = `se_qr'
+	ereturn scalar se_q = `se_q'
+	ereturn scalar pv_q = `pv_q'
+	ereturn scalar T_q = `T_q'
+
+	if ("`all'"!=""){
+	ereturn scalar f_pl = `f_pl'
+	ereturn scalar f_pr = `f_pr'
+	ereturn scalar se_pl = `se_pl'
+	ereturn scalar se_pr = `se_pr'
+	ereturn scalar se_p = `se_p'
+	ereturn scalar pv_p = `pv_p'
+	ereturn scalar T_p = `T_p'
+	}
+	
+	ereturn local runningvar  "`runningvar'"
+	ereturn local kernel  "`kernel'"
+	ereturn local bwmethod  "`bwmethod'"
+	ereturn local vce  "`vce'"
+	
+	mata: mata clear
+	
+end
+	

30/replication_package/Adofiles/rd_2021/rddensity.sthlp

@@ -0,0 +1,450 @@
+{smcl}
+{* *!version 2.3 2021-02-28}{...}
+{viewerjumpto "Syntax" "rdrobust##syntax"}{...}
+{viewerjumpto "Description" "rdrobust##description"}{...}
+{viewerjumpto "Options" "rdrobust##options"}{...}
+{viewerjumpto "Examples" "rdrobust##examples"}{...}
+{viewerjumpto "Saved results" "rdrobust##saved_results"}{...}
+
+{title:Title}
+
+{p 4 8}{cmd:rddensity} {hline 2} Manipulation Testing Using Local Polynomial Density Estimation.{p_end}
+
+{marker syntax}{...}
+{title:Syntax}
+
+{p 4 8}{cmd:rddensity} {it:Var} {ifin} 
+[{cmd:,} 
+{p_end}
+{p 14 18}
+{cmd:c(}{it:#}{cmd:)} 
+{cmd:p(}{it:#}{cmd:)} 
+{cmd:q(}{it:#}{cmd:)}
+{cmd:fitselect(}{it:FitMethod}{cmd:)}
+{cmd:kernel(}{it:KernelFn}{cmd:)}
+{cmd:vce(}{it:VceMethod}{cmd:)}
+{cmd:nomasspoints}
+{cmd:level(}{it:#}{cmd:)}
+{cmd:all}
+{p_end}
+{p 14 18}
+{cmd:h(}{it:# #}{cmd:)} 
+{cmd:bwselect(}{it:BwMethod}{cmd:)}
+{cmd:nlocalmin(}{it:#}{cmd:)}
+{cmd:nuniquemin(}{it:#}{cmd:)}
+{cmd:noregularize}
+{p_end}
+{p 14 18}
+{cmd:bino_n(}{it:#}{cmd:)} 
+{cmd:bino_nstep(}{it:#}{cmd:)} 
+{cmd:bino_w(}{it:# #}{cmd:)} 
+{cmd:bino_wstep(}{it:# #}{cmd:)} 
+{cmd:bino_nw(}{it:#}{cmd:)} 
+{cmd:bino_p(}{it:#}{cmd:)}
+{cmd:nobinomial}
+{p_end}
+{p 14 18}
+{cmd:plot}  
+{cmd:plot_range(}{it:# #}{cmd:)} 
+{cmd:plot_n(}{it:# #}{cmd:)} 
+{cmd:plot_grid(}{it:GridMethod}{cmd:)}
+{cmd:plot_bwselect(}{it:BwMethod}{cmd:)}
+{p_end}
+{p 14 18}
+{cmd:plot_ciuniform}
+{cmd:plot_cisimul(}{it:# #}{cmd:)} 
+{p_end}
+{p 14 18}
+{cmd:graph_opt(}{it:GraphOpt}{cmd:)}
+{cmd:genvars(}{it:NewVarName}{cmd:)}
+{p_end}
+{p 14 18}
+{cmd:plotl_estype(}{it:EstType}{cmd:)}
+{cmd:esll_opt(}{it:LineOpt}{cmd:)}
+{cmd:espl_opt(}{it:PtOpt}{cmd:)}
+{p_end}
+{p 14 18}
+{cmd:plotr_estype(}{it:EstType}{cmd:)}
+{cmd:eslr_opt(}{it:LineOpt}{cmd:)}
+{cmd:espr_opt(}{it:PtOpt}{cmd:)}
+{p_end}
+{p 14 18}
+{cmd:plotl_citype(}{it:CIType}{cmd:)}
+{cmd: cirl_opt(}{it:AreaOpt}{cmd:)}
+{cmd: cill_opt(}{it:LineOpt}{cmd:)}
+{cmd: cibl_opt(}{it:EbarOpt}{cmd:)}
+{p_end}
+{p 14 18}
+{cmd:plotr_citype(}{it:CIType}{cmd:)}
+{cmd:cirr_opt(}{it:AreaOpt}{cmd:)}
+{cmd:cilr_opt(}{it:LineOpt}{cmd:)}
+{cmd:cibr_opt(}{it:EbarOpt}{cmd:)}
+{p_end}
+{p 14 18}
+{cmd:hist_range(}{it:# #}{cmd:)} 
+{cmd:hist_n(}{it:# #}{cmd:)} 
+{cmd:hist_width(}{it:# #}{cmd:)} 
+{cmd:histl_opt(}{it:BarOpt}{cmd:)}
+{cmd:histr_opt(}{it:BarOpt}{cmd:)}
+{cmd:nohistogram}
+{p_end}
+{p 14 18}
+]{p_end}
+
+{synoptset 28 tabbed}{...}
+
+{marker description}{...}
+{title:Description}
+
+{p 4 8}{cmd:rddensity} implements manipulation testing procedures using the local polynomial density estimators proposed in
+{browse "https://rdpackages.github.io/references/Cattaneo-Jansson-Ma_2020_JASA.pdf":Cattaneo, Jansson and Ma (2020)},
+and implements graphical procedures with valid confidence bands using the results in
+{browse "https://rdpackages.github.io/references/Cattaneo-Jansson-Ma_2021_JoE.pdf":Cattaneo, Jansson and Ma (2021)}.
+In addition, the command provides complementary manipulation testing based on finite sample exact binomial testing following the results in
+{browse "https://rdpackages.github.io/references/Cattaneo-Frandsen-Titiunik_2015_JCI.pdf":Cattaneo, Frandsen and Titiunik (2015)}
+and
+{browse "https://rdpackages.github.io/references/Cattaneo-Titiunik-VazquezBare_2017_JPAM.pdf":Cattaneo, Frandsen and Vazquez-Bare (2017)}.
+For an introduction to manipulation testing see McCrary (2008).{p_end}
+
+{p 4 8}A detailed introduction to this Stata command is given in {browse "https://rdpackages.github.io/references/Cattaneo-Jansson-Ma_2018_Stata.pdf":Cattaneo, Jansson and Ma (2018)}.{p_end}
+{p 8 8}Companion {browse "www.r-project.org":R} functions are also available {browse "https://rdpackages.github.io/rddensity":here}.{p_end}
+
+{p 4 8}Companion function is {help rdbwdensity:rdbwdensity}.
+For graphical procedures, the 
+{browse "https://nppackages.github.io/lpdensity":lpdensity}
+package is required.{p_end}
+
+{p 4 8}Related Stata and R packages useful for inference in regression discontinuity (RD) designs are described in the following website:{p_end}
+
+{p 8 8}{browse "https://rdpackages.github.io/":https://rdpackages.github.io/}{p_end}
+
+{marker options}{...}
+{title:Options}
+
+{dlgtab:Density Estimation}
+
+{p 4 8}{opt c:}{cmd:(}{it:#}{cmd:)} specifies the threshold or cutoff value in the support of {it:Var}, which determines the two samples (e.g., control and treatment units in RD settings).
+Default is {cmd:c(0)}.{p_end}
+
+{p 4 8}{opt p:}{cmd:(}{it:#}{cmd:)} specifies the local polynomial order used to construct the density estimators.
+Default is {cmd:p(2)} (local quadratic approximation).{p_end}
+
+{p 4 8}{opt q:}{cmd:(}{it:#}{cmd:)} specifies the local polynomial order used to construct the bias-corrected density estimators.
+Default is {cmd:q(p(}{it:#}{cmd:)+1)} (local cubic approximation for default {cmd:p(2)}).{p_end}
+
+{p 4 8}{opt fit:select}{cmd:(}{it:FitMethod}{cmd:)} specifies the density estimation method.{p_end}
+{p 8 12}{opt unrestricted}{bind:} for density estimation without any restrictions (two-sample, unrestricted inference).
+This is the default option.{p_end}
+{p 8 12}{opt restricted}{bind:  } for density estimation assuming equal distribution function and higher-order derivatives.{p_end}
+
+{p 4 8}{opt ker:nel}{cmd:(}{it:KernelFn}{cmd:)} specifies the kernel function used to construct the local polynomial estimators.{p_end}
+{p 8 12}{opt triangular}{bind:  } {it:K(u) = (1 - |u|) * (|u|<=1)}.
+This is the default option.{p_end}
+{p 8 12}{opt epanechnikov}{bind:}  {it:K(u) = 0.75 * (1 - u^2) * (|u|<=1)}.{p_end}
+{p 8 12}{opt uniform}{bind:     }  {it:K(u) = 0.5 * (|u|<=1)}.{p_end}
+
+{p 4 8}{opt vce:}{cmd:(}{it:VceMethod}{cmd:)} specifies the procedure used to compute the variance-covariance matrix estimator.{p_end}
+{p 8 12}{opt plugin}{bind:   } for asymptotic plug-in standard errors.{p_end}
+{p 8 12}{opt jackknife}{bind:} for jackknife standard errors.
+This is the default option.{p_end}
+
+{p 4 8}{opt nomass:points} will not adjust for mass points in the data.{p_end}
+
+{p 4 8}{opt lev:el}{cmd:(}{it:#}{cmd:)} specifies the level of the confidence interval, which should be between 0 and 100.
+Default is {cmd:level(95)}.{p_end}
+
+{p 4 8}{opt all} if specified, {cmd:rddensity} reports two testing procedures:{p_end}
+{p 8 12}Conventional test statistic (not valid when using MSE-optimal bandwidth choice).{p_end}
+{p 8 12}Robust bias-corrected statistic.
+This is the default option.{p_end}
+
+
+{dlgtab:Bandwidth Selection}
+
+{p 4 8}{opt h:}{cmd:(}{it:#} {it:#}{cmd:)} specifies the bandwidth ({it:h}) used to construct the density estimators on the two sides of the cutoff.
+If not specified, the bandwidth {it:h} is computed by the companion command
+{help rdbwdensity:rdbwdensity}.
+If two bandwidths are specified, the first bandwidth is used for the data below the cutoff and the second bandwidth is used for the data above the cutoff.{p_end}
+
+{p 4 8}{opt bw:select}{cmd:(}{it:BwMethod}{cmd:)} specifies the bandwidth selection procedure to be used.{p_end}
+{p 8 12}{opt each}{bind:} based on MSE of each density estimator separately (two distinct bandwidths, {it:hl} and {it:hr}).{p_end}
+{p 8 12}{opt diff}{bind:} based on MSE of difference of two density estimators (one common bandwidth, {it:hl}={it:hr}).{p_end}
+{p 8 12}{opt sum}{bind: } based on MSE of sum of two density estimators (one common bandwidth, {it:hl}={it:hr}).{p_end}
+{p 8 12}{opt comb}{bind:} bandwidth is selected as a combination of the alternatives above.
+This is the default option.{p_end}
+{p 13 17}For {cmd:fitselect(}{opt unrestricted}{cmd:)}, it selects median({opt each},{opt diff},{opt sum}).{p_end}
+{p 13 17}For {cmd:fitselect(}{opt restricted}{cmd:)}, it selects min({opt diff},{opt sum}).{p_end}
+
+{p 4 8}{opt nloc:almin}{cmd:(}{it:#}{cmd:)} specifies the minimum number of observations in each local neighborhood.
+This option will be ignored if set to 0, or if {cmd:noregularize} is used.
+Default is {cmd:20+p(}{it:#}{cmd:)+1}.{p_end}
+
+{p 4 8}{opt nuni:quemin}{cmd:(}{it:#}{cmd:)} specifies the minimum number of unique observations in each local neighborhood.
+This option will be ignored if set to 0, or if {cmd:noregularize} is used.
+Default is {cmd:20+p(}{it:#}{cmd:)+1}.{p_end}
+
+{p 4 8}{opt noreg:ularize} suppresses local sample size checking.{p_end}
+
+
+{dlgtab:Binomial Test}
+
+{p 4 8}{opt bino_w:}{cmd:(}{it:# #}{cmd:)} specifies the half length(s) of the initial window.
+If two values are provided, they will be used for the data below and above the cutoff separately.{p_end}
+
+{p 4 8}{opt bino_n:}{cmd:(}{it:#}{cmd:)} specifies the sample size in the initial window.
+This option will be ignored if {opt bino_w:}{cmd:(}{it:# #}{cmd:)} is provided.{p_end}
+
+{p 4 8}{opt bino_wstep:}{cmd:(}{it:# #}{cmd:)} specifies the increment in half length(s).{p_end}
+
+{p 4 8}{opt bino_nstep:}{cmd:(}{it:#}{cmd:)} specifies the increment in sample size.
+This option will be ignored if {opt bino_wstep:}{cmd:(}{it:# #}{cmd:)} is provided.{p_end}
+
+{p 4 8}{opt bino_nw:}{cmd:(}{it:#}{cmd:)} specifies the total number of windows.
+Default is {cmd:10}.{p_end}
+
+{p 4 8}{opt bino_p}{cmd:(}{it:#}{cmd:)} specifies the null hypothesis of the binomial test.
+Default is 0.5.{p_end}
+
+{p 4 8}{opt nobino:mial} suppresses the binomial test.
+By default, the initial (smallest) window contains 20 observations, and its length is also used as the increment for subsequent windows.{p_end}
+
+
+{dlgtab:Plotting}
+
+{p 4 8}{opt pl:ot} if specified, {cmd:rddensity} plots density estimates and confidence intervals/bands around the cutoff (this feature depends on a companion package {help lpdensity:lpdensity}).
+Note that additional estimation (computing time) is needed.{p_end}
+
+{p 4 8}{opt plot_range}{cmd:(}{it:#} {it:#}{cmd:)} specifies the lower and upper bound of the plotting region.
+Default is {it:[c-3*hl,c+3*hr]} (three bandwidths around the cutoff).{p_end}
+
+{p 4 8}{opt plot_n}{cmd:(}{it:#} {it:#}{cmd:)} specifies the number of grid points used for plotting on the two sides of the cutoff.
+Default is {cmd:plot_n(10 10)} (i.e., 10 points are used on each side).{p_end}
+
+{p 4 8}{opt plot_grid}{cmd:(}{it:GridMethod}{cmd:)} specifies how the grid points are positioned.
+Options are {opt es} (evenly spaced) and {opt qs} (quantile spaced).{p_end}
+
+{p 4 8}{opt plot_bwselect}{cmd:(}{it:BwMwthod}{cmd:)} specifies the method for data-driven bandwidth selection.
+Options are {cmd:mse-dpi}, {cmd:imse-dpi}, {cmd:mse-rot}, and {cmd:imse-rot}.
+See {help lpdensity:lpdensity} for additional details.
+If this option is omitted, the same bandwidth(s) used for manipulation testing will be employed.{p_end}
+
+{p 4 8}{opt plot_ciuniform} plots uniform confidence bands instead of pointwise confidence intervals.
+The companion option, {opt plot_cisimul}({it:#}), specifies the number of simulations used to construct critical values.
+Default is 2000.{p_end}
+
+{p 4 8}{opt graph_opt}({it:GraphOpt}) specifies additional options for plotting, such as legends and labels.{p_end}
+
+{p 4 8}{opt genv:ars}({it:NewVarName}) specifies if new variables should be generated to store estimation results.{p_end}
+
+{p 4 8}{bf: Remark}. Bias correction is only used for the construction of confidence intervals/bands, but not for point estimation. The point estimates, denoted by f_p, are constructed using local polynomial estimates of order
+{cmd:p(}{it:#}{cmd:)},
+while the centering of the confidence intervals/bands, denoted by f_q, are constructed using local polynomial estimates of order
+{cmd:q(}{it:#}{cmd:)}.
+The confidence intervals/bands take the form:
+[f_q - cv * SE(f_q) , f_q + cv * SE(f_q)],
+where cv denotes the appropriate critical value and SE(f_q) denotes a standard error estimate for the centering of the confidence interval/band.
+As a result, the confidence intervals/bands may not be centered at the point estimates because they have been bias-corrected. Setting
+{cmd:q(}{it:#}{cmd:)}
+and
+{cmd:p(}{it:#}{cmd:)}
+to be equal results on centered at the point estimate confidence intervals/bands, but requires undersmoothing for valid inference (i.e., (I)MSE-optimal bandwdith for the density point estimator cannot be used). 
+Hence the bandwidth would need to be specified manually when
+{cmd:q(}{it:#}{cmd:)} = {cmd:p(}{it:#}{cmd:)},
+and the point estimates will not be (I)MSE optimal. See Cattaneo, Jansson and Ma
+({browse "https://rdpackages.github.io/references/Cattaneo-Jansson-Ma_2020_JoE.pdf":2020b}, {browse "https://rdpackages.github.io/references/Cattaneo-Jansson-Ma_2020_JSS.pdf":2020c})
+for details, and also Calonico, Cattaneo, and Farrell
+({browse "https://rdpackages.github.io/references/Calonico-Cattaneo-Farrell_2018_JASA.pdf":2018},
+{browse "https://rdpackages.github.io/references/Calonico-Cattaneo-Farrell_2020_CEopt.pdf":2020}) 
+for robust bias correction methods.{p_end}
+
+{p 8 8} Sometimes the density point estimates may lie outside of the confidence intervals/bands, which can happen if the underlying distribution exhibits high curvature at some evaluation point(s). 
+One possible solution in this case is to increase the polynomial order {cmd:p(}{it:#}{cmd:)} or to employ a smaller bandwidth.{p_end}
+
+
+{dlgtab:Additional Plotting Options: Histogram}
+
+{p 4 8}{opt hist_range}{cmd:(}{it:#} {it:#}{cmd:)} specifies the lower and upper bound of the histogram plot.
+Default is {it:[c-3*hl,c+3*hr]} (three bandwidths around the cutoff).{p_end}
+
+{p 4 8}{opt hist_n}{cmd:(}{it:#} {it:#}{cmd:)} specifies the number of histogram bars.
+Default is {it:min[sqrt(N),10*log(N)/log(10)]}, where {it:N} is the number of observations within the range specified by {opt hist_range}{cmd:(}{it:#} {it:#}{cmd:)}.{p_end}
+
+{p 4 8}{opt hist_width}{cmd:(}{it:#} {it:#}{cmd:)} specifies the width of histogram bars.
+This option will be ignored if {opt hist_range}{cmd:(}{it:#} {it:#}{cmd:)} is provided.{p_end}
+
+{p 4 8}{opt nohist:ogram} suppresses the histogram in the background of the plot.{p_end}
+
+
+{dlgtab:Additional Plotting Options: Below the Cutoff}
+
+{p 4 8}{opt plotl_estype}{cmd:(}{it:EstType}{cmd:)} specifies the plotting style of point estimates.{p_end}
+{p 8 12}{opt line}{bind:  } a curve.
+This is the default option.{p_end}
+{p 8 12}{opt points}{bind:} individual points.{p_end}
+{p 8 12}{opt both}{bind:  } both of the above.{p_end}
+{p 8 12}{opt none}{bind:  } will not plot point estimates.{p_end}
+
+{p 4 8}{opt esll_opt}{cmd:(}{it:LineOpt}{cmd:)}{bind:} specifies additional {cmd:twoway line}{bind:   } options for plotting point estimates.{p_end}
+
+{p 4 8}{opt espl_opt}{cmd:(}{it:PtOpt}{cmd:)}{bind:  } specifies additional {cmd:twoway scatter}{bind:} options for plotting point estimates.{p_end}
+
+{p 4 8}{opt plotl_citype}{cmd:(}{it:EstType}{cmd:)} specifies the plotting style of confidence intervals/bands.{p_end}
+{p 8 12}{opt region}{bind:} shaded region.
+This is the default option.{p_end}
+{p 8 12}{opt line}{bind:  } upper and lower bounds.{p_end}
+{p 8 12}{opt ebar}{bind:  } error bars.{p_end}
+{p 8 12}{opt all}{bind:   } all of the above.{p_end}
+{p 8 12}{opt none}{bind:  } will not plot confidence intervals/bands.{p_end}
+
+{p 4 8}{opt cirl_opt}{cmd:(}{it:AreaOpt}{cmd:)}{bind:} specifies additional {cmd:twoway rarea}{bind:} options for plotting confidence intervals/regions.{p_end}
+
+{p 4 8}{opt cill_opt}{cmd:(}{it:LineOpt}{cmd:)}{bind:} specifies additional {cmd:twoway rline}{bind:} options for plotting confidence intervals/regions.{p_end}
+
+{p 4 8}{opt cibl_opt}{cmd:(}{it:EbarOpt}{cmd:)}{bind:} specifies additional {cmd:twoway rcap}{bind:} options for plotting confidence intervals/regions.{p_end}
+
+{p 4 8}{opt histl_opt}{cmd:(}{it:BarOpt}{cmd:)}{bind:} specifies additional {cmd:twoway bar}{bind:} options for histogram.{p_end}
+
+
+{dlgtab:Additional Plotting Options: Above the Cutoff}
+
+{p 4 8}{opt plotr_estype}{cmd:(}{it:EstType}{cmd:)} specifies the plotting style of point estimates.{p_end}
+{p 8 12}{opt line}{bind:  } a curve.
+This is the default option.{p_end}
+{p 8 12}{opt points}{bind:} individual points.{p_end}
+{p 8 12}{opt both}{bind:  } both of the above.{p_end}
+{p 8 12}{opt none}{bind:  } will not plot point estimates.{p_end}
+
+{p 4 8}{opt eslr_opt}{cmd:(}{it:LineOpt}{cmd:)}{bind:} specifies additional {cmd:twoway line}{bind:} options for plotting point estimates.{p_end}
+
+{p 4 8}{opt espr_opt}{cmd:(}{it:PtOpt}{cmd:)}{bind:} specifies additional {cmd:twoway scatter}{bind:} options for plotting point estimates.{p_end}
+
+{p 4 8}{opt plotr_citype}{cmd:(}{it:EstType}{cmd:)} specifies the plotting style of confidence intervals/bands.{p_end}
+{p 8 12}{opt region}{bind:} shaded region.
+This is the default option.{p_end}
+{p 8 12}{opt line}{bind:  } upper and lower bounds.{p_end}
+{p 8 12}{opt ebar}{bind:  } error bars.{p_end}
+{p 8 12}{opt all}{bind:   } all of the above.{p_end}
+{p 8 12}{opt none}{bind:  } will not plot confidence intervals/bands.{p_end}
+
+{p 4 8}{opt cirr_opt}{cmd:(}{it:AreaOpt}{cmd:)}{bind:} specifies additional {cmd:twoway rarea}{bind:} options for plotting confidence intervals/regions.{p_end}
+
+{p 4 8}{opt cilr_opt}{cmd:(}{it:LineOpt}{cmd:)}{bind:} specifies additional {cmd:twoway rline}{bind:} options for plotting confidence intervals/regions.{p_end}
+
+{p 4 8}{opt cibr_opt}{cmd:(}{it:EbarOpt}{cmd:)}{bind:} specifies additional {cmd:twoway rcap}{bind:} options for plotting confidence intervals/regions.{p_end}
+ 
+{p 4 8}{opt histr_opt}{cmd:(}{it:BarOpt}{cmd:)}{bind:} specifies additional {cmd:twoway bar}{bind:} options for histogram.{p_end}
+
+
+{marker examples}{...}
+{title:Example: Cattaneo, Frandsen and Titiunik (2015) Incumbency Data}.
+
+{p 4 8}Load dataset (cutoff is 0 in this dataset):{p_end}
+{p 8 8}{cmd:. use rddensity_senate.dta}{p_end}
+
+{p 4 8}Manipulation test using default options: {p_end}
+{p 8 8}{cmd:. rddensity margin}{p_end}
+
+{p 4 8}Reporting both conventional and robust bias-corrected statistics:{p_end}
+{p 8 8}{cmd:. rddensity margin, all}{p_end}
+
+{p 4 8}Manipulation test using manual bandwidths choices and plug-in standard errors:{p_end}
+{p 8 8}{cmd:. rddensity margin, h(10 20) vce(plugin)}{p_end}
+
+{p 4 8}Plot density and save results to variables:{p_end}
+{p 8 8}{cmd:. capture drop temp_*}{p_end}
+{p 8 8}{cmd:. rddensity margin, pl plot_range(-50 50) plot_n(100 100) genvars(temp) }{p_end}
+
+
+{marker saved_results}{...}
+{title:Saved results}
+
+{p 4 8}{cmd:rddensity} saves the following in {cmd:e()}:
+
+{synoptset 20 tabbed}{...}
+{p2col 5 20 24 2: Macros}{p_end}
+{synopt:{cmd:e(c)}}cutoff value{p_end}
+{synopt:{cmd:e(p)}}order of the polynomial used for density estimation{p_end}
+{synopt:{cmd:e(q)}}order of the polynomial used for bias-correction estimation{p_end}
+
+{synopt:{cmd:e(N_l)}}sample size to the left of the cutoff{p_end}
+{synopt:{cmd:e(N_r)}}sample size to the right of the cutoff{p_end}
+{synopt:{cmd:e(N_h_l)}}effective sample size (within bandwidth) to the left of the cutoff{p_end}
+{synopt:{cmd:e(N_h_r)}}effective sample size (within bandwidth) to the right of the cutoff{p_end}
+{synopt:{cmd:e(h_l)}}bandwidth used to the left of the cutoff{p_end}
+{synopt:{cmd:e(h_r)}}bandwidth used to the right of the cutoff{p_end}
+
+{synopt:{cmd:e(f_ql)}}bias-corrected density estimate to the left of the cutoff{p_end}
+{synopt:{cmd:e(f_qr)}}bias-corrected density estimate to the right of the cutoff{p_end}
+{synopt:{cmd:e(se_ql)}}standard error for bias-corrected density estimate to the left of the cutoff{p_end}
+{synopt:{cmd:e(se_qr)}}standard error for bias-corrected density estimate to the right of the cutoff{p_end}
+{synopt:{cmd:e(se_q)}}standard error for bias-corrected density test{p_end}
+{synopt:{cmd:e(T_q)}}bias-corrected t-statistic{p_end}
+{synopt:{cmd:e(pv_q)}}p-value for bias-corrected density test{p_end}
+
+{synopt:{cmd:e(runningvar)}}running variable used{p_end}
+{synopt:{cmd:e(kernel)}}kernel used{p_end}
+{synopt:{cmd:e(fitmethod)}}model used{p_end}
+{synopt:{cmd:e(bwmethod)}}bandwidth selection method used{p_end}
+{synopt:{cmd:e(vce)}}standard errors estimator used{p_end}
+
+{p2col 5 20 24 2: Only available if {cmd:all} is specified:}{p_end}
+{synopt:{cmd:e(f_pl)}}density estimate to the left of the cutoff without bias correction {p_end}
+{synopt:{cmd:e(f_pr)}}density estimate to the right of the cutoff without bias correction{p_end}
+{synopt:{cmd:e(se_pl)}}standard error for density estimate to the left of the cutoff without bias correction{p_end}
+{synopt:{cmd:e(se_pr)}}standard error for density estimate to the right of the cutoff without bias correction{p_end}
+{synopt:{cmd:e(se_p)}}standard error for density test without bias correction{p_end}
+{synopt:{cmd:e(T_p)}}t-statistic without bias correction{p_end}
+{synopt:{cmd:e(pv_p)}}p-value for density test without bias correction{p_end}
+
+
+{title:References}
+
+{p 4 8}Calonico, S., M. D. Cattaneo, and M. H. Farrell. 2018.
+{browse "https://rdpackages.github.io/references/Calonico-Cattaneo-Farrell_2018_JASA.pdf":On the Effect of Bias Estimation on Coverage Accuracy in Nonparametric Inference}.{p_end}
+{p 8 8}{it:Journal of the American Statistical Association} 113(522): 767-779.{p_end}
+
+{p 4 8}Calonico, S., M. D. Cattaneo, and M. H. Farrell. 2020.
+{browse "https://rdpackages.github.io/references/Calonico-Cattaneo-Farrell_2020_CEopt.pdf":Coverage Error Optimal Confidence Intervals for Local Polynomial Regression}.{p_end}
+{p 8 8}Working paper.{p_end}
+
+{p 4 8}Cattaneo, M. D., B. Frandsen, and R. Titiunik. 2015.
+{browse "https://rdpackages.github.io/references/Cattaneo-Frandsen-Titiunik_2015_JCI.pdf":Randomization Inference in the Regression Discontinuity Design: An Application to the Study of Party Advantages in the U.S. Senate}.{p_end}
+{p 8 8}{it:Journal of Causal Inference} 3(1): 1-24.{p_end}
+
+{p 4 8}Cattaneo, M. D., M. Jansson, and X. Ma. 2018.
+{browse "https://rdpackages.github.io/references/Cattaneo-Jansson-Ma_2018_Stata.pdf": Manipulation Testing based on Density Discontinuity}.{p_end}
+{p 8 8}{it:Stata Journal} 18(1): 234-261.{p_end}
+
+{p 4 8}Cattaneo, M. D., M. Jansson, and X. Ma. 2020.
+{browse "https://rdpackages.github.io/references/Cattaneo-Jansson-Ma_2020_JASA.pdf":Simple Local Polynomial Density Estimators}.{p_end}
+{p 8 8}{it:Journal of the American Statistical Association} 115(531): 1449-1455.{p_end}
+
+{p 4 8}Cattaneo, M. D., M. Jansson, and X. Ma. 2021a.
+{browse "https://rdpackages.github.io/references/Cattaneo-Jansson-Ma_2021_JoE.pdf":Local Regression Distribution Estimators}.{p_end}
+{p 8 8}{it:Journal of Econometrics}, forthcoming.{p_end}
+
+{p 4 8}Cattaneo, M. D., Michael Jansson, and Xinwei Ma. 2021b.
+{browse "https://rdpackages.github.io/references/Cattaneo-Jansson-Ma_2021_JSS.pdf":lpdensity: Local Polynomial Density Estimation and Inference}.{p_end}
+{p 8 8}{it:Journal of Statistical Software}, forthcoming.{p_end}
+
+{p 4 8}Cattaneo, M. D., Titiunik, R. and G. Vazquez-Bare. 2017.
+{browse "https://rdpackages.github.io/references/Cattaneo-Titiunik-VazquezBare_2017_JPAM.pdf":Comparing Inference Approaches for RD Designs: A Reexamination of the Effect of Head Start on Child Mortality}.{p_end}
+{p 8 8}{it:Journal of Policy Analysis and Management} 36(3): 643-681.{p_end}
+
+{p 4 8}McCrary, J. 2008. Manipulation of the Running Variable in the Regression Discontinuity Design: A Density Test.{p_end}
+{p 8 8}{it:Journal of Econometrics} 142(2): 698-714.{p_end}
+
+
+{title:Authors}
+
+{p 4 8}Matias D. Cattaneo, Princeton University, Princeton, NJ.
+{browse "mailto:[email protected]":[email protected]}.{p_end}
+
+{p 4 8}Michael Jansson, University of California Berkeley, Berkeley, CA.
+{browse "mailto:[email protected]":[email protected]}.{p_end}
+
+{p 4 8}Xinwei Ma, University of California San Diego, La Jolla, CA.
+{browse "mailto:[email protected]":[email protected]}.{p_end}
+
+
+

30/replication_package/Adofiles/rd_2021/rdplot.ado

@@ -0,0 +1,796 @@
+*!version 8.1.0  2021-02-22
+
+capture program drop rdplot
+program define rdplot, eclass
+	syntax anything [if] [, c(real 0) p(integer 4) nbins(string) covs(string) covs_eval(string) covs_drop(string)  binselect(string) scale(string) kernel(string) weights(string) h(string) k(integer 4) support(string) masspoints(string) genvars hide ci(real 0) shade graph_options(string) nochecks  *]
+
+	marksample touse
+	tokenize "`anything'"
+	local y `1'
+	local x `2'
+	
+	******************** Set BW ***************************
+	tokenize `h'	
+	local w : word count `h'
+	if `w' == 1 {
+		local h_r = `"`1'"'
+		local h_l = `"`1'"'
+	}
+	if `w' == 2 {
+		local h_l `"`1'"'
+		local h_r `"`2'"'
+	}
+	if `w' >= 3 {
+		di as error  "{err}{cmd:h()} accepts at most two inputs"  
+		exit 125
+	}
+	******************** Set scale ***************************
+	tokenize `scale'	
+	local w : word count `scale'
+	if `w' == 1 {
+		local scale_r = `"`1'"'
+		local scale_l = `"`1'"'
+	}
+	if `w' == 2 {
+		local scale_l `"`1'"'
+		local scale_r `"`2'"'
+	}
+	if `w' >= 3 {
+		di as error  "{err}{cmd:scale()} accepts at most two inputs"  
+		exit 125
+	}
+	******************** Set nbins ***************************
+	tokenize `nbins'	
+	local w : word count `nbins'
+	if `w' == 1 {
+		local nbins_r = `"`1'"'
+		local nbins_l = `"`1'"'
+	}
+	if `w' == 2 {
+		local nbins_l `"`1'"'
+		local nbins_r `"`2'"'
+	}
+	if `w' >= 3 {
+		di as error  "{err}{cmd:nbins()} accepts at most two inputs"  
+		exit 125
+	}	
+	******************** Set support ***************************
+	tokenize `support'	
+	local w : word count `support'
+	if `w' == 2 {
+		local support_l = `"`1'"'
+		local support_r = `"`2'"'
+	}
+	if (`w' != 2 & "`support'"!="") {
+		di as error  "{err}{cmd:support()} only accepts two inputs"  
+		exit 125
+	}	
+
+	*****************************************
+	preserve
+	sort `x', stable
+	qui keep if `touse'
+	
+	*****************************************************************
+	**** DROP MISSINGS ******************************************
+	*****************************************************************
+	qui drop if `y'==. | `x'==.	
+	if ("`covs'"~="") {
+		qui ds `covs'
+		local covs_list = r(varlist)
+		local ncovs: word count `covs_list'	
+		foreach z in `covs_list' {
+			qui drop if `z'==.
+		}
+	}
+		
+	**** CHECK colinearity ******************************************
+	local covs_drop_coll = 0	
+	if ("`covs_drop'"=="") local covs_drop = "pinv"	
+	if ("`covs'"~="") {	
+		
+	if ("`covs_drop'"=="invsym")  local covs_drop_coll = 1
+	if ("`covs_drop'"=="pinv")    local covs_drop_coll = 2
+	
+		qui _rmcoll `covs_list'
+		local nocoll_controls_cat `r(varlist)'
+		local nocoll_controls ""
+		foreach myString of local nocoll_controls_cat {
+			if ~strpos("`myString'", "o."){
+				if ~strpos("`myString'", "MYRUNVAR"){
+					local nocoll_controls "`nocoll_controls' `myString'"
+				}
+				}
+			}			
+		local covs_new `nocoll_controls'
+		qui ds `covs_new', alpha
+		local covs_list_new = r(varlist)
+		local ncovs_new: word count `covs_list_new'
+		
+		if (`ncovs_new'<`ncovs') {
+			if ("`covs_drop'"=="off") {	
+				di as error  "{err}Multicollinearity issue detected in {cmd:covs}. Please rescale and/or remove redundant covariates, or add {cmd:covs_drop} option." 
+				exit 125
+			} 
+			else {
+				local ncovs = "`ncovs_new'"
+				local covs_list = "`covs_list_new'"
+				*local covs_drop_coll = 1
+			}	
+		}
+	}
+	
+	
+	
+		
+	**** DEFAULTS ***************************************
+	if ("`masspoints'"=="") local masspoints = "adjust"
+	if ("`covs_eval'"=="")  local covs_eval = "mean"
+	*****************************************************************
+	
+	
+	
+	qui su `x'	
+	local N = r(N)
+	local x_min = r(min)
+	local x_max = r(max)
+	if ("`support'"!="") {	
+		if (`support_l'<`x_min') {
+			local x_min = `support_l'
+		}
+		if (`support_r'>`x_max') {
+			local x_max = `support_r'
+		}
+	}
+	local range_l = abs(`c'-`x_min')
+	local range_r = abs(`x_max'-`c')
+	
+	qui su `x' if `x'<`c', d
+	local n_l = r(N)
+	
+	qui su `x' if `x'>=`c', d
+	local n_r = r(N)
+	local n = `n_r' + `n_l'
+	
+	qui su `y' if `x'<`c'
+	local var_l = r(sd)
+	
+	qui su `y' if `x'>=`c'
+	local var_r = r(sd)
+	
+	if ("`h_l'"=="" & "`h_r'"=="") {
+		local h_l = `range_l'
+		local h_r = `range_r'
+	}
+	if "`kernel'"=="" local kernel = "uni"
+	
+	qui count if `x'<`c'  & `x'>=`c'-`h_l'
+	local n_h_l = r(N)
+	qui count if `x'>=`c' & `x'<=`c'+`h_r'
+	local n_h_r = r(N)
+	
+	**************************** ERRORS
+	if ("`scale_l'"=="" & "`scale_r'"=="") {
+		local scale_r = 1
+		local scale_l = 1
+	}
+	if ("`nbins_l'"=="" & "`nbins_r'"=="") {
+		local nbins_r = 0
+		local nbins_l = 0
+	}
+	
+	if ("`binselect'"=="") {
+		local binselect = "esmv" 
+	}
+	
+	if ("`nochecks'"=="") {
+		if (`c'<=`x_min' | `c'>=`x_max'){
+			di as error  "{err}{cmd:c()} should be set within the range of `x'"  
+		exit 125
+		}
+
+		if ("`p'"<"0" | "`nbins_l'"<"0" | "`nbins_r'"<"0"){
+			di as error  "{err}{cmd:p()} and {cmd:nbins()} should be a positive integers"  
+			exit 411
+		}
+			
+		if ("`k'"<="0"){
+			di as error  "{err}{cmd:k()} should be a positive integer"  
+			exit 411
+		}
+		
+		if (`n'<20){
+			 di as error "{err}Not enough observations to perform bin calculations"  
+			 exit 2001
+		}
+	}
+
+
+	*******************************
+	****** Start MATA *************
+	*******************************
+	mata{
+		n_l=`n_l'
+		n_r=`n_r'
+		p=`p'
+		k=`k'
+		n=`n'
+		c=`c'
+		x_min = `x_min'
+		x_max = `x_max'
+		h_l     = strtoreal("`h_l'");     h_r     = strtoreal("`h_r'")
+		nbins_l = strtoreal("`nbins_l'"); nbins_r = strtoreal("`nbins_r'")
+		scale_l = strtoreal("`scale_l'"); scale_r = strtoreal("`scale_r'")
+				
+		y = st_data(.,("`y'"), 0);	x = st_data(.,("`x'"), 0)
+		x_l = select(x,x:<c);	x_r = select(x,x:>=c)
+		y_l = select(y,x:<c);	y_r = select(y,x:>=c)
+				
+		*** Mass points check ********************************************
+		masspoints_found = 0
+		if ("`masspoints'"=="check" | "`masspoints'"=="adjust") {
+			X_uniq_l = sort(uniqrows(x_l),-1)
+			X_uniq_r = uniqrows(x_r)
+			M_l = length(X_uniq_l)
+			M_r = length(X_uniq_r)
+			M = M_l + M_r
+			st_numscalar("M_l", M_l); st_numscalar("M_r", M_r)
+			mass_l = 1-M_l/n_l
+			mass_r = 1-M_r/n_r				
+			if (mass_l>=0.1 | mass_r>=0.1){
+				masspoints_found = 1
+				display("{err}Mass points detected in the running variable.")
+				if ("`masspoints'"=="adjust") {
+					if ("`binselect'"=="es")    st_local("binselect","espr") 
+					if ("`binselect'"=="esmv")  st_local("binselect","esmvpr") 
+					if ("`binselect'"=="qs")    st_local("binselect","qspr") 
+					if ("`binselect'"=="qsmv")  st_local("binselect","qsmvpr") 				
+				}
+				if ("`masspoints'"=="check") display("{err}Try using option {cmd:masspoints(adjust)}.")
+
+			}				
+		}	
+		******************************************************************************************
+	
+	}
+	
+	mata{
+	
+		*if ("`hide'"=="" | "`genvars'"!="" ){
+		
+		************************************************************	
+		************ Polynomial curve (order = p) ******************
+		************************************************************
+		
+		if ("`covs'"=="") {
+		
+		rp_l = J(n_l,(p+1),.)
+		rp_r = J(n_r,(p+1),.)
+		for (j=1; j<=(p+1); j++) {
+			rp_l[.,j] = (x_l:-c):^(j-1)
+			rp_r[.,j] = (x_r:-c):^(j-1)
+		}
+
+		wh_l = rdrobust_kweight(x_l,c,h_l,"`kernel'")
+		wh_r = rdrobust_kweight(x_r,c,h_r,"`kernel'")
+		
+		if ("`weights'"~="") {
+			fw = st_data(.,("`weights'"), 0)
+			fw_l = select(fw,x:<c);	fw_r = select(fw,x:>=c)
+			wh_l = fw_l:*wh_l;	wh_r = fw_r:*wh_r
+		}			
+
+		
+			gamma_p1_l = cholinv(cross(rp_l,wh_l,rp_l))*cross(rp_l, wh_l, y_l)	
+			gamma_p1_r = cholinv(cross(rp_r,wh_r,rp_r))*cross(rp_r, wh_r, y_r)
+
+		
+
+		} else {
+		
+		Y = st_data(.,("`y'"), 0);	X = st_data(.,("`x'"), 0)
+		X_l = select(X,X:<`c');	X_r = select(X,X:>=`c')
+		Y_l = select(Y,X:<`c');	Y_r = select(Y,X:>=`c')
+		h_l = strtoreal("`h_l'"); h_r = strtoreal("`h_r'")
+		w_h_l = rdrobust_kweight(X_l,`c',h_l,"`kernel'");	w_h_r = rdrobust_kweight(X_r,`c',h_r,"`kernel'")
+		ind_l = selectindex(w_h_l:> 0);	ind_r = selectindex(w_h_r:> 0)
+	
+		eY_l  = Y_l[ind_l];	eY_r  = Y_r[ind_r]
+		eX_l  = X_l[ind_l];	eX_r  = X_r[ind_r]
+		W_h_l = w_h_l[ind_l];	W_h_r = w_h_r[ind_r]
+	
+		u_l = (eX_l:-`c')/h_l;	u_r = (eX_r:-`c')/h_r;
+		R_p_l = J(length(ind_l),(`p'+1),.); R_p_r = J(length(ind_r),(`p'+1),.)
+		for (j=1; j<=(`p'+1); j++)  {
+			R_p_l[.,j] = (eX_l:-`c'):^(j-1);  R_p_r[.,j] = (eX_r:-`c'):^(j-1)
+		}
+		
+		L_l = quadcross(R_p_l:*W_h_l,u_l:^(`p'+1)); L_r = quadcross(R_p_r:*W_h_r,u_r:^(`p'+1)) 
+		
+
+		invG_p_l  = cholinv(quadcross(R_p_l,W_h_l,R_p_l));	
+		invG_p_r  = cholinv(quadcross(R_p_r,W_h_r,R_p_r)) 
+		
+		Z    = st_data(.,tokens("`covs'"), 0); dZ = cols(Z)
+		Z_l  = select(Z,X:<`c');	eZ_l = Z_l[ind_l,]
+		Z_r  = select(Z,X:>=`c');	eZ_r = Z_r[ind_r,]
+		D_l  = eY_l,eZ_l; D_r = eY_r,eZ_r
+		U_p_l = quadcross(R_p_l:*W_h_l,D_l); U_p_r = quadcross(R_p_r:*W_h_r,D_r)
+		
+		beta_p_l = invG_p_l*quadcross(R_p_l:*W_h_l,D_l) 
+		beta_p_r = invG_p_r*quadcross(R_p_r:*W_h_r,D_r)
+		
+		ZWD_p_l  = quadcross(eZ_l,W_h_l,D_l)
+		ZWD_p_r  = quadcross(eZ_r,W_h_r,D_r)
+		colsZ = (2)::(2+dZ-1)
+			
+		UiGU_p_l =  quadcross(U_p_l[,colsZ],invG_p_l*U_p_l) 
+		UiGU_p_r =  quadcross(U_p_r[,colsZ],invG_p_r*U_p_r) 
+		ZWZ_p_l = ZWD_p_l[,colsZ] - UiGU_p_l[,colsZ] 
+		ZWZ_p_r = ZWD_p_r[,colsZ] - UiGU_p_r[,colsZ]     
+		ZWY_p_l = ZWD_p_l[,1] - UiGU_p_l[,1] 
+		ZWY_p_r = ZWD_p_r[,1] - UiGU_p_r[,1]     
+		ZWZ_p = ZWZ_p_r + ZWZ_p_l
+		ZWY_p = ZWY_p_r + ZWY_p_l
+				
+		if ("`covs_drop_coll'"=="0") gamma_p = cholinv(ZWZ_p)*ZWY_p
+		if ("`covs_drop_coll'"=="1") gamma_p =  invsym(ZWZ_p)*ZWY_p
+		if ("`covs_drop_coll'"=="2") gamma_p =    pinv(ZWZ_p)*ZWY_p
+			
+			
+		s_Y = (1 \  -gamma_p[,1])
+		gamma_p1_l  = (s_Y'*beta_p_l')'
+		gamma_p1_r  = (s_Y'*beta_p_r')'		
+		}
+		
+		st_matrix("gamma_p1_l", gamma_p1_l)
+		st_matrix("gamma_p1_r", gamma_p1_r)
+		
+		*********** Preparte data for polynomial curve plot *****
+		nplot = 500
+		x_plot_l = rangen(c-h_l,c,nplot)
+		x_plot_r = rangen(c,c+h_r,nplot)
+		rplot_l = J(nplot,(p+1),.)
+		rplot_r = J(nplot,(p+1),.)
+		for (j=1; j<=(p+1); j++) {
+			rplot_l[.,j] = (x_plot_l:-c):^(j-1)
+			rplot_r[.,j] = (x_plot_r:-c):^(j-1)
+		}	
+		
+		gammaZ = 0		
+		if ("`covs_eval'"=="mean" & "`covs'"!="") gammaZ = mean(Z)*gamma_p
+				
+		*yhat_x = (R_p_l*gamma_p1_l  \ R_p_r*gamma_p1_r ) :+ gammaZ
+		*resid_yz = y-Z*gamma_p
+					
+		y_plot_l = rplot_l*gamma_p1_l :+ gammaZ
+		y_plot_r = rplot_r*gamma_p1_r :+ gammaZ
+		
+		*}
+		
+		*******************************************************
+		**** Optimal Bins (using polynomial order k) **********
+		*******************************************************
+		rk_l = J(n_l,(k+1),.)
+		rk_r = J(n_r,(k+1),.)
+		for (j=1; j<=(k+1); j++) {
+			rk_l[.,j] = x_l:^(j-1)
+			rk_r[.,j] = x_r:^(j-1)
+		}
+		gamma_k1_l = invsym(cross(rk_l,rk_l))*cross(rk_l,y_l)		
+		gamma_k2_l = invsym(cross(rk_l,rk_l))*cross(rk_l,y_l:^2)	
+		gamma_k1_r = invsym(cross(rk_r,rk_r))*cross(rk_r,y_r)		
+		gamma_k2_r = invsym(cross(rk_r,rk_r))*cross(rk_r,y_r:^2)
+			
+		*** Bias w/sample
+		mu0_k1_l = rk_l*gamma_k1_l
+		mu0_k1_r = rk_r*gamma_k1_r
+		mu0_k2_l = rk_l*gamma_k2_l
+		mu0_k2_r = rk_r*gamma_k2_r
+		drk_l = J(n_l,k,.)
+		drk_r = J(n_r,k,.)
+		for (j=1; j<=k; j++) {
+			drk_l[.,j] = j*x_l:^(j-1)
+			drk_r[.,j] = j*x_r:^(j-1)
+		}
+		
+	dxi_l=(x_l[2::length(x_l)]-x_l[1::(length(x_l)-1)])
+	dxi_r=(x_r[2::length(x_r)]-x_r[1::(length(x_r)-1)])
+	dyi_l=(y_l[2::length(y_l)]-y_l[1::(length(y_l)-1)])
+	dyi_r=(y_r[2::length(y_r)]-y_r[1::(length(y_r)-1)])
+		
+	x_bar_i_l = (x_l[2::length(x_l)]+x_l[1::(length(x_l)-1)])/2
+	x_bar_i_r = (x_r[2::length(x_r)]+x_r[1::(length(x_r)-1)])/2
+		
+	drk_i_l = J(n_l-1,k,.);	rk_i_l  = J(n_l-1,(k+1),.)
+	drk_i_r = J(n_r-1,k,.);	rk_i_r  = J(n_r-1,(k+1),.)
+				   
+	for (j=1; j<=(k+1); j++) {
+		rk_i_l[.,j] = x_bar_i_l:^(j-1)
+		rk_i_r[.,j] = x_bar_i_r:^(j-1)
+	}
+	  
+	  for (j=1; j<=k; j++) {
+		drk_i_l[.,j] = j*x_bar_i_l:^(j-1)
+		drk_i_r[.,j] = j*x_bar_i_r:^(j-1)
+	  }
+	  mu1_i_hat_l = drk_i_l*(gamma_k1_l[2::(k+1)])
+	  mu1_i_hat_r = drk_i_r*(gamma_k1_r[2::(k+1)])
+	   
+	  mu0_i_hat_l = rk_i_l*gamma_k1_l
+	  mu0_i_hat_r = rk_i_r*gamma_k1_r
+	  mu2_i_hat_l = rk_i_l*gamma_k2_l
+	  mu2_i_hat_r = rk_i_r*gamma_k2_r
+
+	  mu0_hat_l = rk_l*gamma_k1_l
+	  mu0_hat_r = rk_r*gamma_k1_r
+	  mu2_hat_l = rk_l*gamma_k2_l
+	  mu2_hat_r = rk_r*gamma_k2_r
+	  
+	  mu1_hat_l = drk_l*(gamma_k1_l[2::(k+1)])
+	  mu1_hat_r = drk_r*(gamma_k1_r[2::(k+1)])
+		
+	  mu1_i_hat_l = drk_i_l*(gamma_k1_l[2::(k+1)])
+	  mu1_i_hat_r = drk_i_r*(gamma_k1_r[2::(k+1)])
+	  
+	  sigma2_hat_l_bar = mu2_i_hat_l - mu0_i_hat_l:^2
+	  sigma2_hat_r_bar = mu2_i_hat_r - mu0_i_hat_r:^2
+
+	  sigma2_hat_l = mu2_hat_l - mu0_hat_l:^2
+	  sigma2_hat_r = mu2_hat_r - mu0_hat_r:^2
+	  
+	  var_y_l = variance(y_l)
+	  var_y_r = variance(y_r)
+
+	  B_es_hat_dw = (((c-x_min)^2/(12*n))*sum(mu1_hat_l:^2),((x_max-c)^2/(12*n))*sum(mu1_hat_r:^2))
+	  V_es_hat_dw = ((0.5/(c-x_min))*sum(dxi_l:*dyi_l:^2),(0.5/(x_max-c))*sum(dxi_r:*dyi_r:^2))
+	  V_es_chk_dw = ((1/(c-x_min))*sum(dxi_l:*sigma2_hat_l_bar),(1/(x_max-c))*sum(dxi_r:*sigma2_hat_r_bar))
+	  J_es_hat_dw = ceil((((2*B_es_hat_dw):/V_es_hat_dw)*n):^(1/3))
+	  J_es_chk_dw = ceil((((2*B_es_hat_dw):/V_es_chk_dw)*n):^(1/3))
+		
+	  B_qs_hat_dw = ((n_l^2/(24*n))*sum(dxi_l:^2:*mu1_i_hat_l:^2), (n_r^2/(24*n))*sum(dxi_r:^2:*mu1_i_hat_r:^2))
+	  V_qs_hat_dw = ((1/(2*n_l))*sum(dyi_l:^2),(1/(2*n_r))*sum(dyi_r:^2))
+	  V_qs_chk_dw = ((1/n_l)*sum(sigma2_hat_l), (1/n_r)*sum(sigma2_hat_r))
+	  J_qs_hat_dw = ceil((((2*B_qs_hat_dw):/V_qs_hat_dw)*n):^(1/3))
+	  J_qs_chk_dw = ceil((((2*B_qs_hat_dw):/V_qs_chk_dw)*n):^(1/3))
+	  
+	  J_es_hat_mv  = (ceil((var_y_l/V_es_hat_dw[1])*(n/log(n)^2)), ceil((var_y_r/V_es_hat_dw[2])*(n/log(n)^2)))
+	  J_es_chk_mv  = (ceil((var_y_l/V_es_chk_dw[1])*(n/log(n)^2)), ceil((var_y_r/V_es_chk_dw[2])*(n/log(n)^2)))
+	  J_qs_hat_mv  = (ceil((var_y_l/V_qs_hat_dw[1])*(n/log(n)^2)), ceil((var_y_r/V_qs_hat_dw[2])*(n/log(n)^2)))
+	  J_qs_chk_mv  = (ceil((var_y_l/V_qs_chk_dw[1])*(n/log(n)^2)), ceil((var_y_r/V_qs_chk_dw[2])*(n/log(n)^2)))
+
+	if ("`binselect'"=="es" ) {
+		J_star_l_orig = J_es_hat_dw[1]
+		J_star_r_orig = J_es_hat_dw[2]
+	}
+	
+	if ("`binselect'"=="esmv" | "`binselect'"=="") {
+		J_star_l_orig = J_es_hat_mv[1]
+		J_star_r_orig = J_es_hat_mv[2]
+	}
+	
+	if ("`binselect'"=="espr" ) {
+		J_star_l_orig = J_es_chk_dw[1]
+		J_star_r_orig = J_es_chk_dw[2]
+	}
+	
+	if ("`binselect'"=="esmvpr" ) {
+		J_star_l_orig = J_es_chk_mv[1]
+		J_star_r_orig = J_es_chk_mv[2]
+	}
+	
+	if ("`binselect'"=="qs" ) {
+		J_star_l_orig = J_qs_hat_dw[1]
+		J_star_r_orig = J_qs_hat_dw[2]
+	}
+	
+	if ("`binselect'"=="qsmv" ) {
+		J_star_l_orig = J_qs_hat_mv[1]
+		J_star_r_orig = J_qs_hat_mv[2]
+	}
+	
+	if ("`binselect'"=="qspr" ) {
+		J_star_l_orig = J_qs_chk_dw[1]
+		J_star_r_orig = J_qs_chk_dw[2]
+	}
+	
+	if ("`binselect'"=="qsmvpr" ) {
+		J_star_l_orig = J_qs_chk_mv[1]
+		J_star_r_orig = J_qs_chk_mv[2]
+	}
+
+	if (nbins_l!=0 & nbins_r!=0) {
+		J_star_l_orig = nbins_l
+		J_star_r_orig = nbins_r
+	}
+	
+	if (`var_l'==0) {
+		J_star_l = 1
+		J_star_l_orig = 1
+		display("{err}Warning: not enough variability in the outcome variable below the threshold")
+	}
+	if (`var_r'==0) {
+		J_star_r = 1
+		J_star_r_orig = 1
+		display("{err}Warning: not enough variability in the outcome variable above the threshold")
+	}
+
+	J_star_l = round(`scale_l'*J_star_l_orig)
+	J_star_r = round(`scale_r'*J_star_r_orig)
+	
+	st_numscalar("nbins_l", nbins_l)
+	st_numscalar("nbins_r", nbins_r)
+	st_numscalar("J_star_l", J_star_l)
+	st_numscalar("J_star_r", J_star_r)
+	st_numscalar("J_star_l_orig", J_star_l_orig)
+	st_numscalar("J_star_r_orig", J_star_r_orig)
+		
+	st_matrix("J_es_hat_dw", J_es_hat_dw)
+	st_matrix("J_qs_hat_dw", J_qs_hat_dw)
+	st_matrix("J_es_chk_dw", J_es_chk_dw)
+	st_matrix("J_qs_chk_dw", J_qs_chk_dw)
+	st_matrix("J_es_hat_mv", J_es_hat_mv)
+	st_matrix("J_qs_hat_mv", J_qs_hat_mv)
+	st_matrix("J_es_chk_mv", J_es_chk_mv)
+	st_matrix("J_qs_chk_mv", J_qs_chk_mv)
+	}
+	
+
+	********************************************************
+	**** Generate id and rdplot vars ***********************
+	********************************************************	
+	local J_star_l = J_star_l
+	local J_star_r = J_star_r
+	
+	qui gen rdplot_id = .
+	qui gen rdplot_min_bin = .
+	qui gen rdplot_max_bin = .
+	qui gen rdplot_mean_bin = .
+	
+	
+	if ("`binselect'"=="qs" | "`binselect'"=="qspr"  | "`binselect'"=="qsmv" | "`binselect'"=="qsmvpr") {
+		pctile binsL = `x' if `x'<`c',  nq(`J_star_l')
+		pctile binsR = `x' if `x'>=`c', nq(`J_star_r')
+	}
+
+mata {
+	x_min = `x_min'
+	x_max = `x_max'
+
+	if ("`binselect'"=="es" | "`binselect'"=="espr"  | "`binselect'"=="esmv" | "`binselect'"=="esmvpr" | "`binselect'"=="") {
+		binsL = rangen(x_min,c    , `J_star_l'+1)
+		binsR = rangen(c    ,x_max, `J_star_r'+1)
+		bins = binsL[1..length(binsL)-1]\binsR		
+	}
+	
+	if ("`binselect'"=="qs" | "`binselect'"=="qspr"  | "`binselect'"=="qsmv" | "`binselect'"=="qsmvpr") {
+		bins = (x_min \ st_data(.,"binsL",0) \ c \ st_data(.,"binsR",0) \ x_max )
+	}
+	
+	st_view(ZZ=.,., "`x' rdplot_id rdplot_min_bin rdplot_max_bin rdplot_mean_bin", "`touse'")
+	bin_i = 2
+	for(i=1; i<=rows(ZZ); i++) {
+		while(ZZ[i,1] >= bins[bin_i] & bin_i < length(bins)) bin_i++
+		/* PUT rdplot_id */
+		ZZ[i,2] = bin_i - `J_star_l' - 2
+		if (ZZ[i,2] >= 0) ZZ[i,2] = ZZ[i,2] + 1
+		/* PUT rdplot_min_bin rdplot_max_bin rdplot_mean_bin */
+		ZZ[i,3] = bins[bin_i-1] 
+		ZZ[i,4] = bins[bin_i]
+		ZZ[i,5] = (bins[bin_i]+bins[bin_i-1])/2
+	}
+	
+}
+
+** STATA: Generate inputs for RDPLOT (and possibly for reporting back to user)
+if  ("`covs_eval'"=="" | "`covs_eval'"=="0") {
+collapse (count) rdplot_N=`x' (mean) rdplot_min_bin rdplot_max_bin rdplot_mean_bin    ///
+         (mean) rdplot_mean_x=`x'  rdplot_mean_y=`y'    ///
+		 (semean) rdplot_se_y=`y', by(rdplot_id) fast
+}
+
+**************************************************************************
+**** covs_eval **********************************************************
+**************************************************************************
+if  ("`covs_eval'"=="mean") {
+	tempvar  rdplot_id2  yhat_tmp yhatZ
+	qui gen `rdplot_id2' = rdplot_id + `J_star_l'
+	qui reg `y' `covs_list' i.`rdplot_id2'
+	qui predict `yhatZ'
+	
+	collapse (count) rdplot_N=`x' (mean) rdplot_min_bin rdplot_max_bin rdplot_mean_bin    ///
+         (mean) rdplot_mean_x=`x'   rdplot_mean_y=`yhatZ'     ///
+		 (semean) rdplot_se_y=`y', by(rdplot_id) fast
+}		 
+
+		qui replace rdplot_N=rdplot_N-1
+		qui gen quant = -invt(rdplot_N, abs((1-(`ci'/100))/2))
+		qui gen rdplot_ci_l = rdplot_mean_y - quant*rdplot_se_y
+		qui gen rdplot_ci_r = rdplot_mean_y + quant*rdplot_se_y
+		qui drop quant
+	
+	mata{
+	if ("`genvars'"!="") {
+	** MATA: Save rdplot inputs to return to user in original dataset
+	rdplot = st_data(.,.)
+	}
+	}
+	
+	qui gen bin_length = rdplot_max_bin-rdplot_min_bin
+	qui su bin_length if rdplot_id<0, d
+	local bin_avg_l = r(mean)
+	local bin_med_l = r(p50)
+	qui su bin_length if rdplot_id>0, d
+	local bin_avg_r = r(mean)
+	local bin_med_r = r(p50)
+		 
+	if ("`binselect'"=="es"){
+		local binselect_type="evenly spaced number of bins using spacings estimators."
+		scalar J_star_l_IMSE = J_es_hat_dw[1,1]
+		scalar J_star_r_IMSE = J_es_hat_dw[1,2]
+		scalar J_star_l_MV   = J_es_hat_mv[1,1]
+		scalar J_star_r_MV   = J_es_hat_mv[1,2]
+	}
+	if ("`binselect'"=="espr"){
+		local binselect_type="evenly spaced number of bins using polynomial regression."
+		scalar J_star_l_IMSE = J_es_chk_dw[1,1]
+		scalar J_star_r_IMSE = J_es_chk_dw[1,2]
+		scalar J_star_l_MV   = J_es_chk_mv[1,1]
+		scalar J_star_r_MV   = J_es_chk_mv[1,2]
+	}
+    if ("`binselect'"=="esmv" | "`binselect'"==""){
+		local binselect_type="evenly spaced mimicking variance number of bins using spacings estimators."
+		scalar J_star_l_IMSE = J_es_hat_dw[1,1]
+		scalar J_star_r_IMSE = J_es_hat_dw[1,2]
+		scalar J_star_l_MV   = J_es_hat_mv[1,1]
+		scalar J_star_r_MV   = J_es_hat_mv[1,2]
+	}
+    if ("`binselect'"=="esmvpr"){
+		local binselect_type="evenly spaced mimicking variance number of bins using polynomial regression."
+		scalar J_star_l_IMSE = J_es_chk_dw[1,1]
+		scalar J_star_r_IMSE = J_es_chk_dw[1,2]
+		scalar J_star_l_MV   = J_es_chk_mv[1,1]
+		scalar J_star_r_MV   = J_es_chk_mv[1,2]
+	}
+    if ("`binselect'"=="qs"){
+		local binselect_type="quantile spaced number of bins using spacings estimators."
+		scalar J_star_l_IMSE = J_qs_hat_dw[1,1]
+		scalar J_star_r_IMSE = J_qs_hat_dw[1,2]
+		scalar J_star_l_MV   = J_qs_hat_mv[1,1]
+		scalar J_star_r_MV   = J_qs_hat_mv[1,2]
+	}
+    if ("`binselect'"=="qspr"){
+		local binselect_type="quantile spaced number of bins using polynomial regression."
+		scalar J_star_l_IMSE = J_qs_chk_dw[1,1]
+		scalar J_star_r_IMSE = J_qs_chk_dw[1,2]
+		scalar J_star_l_MV   = J_qs_chk_mv[1,1]
+		scalar J_star_r_MV   = J_qs_chk_mv[1,2]
+	}
+    if ("`binselect'"=="qsmv"){
+		local binselect_type="quantile spaced mimicking variance quantile spaced using spacings estimators."  
+		scalar J_star_l_IMSE = J_qs_hat_dw[1,1]
+		scalar J_star_r_IMSE = J_qs_hat_dw[1,2]
+		scalar J_star_l_MV   = J_qs_hat_mv[1,1]
+		scalar J_star_r_MV   = J_qs_hat_mv[1,2]
+	}
+    if ("`binselect'"=="qsmvpr"){
+		local binselect_type="quantile spaced mimicking variance number of bins using polynomial regression."
+		scalar J_star_l_IMSE = J_qs_chk_dw[1,1]
+		scalar J_star_r_IMSE = J_qs_chk_dw[1,2]
+		scalar J_star_l_MV   = J_qs_chk_mv[1,1]
+		scalar J_star_r_MV   = J_qs_chk_mv[1,2]
+	}
+	if (nbins_l!=0 | nbins_r!=0 ) local binselect_type= "RD plot with manually set number of bins."
+	
+	scalar scale_l = J_star_l / J_star_l_IMSE
+	scalar scale_r = J_star_r / J_star_r_IMSE
+		
+	qui getmata x_plot_l x_plot_r y_plot_l y_plot_r, force
+		
+	ereturn clear
+	ereturn scalar N_l = `n_l'
+	ereturn scalar N_r = `n_r'
+	ereturn scalar c = `c'
+	ereturn scalar J_star_l = J_star_l
+	ereturn scalar J_star_r = J_star_r
+	ereturn matrix coef_l = gamma_p1_l
+	ereturn matrix coef_r = gamma_p1_r
+	ereturn local binselect = "`binselect'"
+
+	if ("`kernel'"=="epanechnikov" | "`kernel'"=="epa") local kernel_type = "Epanechnikov"
+	else if ("`kernel'"=="uniform" | "`kernel'"=="uni") local kernel_type = "Uniform"
+	else  local kernel_type = "Triangular"
+			
+	disp ""
+	disp in smcl in yellow "RD Plot with " "`binselect_type'" 
+	disp ""
+	
+	disp in smcl in gr "{ralign 21: Cutoff c = `c'}"      _col(22) " {c |} " _col(23) in gr "Left of " in yellow "c"  _col(36) in gr "Right of " in yellow "c" _col(54) in gr "Number of obs  = "  in yellow %10.0f `n'
+	disp in smcl in gr "{hline 22}{c +}{hline 22}"                                                                                                             _col(54) in gr "Kernel         = "  in yellow "{ralign 10:`kernel_type'}" 
+	disp in smcl in gr "{ralign 21:Number of obs}"        _col(22) " {c |} " _col(23) as result %9.0f `n_l'      _col(37) %9.0f  `n_r'                        
+	disp in smcl in gr "{ralign 21:Eff. Number of obs}"   _col(22) " {c |} " _col(23) as result %9.0f `n_h_l'      _col(37) %9.0f  `n_h_r'                        
+	disp in smcl in gr "{ralign 21:Order poly. fit (p)}"  _col(22) " {c |} " _col(23) as result %9.0f `p'        _col(37) %9.0f  `p'                              
+	disp in smcl in gr "{ralign 21:BW poly. fit (h)}"     _col(22) " {c |} " _col(23) as result %9.3f `h_l'      _col(37) %9.3f  `h_r' 
+	disp in smcl in gr "{ralign 21:Number of bins scale}" _col(22) " {c |} " _col(23) as result %9.3f `scale_l'  _col(37) %9.3f  `scale_r' 
+	disp ""
+	disp "Outcome: `y'. Running variable: `x'."
+	disp in smcl in gr "{hline 22}{c TT}{hline 22}"
+	disp in smcl in gr   _col(22) " {c |} " _col(23) in gr "Left of " in yellow "c"  _col(36) in gr "Right of " in yellow "c" 
+	disp in smcl in gr "{hline 22}{c +}{hline 22}"                                                                                
+	disp in smcl in gr "{ralign 21:Bins selected}"          _col(22) " {c |} " _col(23) as result %9.0f e(J_star_l)      _col(37) %9.0f  e(J_star_r)
+	disp in smcl in gr "{ralign 21:Average bin length}"    _col(22) " {c |} " _col(23) as result %9.3f `bin_avg_l'   _col(37) %9.3f  `bin_avg_r'
+	disp in smcl in gr "{ralign 21:Median bin length}"     _col(22) " {c |} " _col(23) as result %9.3f `bin_med_l'   _col(37) %9.3f  `bin_med_r'
+	disp in smcl in gr "{hline 22}{c +}{hline 22}"  
+	disp in smcl in gr "{ralign 21:IMSE-optimal bins}"      _col(22) " {c |} " _col(23) as result %9.0f J_star_l_IMSE    _col(37) %9.0f  J_star_r_IMSE
+	disp in smcl in gr "{ralign 21:Mimicking Var. bins}"    _col(22) " {c |} " _col(23) as result %9.0f J_star_l_MV      _col(37) %9.0f  J_star_r_MV
+	disp in smcl in gr "{hline 22}{c +}{hline 22}"    
+	disp in smcl in gr "{lalign 1:Rel. to IMSE-optimal:}"   _col(22) " {c |} " 
+	disp in smcl in gr "{ralign 21:Implied scale}"          _col(22) " {c |} " _col(23) as result %9.3f scale_l                 _col(37) %9.3f  scale_r
+	disp in smcl in gr "{ralign 21:WIMSE var. weight}"      _col(22) " {c |} " _col(23) as result %9.3f 1/(1+scale_l^3)         _col(37) %9.3f  1/(1+scale_r^3)
+   	disp in smcl in gr "{ralign 21:WIMSE bias weight}"      _col(22) " {c |} " _col(23) as result %9.3f scale_l^3/(1+scale_l^3) _col(37) %9.3f  scale_r^3/(1+scale_r^3)
+	disp in smcl in gr "{hline 22}{c BT}{hline 22}"    	
+	disp ""
+		if ("`covs'"!="")    disp "Covariate-adjusted estimates. Additional covariates included: `ncovs'"
+		if (`covs_drop_coll'==1) di as error  "{err}Variables dropped due to multicollinearity."
+
+
+	if ("`hide'"==""){
+		if (`"`graph_options'"'=="" ) local graph_options = `"title("Regression function fit", color(gs0)) "'
+		
+		if (`ci'==0) {
+				twoway (scatter rdplot_mean_y rdplot_mean_bin, sort msize(small)  mcolor(gs10)) ///
+				(line y_plot_l x_plot_l, lcolor(black) sort lwidth(medthin) lpattern(solid) ) ///
+				(line y_plot_r x_plot_r, lcolor(black) sort lwidth(medthin) lpattern(solid) ),  ///
+				xline(`c', lcolor(black) lwidth(medthin)) xscale(r(`x_min' `x_max'))  legend(cols(2) order(1 "Sample average within bin" 2 "Polynomial fit of order `p'" )) `graph_options'
+		}
+		else {
+			if ("`shade'"==""){
+				twoway (rcap rdplot_ci_l rdplot_ci_r rdplot_mean_bin, color(gs11)) ///
+				(scatter rdplot_mean_y rdplot_mean_bin, sort msize(small)  mcolor(gs10)) ///
+				(line y_plot_l x_plot_l, lcolor(black) sort lwidth(medthin) lpattern(solid))   ///
+				(line y_plot_r x_plot_r, lcolor(black) sort lwidth(medthin) lpattern(solid)),  ///
+				xline(`c', lcolor(black) lwidth(medthin)) xscale(r(`x_min' `x_max')) legend(cols(2) order(2 "Sample average within bin" 3 "Polynomial fit of order `p'" )) `graph_options'
+			}
+			else {
+				twoway (rarea rdplot_ci_l rdplot_ci_r rdplot_mean_bin if rdplot_id<0, sort color(gs11)) ///
+				       (rarea rdplot_ci_l rdplot_ci_r rdplot_mean_bin if rdplot_id>0, sort color(gs11)) ///
+				(scatter rdplot_mean_y rdplot_mean_bin, sort msize(small)  mcolor(gs10)) ///
+				(line y_plot_l x_plot_l, lcolor(black) sort lwidth(medthin) lpattern(solid)) ///
+				(line y_plot_r x_plot_r, lcolor(black) sort lwidth(medthin) lpattern(solid)) ,  ///
+				xline(`c', lcolor(black) lwidth(medthin)) xscale(r(`x_min' `x_max')) legend(cols(2) order(2 "Sample average within bin" 3 "Polynomial fit of order `p'" )) `graph_options'
+			}						
+		}
+	}
+	
+restore
+
+****************************
+** PART 2: genvars=TRUE
+****************************
+if ("`genvars'"!="") {
+	qui for any id N min_bin max_bin mean_bin mean_x mean_y se_y ci_l ci_r hat_y: qui gen rdplot_X = .
+}
+	
+mata{
+	if ("`genvars'"~="") {
+		st_view(ZZ=.,., "`x' rdplot_id rdplot_N rdplot_min_bin rdplot_max_bin rdplot_mean_bin rdplot_mean_x rdplot_mean_y rdplot_se_y rdplot_ci_l rdplot_ci_r rdplot_hat_y", "`touse'")
+		for (i=1; i<=rows(ZZ); i++) {
+		if (ZZ[i,1]!=.) {
+			bin_i = 2; while(ZZ[i,1] >= bins[bin_i] & bin_i < length(bins)) bin_i++
+		 	rdplot_i = bin_i - `J_star_l' - 2
+			if (rdplot_i >= 0) rdplot_i = rdplot_i + 1
+			ZZ[i,2..11] = select(rdplot, rdplot[.,1]:==rdplot_i)
+			ZZ[i,12] = 0; for (j=0; j<=p; j++) {
+			if (ZZ[i,2] <0) ZZ[i,12] = ZZ[i,12] + ((ZZ[i,1]-c)^j)*gamma_p1_l[j+1] 
+			else           ZZ[i,12] = ZZ[i,12] + ((ZZ[i,1]-c)^j)*gamma_p1_r[j+1]
+			}		
+		}
+		}
+	}
+}
+
+mata mata clear
+end
+
+
+ 

30/replication_package/Adofiles/rd_2021/rdplot.sthlp

@@ -0,0 +1,222 @@
+{smcl}
+{* *!version 8.1.0  2021-02-22}{...}
+{viewerjumpto "Syntax" "rdplot##syntax"}{...}
+{viewerjumpto "Description" "rdplot##description"}{...}
+{viewerjumpto "Options" "rdplot##options"}{...}
+{viewerjumpto "Examples" "rdplot##examples"}{...}
+{viewerjumpto "Stored results" "rdplot##stored_results"}{...}
+{viewerjumpto "References" "rdplot##references"}{...}
+{viewerjumpto "Authors" "rdplot##authors"}{...}
+
+{title:Title}
+
+{p 4 8}{cmd:rdplot} {hline 2} Data-Driven Regression Discontinuity Plots.{p_end}
+
+{marker syntax}{...}
+{title:Syntax}
+
+{p 4 8}{cmd:rdplot } {it:depvar} {it:indepvar} {ifin} 
+[{cmd:,} 
+{cmd:c(}{it:#}{cmd:)} 
+{cmd:nbins(}{it:# #}{cmd:)}
+{cmd:binselect(}{it:binmethod}{cmd:)}
+{cmd:scale(}{it:# #}{cmd:)}
+{cmd:support(}{it:# #}{cmd:)}  
+{cmd:p(}{it:#}{cmd:)}
+{cmd:h(}{it:# #}{cmd:)} 
+{cmd:kernel(}{it:kernelfn}{cmd:)}
+{cmd:weights(}{it:weightsvar}{cmd:)}
+{cmd:covs(}{it:covars}{cmd:)}
+{cmd:covs_eval(}{it:covars_eval}{cmd:)}
+{cmd:covs_drop(}{it:covsdropoption}{cmd:)}
+{cmd:masspoints(}{it:masspointsoption}{cmd:)}
+{cmd:ci(}{it:cilevel}{cmd:)}
+{it:shade}
+{cmd:graph_options(}{it:gphopts}{cmd:)}
+{it:hide}
+{it:genvars}
+]{p_end}
+
+{synoptset 28 tabbed}{...}
+
+{marker description}{...}
+{title:Description}
+
+{p 4 8}{cmd:rdplot} implements several data-driven Regression Discontinuity (RD) plots, using either evenly-spaced or quantile-spaced partitioning. Two type of RD plots are constructed: (i) RD plots with binned sample means tracing out the underlying regression function, and (ii) RD plots with binned sample means
+mimicking the underlying variability of the data. For technical and methodological details see 
+{browse "https://rdpackages.github.io/references/Calonico-Cattaneo-Titiunik_2015_JASA.pdf":Calonico, Cattaneo and Titiunik (2015a)}.{p_end}
+
+{p 8 8} Companion commands are: {help rdrobust:rdrobust} for point estimation and inference procedures, and {help rdbwselect:rdbwselect} for data-driven bandwidth selection.{p_end}
+
+{p 8 8}A detailed introduction to this command is given in
+{browse "https://rdpackages.github.io/references/Calonico-Cattaneo-Titiunik_2014_Stata.pdf":Calonico, Cattaneo and Titiunik (2014)},
+and {browse "https://rdpackages.github.io/references/Calonico-Cattaneo-Farrell-Titiunik_2017_Stata.pdf":Calonico, Cattaneo, Farrell and Titiunik (2017)}. A companion {browse "www.r-project.org":R} package is also described in
+{browse "https://rdpackages.github.io/references/Calonico-Cattaneo-Titiunik_2015_R.pdf":Calonico, Cattaneo and Titiunik (2015b)}.{p_end}
+
+{p 4 8}Related Stata and R packages useful for inference in RD designs are described in the following website:{p_end}
+
+{p 8 8}{browse "https://rdpackages.github.io":https://rdpackages.github.io}{p_end}
+
+
+{marker options}{...}
+{title:Options}
+
+{dlgtab:Estimand}
+
+{p 4 8}{cmd:c(}{it:#}{cmd:)} specifies the RD cutoff in {it:indepvar}.
+Default is {cmd:c(0)}. 
+
+{dlgtab:Bin Selection}
+
+{p 4 8}{cmd:nbins(}{it:# #}{cmd:)} specifies the number of bins used to the left of the cutoff, denoted {it:J-}, and to the right of the cutoff, denoted {it:J+}, respectively.
+If not specified, {it:J+} and {it:J-} are estimated using the method and options chosen below.
+
+{p 4 8}{cmd:binselect(}{it:binmethod}{cmd:)} specifies the data-driven procedure to select the number of bins. This option is available only if {it:J-} and {it:J+} are not set manually using {cmd:nbins(.)}.
+Options are:{p_end}
+{p 8 12}{opt es} IMSE-optimal evenly-spaced method using spacings estimators.{p_end}
+{p 8 12}{opt espr} IMSE-optimal evenly-spaced method using polynomial regression.{p_end}
+{p 8 12}{opt esmv} mimicking variance evenly-spaced method using spacings estimators.{p_end}
+{p 8 12}{opt esmvpr} mimicking variance evenly-spaced method using polynomial regression.{p_end}
+{p 8 12}{opt qs} IMSE-optimal quantile-spaced method using spacings estimators.{p_end}
+{p 8 12}{opt qspr} IMSE-optimal quantile-spaced method using polynomial regression.{p_end}
+{p 8 12}{opt qsmv} mimicking variance quantile-spaced method using spacings estimators.{p_end}
+{p 8 12}{opt qsmvpr} mimicking variance quantile-spaced method using polynomial regression.{p_end}
+{p 8 12}Default is {cmd:binselect(esmv)}.{p_end}
+{p 8 12}Note: procedures involving spacing estimators are not invariant to rearrangements of {it:depvar} when there are repeated values (i.e., mass points in the running variable).{p_end}
+
+{p 4 8}{cmd:scale(}{it:# #}{cmd:)} specifies multiplicative factors, denoted {it:s-} and {it:s+}, respectively, to adjust the number of bins selected. Specifically, the number of bins used for the treatment and control groups will be
+ceil({cmd:s- * J-}) and ceil({cmd:s+ * J+}), where J- and J+ denote the optimal numbers of bins originally computed for each group. 
+Default is {cmd:scale(1 1)}.
+
+{p 4 8}{cmd:support(}{it:# #}{cmd:)} sets an optional extended support of the running variable to be used in the construction of the bins. Default is the sample range.
+
+{p 4 8}{cmd:masspoints(}{it:masspointsoption}{cmd:)} checks and controls for repeated observations in the running variable. 
+Options are:{p_end}
+{p 8 12}{opt off}  ignores the presence of mass points. {p_end}
+{p 8 12}{opt check}  looks for and reports the number of unique observations at each side of the cutoff.   {p_end}
+{p 8 12}{opt adjust}  sets {cmd:binselect(}{it:binmethod}{cmd:)} as polynomial regression when mass points are present. {p_end}
+{p 8 12} Default option is {cmd:masspoints(adjust)}.{p_end}
+
+{dlgtab:Polynomial Fit}
+
+{p 4 8}{cmd:p(}{it:#}{cmd:)} specifies the order of the (global) polynomial fit used to approximate the population conditional expectation functions for control and treated units.
+Default is {cmd:p(4)}.
+
+{p 4 8}{cmd:h(}{it:# #}{cmd:)} specifies the bandwidth used to construct the (global) polynomial fits given the kernel choice {cmd:kernel(.)}.
+If not specified, the bandwidths are chosen to span the full support of the data. If two bandwidths are specified, the first bandwidth is used for the data below the cutoff and the second bandwidth is used for the data above the cutoff.
+
+{p 4 8}{cmd:kernel(}{it:kernelfn}{cmd:)} specifies the kernel function used to construct the local-polynomial estimator(s). Options are: {opt tri:angular}, {opt epa:nechnikov}, and {opt uni:form}.
+Default is {cmd:kernel(uniform)} (i.e., equal/no weighting to all observations on the support of the kernel).
+
+{p 4 8}{cmd:weights(}{it:weightsvar}{cmd:)} is the variable used for optional weighting of the estimation procedure. The unit-specific weights multiply the kernel function.{p_end}
+
+{p 4 8}{cmd:covs(}{it:covars}{cmd:)} additional covariates used to construct the local-polynomial estimator(s).{p_end}
+
+{p 4 8}{cmd:covs_eval(}{it:covars_eval}{cmd:)} sets the evaluation points for the additional covariates, when included in the estimation. Options are: {opt 0} (default) and {opt mean}.
+
+{p 4 8}{cmd:covs_drop(}{it:covsdropoption}{cmd:)} assess collinearity in additional covariates used for estimation and inference. Options {opt pinv} (default choice) and {opt invsym} drops collinear additional covariates, differing only in the type of inverse function used. Option {opt off} only checks collinear additional covariates but does not drop them.{p_end}
+
+{dlgtab:Plot Options}
+
+{p 4 8}{cmd:ci(}{it:cilevel}{cmd:)} graphical option to display confidence intervals of level {it:cilevel} for each bin. 
+
+{p 4 8}{cmd:shade} graphical option to replace confidence intervals with shaded areas.
+
+{p 4 8}{cmd:graph_options(}{it:gphopts}{cmd:)} graphical options to be passed on to the underlying graph command.
+
+{p 4 8}{cmd:hide} omits the RD plot.
+
+{dlgtab:Generate Variables}
+
+{p 4 8}{it:genvars} generates new variables storing the following results.{p_end}
+{p 8 12}{opt rdplot_id} unique bin ID for each observation. Negative natural numbers are assigned to observations to the left of the cutoff, and positive natural numbers are assigned to observations to the right of the cutoff.{p_end}
+{p 8 12}{opt rdplot_N} number of observations in the corresponding bin for each observation.{p_end}
+{p 8 12}{opt rdplot_min_bin} lower end value of the bin for each observation.{p_end}
+{p 8 12}{opt rdplot_max_bin} upper end value of the bin for each observation.{p_end}
+{p 8 12}{opt rdplot_mean_bin} middle point of the corresponding bin for each observation.{p_end}
+{p 8 12}{opt rdplot_mean_x} sample mean of the running variable within the corresponding bin for each observation.{p_end}
+{p 8 12}{opt rdplot_mean_y} sample mean of the outcome variable within the corresponding bin for each observation.{p_end}
+{p 8 12}{opt rdplot_se_y} standard deviation of the mean of the outcome variable within the corresponding bin for each observation.{p_end}
+{p 8 12}{opt rdplot_ci_l} lower end value of the confidence interval for the sample mean of the outcome variable within the corresponding bin for each observation.{p_end}
+{p 8 12}{opt rdplot_ci_r} upper end value of the confidence interval for the sample mean of the outcome variable within the corresponding bin for each observation.{p_end}
+{p 8 12}{opt rdplot_hat_y} predicted value of the outcome variable given by the global polynomial estimator.{p_end}
+
+
+    {hline}
+
+
+{marker examples}{...}
+{title:Example: Cattaneo, Frandsen and Titiunik (2015) Incumbency Data}
+
+{p 4 8}Setup{p_end}
+{p 8 8}{cmd:. use rdrobust_senate.dta}{p_end}
+
+{p 4 8}Basic specification with title{p_end}
+{p 8 8}{cmd:. rdplot vote margin, graph_options(title(RD Plot))}{p_end}
+
+{p 4 8}Quadratic global polynomial with confidence bands{p_end}
+{p 8 8}{cmd:. rdplot vote margin, p(2) ci(95) shade}{p_end}
+
+{marker stored_results}{...}
+{title:Stored results}
+
+{p 4 8}{cmd:rdplot} stores the following in {cmd:e()}:
+
+{synoptset 20 tabbed}{...}
+{p2col 5 20 24 2: Scalars}{p_end}
+{synopt:{cmd:e(N_l)}}original number of observations to the left of the cutoff{p_end}
+{synopt:{cmd:e(N_r)}}original number of observations to the right of the cutoff{p_end}
+{synopt:{cmd:e(c)}}cutoff value{p_end}
+{synopt:{cmd:e(J_star_l)}}selected number of bins to the left of the cutoff{p_end}
+{synopt:{cmd:e(J_star_r)}}selected number of bins to the right of the cutoff{p_end}
+
+{p2col 5 20 24 2: Macros}{p_end}
+{synopt:{cmd:e(binselect)}}method used to compute the optimal number of bins{p_end}
+
+{synoptset 20 tabbed}{...}
+{p2col 5 20 24 2: Matrices}{p_end}
+{synopt:{cmd:e(coef_l)}}coefficients of the {it:p}-th order polynomial estimated to the left of the cutoff{p_end}
+{synopt:{cmd:e(coef_r)}}coefficients of the {it:p}-th order polynomial estimated to the right of the cutoff{p_end}
+
+
+{marker references}{...}
+{title:References}
+
+{p 4 8}Calonico, S., M. D. Cattaneo, M. H. Farrell, and R. Titiunik. 2017.
+{browse "https://rdpackages.github.io/references/Calonico-Cattaneo-Farrell-Titiunik_2017_Stata.pdf":rdrobust: Software for Regression Discontinuity Designs}.
+{it:Stata Journal} 17(2): 372-404.{p_end}
+
+{p 4 8}Calonico, S., M. D. Cattaneo, and R. Titiunik. 2014b.
+{browse "https://rdpackages.github.io/references/Calonico-Cattaneo-Titiunik_2014_Stata.pdf":Robust Data-Driven Inference in the Regression-Discontinuity Design}.
+{it:Stata Journal} 14(4): 909-946.{p_end}
+
+{p 4 8}Calonico, S., M. D. Cattaneo, and R. Titiunik. 2015a.
+{browse "https://rdpackages.github.io/references/Calonico-Cattaneo-Titiunik_2015_JASA.pdf":Optimal Data-Driven Regression Discontinuity Plots}.
+{it:Journal of the American Statistical Association} 110(512): 1753-1769.{p_end}
+
+{p 4 8}Calonico, S., M. D. Cattaneo, and R. Titiunik. 2015b.
+{browse "https://rdpackages.github.io/references/Calonico-Cattaneo-Titiunik_2015_R.pdf":rdrobust: An R Package for Robust Nonparametric Inference in Regression-Discontinuity Designs}.
+{it:R Journal} 7(1): 38-51.{p_end}
+
+{p 4 8}Cattaneo, M. D., B. Frandsen, and R. Titiunik. 2015.
+{browse "https://rdpackages.github.io/references/Cattaneo-Frandsen-Titiunik_2015_JCI.pdf":Randomization Inference in the Regression Discontinuity Design: An Application to Party Advantages in the U.S. Senate}.
+{it:Journal of Causal Inference} 3(1): 1-24.{p_end}
+
+
+{marker authors}{...}
+{title:Authors}
+
+{p 4 8}Sebastian Calonico, Columbia University, New York, NY.
+{browse "mailto:[email protected]":[email protected]}.{p_end}
+
+{p 4 8}Matias D. Cattaneo, Princeton University, Princeton, NJ.
+{browse "mailto:[email protected]":[email protected]}.{p_end}
+
+{p 4 8}Max H. Farrell, University of Chicago, Chicago, IL.
+{browse "mailto:[email protected]":[email protected]}.{p_end}
+
+{p 4 8}Rocio Titiunik, Princeton University, Princeton, NJ.
+{browse "mailto:[email protected]":[email protected]}.{p_end}
+
+
+

30/replication_package/Adofiles/rd_2021/rdrobust.ado

@@ -0,0 +1,1009 @@
+*!version 8.1.0  2021-02-22
+
+capture program drop rdrobust 
+program define rdrobust, eclass
+	syntax anything [if] [in] [, c(real 0) fuzzy(string) deriv(real 0) p(real 1) q(real 0) h(string) b(string) rho(real 0) covs(string) covs_drop(string) kernel(string) weights(string) bwselect(string) vce(string) level(real 95) all scalepar(real 1) scaleregul(real 1) nochecks masspoints(string) bwcheck(real 0) bwrestrict(string) stdvars(string)]
+	*disp in yellow "Preparing data." 
+	marksample touse
+	preserve
+	qui keep if `touse'
+	tokenize "`anything'"
+	local y `1'
+	local x `2'
+	local kernel   = lower("`kernel'")
+	local bwselect = lower("`bwselect'")
+	
+	******************** Set VCE ***************************
+	local nnmatch = 3
+	tokenize `vce'	
+	local w : word count `vce'
+	if `w' == 1 {
+		local vce_select `"`1'"'
+	}
+	if `w' == 2 {
+		local vce_select `"`1'"'
+		if ("`vce_select'"=="nn")      local nnmatch     `"`2'"'
+		if ("`vce_select'"=="cluster" | "`vce_select'"=="nncluster") local clustvar `"`2'"'	
+	}
+	if `w' == 3 {
+		local vce_select `"`1'"'
+		local clustvar   `"`2'"'
+		local nnmatch    `"`3'"'
+		if ("`vce_select'"!="cluster" & "`vce_select'"!="nncluster") di as error  "{err}{cmd:vce()} incorrectly specified"  
+	}
+	if `w' > 3 {
+		di as error "{err}{cmd:vce()} incorrectly specified"  
+		exit 125
+	}
+	
+	local vce_type = "NN"
+	if ("`vce_select'"=="hc0")     		 local vce_type = "HC0"
+	if ("`vce_select'"=="hc1")      	 local vce_type = "HC1"
+	if ("`vce_select'"=="hc2")      	 local vce_type = "HC2"
+	if ("`vce_select'"=="hc3")      	 local vce_type = "HC3"
+	if ("`vce_select'"=="cluster")  	 local vce_type = "Cluster"
+	if ("`vce_select'"=="nncluster") 	 local vce_type = "NNcluster"
+
+	if ("`vce_select'"=="cluster" | "`vce_select'"=="nncluster") local cluster = "cluster"
+	if ("`vce_select'"=="cluster")       local vce_select = "hc0"
+	if ("`vce_select'"=="nncluster")     local vce_select = "nn"
+	if ("`vce_select'"=="")              local vce_select = "nn"
+
+	******************** Set BW ***************************
+	tokenize `h'	
+	local w : word count `h'
+	if `w' == 1 {
+		local h_l `"`1'"'
+		local h_r `"`1'"'
+	}
+	if `w' == 2 {
+		local h_l `"`1'"'
+		local h_r `"`2'"'
+	}
+	if `w' >= 3 {
+		di as error  "{err}{cmd:h()} only accepts two inputs"  
+		exit 125
+	}
+	
+	tokenize `b'	
+	local w : word count `b'
+	if `w' == 1 {
+		local b_l `"`1'"'
+		local b_r `"`1'"'
+	}
+	if `w' == 2 {
+		local b_l `"`1'"'
+		local b_r `"`2'"'
+	}
+	if `w' >= 3 {
+		di as error  "{err}{cmd:b()} only accepts two inputs"  
+		exit 125
+	}
+	
+	*** Manual bandwidth 
+	if ("`h'"!="") {	
+		local bwselect = "Manual"
+		*if ("`b_l'"=="" & "`b_r'"=="" & "`h_l'"!="" & "`h_r'"!="") {
+		if ("`b'"=="") {	
+			local b_r = `h_r'
+			local b_l = `h_l'
+		}		
+		if ("`rho'">"0")  {
+			local b_l = `h_l'/`rho'
+			local b_r = `h_r'/`rho'
+		}		
+	}	
+	
+	*** Default bandwidth 
+	if ("`h'"=="" & "`bwselect'"=="") local bwselect= "mserd"
+	
+	******************** Set Fuzzy***************************
+	tokenize `fuzzy'	
+	local w : word count `fuzzy'
+	if `w' == 1 {
+		local fuzzyvar `"`1'"'
+	}
+	if `w' == 2 {
+		local fuzzyvar `"`1'"'
+		local sharpbw  `"`2'"'
+		if `"`2'"' != "sharpbw" {
+			di as error  "{err}fuzzy() only accepts sharpbw as a second input" 
+			exit 125
+		}
+	}
+	if `w' >= 3 {
+		di as error  "{err}{cmd:fuzzy()} only accepts two inputs"  
+		exit 125
+	}
+	
+	**** DROP MISSINGS **********************************************
+	qui drop if `y'==. | `x'==.
+	if ("`fuzzy'"~="")   qui drop if `fuzzyvar'==.
+	if ("`cluster'"!="") qui drop if `clustvar'==.
+	if ("`covs'"~="") {
+		qui ds `covs', alpha
+		local covs_list = r(varlist)
+		local ncovs: word count `covs_list'	
+		foreach z in `covs_list' {
+			qui drop if `z'==.
+		}
+	}		
+		
+	**** CHECK colinearity ******************************************
+	local covs_drop_coll = 0	
+	if ("`covs_drop'"=="") local covs_drop = "pinv"	
+	if ("`covs'"~="") {	
+		
+	if ("`covs_drop'"=="invsym")  local covs_drop_coll = 1
+	if ("`covs_drop'"=="pinv")    local covs_drop_coll = 2
+	
+		qui _rmcoll `covs_list'
+		local nocoll_controls_cat `r(varlist)'
+		local nocoll_controls ""
+		foreach myString of local nocoll_controls_cat {
+			if ~strpos("`myString'", "o."){
+				if ~strpos("`myString'", "MYRUNVAR"){
+					local nocoll_controls "`nocoll_controls' `myString'"
+				}
+				}
+			}			
+		local covs_new `nocoll_controls'
+		qui ds `covs_new', alpha
+		local covs_list_new = r(varlist)
+		local ncovs_new: word count `covs_list_new'
+		
+		if (`ncovs_new'<`ncovs') {
+			if ("`covs_drop'"=="off") {	
+				di as error  "{err}Multicollinearity issue detected in {cmd:covs}. Please rescale and/or remove redundant covariates, or add {cmd:covs_drop} option." 
+				exit 125
+			} 
+			else {
+				local ncovs = "`ncovs_new'"
+				local covs_list = "`covs_list_new'"
+				*local covs_drop_coll = 1
+			}	
+		}
+	}
+	
+				
+	**** DEFAULTS ***************************************
+	if ("`masspoints'"=="") local masspoints = "adjust"
+	if ("`stdvars'"=="")    local stdvars    = "off"	
+	if ("`bwrestrict'"=="") local bwrestrict = "on"	
+	*****************************************************************
+	
+	qui su `x', d
+	local N = r(N)
+	local x_min = r(min)
+	local x_max = r(max)
+	local x_iq = r(p75)-r(p25)
+	local x_sd = r(sd)
+
+	if ("`deriv'">"0" & "`p'"=="1" & "`q'"=="0") local p = `deriv'+1
+	if ("`q'"=="0") local q = `p'+1
+
+	**************************** BEGIN ERROR CHECKING ************************************************
+	if ("`nochecks'"=="") {
+			if (`c'<=`x_min' | `c'>=`x_max'){
+			 di as error  "{err}{cmd:c()} should be set within the range of `x'"  
+			 exit 125
+			}
+			
+			
+			if (`N'<20){
+			 di as error  "{err}Not enough observations to perform bandwidth calculations"  
+			 di as error  "{err}Estimates computed using entire sample"  
+			 local bwselect= "Manual"
+			
+			qui su `x' if `x'<`c'
+			local range_l = abs(r(max)-r(min))
+			qui su `x' if `x'>=`c'
+			local range_r = abs(r(max)-r(min))
+			local bw_range = max(`range_l',`range_r')
+			
+			local h   = `bw_range'
+			local b   = `bw_range'
+			local h_l = `bw_range'
+			local h_r = `bw_range'
+			local b_l = `bw_range'
+			local b_r = `bw_range'	
+			}
+			
+			if ("`kernel'"~="uni" & "`kernel'"~="uniform" & "`kernel'"~="tri" & "`kernel'"~="triangular" & "`kernel'"~="epa" & "`kernel'"~="epanechnikov" & "`kernel'"~="" ){
+			 di as error  "{err}{cmd:kernel()} incorrectly specified"  
+			 exit 7
+			}
+
+			if ("`bwselect'"=="CCT" | "`bwselect'"=="IK" | "`bwselect'"=="CV" |"`bwselect'"=="cct" | "`bwselect'"=="ik" | "`bwselect'"=="cv"){
+				di as error  "{err}{cmd:bwselect()} options IK, CCT and CV have been depricated. Please see help for new options"  
+				exit 7
+			}
+	
+			if  ("`bwselect'"!="mserd" & "`bwselect'"!="msetwo" & "`bwselect'"!="msesum" & "`bwselect'"!="msecomb1" & "`bwselect'"!="msecomb2"  & "`bwselect'"!="cerrd" & "`bwselect'"!="certwo" & "`bwselect'"!="cersum" & "`bwselect'"!="cercomb1" & "`bwselect'"!="cercomb2" & "`bwselect'"~="Manual"){
+				di as error  "{err}{cmd:bwselect()} incorrectly specified"  
+				exit 7
+			}
+
+			if ("`vce_select'"~="nn" & "`vce_select'"~="" & "`vce_select'"~="cluster" & "`vce_select'"~="nncluster" & "`vce_select'"~="hc1" & "`vce_select'"~="hc2" & "`vce_select'"~="hc3" & "`vce_select'"~="hc0"){ 
+			 di as error  "{err}{cmd:vce()} incorrectly specified"  
+			 exit 7
+			}
+
+			if ("`p'"<"0" | "`q'"<="0" | "`deriv'"<"0" | "`nnmatch'"<="0" ){
+			 di as error  "{err}{cmd:p()}, {cmd:q()}, {cmd:deriv()}, {cmd:nnmatch()} should be positive"  
+			 exit 411
+			}
+				
+			if ("`p'">="`q'" & "`q'">"0"){
+			 di as error  "{err}{cmd:q()} should be higher than {cmd:p()}"  
+			 exit 125
+			}
+			
+			if ("`deriv'">"`p'" & "`deriv'">"0" ){
+			 di as error  "{err}{cmd:deriv()} can not be higher than {cmd:p()}"  
+			 exit 125
+			}
+
+			if ("`p'">"0" ) {
+				local p_round = round(`p')/`p'
+				local q_round = round(`q')/`q'
+				local d_round = round(`deriv'+1)/(`deriv'+1)
+				local m_round = round(`nnmatch')/`nnmatch'
+
+				if (`p_round'!=1 | `q_round'!=1 |`d_round'!=1 |`m_round'!=1 ){
+				 di as error  "{err}{cmd:p()}, {cmd:q()}, {cmd:deriv()} and {cmd:nnmatch()} should be integers"  
+				 exit 126
+				}
+			}
+			if (`level'>100 | `level'<=0){
+			 di as error  "{err}{cmd:level()}should be set between 0 and 100"  
+			 exit 125
+			}
+	}
+	*********************** END ERROR CHECKING ************************************************************
+		
+	if ("`vce_select'"=="nn" | "`masspoints'"=="check" | "`masspoints'"=="adjust") {
+		sort `x', stable
+		if ("`vce_select'"=="nn") {
+			tempvar dups dupsid
+			by `x': gen dups = _N
+			by `x': gen dupsid = _n
+		}
+	}
+
+	if ("`kernel'"=="epanechnikov" | "`kernel'"=="epa") {
+		local kernel_type = "Epanechnikov"
+		local C_c = 2.34
+	}
+	else if ("`kernel'"=="uniform" | "`kernel'"=="uni") {
+		local kernel_type = "Uniform"
+		local C_c = 1.843
+	}
+	else {
+		local kernel_type = "Triangular"
+		local C_c = 2.576
+	}
+	
+	*** Start MATA ********************************************************
+
+	mata{
+	
+	*** Preparing data
+		Y = st_data(.,("`y'"), 0);	X = st_data(.,("`x'"), 0)		
+		ind_l = selectindex(X:<`c'); ind_r = selectindex(X:>=`c')			
+		X_l = X[ind_l];	X_r = X[ind_r]
+		Y_l = Y[ind_l];	Y_r = Y[ind_r]
+		dZ=dT=dC=Z_l=Z_r=T_l=T_r=C_l=C_r=fw_l=fw_r=g_l=g_r=dups_l=dups_r=dupsid_l=dupsid_r=g_l=g_r=eT_l=eT_r=eZ_l=eZ_r=indC_l=indC_r=eC_l=eC_r=0
+		
+		N   = length(X);	N_l = length(X_l);	N_r = length(X_r)
+				
+		if ("`covs'"~="") {
+			Z   = st_data(.,tokens("`covs_list'"), 0); dZ  = cols(Z)
+			Z_l = Z[ind_l,];	Z_r = Z[ind_r,]
+		}
+	
+		if ("`fuzzy'"~="") {
+			T = st_data(.,("`fuzzyvar'"), 0);	T_l = T[ind_l];	T_r = T[ind_r]; dT = 1
+			if (variance(T_l)==0 | variance(T_r)==0){
+				T_l = T_r = 0
+				st_local("perf_comp","perf_comp")
+			}
+			if ("`sharpbw'"!=""){
+				T_l = T_r = 0
+				st_local("sharpbw","sharpbw")
+			}
+		}	
+	
+		if ("`cluster'"!="") {
+			C  = st_data(.,("`clustvar'"), 0)
+			C_l  = C[ind_l]; C_r  = C[ind_r]
+			indC_l = order(C_l,1);  indC_r = order(C_r,1) 
+			g_l = rows(panelsetup(C_l[indC_l],1));	g_r = rows(panelsetup(C_r[indC_r],1))
+			st_numscalar("g_l",  g_l);     st_numscalar("g_r",   g_r)
+		}	
+	
+		if ("`weights'"~="") {
+			fw = st_data(.,("`weights'"), 0)
+			fw_l = fw[ind_l];	fw_r = fw[ind_r]
+		}
+		
+		if ("`vce_select'"=="nn") {
+			dups      = st_data(.,("dups"), 0); dupsid    = st_data(.,("dupsid"), 0)
+			dups_l    = dups[ind_l];    dups_r    = dups[ind_r]
+			dupsid_l  = dupsid[ind_l];  dupsid_r  = dupsid[ind_r]
+		}
+		
+		
+		h_l = `h_l'
+		h_r = `h_r'
+		b_l = `b_l'
+		b_r = `b_r'
+
+	***********************************************************************
+	******** Computing bandwidth selector *********************************
+	***********************************************************************		
+masspoints_found = 0
+	
+	if ("`h'"=="") {	
+	
+		BWp = min((`x_sd',`x_iq'/1.349))
+		x_sd = y_sd = 1
+		c = `c'
+		*** Starndardized ******************
+		if  ("`stdvars'"=="on")  {	
+			y_sd = sqrt(variance(Y))
+			x_sd = sqrt(variance(X))
+			X_l = X_l/x_sd;	X_r = X_r/x_sd
+			Y_l = Y_l/y_sd;	Y_r = Y_r/y_sd
+			c = `c'/x_sd
+			BWp = min((1, (`x_iq'/x_sd)/1.349))
+		}		
+		x_l_min = min(X_l);	x_l_max = max(X_l)
+		x_r_min = min(X_r);	x_r_max = max(X_r)
+	
+		range_l = c - x_l_min
+		range_r = x_r_max - c  
+		************************************		
+		
+		mN = `N'
+		bwcheck = `bwcheck'
+		covs_drop_coll = `covs_drop_coll'
+
+		if ("`masspoints'"=="check" | "`masspoints'"=="adjust") {
+			X_uniq_l = sort(uniqrows(X_l),-1)
+			X_uniq_r = uniqrows(X_r)
+			M_l = length(X_uniq_l)
+			M_r = length(X_uniq_r)
+			M = M_l + M_r
+			st_numscalar("M_l", M_l); st_numscalar("M_r", M_r)
+			mass_l = 1-M_l/N_l
+			mass_r = 1-M_r/N_r				
+			if (mass_l>=0.1 | mass_r>=0.1){
+				masspoints_found = 1
+				display("{err}Mass points detected in the running variable.")
+				if ("`masspoints'"=="adjust" & "`bwcheck'"=="0") bwcheck = 10
+				if ("`masspoints'"=="check") display("{err}Try using option {cmd:masspoints(adjust)}.")
+			}				
+		}	
+		
+		
+		c_bw = `C_c'*BWp*mN^(-1/5)
+		if ("`masspoints'"=="adjust") c_bw = `C_c'*BWp*M^(-1/5)
+		if  ("`bwrestrict'"=="on") {
+		bw_max = max((range_l,range_r))
+		c_bw = min((c_bw, bw_max))
+		}
+		if (bwcheck > 0) {
+			bwcheck_l = min((bwcheck, M_l))
+			bwcheck_r = min((bwcheck, M_r))
+			bw_min_l = abs(X_uniq_l:-c)[bwcheck_l] + 1e-8
+			bw_min_r = abs(X_uniq_r:-c)[bwcheck_r] + 1e-8
+			c_bw = max((c_bw, bw_min_l, bw_min_r))
+		}		
+		
+			
+		*** Step 1: d_bw
+		C_d_l = rdrobust_bw(Y_l, X_l, T_l, Z_l, C_l, fw_l, c=c, o=`q'+1, nu=`q'+1, o_B=`q'+2, h_V=c_bw, h_B=range_l+1e-8, 0, "`vce_select'", `nnmatch', "`kernel'", dups_l, dupsid_l, covs_drop_coll)
+		C_d_r = rdrobust_bw(Y_r, X_r, T_r, Z_r, C_r, fw_r, c=c, o=`q'+1, nu=`q'+1, o_B=`q'+2, h_V=c_bw, h_B=range_r+1e-8, 0, "`vce_select'", `nnmatch', "`kernel'", dups_r, dupsid_r, covs_drop_coll)
+		if (C_d_l[1]==0 | C_d_l[2]==0 | C_d_r[1]==0 | C_d_r[2]==0 |C_d_l[1]==. | C_d_l[2]==. | C_d_l[3]==. |C_d_r[1]==. | C_d_r[2]==. | C_d_r[3]==.) printf("{err}Not enough variability to compute the preliminary bandwidth. Try checking for mass points with option {cmd:masspoints(check)}.\n")  
+
+		*printf("i=%g\n ",C_d_l[5])
+		*printf("i=%g\n ",C_d_r[5])
+
+		
+		*** BW-TWO
+		if  ("`bwselect'"=="msetwo" |  "`bwselect'"=="certwo" | "`bwselect'"=="msecomb2" | "`bwselect'"=="cercomb2" )  {		
+			* Preliminar bw
+			d_bw_l = (  (C_d_l[1]              /   C_d_l[2]^2)    * (`N'/mN)         )^C_d_l[4] 
+			d_bw_r = (  (C_d_r[1]              /   C_d_r[2]^2)    * (`N'/mN)         )^C_d_l[4]
+			if  ("`bwrestrict'"=="on") {
+			d_bw_l = min((d_bw_l, range_l))
+			d_bw_r = min((d_bw_r, range_r))
+			}
+			if (bwcheck > 0) {
+				d_bw_l = max((d_bw_l, bw_min_l))
+				d_bw_r = max((d_bw_r, bw_min_r))
+			}
+			* Bias bw
+			C_b_l  = rdrobust_bw(Y_l, X_l, T_l, Z_l, C_l, fw_l, c=c, o=`q', nu=`p'+1, o_B=`q'+1, h_V=c_bw, h_B=d_bw_l, `scaleregul', "`vce_select'", `nnmatch', "`kernel'", dups_l, dupsid_l, covs_drop_coll)
+			b_bw_l = (  (C_b_l[1]              /   (C_b_l[2]^2 + `scaleregul'*C_b_l[3]))  * (`N'/mN)     )^C_b_l[4]
+			C_b_r  = rdrobust_bw(Y_r, X_r, T_r, Z_r, C_r, fw_r, c=c, o=`q', nu=`p'+1, o_B=`q'+1, h_V=c_bw, h_B=d_bw_r, `scaleregul', "`vce_select'", `nnmatch', "`kernel'", dups_r, dupsid_r, covs_drop_coll)
+			b_bw_r = (  (C_b_r[1]              /   (C_b_r[2]^2 + `scaleregul'*C_b_r[3]))   * (`N'/mN)    )^C_b_l[4]
+			if  ("`bwrestrict'"=="on") {
+			b_bw_l = min((b_bw_l, range_l))
+			b_bw_r = min((b_bw_r, range_r))
+			}
+			* Main bw
+			C_h_l  = rdrobust_bw(Y_l, X_l, T_l, Z_l, C_l, fw_l, c=c, o=`p', nu=`deriv', o_B=`q', h_V=c_bw, h_B=b_bw_l, `scaleregul', "`vce_select'", `nnmatch', "`kernel'", dups_l, dupsid_l, covs_drop_coll)
+			h_bw_l = (  (C_h_l[1]              /   (C_h_l[2]^2 + `scaleregul'*C_h_l[3]))  * (`N'/mN)       )^C_h_l[4]
+			C_h_r  = rdrobust_bw(Y_r, X_r, T_r, Z_r, C_r, fw_r, c=c, o=`p', nu=`deriv', o_B=`q', h_V=c_bw, h_B=b_bw_r, `scaleregul', "`vce_select'", `nnmatch', "`kernel'", dups_r, dupsid_r, covs_drop_coll)
+			h_bw_r = (  (C_h_r[1]              /   (C_h_r[2]^2 + `scaleregul'*C_h_r[3]))  * (`N'/mN)       )^C_h_l[4]
+			if  ("`bwrestrict'"=="on") {
+			h_bw_l = min((h_bw_l, range_l))
+			h_bw_r = min((h_bw_r, range_r))
+			}
+		}
+		
+		*** BW-SUM
+		if  ("`bwselect'"=="msesum" | "`bwselect'"=="cersum" |  "`bwselect'"=="msecomb1" | "`bwselect'"=="msecomb2" |  "`bwselect'"=="cercomb1" | "`bwselect'"=="cercomb2")  {
+			* Preliminar bw
+			d_bw_s = ( ((C_d_l[1] + C_d_r[1])  /  (C_d_r[2] + C_d_l[2])^2)  * (`N'/mN)  )^C_d_l[4]
+			if  ("`bwrestrict'"=="on")  d_bw_s = min((d_bw_s, bw_max))
+			if (bwcheck > 0) d_bw_s = max((d_bw_s, bw_min_l, bw_min_r))		
+			* Bias bw
+			C_b_l  = rdrobust_bw(Y_l, X_l, T_l, Z_l, C_l, fw_l, c=c, o=`q', nu=`p'+1, o_B=`q'+1, h_V=c_bw, h_B=d_bw_s, `scaleregul', "`vce_select'", `nnmatch', "`kernel'", dups_l, dupsid_l, covs_drop_coll)
+			C_b_r  = rdrobust_bw(Y_r, X_r, T_r, Z_r, C_r, fw_r, c=c, o=`q', nu=`p'+1, o_B=`q'+1, h_V=c_bw, h_B=d_bw_s, `scaleregul', "`vce_select'", `nnmatch', "`kernel'", dups_r, dupsid_r, covs_drop_coll)
+			b_bw_s = ( ((C_b_l[1] + C_b_r[1])  /  ((C_b_r[2] + C_b_l[2])^2 + `scaleregul'*(C_b_r[3]+C_b_l[3])))  * (`N'/mN)  )^C_b_l[4]
+			if  ("`bwrestrict'"=="on") b_bw_s = min((b_bw_s, bw_max))
+			* Main bw
+			C_h_l  = rdrobust_bw(Y_l, X_l, T_l, Z_l, C_l, fw_l, c=c, o=`p', nu=`deriv', o_B=`q', h_V=c_bw, h_B=b_bw_s, `scaleregul', "`vce_select'", `nnmatch', "`kernel'", dups_l, dupsid_l, covs_drop_coll)
+			C_h_r  = rdrobust_bw(Y_r, X_r, T_r, Z_r, C_r, fw_r, c=c, o=`p', nu=`deriv', o_B=`q', h_V=c_bw, h_B=b_bw_s, `scaleregul', "`vce_select'", `nnmatch', "`kernel'", dups_r, dupsid_r, covs_drop_coll)
+			h_bw_s = ( ((C_h_l[1] + C_h_r[1])  /  ((C_h_r[2] + C_h_l[2])^2 + `scaleregul'*(C_h_r[3] + C_h_l[3])))  * (`N'/mN)  )^C_h_l[4]			
+			if  ("`bwrestrict'"=="on") h_bw_s = min((h_bw_s, bw_max))
+		}
+		
+		*** RD
+		if  ("`bwselect'"=="mserd" | "`bwselect'"=="cerrd" | "`bwselect'"=="msecomb1" | "`bwselect'"=="msecomb2" | "`bwselect'"=="cercomb1" | "`bwselect'"=="cercomb2" | "`bwselect'"=="") {
+			* Preliminar bw
+			d_bw_d = ( ((C_d_l[1] + C_d_r[1])  /  (C_d_r[2] - C_d_l[2])^2)  * (`N'/mN)   )^C_d_l[4]
+			if  ("`bwrestrict'"=="on") d_bw_d = min((d_bw_d, bw_max))
+			
+			if (bwcheck > 0) d_bw_d = max((d_bw_d, bw_min_l, bw_min_r))		
+			* Bias bw
+			C_b_l  = rdrobust_bw(Y_l, X_l, T_l, Z_l, C_l, fw_l, c=c, o=`q', nu=`p'+1, o_B=`q'+1, h_V=c_bw, h_B=d_bw_d, `scaleregul', "`vce_select'", `nnmatch', "`kernel'", dups_l, dupsid_l, covs_drop_coll)
+			C_b_r  = rdrobust_bw(Y_r, X_r, T_r, Z_r, C_r, fw_r, c=c, o=`q', nu=`p'+1, o_B=`q'+1, h_V=c_bw, h_B=d_bw_d, `scaleregul', "`vce_select'", `nnmatch', "`kernel'", dups_r, dupsid_r, covs_drop_coll)
+			b_bw_d = ( ((C_b_l[1] + C_b_r[1])  /  ((C_b_r[2] - C_b_l[2])^2 + `scaleregul'*(C_b_r[3] + C_b_l[3])))  * (`N'/mN)    )^C_b_l[4]
+			if  ("`bwrestrict'"=="on") b_bw_d = min((b_bw_d, bw_max))
+			
+			* Main bw
+			C_h_l  = rdrobust_bw(Y_l, X_l, T_l, Z_l, C_l, fw_l, c=c, o=`p', nu=`deriv', o_B=`q', h_V=c_bw, h_B=b_bw_d, `scaleregul', "`vce_select'", `nnmatch', "`kernel'", dups_l, dupsid_l, covs_drop_coll)
+			C_h_r  = rdrobust_bw(Y_r, X_r, T_r, Z_r, C_r, fw_r, c=c, o=`p', nu=`deriv', o_B=`q', h_V=c_bw, h_B=b_bw_d, `scaleregul', "`vce_select'", `nnmatch', "`kernel'", dups_r, dupsid_r, covs_drop_coll)
+			h_bw_d = ( ((C_h_l[1] + C_h_r[1])  /  ((C_h_r[2] - C_h_l[2])^2 + `scaleregul'*(C_h_r[3] + C_h_l[3])))  * (`N'/mN)   )^C_h_l[4]
+			if  ("`bwrestrict'"=="on") h_bw_d = min((h_bw_d, bw_max))
+			
+		}	
+		
+
+
+		if (C_b_l[1]==0 | C_b_l[2]==0 | C_b_r[1]==0 | C_b_r[2]==0 |C_b_l[1]==. | C_b_l[2]==. | C_b_l[3]==. | C_b_r[1]==. | C_b_r[2]==. | C_b_r[3]==.) printf("{err}Not enough variability to compute the bias bandwidth (b). Try checking for mass points with option {cmd:masspoints(check)}. \n")  
+		if (C_h_l[1]==0 | C_h_l[2]==0 | C_h_r[1]==0 | C_h_r[2]==0 |C_h_l[1]==. | C_h_l[2]==. | C_h_l[3]==. | C_h_r[1]==. | C_h_r[2]==. | C_h_r[3]==.) printf("{err}Not enough variability to compute the loc. poly. bandwidth (h). Try checking for mass points with option {cmd:masspoints(check)}.\n") 
+	
+		cer_h = mN^(-(`p'/((3+`p')*(3+2*`p'))))
+		if ("`cluster'"!="") cer_h = (g_l+g_r)^(-(`p'/((3+`p')*(3+2*`p'))))
+		cer_b = 1	
+			
+		if  ("`bwselect'"=="mserd" | "`bwselect'"=="cerrd" | "`bwselect'"=="msecomb1" | "`bwselect'"=="msecomb2" | "`bwselect'"=="cercomb1" | "`bwselect'"=="cercomb2") {
+			h_l = h_r = h_mserd = x_sd*h_bw_d
+			b_l = b_r = b_mserd = x_sd*b_bw_d
+		}	
+		if  ("`bwselect'"=="msesum" | "`bwselect'"=="cersum" |  "`bwselect'"=="msecomb1" | "`bwselect'"=="msecomb2" |  "`bwselect'"=="cercomb1" | "`bwselect'"=="cercomb2")  {
+			h_l = h_r = h_msesum = x_sd*h_bw_s
+			b_l = b_r = b_msesum = x_sd*b_bw_s
+		}
+		if  ("`bwselect'"=="msetwo" |  "`bwselect'"=="certwo" | "`bwselect'"=="msecomb2" | "`bwselect'"=="cercomb2")  {		
+			h_l = h_msetwo_l = x_sd*h_bw_l
+			h_r = h_msetwo_r = x_sd*h_bw_r
+			b_l = b_msetwo_l = x_sd*b_bw_l
+			b_r = b_msetwo_r = x_sd*b_bw_r
+		}
+		if  ("`bwselect'"=="msecomb1" | "`bwselect'"=="cercomb1") {
+			h_l = h_r = h_msecomb1 = min((h_mserd,h_msesum))
+			b_l = b_r = b_msecomb1 = min((b_mserd,b_msesum))
+		}
+		if  ("`bwselect'"=="msecomb2" | "`bwselect'"=="cercomb2") {
+			h_l = (sort((h_mserd,h_msesum,h_msetwo_l)',1))[2]
+			h_r = (sort((h_mserd,h_msesum,h_msetwo_r)',1))[2]
+			b_l = (sort((b_mserd,b_msesum,b_msetwo_l)',1))[2]
+			b_r = (sort((b_mserd,b_msesum,b_msetwo_r)',1))[2]
+		}		
+		if  ("`bwselect'"=="cerrd" | "`bwselect'"=="cersum" | "`bwselect'"=="certwo" | "`bwselect'"=="cercomb1" | "`bwselect'"=="cercomb2"){
+			h_l = h_l*cer_h
+			h_r = h_r*cer_h
+			b_l = b_l*cer_b
+			b_r = b_r*cer_b
+		}
+		
+		if ("`rho'">"0")  {
+			b_l = h_l/`rho'
+			b_r = h_r/`rho'
+		}
+					
+		*** De-Starndardized *********************************
+		c = `c'*x_sd
+		X_uniq_l = X_uniq_l*x_sd
+		X_uniq_r = X_uniq_r*x_sd
+		X_l = X_l*x_sd;	X_r = X_r*x_sd
+		Y_l = Y_l*y_sd;	Y_r = Y_r*y_sd
+		range_l = range_l*x_sd
+		range_r = range_r*x_sd  
+		*****************************************************
+
+		
+		} /* close if for bw selector */
+	
+	}
+	
+
+	mata{
+	
+		*** Estimation and Inference
+		
+		c = strtoreal("`c'")
+	
+		w_h_l = rdrobust_kweight(X_l,`c',h_l,"`kernel'");	w_h_r = rdrobust_kweight(X_r,`c',h_r,"`kernel'")
+		w_b_l = rdrobust_kweight(X_l,`c',b_l,"`kernel'");	w_b_r = rdrobust_kweight(X_r,`c',b_r,"`kernel'")
+		
+		if ("`weights'"~="") {
+			w_h_l = fw_l:*w_h_l;	w_h_r = fw_r:*w_h_r
+			w_b_l = fw_l:*w_b_l;	w_b_r = fw_r:*w_b_r			
+		}
+		
+		ind_h_l = selectindex(w_h_l:> 0);		ind_h_r = selectindex(w_h_r:> 0)
+		ind_b_l = selectindex(w_b_l:> 0);		ind_b_r = selectindex(w_b_r:> 0)
+		N_h_l = length(ind_h_l);	N_b_l = length(ind_b_l)
+		N_h_r = length(ind_h_r);	N_b_r = length(ind_b_r)
+		
+		if (N_h_l<10 | N_h_r<10 | N_b_l<10 | N_b_r<10){
+		 display("{err}Estimates might be unreliable due to low number of effective observations.")
+		 *exit(1)
+		}
+		
+		ind_l = ind_b_l; ind_r = ind_b_r
+		if (h_l>b_l) ind_l = ind_h_l   
+		if (h_r>b_r) ind_r = ind_h_r   
+		eN_l = length(ind_l); eN_r = length(ind_r)
+		eY_l  = Y_l[ind_l];	eY_r  = Y_r[ind_r]
+		eX_l  = X_l[ind_l];	eX_r  = X_r[ind_r]
+		W_h_l = w_h_l[ind_l];	W_h_r = w_h_r[ind_r]
+		W_b_l = w_b_l[ind_l];	W_b_r = w_b_r[ind_r]
+		
+		edups_l = edups_r = edupsid_l= edupsid_r = 0	
+		if ("`vce_select'"=="nn") {
+			edups_l   = dups_l[ind_l];	  	    edups_r   = dups_r[ind_r]
+			edupsid_l = dupsid_l[ind_l];	    edupsid_r = dupsid_r[ind_r]
+		}
+		
+		u_l = (eX_l:-`c')/h_l;	u_r = (eX_r:-`c')/h_r;
+		R_q_l = J(eN_l,(`q'+1),.); R_q_r = J(eN_r,(`q'+1),.)
+		for (j=1; j<=(`q'+1); j++)  {
+			R_q_l[.,j] = (eX_l:-`c'):^(j-1);  R_q_r[.,j] = (eX_r:-`c'):^(j-1)
+		}
+		R_p_l = R_q_l[,1::(`p'+1)]; R_p_r = R_q_r[,1::(`p'+1)]	
+	
+		********************************************************************************
+		************ Computing RD estimates ********************************************
+		********************************************************************************
+		L_l = quadcross(R_p_l:*W_h_l,u_l:^(`p'+1)); L_r = quadcross(R_p_r:*W_h_r,u_r:^(`p'+1)) 
+			invG_q_l  = cholinv(quadcross(R_q_l,W_b_l,R_q_l));	invG_q_r  = cholinv(quadcross(R_q_r,W_b_r,R_q_r))
+			invG_p_l  = cholinv(quadcross(R_p_l,W_h_l,R_p_l));	invG_p_r  = cholinv(quadcross(R_p_r,W_h_r,R_p_r)) 
+		
+		if (rank(invG_p_l)==. | rank(invG_p_r)==. | rank(invG_q_l)==. | rank(invG_q_r)==. ){
+		display("{err}Invertibility problem: check variability of running variable around cutoff. Try checking for mass points with option {cmd:masspoints(check)}.")
+			exit(1)
+		}
+		
+		e_p1 = J((`q'+1),1,0); e_p1[`p'+2]=1
+		e_v  = J((`p'+1),1,0); e_v[`deriv'+1]=1
+		Q_q_l = ((R_p_l:*W_h_l)' - h_l^(`p'+1)*(L_l*e_p1')*((invG_q_l*R_q_l')':*W_b_l)')'
+		Q_q_r = ((R_p_r:*W_h_r)' - h_r^(`p'+1)*(L_r*e_p1')*((invG_q_r*R_q_r')':*W_b_r)')'
+		D_l = eY_l; D_r = eY_r		
+		
+		if ("`fuzzy'"~="") {
+			T    = st_data(.,("`fuzzyvar'"), 0);	dT = 1
+			T_l  = select(T,X:<`c');  eT_l  = T_l[ind_l]
+			T_r  = select(T,X:>=`c'); eT_r  = T_r[ind_r]
+			D_l  = D_l,eT_l; D_r = D_r,eT_r
+		}
+		
+		if ("`covs'"~="") {
+			eZ_l = Z_l[ind_l,]; eZ_r = Z_r[ind_r,]
+			D_l  = D_l,eZ_l; D_r = D_r,eZ_r
+			U_p_l = quadcross(R_p_l:*W_h_l,D_l); U_p_r = quadcross(R_p_r:*W_h_r,D_r)
+		}
+		
+		if ("`cluster'"~="") {
+			eC_l  = C_l[ind_l];	     eC_r  = C_r[ind_r]
+			indC_l = order(eC_l,1);  indC_r = order(eC_r,1) 
+			g_l = rows(panelsetup(eC_l[indC_l],1));	g_r = rows(panelsetup(eC_r[indC_r],1))
+		}
+		
+		beta_p_l = invG_p_l*quadcross(R_p_l:*W_h_l,D_l); beta_q_l = invG_q_l*quadcross(R_q_l:*W_b_l,D_l); beta_bc_l = invG_p_l*quadcross(Q_q_l,D_l) 
+		beta_p_r = invG_p_r*quadcross(R_p_r:*W_h_r,D_r); beta_q_r = invG_q_r*quadcross(R_q_r:*W_b_r,D_r); beta_bc_r = invG_p_r*quadcross(Q_q_r,D_r)
+		beta_p  = beta_p_r  - beta_p_l
+		beta_q  = beta_q_r  - beta_q_l
+		beta_bc = beta_bc_r - beta_bc_l
+		
+		if (dZ==0) {		
+				tau_cl = tau_Y_cl = `scalepar'*factorial(`deriv')*beta_p[(`deriv'+1),1]
+				tau_bc = tau_Y_bc = `scalepar'*factorial(`deriv')*beta_bc[(`deriv'+1),1]
+				s_Y = 1				
+				tau_Y_cl_l = `scalepar'*factorial(`deriv')*beta_p_l[(`deriv'+1),1]
+				tau_Y_cl_r = `scalepar'*factorial(`deriv')*beta_p_r[(`deriv'+1),1]
+				tau_Y_bc_l = `scalepar'*factorial(`deriv')*beta_bc_l[(`deriv'+1),1]
+				tau_Y_bc_r = `scalepar'*factorial(`deriv')*beta_bc_r[(`deriv'+1),1]				
+				bias_l = tau_Y_cl_l-tau_Y_bc_l
+				bias_r = tau_Y_cl_r-tau_Y_bc_r 		
+				if (dT>0) {
+					tau_T_cl =  factorial(`deriv')*beta_p[(`deriv'+1),2]
+					tau_T_bc = 	factorial(`deriv')*beta_bc[(`deriv'+1),2]
+					s_Y = (1/tau_T_cl \ -(tau_Y_cl/tau_T_cl^2))
+					B_F = tau_Y_cl-tau_Y_bc \ tau_T_cl-tau_T_bc
+					tau_cl = tau_Y_cl/tau_T_cl
+					tau_bc = tau_cl - s_Y'*B_F
+					sV_T = 0 \ 1										
+					tau_T_cl_l =  factorial(`deriv')*beta_p_l[(`deriv'+1),2]
+					tau_T_cl_r =  factorial(`deriv')*beta_p_r[(`deriv'+1),2]
+					tau_T_bc_l =  factorial(`deriv')*beta_bc_l[(`deriv'+1),2]
+					tau_T_bc_r =  factorial(`deriv')*beta_bc_r[(`deriv'+1),2]					
+					B_F_l = tau_Y_cl_l-tau_Y_bc_l \ tau_T_cl_l-tau_T_bc_l
+					B_F_r = tau_Y_cl_r-tau_Y_bc_r \ tau_T_cl_r-tau_T_bc_r					
+					bias_l = s_Y'*B_F_l
+					bias_r = s_Y'*B_F_r					
+				}	
+		}
+		
+		if (dZ>0) {	
+			ZWD_p_l  = quadcross(eZ_l,W_h_l,D_l)
+			ZWD_p_r  = quadcross(eZ_r,W_h_r,D_r)
+			colsZ = (2+dT)::(2+dT+dZ-1)
+			UiGU_p_l =  quadcross(U_p_l[,colsZ],invG_p_l*U_p_l) 
+			UiGU_p_r =  quadcross(U_p_r[,colsZ],invG_p_r*U_p_r) 
+			ZWZ_p_l = ZWD_p_l[,colsZ] - UiGU_p_l[,colsZ] 
+			ZWZ_p_r = ZWD_p_r[,colsZ] - UiGU_p_r[,colsZ]     
+			ZWY_p_l = ZWD_p_l[,1::1+dT] - UiGU_p_l[,1::1+dT] 
+			ZWY_p_r = ZWD_p_r[,1::1+dT] - UiGU_p_r[,1::1+dT]     
+			ZWZ_p = ZWZ_p_r + ZWZ_p_l
+			ZWY_p = ZWY_p_r + ZWY_p_l
+			if ("`covs_drop_coll'"=="0") gamma_p = cholinv(ZWZ_p)*ZWY_p
+			if ("`covs_drop_coll'"=="1") gamma_p =  invsym(ZWZ_p)*ZWY_p
+			if ("`covs_drop_coll'"=="2") gamma_p =    pinv(ZWZ_p)*ZWY_p
+	
+			s_Y = (1 \  -gamma_p[,1])
+			
+			if (dT==0) {
+				tau_cl = `scalepar'*s_Y'*beta_p[(`deriv'+1),]'
+				tau_bc = `scalepar'*s_Y'*beta_bc[(`deriv'+1),]'				
+				tau_Y_cl_l = `scalepar'*s_Y'*beta_p_l[(`deriv'+1),]'
+				tau_Y_cl_r = `scalepar'*s_Y'*beta_p_r[(`deriv'+1),]'
+				tau_Y_bc_l = `scalepar'*s_Y'*beta_bc_l[(`deriv'+1),]'
+				tau_Y_bc_r = `scalepar'*s_Y'*beta_bc_r[(`deriv'+1),]'				
+				bias_l = tau_Y_cl_l-tau_Y_bc_l
+				bias_r = tau_Y_cl_r-tau_Y_bc_r 				
+
+			}
+			
+			if (dT>0) {
+					s_T  = 1 \ -gamma_p[,2]
+					sV_T = (0 \ 1 \ -gamma_p[,2] )
+					tau_Y_cl = `scalepar'*factorial(`deriv')*s_Y'*vec((beta_p[(`deriv'+1),1],beta_p[(`deriv'+1),colsZ]))
+					tau_T_cl = factorial(`deriv')*s_T'*vec((beta_p[(`deriv'+1),2],beta_p[(`deriv'+1),colsZ]))
+					tau_Y_bc = `scalepar'*factorial(`deriv')*s_Y'*vec((beta_bc[(`deriv'+1),1],beta_bc[(`deriv'+1),colsZ]))
+					tau_T_bc = factorial(`deriv')*s_T'*vec((beta_bc[(`deriv'+1),2],beta_bc[(`deriv'+1),colsZ]))
+			
+					tau_Y_cl_l = `scalepar'*factorial(`deriv')*s_Y'*vec((beta_p_l[(`deriv'+1),1], beta_p_l[(`deriv'+1),colsZ]))
+					tau_Y_cl_r = `scalepar'*factorial(`deriv')*s_Y'*vec((beta_p_r[(`deriv'+1),2], beta_p_r[(`deriv'+1),colsZ]))
+					tau_Y_bc_l = `scalepar'*factorial(`deriv')*s_Y'*vec((beta_bc_l[(`deriv'+1),1],beta_bc_l[(`deriv'+1),colsZ]))
+					tau_Y_bc_r = `scalepar'*factorial(`deriv')*s_Y'*vec((beta_bc_r[(`deriv'+1),2],beta_bc_r[(`deriv'+1),colsZ]))
+					
+					tau_T_cl_l = factorial(`deriv')*s_T'*vec((beta_p_l[(`deriv'+1),1], beta_p_l[(`deriv'+1),colsZ]))
+					tau_T_cl_r = factorial(`deriv')*s_T'*vec((beta_p_r[(`deriv'+1),2], beta_p_r[(`deriv'+1),colsZ]))
+					tau_T_bc_l = factorial(`deriv')*s_T'*vec((beta_bc_l[(`deriv'+1),1],beta_bc_l[(`deriv'+1),colsZ]))
+					tau_T_bc_r = factorial(`deriv')*s_T'*vec((beta_bc_r[(`deriv'+1),2],beta_bc_r[(`deriv'+1),colsZ]))
+					
+					
+					B_F = tau_Y_cl-tau_Y_bc \ tau_T_cl-tau_T_bc
+					s_Y = 1/tau_T_cl \ -(tau_Y_cl/tau_T_cl^2)
+					tau_cl = tau_Y_cl/tau_T_cl
+					tau_bc = tau_cl - s_Y'*B_F
+					
+					B_F_l = tau_Y_cl_l-tau_Y_bc_l \ tau_T_cl_l-tau_T_bc_l
+					B_F_r = tau_Y_cl_r-tau_Y_bc_r \ tau_T_cl_r-tau_T_bc_r
+					
+					bias_l = s_Y'*B_F_l
+					bias_r = s_Y'*B_F_r
+					
+					s_Y = (1/tau_T_cl \ -(tau_Y_cl/tau_T_cl^2) \ -(1/tau_T_cl)*gamma_p[,1] + (tau_Y_cl/tau_T_cl^2)*gamma_p[,2])
+			}
+		}
+			
+		**************************************************************************
+		************ Computing variance-covariance matrix ************************
+		**************************************************************************
+		hii_l=hii_r=predicts_p_l=predicts_p_r=predicts_q_l=predicts_q_r=0
+		if ("`vce_select'"=="hc0" | "`vce_select'"=="hc1" | "`vce_select'"=="hc2" | "`vce_select'"=="hc3") {
+			predicts_p_l=R_p_l*beta_p_l
+			predicts_p_r=R_p_r*beta_p_r
+			predicts_q_l=R_q_l*beta_q_l
+			predicts_q_r=R_q_r*beta_q_r
+			if ("`vce_select'"=="hc2" | "`vce_select'"=="hc3") {
+				hii_l=J(eN_l,1,.)	
+					for (i=1; i<=eN_l; i++) {
+						hii_l[i] = R_p_l[i,]*invG_p_l*(R_p_l:*W_h_l)[i,]'
+				}
+				hii_r=J(eN_r,1,.)	
+					for (i=1; i<=eN_r; i++) {
+						hii_r[i] = R_p_r[i,]*invG_p_r*(R_p_r:*W_h_r)[i,]'
+				}
+			}
+		}
+			
+		res_h_l = rdrobust_res(eX_l, eY_l, eT_l, eZ_l, predicts_p_l, hii_l, "`vce_select'", `nnmatch', edups_l, edupsid_l, `p'+1)
+		res_h_r = rdrobust_res(eX_r, eY_r, eT_r, eZ_r, predicts_p_r, hii_r, "`vce_select'", `nnmatch', edups_r, edupsid_r, `p'+1)
+		if ("`vce_select'"=="nn") {
+				res_b_l = res_h_l;	res_b_r = res_h_r
+		}
+		else {
+				res_b_l = rdrobust_res(eX_l, eY_l, eT_l, eZ_l, predicts_q_l, hii_l, "`vce_select'", `nnmatch', edups_l, edupsid_l, `q'+1)
+				res_b_r = rdrobust_res(eX_r, eY_r, eT_r, eZ_r, predicts_q_r, hii_r, "`vce_select'", `nnmatch', edups_r, edupsid_r, `q'+1)
+		}
+
+		V_Y_cl_l = invG_p_l*rdrobust_vce(dT+dZ, s_Y, R_p_l:*W_h_l, res_h_l, eC_l, indC_l)*invG_p_l
+		V_Y_cl_r = invG_p_r*rdrobust_vce(dT+dZ, s_Y, R_p_r:*W_h_r, res_h_r, eC_r, indC_r)*invG_p_r
+		V_Y_bc_l = invG_p_l*rdrobust_vce(dT+dZ, s_Y, Q_q_l, res_b_l, eC_l, indC_l)*invG_p_l
+		V_Y_bc_r = invG_p_r*rdrobust_vce(dT+dZ, s_Y, Q_q_r, res_b_r, eC_r, indC_r)*invG_p_r
+		V_tau_cl = (`scalepar')^2*factorial(`deriv')^2*(V_Y_cl_l+V_Y_cl_r)[`deriv'+1,`deriv'+1]
+		V_tau_rb = (`scalepar')^2*factorial(`deriv')^2*(V_Y_bc_l+V_Y_bc_r)[`deriv'+1,`deriv'+1]
+		se_tau_cl = sqrt(V_tau_cl);	se_tau_rb = sqrt(V_tau_rb)
+
+		if ("`fuzzy'"!="") {
+			V_T_cl_l = invG_p_l*rdrobust_vce(dT+dZ, sV_T, R_p_l:*W_h_l, res_h_l, eC_l, indC_l)*invG_p_l
+			V_T_cl_r = invG_p_r*rdrobust_vce(dT+dZ, sV_T, R_p_r:*W_h_r, res_h_r, eC_r, indC_r)*invG_p_r
+			V_T_bc_l = invG_p_l*rdrobust_vce(dT+dZ, sV_T, Q_q_l, res_b_l, eC_l, indC_l)*invG_p_l
+			V_T_bc_r = invG_p_r*rdrobust_vce(dT+dZ, sV_T, Q_q_r, res_b_r, eC_r, indC_r)*invG_p_r
+			V_T_cl = factorial(`deriv')^2*(V_T_cl_l+V_T_cl_r)[`deriv'+1,`deriv'+1]
+			V_T_rb = factorial(`deriv')^2*(V_T_bc_l+V_T_bc_r)[`deriv'+1,`deriv'+1]
+			se_tau_T_cl = sqrt(V_T_cl);	se_tau_T_rb = sqrt(V_T_rb)
+		}
+		
+		
+		**** Stored results
+		st_numscalar("N", N)
+		st_numscalar("N_l", N_l)
+		st_numscalar("N_r", N_r)
+		st_numscalar("x_l_min", x_l_min)
+		st_numscalar("x_l_max", x_l_max)
+		st_numscalar("x_r_min", x_r_min)
+		st_numscalar("x_r_max", x_r_max)
+	
+		st_numscalar("h_l", h_l)
+		st_numscalar("h_r", h_r)
+		st_numscalar("b_l", b_l)
+		st_numscalar("b_r", b_r)
+	
+		st_numscalar("quant", -invnormal(abs((1-(`level'/100))/2)))
+		st_numscalar("N_h_l", N_h_l);	st_numscalar("N_b_l", N_b_l)
+		st_numscalar("N_h_r", N_h_r);	st_numscalar("N_b_r", N_b_r)
+		st_numscalar("tau_cl", tau_cl); st_numscalar("se_tau_cl", se_tau_cl)
+		st_numscalar("tau_bc", tau_bc);	st_numscalar("se_tau_rb", se_tau_rb)
+		st_numscalar("tau_Y_cl_r", tau_Y_cl_r); st_numscalar("tau_Y_cl_l", tau_Y_cl_l)
+		st_numscalar("tau_Y_bc_r", tau_Y_bc_r);	st_numscalar("tau_Y_bc_l", tau_Y_bc_l)
+		st_numscalar("bias_l", bias_l);  st_numscalar("bias_r", bias_r)
+		st_matrix("beta_p_r", beta_p_r); st_matrix("beta_p_l", beta_p_l)
+		st_matrix("beta_q_r", beta_q_r); st_matrix("beta_q_l", beta_q_l)
+		st_numscalar("g_l",  g_l);       st_numscalar("g_r",   g_r)
+		st_matrix("b", (tau_cl))
+		st_matrix("V", (V_tau_cl))
+		st_matrix("V_Y_cl_r", V_Y_cl_r); st_matrix("V_Y_cl_l", V_Y_cl_l)
+		st_matrix("V_Y_bc_r", V_Y_bc_r); st_matrix("V_Y_bc_l", V_Y_bc_l)
+		st_numscalar("masspoints_found", masspoints_found)
+		
+		if ("`all'"~="") {
+			st_matrix("b", (tau_cl,tau_bc,tau_bc))
+			st_matrix("V", (V_tau_cl,0,0 \ 0,V_tau_cl,0 \0,0,V_tau_rb))
+		}		
+		
+		if ("`fuzzy'"!="") {
+			st_numscalar("tau_T_cl", tau_T_cl); st_numscalar("se_tau_T_cl", se_tau_T_cl)
+			st_numscalar("tau_T_bc", tau_T_bc);	st_numscalar("se_tau_T_rb", se_tau_T_rb)	
+			
+			st_numscalar("tau_T_cl_r", tau_T_cl_r); st_numscalar("tau_T_cl_l", tau_T_cl_l)
+			st_numscalar("tau_T_bc_r", tau_T_bc_r);	st_numscalar("tau_T_bc_l", tau_T_bc_l)
+		}
+	}
+	
+	************************************************
+	********* OUTPUT TABLE *************************
+	************************************************
+	local rho_l = scalar(h_l)/scalar(b_l)
+	local rho_r = scalar(h_r)/scalar(b_r)
+	
+	disp ""
+	if "`fuzzy'"=="" {
+		if ("`covs'"=="") {
+			if      ("`deriv'"=="0") disp "Sharp RD estimates using local polynomial regression." 
+			else if ("`deriv'"=="1") disp "Sharp kink RD estimates using local polynomial regression."	
+			else                     disp "Sharp RD estimates using local polynomial regression. Derivative of order " `deriv' "."	
+		}
+		else {
+			if      ("`deriv'"=="0") disp "Covariate-adjusted sharp RD estimates using local polynomial regression." 
+			else if ("`deriv'"=="1") disp "Covariate-adjusted sharp kink RD estimates using local polynomial regression."	
+			else                     disp "Covariate-adjusted sharp RD estimates using local polynomial regression. Derivative of order " `deriv' "."	
+		}
+	}
+	else {
+		if ("`covs'"=="") {
+			if      ("`deriv'"=="0") disp "Fuzzy RD estimates using local polynomial regression." 
+			else if ("`deriv'"=="1") disp "Fuzzy kink RD estimates using local polynomial regression."	
+			else                     disp "Fuzzy RD estimates using local polynomial regression. Derivative of order " `deriv' "."	
+		}
+		else {
+			if      ("`deriv'"=="0") disp "Covariate-adjusted sharp RD estimates using local polynomial regression." 
+			else if ("`deriv'"=="1") disp "Covariate-adjusted sharp kink RD estimates using local polynomial regression."	
+			else                     disp "Covariate-adjusted sharp RD estimates using local polynomial regression. Derivative of order " `deriv' "."			
+		}
+	}
+
+	disp ""
+	disp in smcl in gr "{ralign 18: Cutoff c = `c'}"        _col(19) " {c |} " _col(21) in gr "Left of " in yellow "c"  _col(33) in gr "Right of " in yellow "c"         _col(55) in gr "Number of obs = "  in yellow %10.0f scalar(N)
+	disp in smcl in gr "{hline 19}{c +}{hline 22}"                                                                                                                       _col(55) in gr "BW type       = "  in yellow "{ralign 10:`bwselect'}" 
+	disp in smcl in gr "{ralign 18:Number of obs}"          _col(19) " {c |} " _col(21) as result %9.0f scalar(N_l)             _col(34) %9.0f  scalar(N_r)                              _col(55) in gr "Kernel        = "  in yellow "{ralign 10:`kernel_type'}" 
+	disp in smcl in gr "{ralign 18:Eff. Number of obs}"     _col(19) " {c |} " _col(21) as result %9.0f scalar(N_h_l)           _col(34) %9.0f  scalar(N_h_r)                            _col(55) in gr "VCE method    = "  in yellow "{ralign 10:`vce_type'}" 
+	disp in smcl in gr "{ralign 18:Order est. (p)}"         _col(19) " {c |} " _col(21) as result %9.0f `p'             _col(34) %9.0f  `p'         
+	disp in smcl in gr "{ralign 18:Order bias (q)}"         _col(19) " {c |} " _col(21) as result %9.0f `q'             _col(34) %9.0f  `q'                              
+	disp in smcl in gr "{ralign 18:BW est. (h)}"            _col(19) " {c |} " _col(21) as result %9.3f scalar(h_l)           _col(34) %9.3f  scalar(h_r)                                   
+	disp in smcl in gr "{ralign 18:BW bias (b)}"            _col(19) " {c |} " _col(21) as result %9.3f scalar(b_l)           _col(34) %9.3f  scalar(b_r)
+	disp in smcl in gr "{ralign 18:rho (h/b)}"              _col(19) " {c |} " _col(21) as result %9.3f `rho_l'         _col(34) %9.3f  `rho_r'
+	if ("`masspoints'"=="check" | masspoints_found==1) disp in smcl in gr "{ralign 18:Unique obs}"         _col(19) " {c |} " _col(21) as result %9.0f scalar(M_l)           _col(34) %9.0f  scalar(M_r)                    
+	if ("`cluster'"!="")                               disp in smcl in gr "{ralign 18:Number of clusters}" _col(19) " {c |} " _col(21) as result %9.0f scalar(g_l)           _col(34) %9.0f  scalar(g_r)                         
+	disp ""
+			
+	if ("`fuzzy'"~="") {
+		disp in yellow "First-stage estimates. Outcome: `fuzzyvar'. Running variable: `x'."
+		disp in smcl in gr "{hline 19}{c TT}{hline 60}"
+	    disp in smcl in gr "{ralign 18:Method}"  _col(19) " {c |} " _col(24) "Coef."  _col(33) `"Std. Err."'   _col(46) "z"    _col(52) "P>|z|"   _col(61) `"[`level'% Conf. Interval]"'
+		disp in smcl in gr "{hline 19}{c +}{hline 60}"
+		
+		if ("`all'"=="") {
+			disp in smcl in gr "{ralign 18:Conventional}"      _col(19) " {c |} " _col(22) in ye %7.0g scalar(tau_T_cl) _col(33) %7.0g scalar(se_tau_T_cl) _col(43) %5.4f scalar(tau_T_cl/se_tau_T_cl) _col(52) %5.3f  scalar(2*normal(-abs(tau_T_cl/se_tau_T_cl)))  _col(60) %8.0g  scalar(tau_T_cl) - scalar(quant*se_tau_T_cl) _col(73) %8.0g scalar(tau_T_cl + quant*se_tau_T_cl) 
+			disp in smcl in gr "{ralign 18:Robust}"            _col(19) " {c |} " _col(22) in ye %7.0g "    -"  _col(33) %7.0g "    -"     _col(43) %5.4f scalar(tau_T_bc/se_tau_T_rb) _col(52) %5.3f  scalar(2*normal(-abs(tau_T_bc/se_tau_T_rb)))  _col(60) %8.0g  scalar(tau_T_bc - quant*se_tau_T_rb) _col(73) %8.0g scalar(tau_T_bc + quant*se_tau_T_rb) 
+		}
+		else {
+			disp in smcl in gr "{ralign 18:Conventional}"      _col(19) " {c |} " _col(22) in ye %7.0g scalar(tau_T_cl) _col(33) %7.0g scalar(se_tau_T_cl) _col(43) %5.4f scalar(tau_T_cl/se_tau_T_cl) _col(52) %5.3f  scalar(2*normal(-abs(tau_T_cl/se_tau_T_cl))) _col(60) %8.0g  scalar(tau_T_cl - quant*se_tau_T_cl) _col(73) %8.0g scalar(tau_T_cl + quant*se_tau_T_cl)  
+			disp in smcl in gr "{ralign 18:Bias-corrected}"    _col(19) " {c |} " _col(22) in ye %7.0g scalar(tau_T_bc) _col(33) %7.0g scalar(se_tau_T_cl) _col(43) %5.4f scalar(tau_T_bc/se_tau_T_cl) _col(52) %5.3f  scalar(2*normal(-abs(tau_T_bc/se_tau_T_cl))) _col(60) %8.0g  scalar(tau_T_bc - quant*se_tau_T_cl) _col(73) %8.0g scalar(tau_T_bc + quant*se_tau_T_cl) 
+			disp in smcl in gr "{ralign 18:Robust}"            _col(19) " {c |} " _col(22) in ye %7.0g scalar(tau_T_bc) _col(33) %7.0g scalar(se_tau_T_rb) _col(43) %5.4f scalar(tau_T_bc/se_tau_T_rb) _col(52) %5.3f  scalar(2*normal(-abs(tau_T_bc/se_tau_T_rb))) _col(60) %8.0g  scalar(tau_T_bc - quant*se_tau_T_rb) _col(73) %8.0g scalar(tau_T_bc + quant*se_tau_T_rb) 
+		}
+			disp in smcl in gr "{hline 19}{c BT}{hline 60}"
+			disp ""
+	}
+	
+	if ("`fuzzy'"=="") disp           "Outcome: `y'. Running variable: `x'."
+	else               disp in yellow "Treatment effect estimates. Outcome: `y'. Running variable: `x'. Treatment Status: `fuzzyvar'."
+		
+	disp in smcl in gr "{hline 19}{c TT}{hline 60}"
+	disp in smcl in gr "{ralign 18:Method}"             _col(19) " {c |} " _col(24) "Coef."               _col(33) `"Std. Err."'    _col(46) "z"                    _col(52) "P>|z|"                                  _col(61) `"[`level'% Conf. Interval]"'
+	disp in smcl in gr "{hline 19}{c +}{hline 60}"
+
+	if ("`all'"=="") {
+		disp in smcl in gr "{ralign 18:Conventional}"   _col(19) " {c |} " _col(22) in ye %7.0g scalar(tau_cl)    _col(33) %7.0g scalar(se_tau_cl)  _col(43) %5.4f scalar(tau_cl/se_tau_cl) _col(52) %5.3f  scalar(2*normal(-abs(tau_cl/se_tau_cl)))  _col(60) %8.0g scalar(tau_cl - quant*se_tau_cl) _col(73) %8.0g scalar(tau_cl + quant*se_tau_cl) 
+		disp in smcl in gr "{ralign 18:Robust}"         _col(19) " {c |} " _col(22) in ye %7.0g "    -"   _col(33) %7.0g "    -"    _col(43) %5.4f scalar(tau_bc/se_tau_rb) _col(52) %5.3f  scalar(2*normal(-abs(tau_bc/se_tau_rb)))  _col(60) %8.0g scalar(tau_bc - quant*se_tau_rb) _col(73) %8.0g scalar(tau_bc + quant*se_tau_rb) 
+	}
+	else {
+		disp in smcl in gr "{ralign 18:Conventional}"   _col(19) " {c |} " _col(22) in ye %7.0g scalar(tau_cl)    _col(33) %7.0g scalar(se_tau_cl) _col(43) %5.4f scalar(tau_cl/se_tau_cl) _col(52) %5.3f  scalar(2*normal(-abs(tau_cl/se_tau_cl))) _col(60) %8.0g  scalar(tau_cl - quant*se_tau_cl) _col(73) %8.0g scalar(tau_cl + quant*se_tau_cl)  
+		disp in smcl in gr "{ralign 18:Bias-corrected}" _col(19) " {c |} " _col(22) in ye %7.0g scalar(tau_bc)    _col(33) %7.0g scalar(se_tau_cl) _col(43) %5.4f scalar(tau_bc/se_tau_cl) _col(52) %5.3f  scalar(2*normal(-abs(tau_bc/se_tau_cl))) _col(60) %8.0g  scalar(tau_bc - quant*se_tau_cl) _col(73) %8.0g scalar(tau_bc + quant*se_tau_cl)  
+		disp in smcl in gr "{ralign 18:Robust}"         _col(19) " {c |} " _col(22) in ye %7.0g scalar(tau_bc)    _col(33) %7.0g scalar(se_tau_rb) _col(43) %5.4f scalar(tau_bc/se_tau_rb) _col(52) %5.3f  scalar(2*normal(-abs(tau_bc/se_tau_rb))) _col(60) %8.0g  scalar(tau_bc - quant*se_tau_rb) _col(73) %8.0g scalar(tau_bc + quant*se_tau_rb)  
+	}
+		disp in smcl in gr "{hline 19}{c BT}{hline 60}"
+
+	if ("`covs'"!="")        di "Covariate-adjusted estimates. Additional covariates included: `ncovs'"
+*	if (`covs_drop_coll'>=1) di "Variables dropped due to multicollinearity."
+	if ("`cluster'"!="")     di "Std. Err. adjusted for clusters in " "`clustvar'"
+	if ("`scalepar'"!="1")   di "Scale parameter: " `scalepar' 
+	if ("`scaleregul'"!="1") di "Scale regularization: " `scaleregul'
+	if ("`masspoints'"=="check")  di "Running variable checked for mass points."  
+	if ("`masspoints'"=="adjust" & masspoints_found==1) di "Estimates adjusted for mass points in the running variable."  	
+	
+	if ("`nowarnings'"!="") {
+		if (scalar(h_l)>=`range_l' | scalar(h_r)>=`range_r') disp in red "WARNING: bandwidth {it:h} greater than the range of the data."
+		if (scalar(b_l)>=`range_l' | scalar(b_r)>=`range_r') disp in red "WARNING: bandwidth {it:b} greater than the range of the data."
+		if (scalar(N_h_l)<20 | scalar(N_h_r)<20) 				 disp in red "WARNING: bandwidth {it:h} too low."
+		if (scalar(N_b_l)<20 | scalar(N_b_r)<20) 				 disp in red "WARNING: bandwidth {it:b} too low."
+		if ("`sharpbw'"~="")   					 disp in red "WARNING: bandwidths automatically computed for sharp RD estimation."
+		if ("`perf_comp'"~="")   				 disp in red "WARNING: bandwidths automatically computed for sharp RD estimation because perfect compliance was detected on at least one side of the threshold."
+	}
+	
+	local ci_l_rb = round(scalar(tau_bc - quant*se_tau_rb),0.001)
+	local ci_r_rb = round(scalar(tau_bc + quant*se_tau_rb),0.001)
+
+	matrix rownames V = RD_Estimate
+	matrix colnames V = RD_Estimate
+	matrix colnames b = RD_Estimate
+	
+	local tempo: colfullnames V
+	matrix rownames V = `tempo'
+	
+	if ("`all'"~="") {
+		matrix rownames V = Conventional Bias-corrected Robust
+		matrix colnames V = Conventional Bias-corrected Robust
+		matrix colnames b = Conventional Bias-corrected Robust
+	}
+		
+	restore
+
+	ereturn clear
+	cap ereturn post b V, esample(`touse')
+	ereturn scalar N = `N'
+	ereturn scalar N_l = scalar(N_l)
+	ereturn scalar N_r = scalar(N_r)
+	ereturn scalar N_h_l = scalar(N_h_l)
+	ereturn scalar N_h_r = scalar(N_h_r)
+	ereturn scalar N_b_l = scalar(N_b_l)
+	ereturn scalar N_b_r = scalar(N_b_r)
+	ereturn scalar c = `c'
+	ereturn scalar p = `p'
+	ereturn scalar q = `q'
+	ereturn scalar h_l = scalar(h_l)
+	ereturn scalar h_r = scalar(h_r)
+	ereturn scalar b_l = scalar(b_l)
+	ereturn scalar b_r = scalar(b_r)
+	ereturn scalar level = `level'
+	ereturn scalar tau_cl   = scalar(tau_cl)
+	ereturn scalar tau_bc   = scalar(tau_bc)
+	ereturn scalar tau_cl_l = scalar(tau_Y_cl_l)
+	ereturn scalar tau_cl_r = scalar(tau_Y_cl_r)
+	ereturn scalar tau_bc_l = scalar(tau_Y_bc_l)
+	ereturn scalar tau_bc_r = scalar(tau_Y_bc_r)
+	ereturn scalar bias_l = scalar(bias_l)
+	ereturn scalar bias_r = scalar(bias_r)
+	ereturn scalar se_tau_cl = scalar(se_tau_cl)
+	ereturn scalar se_tau_rb = scalar(se_tau_rb)
+	ereturn scalar ci_l_cl = scalar(tau_cl - quant*se_tau_cl)
+	ereturn scalar ci_r_cl = scalar(tau_cl + quant*se_tau_cl)
+	ereturn scalar pv_cl = scalar(2*normal(-abs(tau_cl/se_tau_cl)))
+	ereturn scalar ci_l_rb = scalar(tau_bc - quant*se_tau_rb)
+	ereturn scalar ci_r_rb = scalar(tau_bc + quant*se_tau_rb)
+	ereturn scalar pv_rb = scalar(2*normal(-abs(tau_bc/se_tau_rb)))
+	
+	if ("`fuzzy'"!="") {
+		ereturn scalar tau_T_cl  = scalar(tau_T_cl)
+		ereturn scalar tau_T_bc  = scalar(tau_T_bc)
+		ereturn scalar se_tau_T_cl   = scalar(se_tau_T_cl)
+		ereturn scalar se_tau_T_rb   = scalar(se_tau_T_rb)
+		
+		ereturn scalar tau_T_cl_l = scalar(tau_T_cl_l)
+		ereturn scalar tau_T_cl_r = scalar(tau_T_cl_r)
+		ereturn scalar tau_T_bc_l = scalar(tau_T_bc_l)
+		ereturn scalar tau_T_bc_r = scalar(tau_T_bc_r)
+	}
+	
+	ereturn matrix beta_p_r = beta_p_r
+	ereturn matrix beta_p_l = beta_p_l
+	
+	ereturn matrix V_cl_l = V_Y_cl_l 
+	ereturn matrix V_cl_r = V_Y_cl_r 
+	ereturn matrix V_rb_l = V_Y_bc_l 
+	ereturn matrix V_rb_r = V_Y_bc_r 
+	
+	ereturn local ci_rb  [`ci_l_rb' ; `ci_r_rb']
+	ereturn local kernel = "`kernel_type'"
+	ereturn local bwselect = "`bwselect'"
+	ereturn local vce_select = "`vce_type'"
+	if ("`covs'"!="")    ereturn local covs "`covs_list'"
+	if ("`cluster'"!="") ereturn local clustvar "`clustvar'"
+	ereturn local outcomevar "`y'"
+	ereturn local runningvar "`x'"
+	ereturn local depvar "`y'"
+	ereturn local cmd "rdrobust"
+
+	mata mata clear
+ 
+end

30/replication_package/Adofiles/rd_2021/rdrobust.sthlp

@@ -0,0 +1,309 @@
+{smcl}
+{* *!version 8.1.0  2021-02-22}{...}
+{viewerjumpto "Syntax" "rdrobust##syntax"}{...}
+{viewerjumpto "Description" "rdrobust##description"}{...}
+{viewerjumpto "Options" "rdrobust##options"}{...}
+{viewerjumpto "Examples" "rdrobust##examples"}{...}
+{viewerjumpto "Stored results" "rdrobust##stored_results"}{...}
+{viewerjumpto "References" "rdrobust##references"}{...}
+{viewerjumpto "Authors" "rdrobust##authors"}{...}
+
+
+{title:Title}
+
+{p 4 8}{cmd:rdrobust} {hline 2} Local Polynomial Regression Discontinuity Estimation with Robust Bias-Corrected Confidence Intervals and Inference Procedures.{p_end}
+
+{marker syntax}{...}
+{title:Syntax}
+
+{p 4 8}{cmd:rdrobust} {it:depvar} {it:runvar} {ifin} 
+[{cmd:,} 
+{cmd:c(}{it:#}{cmd:)} 
+{cmd:fuzzy(}{it:fuzzyvar [sharpbw]}{cmd:)}
+{cmd:deriv(}{it:#}{cmd:)}
+{cmd:scalepar(}{it:#}{cmd:)}
+{cmd:p(}{it:#}{cmd:)} 
+{cmd:q(}{it:#}{cmd:)}
+{cmd:h(}{it:# #}{cmd:)} 
+{cmd:b(}{it:# #}{cmd:)}
+{cmd:rho(}{it:#}{cmd:)}
+{cmd:covs(}{it:covars}{cmd:)}
+{cmd:covs_drop(}{it:covsdropoption}{cmd:)}
+{cmd:kernel(}{it:kernelfn}{cmd:)}
+{cmd:weights(}{it:weightsvar}{cmd:)}
+{cmd:bwselect(}{it:bwmethod}{cmd:)}
+{cmd:scaleregul(}{it:#}{cmd:)}
+{cmd:masspoints(}{it:masspointsoption}{cmd:)}
+{cmd:bwcheck(}{it:#}{cmd:)}
+{cmd:bwrestrict(}{it:bwropt}{cmd:)}
+{cmd:stdvars(}{it:stdopt}{cmd:)}
+{cmd:vce(}{it:vcetype [vceopt1 vceopt2]}{cmd:)}
+{cmd:level(}{it:#}{cmd:)}
+{cmd:all} 
+]{p_end}
+
+{synoptset 28 tabbed}{...}
+
+{marker description}{...}
+{title:Description}
+
+{p 4 8}{cmd:rdrobust} implements local polynomial Regression Discontinuity (RD) point estimators with robust bias-corrected confidence intervals and inference procedures developed in
+{browse "https://rdpackages.github.io/references/Calonico-Cattaneo-Titiunik_2014_ECMA.pdf":Calonico, Cattaneo and Titiunik (2014a)},
+{browse "https://rdpackages.github.io/references/Calonico-Cattaneo-Farrell_2018_JASA.pdf":Calonico, Cattaneo and Farrell (2018)},
+{browse "https://rdpackages.github.io/references/Calonico-Cattaneo-Farrell-Titiunik_2019_RESTAT.pdf":Calonico, Cattaneo, Farrell and Titiunik (2019)}, 
+and {browse "https://rdpackages.github.io/references/Calonico-Cattaneo-Farrell_2020_ECTJ.pdf":Calonico, Cattaneo and Farrell (2020)}.
+It also computes alternative estimation and inference procedures available in the literature.{p_end}
+
+{p 8 8} Companion commands are: {help rdbwselect:rdbwselect} for data-driven bandwidth selection, and {help rdplot:rdplot} for data-driven RD plots (see
+{browse "https://rdpackages.github.io/references/Calonico-Cattaneo-Titiunik_2015_JASA.pdf":Calonico, Cattaneo and Titiunik (2015a)} for details).{p_end}
+
+{p 8 8}A detailed introduction to this command is given in
+{browse "https://rdpackages.github.io/references/Calonico-Cattaneo-Titiunik_2014_Stata.pdf":Calonico, Cattaneo and Titiunik (2014b)},
+and {browse "https://rdpackages.github.io/references/Calonico-Cattaneo-Farrell-Titiunik_2017_Stata.pdf":Calonico, Cattaneo, Farrell and Titiunik (2017)}. A companion {browse "www.r-project.org":R} package is also described in
+{browse "https://rdpackages.github.io/references/Calonico-Cattaneo-Titiunik_2015_R.pdf":Calonico, Cattaneo and Titiunik (2015b)}.{p_end}
+
+{p 4 8}Related Stata and R packages useful for inference in RD designs are described in the following website:{p_end}
+
+{p 8 8}{browse "https://rdpackages.github.io/":https://rdpackages.github.io/}{p_end}
+
+
+{marker options}{...}
+{title:Options}
+
+{dlgtab:Estimand}
+
+{p 4 8}{cmd:c(}{it:#}{cmd:)} specifies the RD cutoff for {it:indepvar}.
+Default is {cmd:c(0)}.{p_end}
+
+{p 4 8}{cmd:fuzzy(}{it:fuzzyvar [sharpbw]}{cmd:)} specifies the treatment status variable used to implement fuzzy RD estimation (or Fuzzy Kink RD if {cmd:deriv(1)} is also specified).
+Default is Sharp RD design and hence this option is not used.
+If the option {it:sharpbw} is set, the fuzzy RD estimation is performed using a bandwidth selection procedure for the sharp RD model. This option is automatically selected if there is perfect compliance at either side of the threshold.
+{p_end}
+
+{p 4 8}{cmd:deriv(}{it:#}{cmd:)} specifies the order of the derivative of the regression functions to be estimated.
+Default is {cmd:deriv(0)} (for Sharp RD, or for Fuzzy RD if {cmd:fuzzy(.)} is also specified). Setting {cmd:deriv(1)} results in estimation of a Kink RD design (up to scale), or Fuzzy Kink RD if {cmd:fuzzy(.)} is also specified.{p_end}
+
+{p 4 8}{cmd:scalepar(}{it:#}{cmd:)} specifies scaling factor for RD parameter of interest. This option is useful when the estimator of interest requires a known multiplicative factor rescaling (e.g., Sharp Kink RD).
+Default is {cmd:scalepar(1)} (no rescaling).{p_end}
+
+{dlgtab:Local Polynomial Regression}
+
+{p 4 8}{cmd:p(}{it:#}{cmd:)} specifies the order of the local polynomial used to construct the point estimator.
+Default is {cmd:p(1)} (local linear regression).{p_end}
+
+{p 4 8}{cmd:q(}{it:#}{cmd:)} specifies the order of the local polynomial used to construct the bias correction.
+Default is {cmd:q(2)} (local quadratic regression).{p_end}
+
+{p 4 8}{cmd:h(}{it:# #}{cmd:)} specifies the main bandwidth ({it:h}) used to construct the RD point estimator. If not specified, bandwidth {it:h} is computed by the companion command {help rdbwselect:rdbwselect}.
+If two bandwidths are specified, the first bandwidth is used for the data below the cutoff and the second bandwidth is used for the data above the cutoff.{p_end}
+
+{p 4 8}{cmd:b(}{it:# #}{cmd:)} specifies the bias bandwidth ({it:b}) used to construct the bias-correction estimator. If not specified, bandwidth {it:b} is computed by the companion command {help rdbwselect:rdbwselect}.
+If two bandwidths are specified, the first bandwidth is used for the data below the cutoff and the second bandwidth is used for the data above the cutoff.{p_end}
+
+{p 4 8}{cmd:rho(}{it:#}{cmd:)} specifies the value of {it:rho}, so that the bias bandwidth {it:b} equals {it:b}={it:h}/{it:rho}.
+Default is {cmd:rho(1)} if {it:h} is specified but {it:b} is not.{p_end}
+
+{p 4 8}{cmd:covs(}{it:covars}{cmd:)} specifies additional covariates to be used for estimation and inference.{p_end}
+
+{p 4 8}{cmd:covs_drop(}{it:covsdropoption}{cmd:)} assess collinearity in additional covariates used for estimation and inference. Options {opt pinv} (default choice) and {opt invsym} drops collinear additional covariates, differing only in the type of inverse function used. Option {opt off} only checks collinear additional covariates but does not drop them.{p_end}
+
+{p 4 8}{cmd:kernel(}{it:kernelfn}{cmd:)} specifies the kernel function used to construct the local-polynomial estimator(s). Options are: {opt tri:angular}, {opt epa:nechnikov}, and {opt uni:form}.
+Default is {cmd:kernel(triangular)}.{p_end}
+
+{p 4 8}{cmd:weights(}{it:weightsvar}{cmd:)} is the variable used for optional weighting of the estimation procedure. The unit-specific weights multiply the kernel function.{p_end}
+
+{dlgtab:Bandwidth Selection}
+
+{p 4 8}{cmd:bwselect(}{it:bwmethod}{cmd:)} specifies the bandwidth selection procedure to be used. By default it computes both {it:h} and {it:b}, unless {it:rho} is specified, in which case it only computes {it:h} and sets {it:b}={it:h}/{it:rho}.
+Options are:{p_end}
+{p 8 12}{opt mserd} one common MSE-optimal bandwidth selector for the RD treatment effect estimator.{p_end}
+{p 8 12}{opt msetwo} two different MSE-optimal bandwidth selectors (below and above the cutoff) for the RD treatment effect estimator.{p_end}
+{p 8 12}{opt msesum} one common MSE-optimal bandwidth selector for the sum of regression estimates (as opposed to difference thereof).{p_end}
+{p 8 12}{opt msecomb1} for min({opt mserd},{opt msesum}).{p_end}
+{p 8 12}{opt msecomb2} for median({opt msetwo},{opt mserd},{opt msesum}), for each side of the cutoff separately.{p_end}
+{p 8 12}{opt cerrd} one common CER-optimal bandwidth selector for the RD treatment effect estimator.{p_end}
+{p 8 12}{opt certwo} two different CER-optimal bandwidth selectors (below and above the cutoff) for the RD treatment effect estimator.{p_end}
+{p 8 12}{opt cersum} one common CER-optimal bandwidth selector for the sum of regression estimates (as opposed to difference thereof).{p_end}
+{p 8 12}{opt cercomb1} for min({opt cerrd},{opt cersum}).{p_end}
+{p 8 12}{opt cercomb2} for median({opt certwo},{opt cerrd},{opt cersum}), for each side of the cutoff separately.{p_end}
+{p 8 12}Note: MSE = Mean Square Error; CER = Coverage Error Rate.{p_end}
+{p 8 12}Default is {cmd:bwselect(mserd)}. For details on implementation see
+{browse "https://rdpackages.github.io/references/Calonico-Cattaneo-Titiunik_2014_ECMA.pdf":Calonico, Cattaneo and Titiunik (2014a)},
+{browse "https://rdpackages.github.io/references/Calonico-Cattaneo-Farrell_2018_JASA.pdf":Calonico, Cattaneo and Farrell (2017)},
+{browse "https://rdpackages.github.io/references/Calonico-Cattaneo-Farrell_2020_ECTJ.pdf":Calonico, Cattaneo and Farrell (2020)},
+and {browse "https://rdpackages.github.io/references/Calonico-Cattaneo-Farrell-Titiunik_2019_RESTAT.pdf":Calonico, Cattaneo, Farrell and Titiunik (2019)},
+and the companion software articles.{p_end}
+
+{p 4 8}{cmd:scaleregul(}{it:#}{cmd:)} specifies scaling factor for the regularization term added to the denominator of the bandwidth selectors. Setting {cmd:scaleregul(0)} removes the regularization term from the bandwidth selectors.
+Default is {cmd:scaleregul(1)}.{p_end}
+
+{p 4 8}{cmd:masspoints(}{it:masspointsoption}{cmd:)} checks and controls for repeated observations in the running variable. 
+Options are:{p_end}
+{p 8 12}{opt off}  ignores the presence of mass points. {p_end}
+{p 8 12}{opt check}  looks for and reports the number of unique observations at each side of the cutoff.   {p_end}
+{p 8 12}{opt adjust}  controls that the preliminary bandwidths used in the calculations contain a minimal number of unique observations. By default it uses 10 observations, but it can be manually adjusted with the option {cmd:bwcheck}.{p_end}
+{p 8 12} Default option is {cmd:masspoints(adjust)}.{p_end}
+		
+{p 4 8}{cmd:bwcheck(}{it:bwcheck}{cmd:)} if a positive integer is provided, the preliminary bandwidth used in the calculations is enlarged so that at least {it:bwcheck} unique observations are used. {p_end}
+  
+{p 4 8}{cmd:bwrestrict(}{it:bwropt}{cmd:)} if set {opt on}, computed bandwidths are restricted to lie within the range of {it:runvar}. Default is {opt on}.{p_end}
+
+{p 4 8}{cmd:stdvars(}{it:stdopt}{cmd:)} if set {opt on}, {it:depvar} and {it:runvar} are standardized before computing the bandwidths. Default is {opt off}.{p_end}
+
+{dlgtab:Variance-Covariance Estimation}
+
+{p 4 8}{cmd:vce(}{it:vcetype [vceopt1 vceopt2]}{cmd:)} specifies the procedure used to compute the variance-covariance matrix estimator.
+Options are:{p_end}
+{p 8 12}{cmd:vce(nn }{it:[nnmatch]}{cmd:)} for heteroskedasticity-robust nearest neighbor variance estimator with {it:nnmatch} indicating the minimum number of neighbors to be used.{p_end}
+{p 8 12}{cmd:vce(hc0)} for heteroskedasticity-robust plug-in residuals variance estimator without weights.{p_end}
+{p 8 12}{cmd:vce(hc1)} for heteroskedasticity-robust plug-in residuals variance estimator with {it:hc1} weights.{p_end}
+{p 8 12}{cmd:vce(hc2)} for heteroskedasticity-robust plug-in residuals variance estimator with {it:hc2} weights.{p_end}
+{p 8 12}{cmd:vce(hc3)} for heteroskedasticity-robust plug-in residuals variance estimator with {it:hc3} weights.{p_end}
+{p 8 12}{cmd:vce(nncluster }{it:clustervar [nnmatch]}{cmd:)} for cluster-robust nearest neighbor variance estimation using with {it:clustervar} indicating the cluster ID variable and {it: nnmatch} matches indicating the minimum number of neighbors to be used.{p_end}
+{p 8 12}{cmd:vce(cluster }{it:clustervar}{cmd:)} for cluster-robust plug-in residuals variance estimation with degrees-of-freedom weights and {it:clustervar} indicating the cluster ID variable.{p_end}
+{p 8 12}Default is {cmd:vce(nn 3)}.{p_end}
+
+{p 4 8}{cmd:level(}{it:#}{cmd:)} specifies confidence level for confidence intervals.
+Default is {cmd:level(95)}.{p_end}
+
+{dlgtab:Other Options}
+
+{p 4 8}{cmd:all} if specified, {cmd:rdrobust} reports three different procedures:{p_end}
+{p 8 12}   (i) conventional RD estimates with conventional variance estimator.{p_end}
+{p 8 12}  (ii) bias-corrected RD estimates with conventional variance estimator.{p_end}
+{p 8 12} (iii) bias-corrected RD estimates with robust variance estimator.{p_end}
+
+   {hline}
+
+
+{marker examples}{...}
+{title:Example: Cattaneo, Frandsen and Titiunik (2015) Incumbency Data}
+
+{p 4 8}Setup{p_end}
+{p 8 8}{cmd:. use rdrobust_senate.dta}{p_end}
+
+{p 4 8}Robust RD Estimation using MSE bandwidth selection procedure{p_end}
+{p 8 8}{cmd:. rdrobust vote margin}{p_end}
+
+{p 4 8}Robust RD Estimation with both bandwidths set to 15{p_end}
+{p 8 8}{cmd:. rdrobust vote margin, h(15)}{p_end}
+
+{p 4 8}Other generic examples ({cmd:y} outcome variable, {cmd:x} running variable, {cmd:t} treatment take-up indicator):
+
+{p 8 8}Estimation for Sharp RD designs{p_end}
+{p 12 12}{cmd:. rdrobust y x, deriv(0)}{p_end}
+
+{p 8 8}Estimation for Sharp Kink RD designs{p_end}
+{p 12 12}{cmd:. rdrobust y x, deriv(1)}{p_end}
+
+{p 8 8}Estimation for Fuzzy RD designs{p_end}
+{p 12 12}{cmd:. rdrobust y x, fuzzy(t)}{p_end}
+
+{p 8 8}Estimation for Fuzzy Kink RD designs{p_end}
+{p 12 12}{cmd:. rdrobust y x, fuzzy(t) deriv(1)}{p_end}
+
+
+{marker stored_results}{...}
+{title:Stored results}
+
+{p 4 8}{cmd:rdrobust} stores the following in {cmd:e()}:
+
+{synoptset 20 tabbed}{...}
+{p2col 5 20 24 2: Scalars}{p_end}
+{synopt:{cmd:e(N)}}original number of observations{p_end}
+{synopt:{cmd:e(N_l)}}original number of observations to the left of the cutoff{p_end}
+{synopt:{cmd:e(N_r)}}original number of observations to the right of the cutoff{p_end}
+{synopt:{cmd:e(N_h_l)}}effective number of observations (given by the bandwidth h_l) used to the left of the cutoff{p_end}
+{synopt:{cmd:e(N_h_r)}}effective number of observations (given by the bandwidth h_r) used to the right of the cutoff{p_end}
+{synopt:{cmd:e(N_b_l)}}effective number of observations (given by the bandwidth b_l) used to the left of the cutoff{p_end}
+{synopt:{cmd:e(N_b_r)}}effective number of observations (given by the bandwidth b_r) used to the right of the cutoff{p_end}
+{synopt:{cmd:e(c)}}cutoff value{p_end}
+{synopt:{cmd:e(p)}}order of the polynomial used for estimation of the regression function{p_end}
+{synopt:{cmd:e(q)}}order of the polynomial used for estimation of the bias of the regression function estimator{p_end}
+{synopt:{cmd:e(h_l)}}bandwidth used for estimation of the regression function below the cutoff{p_end}
+{synopt:{cmd:e(h_r)}}bandwidth used for estimation of the regression function above the cutoff{p_end}
+{synopt:{cmd:e(b_l)}}bandwidth used for estimation of the bias of the regression function estimator below the cutoff{p_end}
+{synopt:{cmd:e(b_r)}}bandwidth used for estimation of the bias of the regression function estimator above the cutoff{p_end}
+{synopt:{cmd:e(tau_cl)}}conventional local-polynomial RD estimate{p_end}
+{synopt:{cmd:e(tau_cl_l)}}conventional local-polynomial left estimate{p_end}
+{synopt:{cmd:e(tau_cl_r)}}conventional local-polynomial right estimate{p_end}
+{synopt:{cmd:e(tau_bc)}}bias-corrected local-polynomial RD estimate{p_end}
+{synopt:{cmd:e(tau_bc_l)}}bias-corrected local-polynomial left estimate{p_end}
+{synopt:{cmd:e(tau_bc_r)}}bias-corrected local-polynomial right estimate{p_end}
+{synopt:{cmd:e(se_tau_cl)}}conventional standard error of the local-polynomial RD estimator{p_end}
+{synopt:{cmd:e(se_tau_rb)}}robust standard error of the local-polynomial RD estimator{p_end}
+{synopt:{cmd:e(bias_l)}}estimated bias for the local-polynomial RD estimator below the cutoff{p_end}
+{synopt:{cmd:e(bias_r)}}estimated bias for the local-polynomial RD estimator above the cutoff{p_end}
+
+{p2col 5 20 24 2: Macros}{p_end}
+{synopt:{cmd:e(runningvar)}}name of running variable{p_end}
+{synopt:{cmd:e(outcomevar)}}name of outcome variable{p_end}
+{synopt:{cmd:e(clustvar)}}name of cluster variable{p_end}
+{synopt:{cmd:e(covs)}}name of covariates{p_end}
+{synopt:{cmd:e(vce_select)}}vcetype specified in vce(){p_end}
+{synopt:{cmd:e(bwselect)}}bandwidth selection choice{p_end}
+{synopt:{cmd:e(kernel)}}kernel choice{p_end}
+
+{p2col 5 20 24 2: Matrices}{p_end}
+{synopt:{cmd:e(beta_p_r)}}conventional p-order local-polynomial estimates to the right of the cutoff{p_end}
+{synopt:{cmd:e(beta_p_l)}}conventional p-order local-polynomial estimates to the left of the cutoff{p_end}
+{synopt:{cmd:e(V_cl_r)}}conventional variance-covariance matrix to the right of the cutoff{p_end}
+{synopt:{cmd:e(V_cl_l)}}conventional variance-covariance matrix to the left of the cutoff{p_end}
+{synopt:{cmd:e(V_rb_r)}}robust variance-covariance matrix to the right of the cutoff{p_end}
+{synopt:{cmd:e(V_rb_l)}}robust variance-covariance matrix to the left of the cutoff{p_end}
+
+{marker references}{...}
+{title:References}
+
+{p 4 8}Calonico, S., M. D. Cattaneo, and M. H. Farrell. 2020.
+{browse "https://rdpackages.github.io/references/Calonico-Cattaneo-Farrell_2020_ECTJ.pdf":Optimal Bandwidth Choice for Robust Bias Corrected Inference in Regression Discontinuity Designs}.
+{it:Econometrics Journal} 23(2): 192-210.{p_end}
+
+{p 4 8}Calonico, S., M. D. Cattaneo, and M. H. Farrell. 2018.
+{browse "https://rdpackages.github.io/references/Calonico-Cattaneo-Farrell_2018_JASA.pdf":On the Effect of Bias Estimation on Coverage Accuracy in Nonparametric Inference}.
+{it:Journal of the American Statistical Association} 113(522): 767-779.{p_end}
+
+{p 4 8}Calonico, S., M. D. Cattaneo, M. H. Farrell, and R. Titiunik. 2019.
+{browse "https://rdpackages.github.io/references/Calonico-Cattaneo-Farrell-Titiunik_2019_RESTAT.pdf":Regression Discontinuity Designs using Covariates}.
+{it:Review of Economics and Statistics}, 101(3): 442-451.{p_end}
+
+{p 4 8}Calonico, S., M. D. Cattaneo, M. H. Farrell, and R. Titiunik. 2017.
+{browse "https://rdpackages.github.io/references/Calonico-Cattaneo-Farrell-Titiunik_2017_Stata.pdf":rdrobust: Software for Regression Discontinuity Designs}.
+{it:Stata Journal} 17(2): 372-404.{p_end}
+
+{p 4 8}Calonico, S., M. D. Cattaneo, and R. Titiunik. 2014a.
+{browse "https://rdpackages.github.io/references/Calonico-Cattaneo-Titiunik_2014_ECMA.pdf":Robust Nonparametric Confidence Intervals for Regression-Discontinuity Designs}.
+{it:Econometrica} 82(6): 2295-2326.{p_end}
+
+{p 4 8}Calonico, S., M. D. Cattaneo, and R. Titiunik. 2014b.
+{browse "https://rdpackages.github.io/references/Calonico-Cattaneo-Titiunik_2014_Stata.pdf":Robust Data-Driven Inference in the Regression-Discontinuity Design}.
+{it:Stata Journal} 14(4): 909-946.{p_end}
+
+{p 4 8}Calonico, S., M. D. Cattaneo, and R. Titiunik. 2015a.
+{browse "https://rdpackages.github.io/references/Calonico-Cattaneo-Titiunik_2015_JASA.pdf":Optimal Data-Driven Regression Discontinuity Plots}.
+{it:Journal of the American Statistical Association} 110(512): 1753-1769.{p_end}
+
+{p 4 8}Calonico, S., M. D. Cattaneo, and R. Titiunik. 2015b.
+{browse "https://rdpackages.github.io/references/Calonico-Cattaneo-Titiunik_2015_R.pdf":rdrobust: An R Package for Robust Nonparametric Inference in Regression-Discontinuity Designs}.
+{it:R Journal} 7(1): 38-51.{p_end}
+
+{p 4 8}Cattaneo, M. D., B. Frandsen, and R. Titiunik. 2015.
+{browse "https://rdpackages.github.io/references/Cattaneo-Frandsen-Titiunik_2015_JCI.pdf":Randomization Inference in the Regression Discontinuity Design: An Application to Party Advantages in the U.S. Senate}.
+{it:Journal of Causal Inference} 3(1): 1-24.{p_end} 
+
+{marker authors}{...}
+{title:Authors}
+
+{p 4 8}Sebastian Calonico, Columbia University, New York, NY.
+{browse "mailto:[email protected]":[email protected]}.{p_end}
+
+{p 4 8}Matias D. Cattaneo, Princeton University, Princeton, NJ.
+{browse "mailto:[email protected]":[email protected]}.{p_end}
+
+{p 4 8}Max H. Farrell, University of Chicago, Chicago, IL.
+{browse "mailto:[email protected]":[email protected]}.{p_end}
+
+{p 4 8}Rocio Titiunik, Princeton University, Princeton, NJ.
+{browse "mailto:[email protected]":[email protected]}.{p_end}
+
+

30/replication_package/Adofiles/reghdfe_2019/reghdfe.ado

@@ -0,0 +1,539 @@
+*! version 5.7.3 13nov2019
+
+program reghdfe, eclass
+	* Intercept old+version
+	cap syntax, version old
+	if !c(rc) {
+		reghdfe_old, version
+		exit
+	}
+
+	* Intercept old
+	cap syntax anything(everything) [fw aw pw/], [*] old
+	if !c(rc) {
+		di as error "(running historical version of reghdfe)"
+		if ("`weight'"!="") local weightexp [`weight'=`exp']
+		reghdfe_old `anything' `weightexp', `options'
+		exit
+	}
+
+	* Aux. subcommands
+	cap syntax, [*]
+	if inlist("`options'", "check", "compile", "reload", "update", "version", "requirements", "store_alphas") {
+		if ("`options'"=="compile") loc args force
+		if ("`options'"=="check") loc options compile
+		if ("`options'"=="update") {
+			loc args 1
+			loc options reload
+		}
+		loc subcmd = proper("`options'")
+		`subcmd' `args'
+	}
+	else if replay() {
+		Replay `0'
+	}
+	else {
+		Cleanup 0
+		ms_get_version ftools, min_version("2.36.1") // Compile // takes 0.01s to run this useful check (ensures .mlib exists)
+		cap noi Estimate `0'
+		Cleanup `c(rc)'
+	}
+end
+
+
+program Compile
+	args force
+	
+	* Check dependencies
+	ftools, check // in case lftools.mlib does not exist or is outdated
+	ms_get_version ftools, min_version("2.34.0")
+	ms_get_version reghdfe // save local package_version
+	loc list_objects "FixedEffects() fixed_effects() BipartiteGraph()"
+	loc list_functions "reghdfe_*() transform_*() accelerate_*() panelmean() panelsolve_*() lsmr()"
+	loc list_misc "weighted_quadcolsum() safe_divide() check_convergence() precompute_inv_xx() _st_data_wrapper()"
+	// TODO: prefix everything with reghdfe_*
+
+	ms_compile_mata, ///
+		package(reghdfe) ///
+		version(`package_version') ///
+		fun("`list_objects' `list_functions' `list_misc'") ///
+		verbose ///
+		`force'
+end
+
+
+program Reload
+	* Internal debugging tool.
+	* Updates dependencies and reghdfe from local path or from github
+	* Usage:
+	* 	reghdfe, update // from c:\git\..
+	* 	reghdfe, reload // from github
+
+	args online
+	if ("`online'" == "") loc online 0
+
+	di as text _n "{bf:reghdfe: updating required packages}"
+	di as text "{hline 64}"
+
+	* -ftools- https://github.com/sergiocorreia/ftools/
+	cap ado uninstall ftools
+	if (`online') net install ftools, from("https://github.com/sergiocorreia/ftools/raw/master/src/")
+	if (!`online') net install ftools, from("c:\git\ftools\src")
+	di as text "{hline 64}"
+	ftools, compile
+	di as text "{hline 64}"
+
+	* Update -reghdfe-
+	di as text _n  _n "{bf:reghdfe: updating self}"
+	di as text "{hline 64}"
+	qui ado uninstall reghdfe
+	if (`online') net install reghdfe, from("https://github.com/sergiocorreia/reghdfe/raw/master/src/")
+	if (!`online') net install reghdfe, from("c:\git\reghdfe\src")
+	qui which reghdfe
+	di as text "{hline 64}"
+	reghdfe, compile
+	di as text "{hline 64}"
+
+	* Cleaning up
+	di as text _n "{bf:Note:} You need to run {stata program drop _all} now."
+end
+
+
+program Version
+	which reghdfe
+	Requirements
+end
+
+
+program Requirements
+	di as text _n "Required packages installed?"
+	loc reqs ftools
+	// ivreg2 avar tuples group3hdfe
+	if (c(stata_version)<13) loc reqs `reqs' boottest
+
+	loc ftools_github "https://github.com/sergiocorreia/ftools/raw/master/src/"
+
+	loc error 0
+
+	foreach req of local reqs {
+		loc fn `req'.ado
+		cap findfile `fn'
+		if (_rc) {
+			loc error 1
+			di as text "{lalign 20:- `req'}" as error "not" _c
+			di as text "    {stata ssc install `req':install from SSC}" _c
+			if inlist("`req'", "ftools") {
+				loc github ``req'_github'
+				di as text `"    {stata `"net install `req', from(`"`github'"')"':install from github}"'
+			}
+			else {
+				di as text // newline
+			}
+		}
+		else {
+			di as text "{lalign 20:- `req'}" as text "yes"
+		}
+	}
+
+	if (`error') exit 601
+end
+
+
+program Store_Alphas, eclass
+	mata: st_local("save_any_fe", strofreal(HDFE.save_any_fe))
+	assert inlist(`save_any_fe', 0, 1)
+	if (`save_any_fe') {
+		_assert e(depvar) != "", msg("e(depvar) is empty")
+		_assert e(resid) != "", msg("e(resid) is empty")
+		// we can't use -confirm var- because it might have TS operators
+		fvrevar `e(depvar)', list
+		confirm numeric var `e(resid)', exact
+		tempvar d
+		if (e(rank)) {
+			qui _predict double `d' if e(sample), xb
+		}
+		else if (e(report_constant)) {
+			gen double `d' = _b[_cons] if e(sample)
+		}
+		else {
+			gen double `d' = 0 if e(sample)
+		}
+		qui replace `d' = `e(depvar)' - `d' - `e(resid)' if e(sample)
+
+		mata: HDFE.store_alphas("`d'")
+		drop `d'
+
+		// Drop resid if we don't want to save it; and update e(resid)
+		cap drop __temp_reghdfe_resid__
+		if (!c(rc)) ereturn local resid
+	}
+end
+
+
+program Cleanup
+	args rc
+	cap mata: mata drop HDFE
+	cap mata: mata drop hdfe_*
+	cap drop __temp_reghdfe_resid__
+	cap matrix drop reghdfe_statsmatrix
+	if (`rc' == 132) {
+		di as text "- If you got the {it:parentheses unbalanced} error, note that IV/2SLS was moved to {help ivreghdfe}"
+		di as smcl `"- Latest version: {browse "https://github.com/sergiocorreia/ivreghdfe":https://github.com/sergiocorreia/ivreghdfe}"'
+		di as smcl `"- SSC version: {stata "net describe ivreghdfe, from(http://fmwww.bc.edu/RePEc/bocode/i)"}"'
+		di as smcl `"- Note: the older functionality can still be accessed through the {it:old} option"'
+	}
+	if (`rc') exit `rc'
+end
+
+
+program Parse
+	* Trim whitespace (caused by "///" line continuations; aesthetic only)
+	mata: st_local("0", stritrim(st_local("0")))
+
+	* Main syntax
+	#d;
+	syntax varlist(fv ts numeric) [if] [in] [aw pw fw/] , [
+
+		/* Model */
+		Absorb(string) NOAbsorb
+		SUmmarize SUmmarize2(string asis) /* simulate implicit options */
+
+		/* Standard Errors */
+		VCE(string) CLuster(string)
+
+		/* Diagnostic */
+		Verbose(numlist min=1 max=1 >=-1 <=5 integer)
+		TIMEit
+
+		/* Speedup and memory Tricks */
+		NOSAMPle /* do not save e(sample) */
+		COMPACT /* use as little memory as possible but is slower */
+
+		/* Extra display options (based on regress) */
+		noHEader noTABle noFOOTnote
+		
+		/* Undocumented */
+		KEEPSINgletons
+		OLD /* use latest v3 */
+		NOTES(string) /* NOTES(key=value ...), will be stored on e() */
+
+		] [*] /* capture optimization options, display options, etc. */
+		;
+	#d cr
+
+	* Unused
+	* SAVEcache
+	* USEcache
+	* CLEARcache
+
+	* Convert options to boolean
+	if ("`verbose'" == "") loc verbose 0
+	loc timeit = ("`timeit'"!="")
+	loc drop_singletons = ("`keepsingletons'" == "")
+	loc compact = ("`compact'" != "")
+
+	if (`timeit') timer on 29
+
+	* Sanity checks
+	if (`verbose'>-1 & "`keepsingletons'"!="") {
+		loc url "http://scorreia.com/reghdfe/nested_within_cluster.pdf"
+		loc msg "WARNING: Singleton observations not dropped; statistical significance is biased"
+		di as error `"`msg' {browse "`url'":(link)}"'
+	}
+	if ("`cluster'"!="") {
+		_assert ("`vce'"==""), msg("cannot specify both cluster() and vce()")
+		loc vce cluster `cluster'
+		loc cluster // clear it to avoid bugs in subsequent lines
+	}
+
+	* Split varlist into <depvar> and <indepvars>
+	ms_parse_varlist `varlist'
+	if (`verbose' > 0) {
+		di as text _n "## Parsing varlist: {res}`varlist'"
+		return list
+	}
+	loc depvar `r(depvar)'
+	loc indepvars `r(indepvars)'
+	loc fe_format "`r(fe_format)'"
+	loc basevars `r(basevars)'
+
+	* Parse Weights
+	if ("`weight'"!="") {
+		unab exp : `exp', min(1) max(1) // simple weights only
+	}
+
+	* Parse VCE
+	ms_parse_vce, vce(`vce') weighttype(`weight')
+	if (`verbose' > 0) {
+		di as text _n "## Parsing vce({res}`vce'{txt})"
+		sreturn list
+	}
+	loc vcetype = "`s(vcetype)'"
+	loc num_clusters = `s(num_clusters)'
+	loc clustervars = "`s(clustervars)'"
+	loc base_clustervars = "`s(base_clustervars)'"
+	loc vceextra = "`s(vceextra)'"
+
+	* Select sample (except for absvars)
+	loc varlist `depvar' `indepvars' `base_clustervars'
+	tempvar touse
+	marksample touse, strok // based on varlist + cluster + if + in + weight
+
+	* Parse noabsorb
+	_assert  ("`absorb'`noabsorb'" != ""), msg("option {bf:absorb()} or {bf:noabsorb} required")
+	if ("`noabsorb'" != "") {
+		_assert ("`absorb'" == ""), msg("{bf:absorb()} and {bf:noabsorb} are mutually exclusive")
+	}
+
+	if (`timeit') timer off 29
+
+	* Construct HDFE object
+	// SYNTAX: fixed_effects(absvars | , touse, wtype, wtvar, dropsing, verbose)
+	ms_add_comma, loc(absorb) cmd(`"`absorb'"') opt(`"`options'"')
+	if (`timeit') timer on 20
+	mata: HDFE = fixed_effects(`"`absorb'"', "`touse'", "`weight'", "`exp'", `drop_singletons', `verbose')
+	if (`timeit') timer off 20
+	mata: HDFE.cmdline = "reghdfe " + st_local("0")
+	loc options `s(options)'
+
+	mata: st_local("N", strofreal(HDFE.N))
+	if (`N' == 0) error 2000
+
+	* Fill out HDFE object
+	* mata: HDFE.varlist = "`base_varlist'"
+	mata: HDFE.depvar = "`depvar'"
+	mata: HDFE.indepvars = "`indepvars'"
+	mata: HDFE.vcetype = "`vcetype'"
+	mata: HDFE.num_clusters = `num_clusters'
+	mata: HDFE.clustervars = tokens("`clustervars'")
+	mata: HDFE.base_clustervars = tokens("`base_clustervars'")
+	mata: HDFE.vceextra = "`vceextra'"
+
+	* Preserve memory
+	mata: HDFE.compact = `compact'
+	if (`compact') {
+		loc panelvar "`_dta[_TSpanel]'"
+		loc timevar "`_dta[_TStvar]'"
+
+		cap conf var `panelvar', exact
+		if (c(rc)) loc panelvar
+
+		cap conf var `timevar', exact
+		if (c(rc)) loc timevar
+
+		mata: HDFE.panelvar = "`panelvar'"
+		mata: HDFE.timevar = "`timevar'"
+		c_local keepvars `basevars' `base_clustervars' `panelvar' `timevar' // `exp'
+	}
+
+	* Parse summarize
+	if ("`summarize'" != "") {
+		_assert ("`summarize2'" == ""), msg("summarize() syntax error")
+		loc summarize2 mean min max  // default values
+	}
+	ParseSummarize `summarize2'
+	mata: HDFE.summarize_stats = "`s(stats)'"
+	mata: HDFE.summarize_quietly = `s(quietly)'
+
+
+	* Parse misc options
+	mata: HDFE.notes = `"`notes'"'
+	mata: HDFE.store_sample = ("`nosample'"=="")
+	mata: HDFE.timeit = `timeit'
+
+
+	* Parse Coef Table Options (do this last!)
+	_get_diopts diopts options, `options' // store in `diopts', and the rest back to `options'
+	loc diopts `diopts' `header' `table' `footnote'
+	_assert (`"`options'"'==""), msg(`"invalid options: `options'"')
+	if ("`hascons'"!="") di in ye "(option ignored: `hascons')"
+	if ("`tsscons'"!="") di in ye "(option ignored: `tsscons')"
+	mata: HDFE.diopts = `"`diopts'"'
+end
+
+
+program ParseSummarize, sclass
+	sreturn clear
+	syntax [namelist(name=stats)] , [QUIetly]
+	local quietly = ("`quietly'"!="")
+	sreturn loc stats "`stats'"
+	sreturn loc quietly = `quietly'
+end
+
+// --------------------------------------------------------------------------
+
+program Estimate, eclass
+	ereturn clear
+
+	* Parse and fill out HDFE object
+	Parse `0'
+	mata: st_local("timeit", strofreal(HDFE.timeit))
+	mata: st_local("compact", strofreal(HDFE.compact))
+	mata: st_local("verbose", strofreal(HDFE.verbose))
+
+	* Compute degrees-of-freedom
+	if (`timeit') timer on 21
+	mata: HDFE.estimate_dof()
+	if (`timeit') timer off 21
+
+	* Save updated e(sample) (singletons reduce sample);
+	* required to parse factor variables to partial out
+	if (`timeit') timer on 29
+	tempvar touse
+	mata: HDFE.save_touse("`touse'")
+	if (`timeit') timer off 29
+
+	* Expand varlists
+	if (`timeit') timer on 22
+	mata: st_local("depvar", HDFE.depvar)
+	mata: st_local("indepvars", HDFE.indepvars)
+	if (`verbose' > 0) di as text _n "## Parsing and expanding indepvars: {res}`indepvars'"
+	ms_expand_varlist `indepvars' if `touse'
+	if (`verbose' > 0) return list
+	mata: HDFE.fullindepvars = "`r(fullvarlist)'"
+	mata: HDFE.indepvars = "`r(varlist)'"
+	mata: HDFE.not_basevar = strtoreal(tokens("`r(not_omitted)'"))
+	mata: HDFE.varlist = "`depvar' `r(varlist)'"
+	if (`timeit') timer off 22
+
+	* Stats
+	mata: st_local("stats", HDFE.summarize_stats)
+	if ("`stats'" != "") Stats `touse'
+
+	* Condition number
+	mata: HDFE.estimate_cond()
+
+	* Preserve
+	if (`compact') {
+		if (`verbose' > 0) di as text "## Preserving dataset"
+		preserve
+		novarabbrev keep `keepvars'
+	}
+
+	* Partial out; save TSS of depvar
+	if (`timeit') timer on 23
+	// SYNTAX: partial_out(Varlist/Matrix | , Save TSS if HDFE.tss is missing? [0], Standardize data? [1], First col is depvar? [1])
+	// Note: standardize=2 will standardize, partial out, and return the data standardized!
+	mata: hdfe_variables = HDFE.partial_out(HDFE.varlist, 1, 2, .)
+	if (`timeit') timer off 23
+
+	* Regress
+	if (`timeit') timer on 24
+	tempname b V N rank df_r
+	mata: reghdfe_post_ols(HDFE, hdfe_variables, "`b'", "`V'", "`N'", "`rank'", "`df_r'")
+	mata: hdfe_variables = .
+	* Restore
+	if (`compact') {
+		if (`verbose' > 0) di as text "## Restoring dataset"
+		restore
+		mata: st_local("residuals", HDFE.residuals)
+		if ("`residuals'" != "") mata: HDFE.save_variable(HDFE.residuals, HDFE.residuals_vector, "Residuals")
+	}
+	RegressOLS `touse' `b' `V' `N' `rank' `df_r'
+	if (`timeit') timer off 24
+
+	* (optional) Store FEs
+	if (`timeit') timer on 29
+	reghdfe, store_alphas
+	if (`timeit') timer off 29
+
+	* View estimation tables
+	mata: st_local("diopts", HDFE.diopts)
+	Replay, `diopts'
+
+	if (`timeit') {
+		di as text _n "{bf: Timer results:}"
+		timer list
+		di as text "Legend: 20: Create HDFE object; 21: Estimate DoF; 22: expand varlists; 23: partial out; 24: regress; 29: rest"
+		di
+	}
+end
+
+
+program RegressOLS, eclass
+	args touse b V N rank df_r
+
+	mata: st_local("store_sample", strofreal(HDFE.store_sample))
+	if (`store_sample') loc esample "esample(`touse')"
+	
+	mata: st_local("indepvars", HDFE.fullindepvars)
+	if ("`indepvars'" != "") {
+		matrix colnames `b' = `indepvars'
+		matrix colnames `V' = `indepvars'
+		matrix rownames `V' = `indepvars'
+		_ms_findomitted `b' `V'
+		ereturn post `b' `V', `esample' buildfvinfo depname(`depvar') 
+	}
+	else {
+		ereturn post, `esample' buildfvinfo depname(`depvar')
+	}
+
+	ereturn scalar N       = `N'
+	ereturn scalar rank    = `rank'
+	ereturn scalar df_r    = `df_r'
+	ereturn local  cmd     "reghdfe"
+	mata: HDFE.post()
+
+	* Post stats
+	cap conf matrix reghdfe_statsmatrix
+	if (!c(rc)) {
+		ereturn matrix summarize = reghdfe_statsmatrix
+		mata: st_local("summarize_quietly", strofreal(HDFE.summarize_quietly))
+		ereturn scalar summarize_quietly = `summarize_quietly'
+	}
+end
+
+
+program Replay, rclass
+	syntax [, noHEader noTABle noFOOTnote *]
+
+	if `"`e(cmd)'"' != "reghdfe"  {
+	        error 301
+	}
+
+	_get_diopts options, `options'
+	if ("`header'" == "") {
+		reghdfe_header // _coef_table_header
+		di ""
+	}
+	if ("`table'" == "") {
+		_coef_table, `options' // ereturn display, `options'
+		return add // adds r(level), r(table), etc. to ereturn (before the footnote deletes them)
+	}
+	if ("`footnote'" == "") {
+		reghdfe_footnote
+	}
+
+	* Replay stats
+	if (e(summarize_quietly)==0) {
+		di as text _n "{sf:Regression Summary Statistics:}" _c
+		matlist e(summarize)', border(top bottom) rowtitle(Variable) // twidth(18) 
+	}
+end
+
+
+program Stats
+	args touse
+	* Optional weights
+	mata: st_local("weight", sprintf("[%s=%s]", HDFE.weight_type, HDFE.weight_var))
+	assert "`weight'" != ""
+	if ("`weight'" == "[=]") loc weight
+	loc weight : subinstr local weight "[pweight" "[aweight"
+
+	mata: st_local("stats", HDFE.summarize_stats)
+	mata: st_local("varlist", HDFE.varlist)
+	mata: st_local("cvars", invtokens(HDFE.cvars))
+	loc full_varlist `varlist' `cvars'
+
+	* quick workaround b/c -tabstat- does not support factor variables
+	fvrevar `full_varlist', list
+	loc full_varlist `r(varlist)'
+
+	qui tabstat `full_varlist' if `touse' `weight' , stat(`stats') col(stat) save
+	matrix reghdfe_statsmatrix = r(StatTotal)
+end
+
+findfile "reghdfe.mata"
+include "`r(fn)'"
+
+exit

30/replication_package/Adofiles/reghdfe_2019/reghdfe.mata

@@ -0,0 +1,62 @@
+// --------------------------------------------------------------------------
+// Mata Code: FE Estimator (REGHDFE)
+// --------------------------------------------------------------------------
+// - Project URL:   https://github.com/sergiocorreia/reghdfe
+// - Dependency:    https://github.com/sergiocorreia/ftools
+
+    *mata: mata clear
+    *mata: mata set matastrict on
+    mata: mata set mataoptimize on
+    *mata: mata set matadebug off
+    *mata: mata set matalnum off
+
+// Include ftools -----------------------------------------------------------
+    cap findfile "ftools.mata"
+    if (_rc) {
+        di as error "reghdfe requires the {bf:ftools} package, which is not installed"
+        di as error `"    - install from {stata ssc install ftools:SSC}"'
+        di as error `"    - install from {stata `"net install ftools, from("https://github.com/sergiocorreia/ftools/raw/master/src/")"':Github}"'
+        exit 9
+    }
+    include "`r(fn)'"
+
+
+// Custom types -------------------------------------------------------------
+    loc FixedEffects        class FixedEffects scalar
+    loc Factors             class Factor rowvector
+    loc BipartiteGraph      class BipartiteGraph scalar
+    loc FactorPointer       pointer(`Factor') scalar
+
+
+// Versioning ---------------------------------------------------------------
+	ms_get_version reghdfe // from parsetools package
+	assert("`package_version'" != "")
+    mata: string scalar reghdfe_version() return("`package_version'")
+    mata: string scalar reghdfe_stata_version() return("`c(stata_version)'")
+    mata: string scalar reghdfe_joint_version() return("`package_version'|`c(stata_version)'")
+
+
+// Includes -----------------------------------------------------------------
+    findfile "reghdfe_bipartite.mata"
+    include "`r(fn)'"
+
+    findfile "reghdfe_class.mata"
+    include "`r(fn)'"
+
+    findfile "reghdfe_constructor.mata"
+    include "`r(fn)'"
+
+    findfile "reghdfe_common.mata"
+    include "`r(fn)'"
+
+    findfile "reghdfe_projections.mata"
+    include "`r(fn)'"
+
+    findfile "reghdfe_transforms.mata"
+    include "`r(fn)'"
+
+    findfile "reghdfe_accelerations.mata"
+    include "`r(fn)'"
+
+    findfile "reghdfe_lsmr.mata"
+    include "`r(fn)'"

30/replication_package/Adofiles/reghdfe_2019/reghdfe.sthlp

@@ -0,0 +1,801 @@
+{smcl}
+{* *! version 5.7.3 13nov2019}{...}
+{vieweralsosee "[R] areg" "help areg"}{...}
+{vieweralsosee "[R] xtreg" "help xtreg"}{...}
+{vieweralsosee "[R] ivregress" "help ivregress"}{...}
+{vieweralsosee "" "--"}{...}
+{vieweralsosee "reghdfe_mata" "help reghdfe_mata"}{...}
+{vieweralsosee "ivreghdfe" "help ivreghdfe"}{...}
+{vieweralsosee "ppmlhdfe" "help ppmlhdfe"}{...}
+{vieweralsosee "ivreg2" "help ivreg2"}{...}
+{vieweralsosee "ftools" "help ftools"}{...}
+{vieweralsosee "" "--"}{...}
+{vieweralsosee "ivregress" "help ivregress"}{...}
+{vieweralsosee "reg2hdfe" "help reg2hdfe"}{...}
+{vieweralsosee "a2reg" "help a2reg"}{...}
+{viewerjumpto "Syntax" "reghdfe##syntax"}{...}
+{viewerjumpto "description" "reghdfe##description"}{...}
+{viewerjumpto "Options" "reghdfe##options"}{...}
+{viewerjumpto "Postestimation Syntax" "reghdfe##postestimation"}{...}
+{viewerjumpto "Remarks" "reghdfe##remarks"}{...}
+{viewerjumpto "Examples" "reghdfe##examples"}{...}
+{viewerjumpto "Stored results" "reghdfe##results"}{...}
+{viewerjumpto "Author" "reghdfe##contact"}{...}
+{viewerjumpto "Updates" "reghdfe##updates"}{...}
+{viewerjumpto "Acknowledgements" "reghdfe##acknowledgements"}{...}
+{viewerjumpto "References" "reghdfe##references"}{...}
+{title:Title}
+
+{p2colset 5 18 20 2}{...}
+{p2col :{cmd:reghdfe} {hline 2}}Linear regression absorbing multiple levels of fixed effects{p_end}
+{p2colreset}{...}
+
+{marker syntax}{...}
+{title:Syntax}
+
+{p 8 15 2} {cmd:reghdfe}
+{depvar} [{indepvars}]
+{ifin} {it:{weight}} {cmd:,} {opth a:bsorb(reghdfe##absvar:absvars)} [{help reghdfe##options:options}] {p_end}
+
+{marker opt_summary}{...}
+{synoptset 22 tabbed}{...}
+{synopthdr}
+{synoptline}
+{syntab:Model {help reghdfe##opt_model:[+]}}
+{p2coldent:* {opth a:bsorb(reghdfe##absvar:absvars)}}categorical variables that identify the fixed effects to be absorbed{p_end}
+{synopt: {cmdab:a:bsorb(}{it:...}{cmd:,} {cmdab:save:fe)}}save all fixed effect estimates with the {it:__hdfe*} prefix{p_end}
+{synopt: {cmdab:noa:bsorb}}only absorb the constant; alternative to 
+{cmd:regress} that supports for multi-way-clustering{p_end}
+{synopt : {opth res:iduals(newvar)}}save residuals; {it:predict, d} requires this option{p_end}
+{synopt :{opth su:mmarize(tabstat##statname:stats)}}equivalent to the postestimation command {help reghdfe##postestimation:estat summarize},
+but more flexible, faster, and saves results on {it:e(summarize)}{p_end}
+	
+{syntab:SE/Robust {help reghdfe##opt_vce:[+]}}
+{p2coldent:+ {opt vce}{cmd:(}{help reghdfe##opt_vce:vcetype} [{cmd:,}{it:opt}]{cmd:)}}{it:vcetype}
+may be {opt un:adjusted} (default), {opt r:obust} or {opt cl:uster} {help fvvarlist} (allowing two- and multi-way clustering){p_end}
+
+{syntab:Diagnostic {help reghdfe##opt_diagnostic:[+]}}
+{synopt :{opt v:erbose(#)}}amount of debugging information to show (0=None, 1=Some, 2=More, 3=Parsing/convergence details, 4=Every iteration){p_end}
+{synopt :{opt time:it}}show elapsed times by stage of computation{p_end}
+
+{syntab:Optimization {help reghdfe##opt_optimization:[+]}}
+{p2coldent:+ {opth tol:erance(#)}}criterion for convergence (default=1e-8){p_end}
+{synopt :{opth maxit:erations(#)}}maximum number of iterations (default=10,000); if set to missing ({cmd:.}) it will run for as long as it takes.{p_end}
+{synopt :{opt accel:eration(str)}}acceleration method; options are conjugate_gradient (cg), steep_descent (sd), aitken (a),
+{browse "http://web.stanford.edu/group/SOL/software/lsmr/":lsmr} (with diagonal preconditioner), and none (no){p_end}
+{synopt :{opt transf:orm(str)}}transform operation that defines the type of alternating projection; options are Kaczmarz (kac), Cimmino (cim), Symmetric Kaczmarz (sym).
+This is ignored with LSMR acceleration{p_end}
+{synopt :{opt prune}}prune vertices of degree-1; acts as a preconditioner
+that is useful if the underlying network is very sparse{p_end}
+{synopt :{opt cond}}compute the finite condition number;
+will only run successfully with few fixed effects
+(because it computes the eigenvalues of the graph Laplacian){p_end}
+
+{syntab:Memory Usage {help reghdfe##memory:[+]}}
+{synopt :{opth pool:size(#)}}apply the within algorithm in groups of {it:#} variables (else, it will run on all variables at the same time).
+A large pool size is usually faster but uses more memory{p_end}
+{synopt :{opt compact}}preserve the dataset and drop variables as much as possible on every step{p_end}
+
+{syntab:Speedup Tricks {help reghdfe##opt_speedup:[+]}}
+{synopt :{opt nosamp:le}}will not create {it:e(sample)},
+saving some space and speed{p_end}
+
+{syntab:Degrees-of-Freedom Adjustments {help reghdfe##opt_dof:[+]}}
+{synopt :{opt dof:adjustments(list)}}allows selecting the desired adjustments for degrees of freedom;
+rarely used{p_end}
+{synopt: {opth groupv:ar(newvar)}}unique identifier for the first mobility group{p_end}
+
+{syntab:Reporting {help reghdfe##opt_reporting:[+]}}
+{synopt :{opt version:}}reports the version number and date of reghdfe, and the list of required packages. standalone option{p_end}
+{synopt :{opt l:evel(#)}}set confidence level; default is {cmd:level(95)}{p_end}
+{synopt :{it:{help reghdfe##display_options:display_options}}}control column formats, row spacing, line width, display of omitted variables and base and empty cells, and factor-variable labeling.{p_end}
+{synopt :}particularly useful are the {opt noomit:ted} and {opt noempty} options to hide regressors omitted due to collinearity{p_end}
+
+{syntab:Undocumented}
+{synopt :{opt keepsin:gletons}}do not drop singleton groups{p_end}
+{synopt :{opt nocon:stant}}Do not report estimates for {it:_cons}{p_end}
+{synopt :{opt old}}will call the latest 3.x version of reghdfe instead (see the {help reghdfe_old:old help file}){p_end}
+{synopt :{opth rre(varname)}}where varname is the residual of a proven prev. regression of y against only the FEs{p_end}
+{synopt :{opt check}}compile {it:lreghdfe.mlib} if it does not exist or if it needs to be updated;
+use {cmd:reghdfe,compile} to force an update{p_end}
+{synopt :{opt update}}update reghdfe and dependencies from the respective Github repositories;
+use {cmd:reghdfe,reload} to do so from {it:c:\git\*}{p_end}
+{synoptline}
+{p2colreset}{...}
+{p 4 6 2}* either {opt a:bsorb(absvars)} or {opt noa:bsorb} is required.{p_end}
+{p 4 6 2}+ indicates a recommended or important option.{p_end}
+{p 4 6 2}the regression variables may contain {help tsvarlist:time-series operators} and {help fvvarlist:factor variables};
+the dependent variable cannot be of the form {it:i.turn}, but {it:42.turn} is allowed{p_end}
+{p 4 6 2}{cmd:fweight}s, {cmd:aweight}s and {cmd:pweight}s are allowed; see {help weight}.{p_end}
+
+
+{marker absvar}{...}
+{title:Absvar Syntax}
+
+{synoptset 22}{...}
+{synopthdr:absvar}
+{synoptline}
+{synopt:{cmd:i.}{it:varname}}categorical variable to be absorbed (the {cmd:i.} prefix is tacit){p_end}
+{synopt:{cmd:i.}{it:var1}{cmd:#i.}{it:var2}}absorb the interactions of multiple categorical variables{p_end}
+{synopt:{cmd:i.}{it:var1}{cmd:#}{cmd:c.}{it:var2}}absorb heterogeneous slopes, where {it:var2} has a different slope coef. depending on the category of {it:var1}{p_end}
+{synopt:{it:var1}{cmd:##}{cmd:c.}{it:var2}}equivalent to "{cmd:i.}{it:var1} {cmd:i.}{it:var1}{cmd:#}{cmd:c.}{it:var2}", but {it:much} faster{p_end}
+{synopt:{it:var1}{cmd:##c.(}{it:var2 var3}{cmd:)}}multiple heterogeneous slopes are allowed together. Alternative syntax: {it:var1}{cmd:##(c.}{it:var2} {cmd:c.}{it:var3}{cmd:)}{p_end}
+{synopt:{it:v1}{cmd:#}{it:v2}{cmd:#}{it:v3}{cmd:##c.(}{it:v4 v5}{cmd:)}}factor operators can be combined{p_end}
+{synoptline}
+{p2colreset}{...}
+{p 4 6 2}To save the estimates specific absvars, write {newvar}{inp:={it:absvar}}.{p_end}
+{p 4 6 2}Please be aware that in most cases these estimates are neither consistent nor econometrically identified.{p_end}
+{p 4 6 2}Using categorical interactions (e.g. {it:x}{cmd:#}{it:z}) is faster than running {it:egen group(...)} beforehand.{p_end}
+{p 4 6 2}Singleton obs. are dropped iteratively until no more singletons are found (see ancilliary article for details).{p_end}
+{p 4 6 2}Slope-only absvars ("state#c.time") have poor numerical stability and slow convergence.
+If you need those, either i) increase tolerance or
+ii) use slope-and-intercept absvars ("state##c.time"), even if the intercept is redundant.
+For instance if absvar is "i.zipcode i.state##c.time" then i.state is redundant given i.zipcode, but
+convergence will still be {it:much} faster.{p_end}
+
+{marker description}{...}
+{title:Description}
+
+{pstd}
+{cmd:reghdfe} is a generalization of {help areg} (and {help xtreg:xtreg,fe}, {help xtivreg:xtivreg,fe}) for multiple levels of fixed effects
+(including heterogeneous slopes), alternative estimators (2sls, gmm2s, liml), and additional robust standard errors (multi-way clustering, HAC standard errors, etc).{p_end}
+
+{pstd}Additional features include:{p_end}
+
+{p2col 8 12 12 2: a)}A novel and robust algorithm to efficiently absorb the fixed effects (extending the work of Guimaraes and Portugal, 2010).{p_end}
+{p2col 8 12 12 2: b)}Coded in Mata, which in most scenarios makes it even faster than {it:areg} and {it:xtreg} for a single fixed effect (see benchmarks on the Github page).{p_end}
+{p2col 8 12 12 2: c)}Can save the point estimates of the fixed effects ({it:caveat emptor}: the fixed effects may not be identified, see the {help reghdfe##references:references}).{p_end}
+{p2col 8 12 12 2: d)}Calculates the degrees-of-freedom lost due to the fixed effects
+(note: beyond two levels of fixed effects, this is still an open problem, but we provide a conservative approximation).{p_end}
+{p2col 8 12 12 2: e)}Iteratively removes singleton groups by default, to avoid biasing the standard errors (see ancillary document).{p_end}
+
+{pstd}
+For a description of its internal Mata API, see {help reghdfe_mata}.
+
+{marker options}{...}
+{title:Options}
+
+{marker opt_model}{...}
+{dlgtab:Model and Miscellanea}
+
+{phang}
+{opth a:bsorb(reghdfe##absvar:absvars)} list of categorical variables (or interactions) representing the fixed effects to be absorbed.
+this is equivalent to including an indicator/dummy variable for each category of each {it:absvar}. {cmd:absorb()} is required.
+
+{pmore}
+To save a fixed effect, prefix the absvar with "{newvar}{cmd:=}".
+For instance, the option {cmd:absorb(firm_id worker_id year_coefs=year_id)} will include firm,
+worker and year fixed effects, but will only save the estimates for the year fixed effects (in the new variable {it:year_coefs}).
+
+{pmore}
+If you want to {help reghdfe##postestimation:predict} afterwards but don't care about setting the names of each fixed effect, use the {cmdab:save:fe} suboption.
+This will delete all variables named {it:__hdfe*__} and create new ones as required.
+Example: {it:reghdfe price weight, absorb(turn trunk, savefe)}
+
+{phang}
+{opth res:iduals(newvar)} will save the regression residuals in a new variable. 
+
+{pmore} {opt res:iduals} (without parenthesis) saves the residuals
+in the variable {it:_reghdfe_resid}.
+
+{pmore}
+This option does not require additional computations, and is required for
+subsequent calls to {cmd:predict, d}.
+
+{phang}
+{opth su:mmarize(tabstat##statname:stats)} will report and save a table of summary of statistics of the regression
+variables (including the instruments, if applicable), using the same sample as the regression.
+
+{pmore} {opt su:mmarize} (without parenthesis) saves the default set of statistics: {it:mean min max}.
+
+{pmore} The complete list of accepted statistics is available in the {help tabstat##statname:tabstat help}. The most useful are {it:count range sd median p##}.
+
+{pmore} The summary table is saved in {it:e(summarize)}
+
+{pmore} To save the summary table silently (without showing it after the regression table), use the {opt qui:etly} suboption. You can use it by itself ({cmd:summarize(,quietly)}) or with custom statistics ({cmd:summarize(mean, quietly)}).
+
+{phang}
+{opt subopt:ions(...)}
+options that will be passed directly to the regression command (either {help regress}, {help ivreg2}, or {help ivregress})
+
+{marker opt_vce}{...}
+{dlgtab:SE/Robust}
+
+{phang}
+{opth vce:(reghdfe##vcetype:vcetype, subopt)}
+specifies the type of standard error reported.
+Note that all the advanced estimators rely on asymptotic theory, and will likely have poor performance with small samples
+(but again if you are using reghdfe, that is probably not your case)
+
+{pmore}
+{opt un:adjusted}/{opt ols:} estimates conventional standard errors, valid even in small samples
+under the assumptions of homoscedasticity and no correlation between observations
+
+{pmore}
+{opt r:obust} estimates heteroscedasticity-consistent standard errors (Huber/White/sandwich estimators), but still assuming independence between observations
+
+{pmore}Warning: in a FE panel regression, using {opt r:obust} will
+lead to inconsistent standard errors if for every fixed effect, the {it:other} dimension is fixed.
+For instance, in an standard panel with individual and time fixed effects, we require both the number of
+individuals and time periods to grow asymptotically.
+If that is not the case, an alternative may be to use clustered errors,
+which as discussed below will still have their own asymptotic requirements.
+For a discussion, see
+{browse "http://www.princeton.edu/~mwatson/papers/ecta6489.pdf":Stock and Watson, "Heteroskedasticity-robust standard errors for fixed-effects panel-data regression," Econometrica 76 (2008): 155-174}
+
+{pmore}
+{opt cl:uster} {it:clustervars} estimates consistent standard errors even when the observations
+are correlated within groups.
+
+{pmore}
+Multi-way-clustering is allowed. Thus, you can indicate as many {it:clustervar}s as desired
+(e.g. allowing for intragroup correlation across individuals, time, country, etc).
+
+{pmore}
+Each {it:clustervar} permits interactions of the type {it:var1{cmd:#}var2}
+(this is faster than using {cmd:egen group()} for a one-off regression).
+
+{pmore} Warning: The number of clusters, for all of the cluster variables, must go off to infinity.
+A frequent rule of thumb is that each cluster variable must have at least 50 different categories
+(the number of categories for each clustervar appears on the header of the regression table).
+
+{pstd}
+The following suboptions require either the {help ivreg2} or the {help avar} package from SSC.
+For a careful explanation, see the {help ivreg2##s_robust:ivreg2 help file}, from which the comments below borrow.
+
+{pmore}
+{opt u:nadjusted}{cmd:, }{opt bw(#)} (or just {cmd:, }{opt bw(#)}) estimates autocorrelation-consistent standard errors (Newey-West).
+
+{pmore}
+{opt r:obust}{cmd:, }{opt bw(#)} estimates autocorrelation-and-heteroscedasticity consistent standard errors (HAC).
+
+{pmore}
+{opt cl:uster} {it:clustervars}{cmd:, }{opt bw(#)} estimates standard errors consistent to common autocorrelated disturbances (Driscoll-Kraay). At most two cluster variables can be used in this case.
+
+{pmore}
+{cmd:, }{opt kiefer} estimates standard errors consistent under arbitrary intra-group autocorrelation (but not heteroskedasticity) (Kiefer).
+
+{pmore}
+{opt kernel(str)} is allowed in all the cases that allow {opt bw(#)}
+The default kernel is {it:bar} (Bartlett). Valid kernels are Bartlett (bar); Truncated (tru); Parzen (par);
+Tukey-Hanning (thann); Tukey-Hamming (thamm); Daniell (dan); Tent (ten); and Quadratic-Spectral (qua or qs). 
+
+{pstd}
+Advanced suboptions:
+
+{pmore}
+{cmd:, }{opt suite(default|mwc|avar)} overrides the package chosen by reghdfe to estimate the VCE.
+{it:default} uses the default Stata computation (allows unadjusted, robust, and at most one cluster variable).
+{it:mwc} allows multi-way-clustering (any number of cluster variables), but without the {it:bw} and {it:kernel} suboptions.
+{it:avar} uses the avar package from SSC. Is the same package used by ivreg2, and allows the {it:bw}, {it:kernel}, {it:dkraay} and {it:kiefer} suboptions.
+This is useful almost exclusively for debugging.
+
+{pmore}
+{cmd:, }{opt twice:robust} will compute robust standard errors not only on the first but on the second step of the gmm2s estimation. Requires {opt ivsuite(ivregress)}, but will not give the exact same results as ivregress.
+
+{pmore}{it:Explanation:} When running instrumental-variable regressions with the {cmd:ivregress} package,
+robust standard errors, and a gmm2s estimator, reghdfe will translate
+{opt vce(robust)} into {opt wmatrix(robust)} {opt vce(unadjusted)}.
+This maintains compatibility with {cmd:ivreg2} and other packages, but may unadvisable as described in {help ivregress} (technical note). Specifying this option will instead use {opt wmatrix(robust)} {opt vce(robust)}.
+
+{pmore}However, computing the second-step vce matrix requires computing updated estimates (including updated fixed effects).
+Since reghdfe currently does not allow this, the resulting standard errors
+{hi:will not be exactly the same as with ivregress}.
+This issue is similar to applying the CUE estimator, described further below.
+
+{pmore}Note: The above comments are also appliable to clustered standard error.
+
+{marker opt_iv}{...}
+{dlgtab:IV/2SLS/GMM}
+
+{phang}
+The IV functionality of {cmd:reghdfe} has been moved into {ivreghdfe}.
+
+{marker opt_diagnostic}{...}
+{dlgtab:Diagnostic}
+
+{phang}
+{opt v:erbose(#)} orders the command to print debugging information.
+
+{pmore}
+Possible values are 0 (none), 1 (some information), 2 (even more), 3 (adds dots for each iteration, and reportes parsing details), 4 (adds details for every iteration step)
+
+{pmore}
+For debugging, the most useful value is 3. For simple status reports, set verbose to 1.
+
+{phang}
+{opt time:it} shows the elapsed time at different steps of the estimation. Most time is usually spent on three steps: map_precompute(), map_solve() and the regression step.
+ 
+{marker opt_dof}{...}
+{dlgtab:Degrees-of-Freedom Adjustments}
+
+{phang}
+{opt dof:adjustments(doflist)} selects how the degrees-of-freedom, as well as e(df_a), are adjusted due to the absorbed fixed effects.
+
+{pmore}
+Without any adjustment, we would assume that the degrees-of-freedom used by the fixed effects is equal to the count of all the fixed effects
+(e.g. number of individuals + number of years in a typical panel).
+However, in complex setups (e.g. fixed effects by individual, firm, job position, and year),
+there may be a huge number of fixed effects collinear with each other, so we want to adjust for that.
+
+{pmore}
+Note: changing the default option is rarely needed, except in benchmarks, and to obtain a marginal speed-up by excluding the {opt pair:wise} option.
+
+{pmore}
+{opt all} is the default and almost always the best alternative. It is equivalent to {opt dof(pairwise clusters continuous)}
+
+{pmore}
+{opt none} assumes no collinearity across the fixed effects (i.e. no redundant fixed effects). This is overtly conservative, although it is the faster method by virtue of not doing anything.
+
+{pmore}
+{opt first:pair} will exactly identify the number of collinear fixed effects across the first two sets of fixed effects
+(i.e. the first absvar and the second absvar).
+The algorithm used for this is described in Abowd et al (1999), and relies on results from graph theory
+(finding the number of connected sub-graphs in a bipartite graph).
+It will not do anything for the third and subsequent sets of fixed effects.
+
+{pmore}
+For more than two sets of fixed effects, there are no known results that provide exact degrees-of-freedom as in the case above.
+One solution is to ignore subsequent fixed effects (and thus oversestimate e(df_a) and understimate the degrees-of-freedom).
+Another solution, described below, applies the algorithm between pairs of fixed effects to obtain a better (but not exact) estimate:
+
+{pmore}
+{opt pair:wise} applies the aforementioned connected-subgraphs algorithm between pairs of fixed effects.
+For instance, if there are four sets of FEs, the first dimension will usually have no redundant coefficients (i.e. e(M1)==1), since we are running the model without a constant.
+For the second FE, the number of connected subgraphs with respect to the first FE will provide an exact estimate of the degrees-of-freedom lost, e(M2).
+
+{pmore}
+For the third FE, we do not know exactly.
+However, we can compute the number of connected subgraphs between the first and third {it:G(1,3)},
+and second and third {it:G(2,3)} fixed effects, and choose the higher of those as the closest estimate for e(M3).
+For the fourth FE, we compute {it:G(1,4)}, {it:G(2,4)} and {it:G(3,4)} and again choose the highest for e(M4).
+
+{pmore}
+Finally, we compute e(df_a) = e(K1) - e(M1) + e(K2) - e(M2) + e(K3) - e(M3) + e(K4) - e(M4);
+where e(K#) is the number of levels or dimensions for the #-th fixed effect (e.g. number of individuals or years).
+Note that e(M3) and e(M4) are only conservative estimates and thus we will usually be overestimating the standard errors. However, given the sizes of the datasets typically used with reghdfe, the difference should be small. 
+
+{pmore}
+Since the gain from {opt pair:wise} is usually {it:minuscule} for large datasets, and the computation is expensive, it may be a good practice to exclude this option for speedups.
+
+{pmore}
+{opt cl:usters}
+will check if a fixed effect is nested within a {it:clustervar}.
+In that case, it will set e(K#)==e(M#) and no degrees-of-freedom will be lost due to this fixed effect.
+The rationale is that we are already assuming that the number of effective observations is the number of cluster levels.
+This is the same adjustment that {cmd:xtreg, fe} does, but {cmd:areg} does not use it.
+
+{pmore}
+{opt cont:inuous}
+Fixed effects with continuous interactions (i.e. individual slopes, instead of individual intercepts) are dealt with differently.
+In an i.categorical#c.continuous interaction, we will do one check: we count the number of categories where c.continuous is always zero.
+In an i.categorical##c.continuous interaction, we do the above check but replace zero for any particular constant.
+In the case where continuous is constant for a level of categorical, we know it is collinear with the intercept, so we adjust for it.
+
+{pmore}
+Additional methods, such as {opt bootstrap} are also possible but not yet implemented.
+Some preliminary simulations done by the author showed a very poor convergence of this method.
+
+{phang}
+{opth groupv:ar(newvar)} name of the new variable that will contain the first mobility group.
+Requires {opt pair:wise}, {opt first:pair}, or the default {opt all}.
+
+{marker opt_speedup}{...}
+{dlgtab:Speeding Up Estimation}
+
+{phang}
+{opt nosample} avoids saving {it:e(sample)} into the regression.
+Since saving the variable only involves copying a Mata vector, the speedup is currently quite small.
+Future versions of reghdfe may change this as features are added.
+
+{pmore}
+Note that {opt nosample} will be disabled when adding variables to the dataset (i.e. when saving residuals, fixed effects, or mobility groups), and is incompatible with most postestimation commands.
+
+{pmore}
+If you wish to use {opt nosample} while reporting {cmd:estat summarize}, see the {opt summarize} option.
+
+{marker opt_optimization}{...}
+{dlgtab:Optimization}
+
+{phang}
+{opth tol:erance(#)} specifies the tolerance criterion for convergence; default is {cmd:tolerance(1e-8)}
+
+{pmore}
+Note that for tolerances beyond 1e-14, the limits of the {it:double} precision are reached and the results will most likely not converge.
+
+{pmore}
+At the other end, is not tight enough, the regression may not identify perfectly collinear regressors. However, those cases can be easily spotted due to their extremely high standard errors.
+
+{pmore}
+Warning: when absorbing heterogeneous slopes without the accompanying heterogeneous intercepts, convergence is quite poor and a tight tolerance is strongly suggested (i.e. higher than the default). In other words, an absvar of {it:var1##c.var2} converges easily, but an absvar of {it:var1#c.var2} will converge slowly and may require a tighter tolerance.
+
+{phang}
+{opth maxit:erations(#)}
+specifies the maximum number of iterations; the default is {cmd:maxiterations(10000)}; set it to missing ({cmd:.}) to run forever until convergence.
+
+{phang}
+{opth pool:size(#)}
+Number of variables that are {it:pooled together} into a matrix that will then be transformed.
+The default is to pool variables in groups of 5. Larger groups are faster with more than one processor, but may cause out-of-memory errors. In that case, set poolsize to 1.
+
+{phang}
+{it:Advanced options:}
+
+{phang}
+{opt acceleration(str)} allows for different acceleration techniques, from the simplest case of 
+no acceleration ({opt no:ne}), to steep descent ({opt st:eep_descent} or {opt sd}), Aitken ({opt a:itken}),
+and finally Conjugate Gradient ({opt co:njugate_gradient} or {opt cg}).
+
+{pmore}
+Note: Each acceleration is just a plug-in Mata function, so a larger number of acceleration techniques are available, albeit undocumented (and slower).
+
+{phang}
+{opt transf:orm(str)} allows for different "alternating projection" transforms. The classical transform is Kaczmarz ({opt kac:zmarz}), and more stable alternatives are Cimmino ({opt cim:mino}) and Symmetric Kaczmarz ({opt sym:metric_kaczmarz})
+
+{pmore}
+Note: Each transform is just a plug-in Mata function, so a larger number of acceleration techniques are available, albeit undocumented (and slower).
+
+{pmore}
+Note: The default acceleration is Conjugate Gradient and the default transform is Symmetric Kaczmarz. Be wary that different accelerations often work better with certain transforms. For instance, do not use conjugate gradient with plain Kaczmarz, as it will not converge.
+
+{phang}
+{opt precondition} {it:(currently disabled)}
+
+{marker opt_reporting}{...}
+{dlgtab:Reporting}
+
+{phang}
+{opt l:evel(#)} sets confidence level; default is {cmd:level(95)}
+
+{marker display_options}{...}
+{phang}
+{it:display_options}:
+{opt noomit:ted},
+{opt vsquish},
+{opt noempty:cells},
+{opt base:levels},
+{opt allbase:levels},
+{opt nofvlabel},
+{opt fvwrap(#)},
+{opt fvwrapon(style)},
+{opth cformat(%fmt)},
+{opt pformat(%fmt)},
+{opt sformat(%fmt)}, and
+{opt nolstretch};
+    see {helpb estimation options##display_options:[R] estimation options}.
+    {p_end}
+
+
+{marker postestimation}{...}
+{title:Postestimation Syntax}
+
+Only {cmd:estat summarize}, {cmd:predict} and {cmd:test} are currently supported and tested.
+
+{p 8 13 2}
+{cmd:estat summarize}
+{p_end}{col 23}Summarizes {it:depvar} and the variables described in {it:_b} (i.e. not the excluded instruments)
+
+{p 8 16 2}
+{cmd:predict} 
+{newvar} 
+{ifin}
+[{cmd:,} {it:statistic}]
+{p_end}{col 23}May require you to previously save the fixed effects (except for option {opt xb}).
+{col 23}To see how, see the details of the {help reghdfe##absvar:absorb} option
+{col 23}Equation: y = xb + d_absorbvars + e
+
+{synoptset 20 tabbed}{...}
+{synopthdr:statistic}
+{synoptline}
+{syntab :Main}
+{p2coldent: {opt xb}}xb fitted values; the default{p_end}
+{p2coldent: {opt xbd}}xb + d_absorbvars{p_end}
+{p2coldent: {opt d}}d_absorbvars{p_end}
+{p2coldent: {opt r:esiduals}}residual{p_end}
+{p2coldent: {opt sc:ore}}score; equivalent to {opt residuals}{p_end}
+{p2coldent: {opt stdp}}standard error of the prediction (of the xb component){p_end}
+{synoptline}
+{p2colreset}{...}
+{p 4 6 2}although {cmd:predict} {help data_types:type} {help newvar} is allowed,
+the resulting variable will always be of type {it:double}.{p_end}
+
+
+{col 8}{cmd:test}{col 23}Performs significance test on the parameters, see the {help test:stata help}
+
+{col 8}{cmd:suest}{col 23}Do not use {cmd:suest}. It will run, but the results will be incorrect. See workaround below
+
+{pmore}If you want to perform tests that are usually run with {cmd:suest},
+such as non-nested models, tests using alternative specifications of the variables,
+or tests on different groups, you can replicate it manually, as described 
+{browse "http://www.stata.com/statalist/archive/2009-11/msg01485.html":here}.
+{p_end}
+
+{marker remarks}{...}
+
+{title:Possible Pitfalls and Common Mistakes}
+
+{p2col 8 12 12 2: 1.}Ignore the constant; it doesn't tell you much. If you want to use descriptive stats, that's what the {opt sum:marize()} and {cmd:estat summ} commands are for.
+Even better, use {opt noconstant} to hide it{p_end}
+{p2col 8 12 12 2: 2.}Think twice before saving the fixed effects. They are probably inconsistent / not identified and you will likely be using them wrong.{p_end}
+{p2col 8 12 12 2: 3.}(note: as of version 3.0 singletons are dropped by default) It's good practice to drop singletons. {opt dropsi:ngleton} is your friend.{p_end}
+{p2col 8 12 12 2: 4.}If you use {opt vce(robust)}, be sure that your {it:other} dimension is not "fixed" but grows with N, or your SEs will be wrong.{p_end}
+{p2col 8 12 12 2: 5.}If you use {opt vce(cluster ...)}, check that your number of clusters is high enough (50+ is a rule of thumb). If not, you are making the SEs even worse!{p_end}
+{p2col 8 12 12 2: 6.}The panel variables (absvars) should probably be nested within the clusters (clustervars) due to the within-panel correlation induced by the FEs.
+(this is not the case for *all* the absvars, only those that are treated as growing as N grows){p_end}
+{p2col 8 12 12 2: 7.}If you run analytic or probability weights,
+you are responsible for ensuring that the weights stay
+constant within each unit of a fixed effect (e.g. individual),
+or that it is correct to allow varying-weights for that case.
+{p_end}
+{p2col 8 12 12 2: 8.}Be aware that adding several HDFEs is not a panacea.
+The first limitation is that it only uses within variation (more than acceptable if you have a large enough dataset).
+The second and subtler limitation occurs if the fixed effects are themselves outcomes of the variable of interest (as crazy as it sounds).
+For instance, imagine a regression where we study the effect of past corporate fraud on future firm performance.
+We add firm, CEO and time fixed-effects (standard practice). This introduces a serious flaw: whenever a fraud event is discovered,
+i) future firm performance will suffer, and ii) a CEO turnover will likely occur.
+Moreover, after fraud events, the new CEOs are usually specialized in dealing with the aftershocks of such events
+(and are usually accountants or lawyers).
+The fixed effects of these CEOs will also tend to be quite low, as they tend to manage firms with very risky outcomes.
+Therefore, the regressor (fraud) affects the fixed effect (identity of the incoming CEO).
+Adding particularly low CEO fixed effects will then overstate the performance of the firm,
+and thus {it:understate} the negative effects of fraud on future firm performance.{p_end}
+
+{title:Missing Features}
+
+{phang}(If you are interested in discussing these or others, feel free to {help reghdfe##contact:contact me})
+
+{phang}Code, medium term:
+
+{p2col 8 12 12 2: -}Complete GT preconditioning (v4){p_end}
+{p2col 8 12 12 2: -}Improve algorithm that recovers the fixed effects (v5){p_end}
+{p2col 8 12 12 2: -}Improve statistics and tests related to the fixed effects (v5){p_end}
+{p2col 8 12 12 2: -}Implement a -bootstrap- option in DoF estimation (v5){p_end}
+
+{phang}Code, long term:
+
+{p2col 8 12 12 2: -}The interaction with cont vars (i.a#c.b) may suffer from numerical accuracy issues, as we are dividing by a sum of squares{p_end}
+{p2col 8 12 12 2: -}Calculate exact DoF adjustment for 3+ HDFEs (note: not a problem with cluster VCE when one FE is nested within the cluster){p_end}
+{p2col 8 12 12 2: -}More postestimation commands (lincom? margins?){p_end}
+
+{phang}Theory:
+
+{p2col 8 12 12 2: -}Add a more thorough discussion on the possible identification issues{p_end}
+{p2col 8 12 12 2: -}Find out a way to use reghdfe iteratively with CUE
+(right now only OLS/2SLS/GMM2S/LIML give the exact same results){p_end}
+{p2col 8 12 12 2: -}Not sure if I should add an F-test for the absvars in the vce(robust) and vce(cluster) cases.
+Discussion on e.g. -areg- (methods and formulas) and textbooks suggests not;
+on the other hand, there may be alternatives:
+{it:{browse "http://www.socialsciences.manchester.ac.uk/disciplines/economics/research/discussionpapers/pdf/EDP-1124.pdf" :A Heteroskedasticity-Robust F-Test Statistic for Individual Effects}}{p_end}
+
+{marker examples}{...}
+{title:Examples}
+
+{hline}
+{pstd}Setup{p_end}
+{phang2}{cmd:. sysuse auto}{p_end}
+
+{pstd}Simple case - one fixed effect{p_end}
+{phang2}{cmd:. reghdfe price weight length, absorb(rep78)}{p_end}
+{hline}
+
+{pstd}As above, but also compute clustered standard errors{p_end}
+{phang2}{cmd:. reghdfe price weight length, absorb(rep78) vce(cluster rep78)}{p_end}
+{hline}
+
+{pstd}Two and three sets of fixed effects{p_end}
+{phang2}{cmd:. webuse nlswork}{p_end}
+{phang2}{cmd:. reghdfe ln_w grade age ttl_exp tenure not_smsa south , absorb(idcode year)}{p_end}
+{phang2}{cmd:. reghdfe ln_w grade age ttl_exp tenure not_smsa south , absorb(idcode year occ)}{p_end}
+{hline}
+
+{title:Advanced examples}
+
+{pstd}Save the FEs as variables{p_end}
+{phang2}{cmd:. reghdfe ln_w grade age ttl_exp tenure not_smsa south , absorb(FE1=idcode FE2=year)}{p_end}
+
+{pstd}Save first mobility group{p_end}
+{phang2}{cmd:. reghdfe ln_w grade age ttl_exp tenure not_smsa , absorb(idcode occ) groupv(mobility_occ)}{p_end}
+
+{pstd}Factor interactions in the independent variables{p_end}
+{phang2}{cmd:. reghdfe ln_w i.grade#i.age ttl_exp tenure not_smsa , absorb(idcode occ)}{p_end}
+
+{pstd}Interactions in the absorbed variables (notice that only the {it:#} symbol is allowed){p_end}
+{phang2}{cmd:. reghdfe ln_w grade age ttl_exp tenure not_smsa , absorb(idcode#occ)}{p_end}
+
+{pstd}Factorial interactions{p_end}
+{phang2}{cmd:. reghdfe price weight length, absorb(rep78 turn##c.price)}{p_end}
+
+{pstd}IV regression (this does NOT work anymore, please use the ivreghdfe package instead{p_end}
+{phang2}{cmd:. sysuse auto}{p_end}
+{phang2}{cmd:. ivreghdfe price weight (length=head), absorb(rep78)}{p_end}
+{phang2}{cmd:. ivreghdfe price weight (length=head), absorb(rep78, resid)}{p_end}
+
+
+{marker results}{...}
+{title:Stored results}
+
+{pstd}
+{cmd:reghdfe} stores the following in {cmd:e()}:
+
+{pstd}
+{it:Note: it also keeps most e() results placed by the regression subcommands (ivreg2, ivregress)}
+
+{synoptset 24 tabbed}{...}
+{syntab:Scalars}
+{synopt:{cmd:e(N)}}number of observations{p_end}
+{synopt:{cmd:e(num_singletons)}}number of singleton observations{p_end}
+{synopt:{cmd:e(N_full)}}number of observations including singletons{p_end}
+
+{synopt:{cmd:e(N_hdfe)}}number of absorbed fixed-effects{p_end}
+{synopt:{cmd:e(tss)}}total sum of squares{p_end}
+{synopt:{cmd:e(rss)}}residual sum of squares{p_end}
+{synopt:{cmd:e(r2)}}R-squared{p_end}
+{synopt:{cmd:e(r2_a)}}adjusted R-squared{p_end}
+{synopt:{cmd:e(r2_within)}}Within R-squared{p_end}
+{synopt:{cmd:e(r2_a_within)}}Adjusted Within R-squared{p_end}
+{synopt:{cmd:e(df_a)}}degrees of freedom lost due to the fixed effects{p_end}
+{synopt:{cmd:e(rmse)}}root mean squared error{p_end}
+{synopt:{cmd:e(ll)}}log-likelihood{p_end}
+{synopt:{cmd:e(ll_0)}}log-likelihood of fixed-effect-only regression{p_end}
+{synopt:{cmd:e(F)}}F statistic{p_end}
+{synopt:{cmd:e(F_absorb)}}F statistic for absorbed effect {it:note: currently disabled}{p_end}
+{synopt:{cmd:e(rank)}}rank of {cmd:e(V)}{p_end}
+{synopt:{cmd:e(N_clustervars)}}number of cluster variables{p_end}
+        
+{synopt:{cmd:e(clust}#{cmd:)}}number of clusters for the #th cluster variable{p_end}
+{synopt:{cmd:e(N_clust)}}number of clusters; minimum of {it:e(clust#)}{p_end}
+
+{synopt:{cmd:e(K}#{cmd:)}}Number of categories of the #th absorbed FE{p_end}
+{synopt:{cmd:e(M}#{cmd:)}}Number of redundant categories of the #th absorbed FE{p_end}
+{synopt:{cmd:e(mobility)}}Sum of all {cmd:e(M#)}{p_end}
+{synopt:{cmd:e(df_m)}}model degrees of freedom{p_end}
+{synopt:{cmd:e(df_r)}}residual degrees of freedom{p_end}
+
+{synopt:{cmd:e(report_constant)}}whether _cons was included in the regressions (default)
+or as part of the fixed effects{p_end}
+
+{synoptset 24 tabbed}{...}
+{syntab:Macros}
+{synopt:{cmd:e(cmd)}}{cmd:reghdfe}{p_end}
+{synopt:{cmd:e(subcmd)}}either {cmd:regress}, {cmd:ivreg2} or {cmd:ivregress}{p_end}
+{synopt:{cmd:e(model)}}{cmd:ols}, {cmd:iv}, {cmd:gmm2s}, {cmd:liml} or {cmd:cue}{p_end}
+{synopt:{cmd:e(cmdline)}}command as typed{p_end}
+{synopt:{cmd:e(dofmethod)}}dofmethod employed in the regression{p_end}
+{synopt:{cmd:e(depvar)}}name of dependent variable{p_end}
+{synopt:{cmd:e(indepvars)}}names of independent variables{p_end}
+{synopt:{cmd:e(absvars)}}name of the absorbed variables or interactions{p_end}
+{synopt:{cmd:e(title)}}title in estimation output{p_end}
+{synopt:{cmd:e(clustvar)}}name of cluster variable{p_end}
+{synopt:{cmd:e(clustvar}#{cmd:)}}name of the #th cluster variable{p_end}
+{synopt:{cmd:e(vce)}}{it:vcetype} specified in {cmd:vce()}{p_end}
+{synopt:{cmd:e(vcetype)}}title used to label Std. Err.{p_end}
+{synopt:{cmd:e(stage)}}stage within an IV-regression; only if {it:stages()} was used{p_end}
+{synopt:{cmd:e(properties)}}{cmd:b V}{p_end}
+
+{synoptset 24 tabbed}{...}
+{syntab:Matrices}
+{synopt:{cmd:e(b)}}coefficient vector{p_end}
+{synopt:{cmd:e(V)}}variance-covariance matrix of the estimators{p_end}
+
+{synoptset 24 tabbed}{...}
+{syntab:Functions}
+{synopt:{cmd:e(sample)}}marks estimation sample{p_end}
+{p2colreset}{...}
+
+{marker contact}{...}
+{title:Author}
+
+{pstd}Sergio Correia{break}
+Board of Governors of the Federal Reserve{break}
+Email: {browse "mailto:[email protected]":[email protected]}
+{p_end}
+
+{marker user_guide}{...}
+{title:User Guide}
+
+{pstd}
+A copy of this help file, as well as a more in-depth user guide is in development and will be available at {browse "http://scorreia.com/reghdfe"}.{p_end}
+
+{marker updates}{...}
+{title:Latest Updates}
+
+{pstd}
+{cmd:reghdfe} is updated frequently, and upgrades or minor bug fixes may not be immediately available in SSC.
+To check or contribute to the latest version of reghdfe, explore the
+{browse "https://github.com/sergiocorreia/reghdfe":Github repository}.
+Bugs or missing features can be discussed through email or at the {browse "https://github.com/sergiocorreia/reghdfe/issues":Github issue tracker}.{p_end}
+
+{pstd}
+To see your current version and installed dependencies, type {cmd:reghdfe, version}
+{p_end}
+
+{marker acknowledgements}{...}
+{title:Acknowledgements}
+
+{pstd}
+This package wouldn't have existed without the invaluable feedback and contributions of Paulo Guimaraes,  Amine Ouazad, Mark Schaffer and Kit Baum. Also invaluable are the great bug-spotting abilities of many users.{p_end}
+
+{pstd}In addition, {it:reghdfe} is build upon important contributions from the Stata community:{p_end}
+
+{phang}{browse "https://ideas.repec.org/c/boc/bocode/s457101.html":reg2hdfe}, from Paulo Guimaraes,
+and {browse "https://ideas.repec.org/c/boc/bocode/s456942.html":a2reg} from Amine Ouazad,
+ were the inspiration and building blocks on which reghdfe was built.{p_end}
+ 
+{phang}{browse "http://www.repec.org/bocode/i/ivreg2.html":ivreg2}, by Christopher F Baum, Mark E Schaffer and Steven Stillman, is the package used by default for instrumental-variable regression.{p_end}
+
+{phang}{browse "https://ideas.repec.org/c/boc/bocode/s457689.html":avar} by Christopher F Baum and Mark E Schaffer, is the package used for estimating the HAC-robust standard errors of ols regressions.{p_end}
+
+{phang}{browse "http://econpapers.repec.org/software/bocbocode/s456797.htm":tuples} by Joseph Lunchman and Nicholas Cox, is used when computing standard errors with multi-way clustering (two or more clustering variables).{p_end}
+
+{marker references}{...}
+{title:References}
+
+{p 0 0 2}
+The algorithm underlying reghdfe is a generalization of the works by:
+
+{phang}
+Paulo Guimaraes and Pedro Portugal. "A Simple Feasible Alternative Procedure to Estimate
+Models with High-Dimensional Fixed Effects".
+{it:Stata Journal, 10(4), 628-649, 2010.}
+{browse "http://www.stata-journal.com/article.html?article=st0212":[link]}
+{p_end}
+
+{phang}
+Simen Gaure. "OLS with Multiple High Dimensional Category Dummies".
+{it:Memorandum 14/2010, Oslo University, Department of Economics, 2010.}
+{browse "https://ideas.repec.org/p/hhs/osloec/2010_014.html":[link]}
+{p_end}
+
+{p 0 0 2}
+It addresses many of the limitation of previous works, such as possible lack of convergence, arbitrary slow convergence times,
+and being limited to only two or three sets of fixed effects (for the first paper).
+The paper explaining the specifics of the algorithm is a work-in-progress and available upon request.
+
+{p 0 0 0}
+If you use this program in your research, please cite either
+the {browse "https://ideas.repec.org/c/boc/bocode/s457874.html":REPEC entry}
+or the aforementioned papers.{p_end}
+
+{title:Additional References}
+
+{p 0 0 0}
+For details on the Aitken acceleration technique employed, please see "method 3" as described by:
+
+{phang}
+Macleod, Allan J. "Acceleration of vector sequences by multi-dimensional Delta-2 methods."
+{it:Communications in Applied Numerical Methods 2.4 (1986): 385-392.}
+{p_end}
+
+{p 0 0 0}
+For the rationale behind interacting fixed effects with continuous variables, see:
+
+{phang}
+Duflo, Esther. "The medium run effects of educational expansion: Evidence from a large school construction program in Indonesia."
+{it:Journal of Development Economics 74.1 (2004): 163-197.}{browse "http://www.sciencedirect.com/science/article/pii/S0304387803001846": [link]}
+{p_end}
+
+{p 0 0 0}
+Also see:
+
+{phang}Abowd, J. M., R. H. Creecy, and F. Kramarz 2002.
+Computing person and firm effects using linked longitudinal employer-employee data.
+{it:Census Bureau Technical Paper TP-2002-06.}
+{p_end}
+
+{phang}
+Cameron, A. Colin & Gelbach, Jonah B. & Miller, Douglas L., 2011.
+"Robust Inference With Multiway Clustering,"
+{it:Journal of Business & Economic Statistics, American Statistical Association, vol. 29(2), pages 238-249.}
+{p_end}
+
+{phang}
+Gormley, T. & Matsa, D. 2014.
+"Common errors: How to (and not to) control for unobserved heterogeneity."
+{it:The Review of Financial Studies, vol. 27(2), pages 617-661.}
+{p_end}
+
+{phang}
+Mittag, N. 2012.
+"New methods to estimate models with large sets of fixed effects with an application to matched employer-employee data from Germany."
+{it:{browse "http://doku.iab.de/fdz/reporte/2012/MR_01-12_EN.pdf":FDZ-Methodenreport 02/2012}.} 
+{p_end}

30/replication_package/Adofiles/reghdfe_2019/reghdfe_accelerations.mata

@@ -0,0 +1,323 @@
+mata:
+
+// --------------------------------------------------------------------------
+// Acceleration Schemes
+// --------------------------------------------------------------------------
+
+`Variables' function accelerate_test(`FixedEffects' S, `Variables' y, `FunctionP' T) {
+	`Integer'	iter, g
+	`Variables'		resid
+	`Factor' f
+	pragma unset resid
+
+	assert(S.converged == 0)
+
+	for (iter=1; iter<=S.maxiter; iter++) {
+		for (g=1; g<=S.G; g++) {
+			f = S.factors[g]
+			if (g==1) resid = y - panelmean(f.sort(y), f)[f.levels, .]
+			else resid = resid - panelmean(f.sort(resid), f)[f.levels, .]
+		}
+		if (check_convergence(S, iter, resid, y)) break
+		y = resid
+	}
+	return(resid)
+}
+
+// --------------------------------------------------------------------------
+
+`Variables' function accelerate_none(`FixedEffects' S, `Variables' y, `FunctionP' T) {
+	`Integer'	iter
+	`Variables'		resid
+	pragma unset resid
+
+	assert(S.converged == 0)
+
+	for (iter=1; iter<=S.maxiter; iter++) {
+		(*T)(S, y, resid) // Faster version of "resid = S.T(y)"
+		if (check_convergence(S, iter, resid, y)) break
+		y = resid
+	}
+	return(resid)
+}
+// --------------------------------------------------------------------------
+
+// Start w/out acceleration, then switch to CG
+`Variables' function accelerate_hybrid(`FixedEffects' S, `Variables' y, `FunctionP' T) {
+	`Integer' iter, accel_start
+	`Variables' resid
+	pragma unset resid
+
+	accel_start = 6
+	assert(S.converged == 0)
+
+	for (iter=1; iter<=accel_start; iter++) {
+		(*T)(S, y, resid) // Faster version of "resid = S.T(y)"
+		if (check_convergence(S, iter, resid, y)) break
+		y = resid
+	}
+
+	T = &transform_sym_kaczmarz() // Override
+
+	return(accelerate_cg(S, y, T))
+}
+
+// --------------------------------------------------------------------------
+// Memory cost is approx = 4*size(y) (actually 3 since y is already there)
+// But we need to add maybe 1 more due to u:*v
+// And I also need to check how much does project and T use..
+// Double check with a call to memory
+
+// For discussion on the stopping criteria, see the following presentation:
+// Arioli & Gratton, "Least-squares problems, normal equations, and stopping criteria for the conjugate gradient method". URL: https://www.stfc.ac.uk/SCD/resources/talks/Arioli-NAday2008.pdf
+
+// Basically, we will use the Hestenes and Stiefel rule
+
+`Variables' function accelerate_cg(`FixedEffects' S, `Variables' y, `FunctionP' T) {
+	// BUGBUG iterate the first 6? without acceleration??
+	`Integer'	iter, d, Q
+	`Variables'		r, u, v
+	`RowVector' alpha, beta, ssr, ssr_old, improvement_potential
+	`Matrix' recent_ssr
+	pragma unset r
+	pragma unset v
+
+	assert(S.converged == 0)
+	if (S.timeit) timer_on(70)
+	Q = cols(y)
+	
+	d = 1 // BUGBUG Set it to 2/3 // Number of recent SSR values to use for convergence criteria (lower=faster & riskier)
+	// A discussion on the stopping criteria used is described in
+	// http://scicomp.stackexchange.com/questions/582/stopping-criteria-for-iterative-linear-solvers-applied-to-nearly-singular-system/585#585
+
+	if (S.timeit) timer_on(73)
+	improvement_potential = weighted_quadcolsum(S, y, y)
+	recent_ssr = J(d, Q, .)
+	if (S.timeit) timer_off(73)
+	
+	if (S.timeit) timer_on(71)
+	(*T)(S, y, r, 1)
+	if (S.timeit) timer_off(71)
+	if (S.timeit) timer_on(73)
+	ssr = weighted_quadcolsum(S, r, r) // cross(r,r) when cols(y)==1 // BUGBUG maybe diag(quadcross()) is faster?
+	u = r
+	if (S.timeit) timer_off(73)
+
+	for (iter=1; iter<=S.maxiter; iter++) {
+		if (S.timeit) timer_on(71)
+		(*T)(S, u, v, 1) // This is the hottest loop in the entire program
+		if (S.timeit) timer_off(71)
+		if (S.timeit) timer_on(73)
+		alpha = safe_divide( ssr , weighted_quadcolsum(S, u, v) )
+		if (S.timeit) timer_off(73)
+		if (S.timeit) timer_on(74)
+		recent_ssr[1 + mod(iter-1, d), .] = alpha :* ssr
+		improvement_potential = improvement_potential - alpha :* ssr
+		y = y - alpha :* u
+		if (S.timeit) timer_off(74)
+		if (S.timeit) timer_on(75)
+		if (S.compute_rre & !S.prune) reghdfe_rre_benchmark(y[., 1], S.rre_true_residual, S.rre_depvar_norm)
+		r = r - alpha :* v
+		ssr_old = ssr
+		if (S.timeit) timer_off(75)
+		if (S.timeit) timer_on(73)
+		if (S.verbose>=5) r
+		ssr = weighted_quadcolsum(S, r, r)
+		beta = safe_divide( ssr , ssr_old) // Fletcher-Reeves formula, but it shouldn't matter in our problem
+		if (S.timeit) timer_off(73)
+		u = r + beta :* u
+		// Convergence if sum(recent_ssr) > tol^2 * improvement_potential
+		if (S.timeit) timer_on(76)
+		if ( check_convergence(S, iter, colsum(recent_ssr), improvement_potential, "hestenes") ) {
+			break
+			if (S.timeit) timer_off(76)
+		}
+		if (S.timeit) timer_off(76)
+	}
+	if (S.timeit) timer_off(70)
+	return(y)
+}
+
+// --------------------------------------------------------------------------
+
+`Variables' function accelerate_sd(`FixedEffects' S, `Variables' y, `FunctionP' T) {
+	`Integer'	iter, g
+	`Variables' proj
+	`RowVector' t
+	pragma unset proj
+
+	assert(S.converged == 0)
+
+	for (iter=1; iter<=S.maxiter; iter++) {
+		(*T)(S, y, proj, 1)
+		if (check_convergence(S, iter, y-proj, y)) break
+		t = safe_divide( weighted_quadcolsum(S, y, proj) , weighted_quadcolsum(S, proj, proj) )
+		if (uniform(1,1)<0.1) t = 1 // BUGBUG: Does this REALLY help to randomly unstuck an iteration?
+
+		y = y - t :* proj
+		if (S.compute_rre & !S.prune) reghdfe_rre_benchmark(y[., 1], S.rre_true_residual, S.rre_depvar_norm)
+
+		if (S.storing_alphas) {
+			for (g=1; g<=S.G; g++) {
+				//g, ., ., t
+				//asarray(S.factors[g].extra, "alphas"), asarray(S.factors[g].extra, "tmp_alphas")
+				if (S.save_fe[g]) {
+					asarray(S.factors[g].extra, "alphas",
+					    asarray(S.factors[g].extra, "alphas") +
+					    t :* asarray(S.factors[g].extra, "tmp_alphas")
+					)
+				}
+			}
+		}
+	}
+	return(y-proj)
+}
+
+// --------------------------------------------------------------------------
+// This is method 3 of Macleod (1986), a vector generalization of the Aitken-Steffensen method
+// Also: "when numerically computing the sequence.. stop..  when rounding errors become too 
+// important in the denominator, where the ^2 operation may cancel too many significant digits"
+// Note: Sometimes the iteration gets "stuck"; can we unstuck it with adding randomness
+// in the accelerate decision? There should be a better way.. (maybe symmetric kacz instead of standard one?)
+
+`Variables' function accelerate_aitken(`FixedEffects' S, `Variables' y, `FunctionP' T) {
+	`Integer'	iter
+	`Variables'		resid, y_old, delta_sq
+	`Boolean'	accelerate
+	`RowVector' t
+	pragma unset resid
+
+	assert(S.converged == 0)
+	y_old = J(rows(y), cols(y), .)
+
+	for (iter=1; iter<=S.maxiter; iter++) {
+		
+		(*T)(S, y, resid)
+		accelerate = iter>=S.accel_start & !mod(iter,S.accel_freq)
+
+		// Accelerate
+		if (accelerate) {
+			delta_sq = resid - 2 * y + y_old // = (resid - y) - (y - y_old) // Equivalent to D2.resid
+			// t is just (d'd2) / (d2'd2)
+			t = safe_divide( weighted_quadcolsum(S,  (resid - y) , delta_sq) ,  weighted_quadcolsum(S, delta_sq , delta_sq) )
+			resid = resid - t :*  (resid - y)
+		}
+
+
+		// Only check converge on non-accelerated iterations
+		// BUGBUG: Do we need to disable the check when accelerating?
+		// if (check_convergence(S, iter, accelerate? resid :* .  : resid, y)) break
+		if (S.compute_rre & !S.prune) reghdfe_rre_benchmark(resid[., 1], S.rre_true_residual, S.rre_depvar_norm)
+		if (check_convergence(S, iter, resid, y)) break
+		y_old = y // y_old is resid[iter-2]
+		y = resid // y is resid[iter-1]
+	}
+	return(resid)
+}
+
+// --------------------------------------------------------------------------
+
+`Boolean' check_convergence(`FixedEffects' S, `Integer' iter, `Variables' y_new, `Variables' y_old,| `String' method) {
+	`Boolean'	is_last_iter
+	`Real'		update_error
+	`Real'		eps_threshold
+
+	// max() ensures that the result when bunching vars is at least as good as when not bunching
+	if (args()<5) method = "vectors"
+
+	if (S.G==1 & !S.storing_alphas) {
+		// Shortcut for trivial case (1 FE)
+		update_error = 0
+	}
+	else if (method=="vectors") {
+		update_error = max(mean(reldif(y_new, y_old), S.weight))
+	}
+	else if (method=="hestenes") {
+		// If the regressor is perfectly explained by the absvars, we can have SSR very close to zero but negative
+		// (so sqrt is missing)
+
+		eps_threshold = 1e-15 // 10 * epsilon(1) ; perhaps too aggressive and should be 1e-14 ?
+		if (S.verbose > 0 & all(y_new :< eps_threshold)) {
+			printf("{txt} note: eps. is very close to zero (%g), so hestenes assumed convergence to avoid numerical precision errors\n", min(y_new))
+		}
+		update_error = safe_divide(edittozerotol(y_new, eps_threshold ),
+		                           editmissing(y_old, epsilon(1)),
+		                           epsilon(1) )
+		update_error = sqrt(max(update_error))
+	}
+	else {
+		exit(error(100))
+	}
+
+	assert_msg(!missing(update_error), "update error is missing")
+
+	S.converged = S.converged + (update_error <= S.tolerance)
+	is_last_iter = iter==S.maxiter
+	
+	if (S.converged >= S.min_ok) {
+		S.iteration_count = max((iter, S.iteration_count))
+		S.accuracy = max((S.accuracy, update_error))
+		if (S.verbose==1) printf("{txt}   converged in %g iterations (last error =%3.1e)\n", iter, update_error)
+		if (S.verbose>1) printf("\n{txt}   - Converged in %g iterations (last error =%3.1e)\n", iter, update_error)
+	}
+	else if (is_last_iter & S.abort) {
+		printf("\n{err}convergence not achieved in %g iterations (last error=%e); try increasing maxiter() or decreasing tol().\n", S.maxiter, update_error)
+		exit(430)
+	}
+	else {
+		if ((S.verbose>=2 & S.verbose<=3 & mod(iter,1)==0) | (S.verbose==1 & mod(iter,1)==0)) {
+			printf("{res}.{txt}")
+			displayflush()
+		}
+		if ( (S.verbose>=2 & S.verbose<=3 & mod(iter,100)==0) | (S.verbose==1 & mod(iter,100)==0) ) {
+			printf("{txt}%9.1f\n      ", update_error/S.tolerance)
+		}
+
+		if (S.verbose==4 & method!="hestenes") printf("{txt} iter={res}%4.0f{txt}\tupdate_error={res}%-9.6e\n", iter, update_error)
+		if (S.verbose==4 & method=="hestenes") printf("{txt} iter={res}%4.0f{txt}\tupdate_error={res}%-9.6e  {txt}norm(ssr)={res}%g\n", iter, update_error, norm(y_new))
+		
+		if (S.verbose>=5) {
+			printf("\n{txt} iter={res}%4.0f{txt}\tupdate_error={res}%-9.6e{txt}\tmethod={res}%s\n", iter, update_error, method)
+			"old:"
+			y_old
+			"new:"
+			y_new
+		}
+	}
+	return(S.converged >= S.min_ok)
+}
+
+// --------------------------------------------------------------------------
+
+`Matrix' weighted_quadcolsum(`FixedEffects' S, `Matrix' x, `Matrix' y) {
+	// BUGBUG: override S.has_weights with pruning
+	// One approach is faster for thin matrices
+	// We are using cross instead of quadcross but it should not matter for this use
+	if (S.has_weights) {
+		if (cols(x) < 14) {
+			return(quadcross(x :* y, S.weight)')
+		}
+		else {
+			return(diagonal(quadcross(x, S.weight, y))')
+		}
+	}
+	else {
+		if (cols(x) < 25) {
+			return(diagonal(quadcross(x, y))')
+		}
+		else {
+			return(colsum(x :* y))
+		}
+	}
+}
+
+
+// RRE benchmarking
+//	|| yk - y || / || y || === || ek - e || / || y ||
+`Real' reghdfe_rre_benchmark(`Vector' resid, `Vector' true_resid, `Real' norm_y) {
+	`Real' ans
+	ans = norm(resid - true_resid) / norm_y
+	return(ans)
+}
+
+end

30/replication_package/Adofiles/reghdfe_2019/reghdfe_bipartite.mata

@@ -0,0 +1,546 @@
+// Bipartite Graphs ---------------------------------------------------------
+// - For simplicity, assume the graph represent (firm, ceo) pairs
+// - TODO: Check when we don't need all these objects anymore and clean them up!
+
+mata:
+
+class BipartiteGraph
+{
+	// Computed by init()
+	`Boolean'				verbose
+	`Integer'				N		// Num. obs
+	`Integer'				N1		// Num. levels of FE 1
+	`Integer'				N2		// Num. levels of FE 2
+	`Integer'				N12		// N1 + N2
+	`FactorPointer'			PF1
+	`FactorPointer'			PF2
+	`Factor'				F12
+	`Factor'				F12_1
+	`Factor'				F12_2
+
+	// Computed by init_zigzag()
+	`Vector' 				queue
+	`Vector' 				stack
+	`Vector' 				keys1_by_2
+	`Vector' 				keys2_by_1
+	`Integer'				num_subgraphs
+	`Variable'				subgraph_id		// (optional)
+
+	// Computed by compute_cores()
+	`Vector' 				cores
+	`Vector' 				drop_order
+
+	// Computed after prune_1core()
+	`Integer'               N_drop
+	`Variable'              mask            // mask (0|1) of obs that are dropped after prunning of degree-1 edges
+	`Boolean'               prune           // Whether to recursively prune degree-1 edges
+	`Vector'                drop2idx
+	`Matrix'                drop2info
+	`Variable'              sorted_w
+	`Boolean'				has_weights
+	`Variable'              sorted_true_weight
+
+
+	// Methods
+	`Void'					init()
+	`Real'					init_zigzag()
+	`Void'					compute_cores()
+	`Void'					prune_1core()
+	`Variables'				expand_1core()
+	`Variables'				partial_out()
+	`Variables'				__partial_out_map()
+	`Variables'				__partial_out_laplacian()
+}
+
+
+`Void' BipartiteGraph::init(`FactorPointer' PF1,
+                            `FactorPointer' PF2,
+                            `Boolean' verbose)
+{
+	if (verbose) {
+		printf("\n{txt}## Initializing bipartite graph\n\n")
+		printf("    - FE #1: {res}%s{txt}\n", invtokens((*PF1).varlist))
+		printf("    - FE #2: {res}%s{txt}\n", invtokens((*PF2).varlist))
+	}
+	this.verbose = verbose
+	this.PF1 = PF1
+	this.PF2 = PF2
+
+	N = (*PF1).num_obs
+	N1 = (*PF1).num_levels
+	N2 = (*PF2).num_levels
+	N12 = N1 + N2
+	(*PF1).panelsetup() // Just in case
+	(*PF2).panelsetup() // Just in case
+
+	// F12 must be created from F1.levels and F2.levels (not from the original keys)
+	// This is set automatically by join_factors() with the correct flag:
+	//			F12 = join_factors(F1, F2, ., ., 1)
+	// But you can also run (slower)
+	//			F12 = _factor( (F1.levels, F2.levels) )
+	//			asarray(F12.extra, "levels_as_keys", 1)
+	if (verbose) printf("{txt}   - computing F12:  ")
+	// join_factors(F1, (*PF2) [, count_levels, save_keys, levels_as_keys])
+	F12 = join_factors((*PF1), (*PF2), ., ., 1)
+	if (verbose) printf("{txt} edges found: {res}%-10.0gc{txt}\n", F12.num_levels)
+	F12.panelsetup()
+	
+	if (verbose) printf("{txt}   - computing F12_1:")
+	// _factor(data [, integers_only, verbose, method, sort_levels, count_levels, hash_ratio, save_keys])
+	F12_1 = _factor(F12.keys[., 1], 1, 0, "", 1, 1, ., 0)
+	if (verbose) printf("{txt} edges found: {res}%-10.0gc{txt}\n", F12_1.num_levels)
+	F12_1.panelsetup()
+	
+	if (verbose) printf("{txt}   - computing F12_2:")
+	F12_2 = _factor(F12.keys[., 2], 1, 0, "", 1, 1, ., 0)
+	if (verbose) printf("{txt} edges found: {res}%-10.0gc{txt}\n", F12_2.num_levels)
+	F12_2.panelsetup()
+}
+
+
+// --------------------------------------------------------------------------
+// init_zigzag()
+// --------------------------------------------------------------------------
+//   Construct -queue- and -stack- vectors that allow zigzag iteration
+//   
+//   queue: firm and CEOs that will be processed, in the required order
+//   	   note: negative values indicate CEOs
+//   
+//   stack: for each firm/CEO, the list of nodes it connects to
+//          note: stacks are zero-separated
+//   
+// --------------------------------------------------------------------------
+//   As a byproduct, also computes the number of disjoint subgraphs.
+//   See the algorithm from on Abowd, Creecy and Kramarz (WP 2002) p4. Sketch:
+//
+//   		g = 0
+//   		While there are firms w/out a group:
+//   		     g++
+//   		     Assign the first firm w/out a group to group g
+//   		     Repeat until no further changes:
+//   		         Add all persons employed by a firm in g to g
+//   		         Add all firms that employ persons in g to g
+//   		 return(g)
+// --------------------------------------------------------------------------
+// --------------------------------------------------------------------------
+`Real' BipartiteGraph::init_zigzag(| `Boolean' save_subgraphs)
+{
+	`Vector'				counter1
+	`Vector'				counter2
+	`Vector' 				done1
+	`Vector' 				done2
+
+	`Integer'				i_stack		// use to process the queue
+	`Integer'				last_i		// use to fill out the queue
+	`Integer'				start_j		// use to search for firms to start graph enumeration
+	`Integer'				i_queue
+	`Integer'				id 			// firm number if id>0; error if id=0; ceo number if id<0
+	`Integer'				j 			// firm # (or viceversa)
+	`Integer'				k 			// ceo # (or viceversa)
+	`Integer'				c 			// temporary counter
+	`Integer'				i 			// temporary iterator
+	
+	`Matrix'				matches // list of CEOs that matched with firm j (or viceversa)
+
+	if (verbose) printf("\n{txt}## Initializing zigzag iterator for bipartite graph\n\n")
+	assert(F12_1.panel_is_setup)
+	assert(F12_2.panel_is_setup)
+	assert(asarray(F12.extra, "levels_as_keys") == 1)
+
+	// If subgraph_id (mobility groups) is anything BUT zero, we will save them
+	if (args()==0 | save_subgraphs==.) save_subgraphs = 0
+	if (save_subgraphs) {
+		subgraph_id = J(N2, 1, .)
+	}
+
+	queue = J(N12, 1, 0)
+	stack = J(F12.num_levels + N12, 1, .) // there are N12 zeros
+	counter1 = J(N1, 1, 0)
+	counter2 = J(N2, 1, 0)
+
+	keys1_by_2 = F12_2.sort(F12.keys[., 1])
+	keys2_by_1 = F12_1.sort(F12.keys[., 2])
+	done1 = J(N1, 1, 0) // if a firm is already on the queue
+	done2 = J(N2, 1, 0) // if a CEO is already on the queue
+
+	// Use -j- for only for firms and -k- only for CEOs
+	// Use -i_queue- to iterate over the queue and -i_stack- over the stack
+	// Use -last_i- to fill out the queue (so its the last filled value)
+	// Use -i- to iterate arbitrary vectors
+	// Use -id- to indicate a possible j or k (negative for k)
+	// Use -start_j- to remember where to start searching for new subgraphs
+
+	i_stack = 0
+	last_i = 0
+	start_j = 1
+	num_subgraphs = 0
+
+	for (i_queue=1; i_queue<=N12; i_queue++) {
+		id = queue[i_queue] // >0 if firm ; <0 if CEO; ==0 if nothing yet
+		j = k = . // just to avoid bugs
+		
+		// Pick starting point (useful if the graph is disjoint!)
+		if (id == 0) {
+			assert(last_i + 1 == i_queue)
+			for (j=start_j; j<=N1; j++) {
+				if (!done1[j]) {
+					queue[i_queue] = id = j
+					start_j = j + 1
+					++last_i
+					break
+				}
+			}
+			// printf("{txt} - starting subgraph with firm %g\n", j)
+			++num_subgraphs
+			assert(id != 0) // Sanity check
+		}
+
+		if (id > 0) {
+			// It's a firm
+			j = id
+			done1[j] = 1
+			matches = panelsubmatrix(keys2_by_1, j, F12_1.info)
+			for (i=1; i<=rows(matches); i++) {
+				k = matches[i]
+				c = counter2[k]
+				counter2[k] = c + 1
+				if (!done2[k]) {
+					if (!c) {
+						queue[++last_i] = -k
+					}
+				 	stack[++i_stack] = k
+				}
+			}
+			stack[++i_stack] = 0
+		}
+		else {
+			// It's a CEO
+			k = -id
+			done2[k] = 1
+			matches = panelsubmatrix(keys1_by_2, k, F12_2.info)
+			for (i=1; i<=rows(matches); i++) {
+				j = matches[i]
+				c = counter1[j]
+				counter1[j] = c + 1
+				if (!done1[j]) {
+					if (!c) {
+						queue[++last_i] = j
+					}
+					stack[++i_stack] = j
+				}
+			}
+			stack[++i_stack] = 0
+			if (save_subgraphs) subgraph_id[k] = num_subgraphs
+		}
+	}
+
+	// Sanity checks
+	assert(counter1 == F12_1.counts)
+	assert(counter2 == F12_2.counts)
+	assert(!anyof(queue, 0)) // queue can't have zeros at the end
+	assert(allof(done1, 1))
+	assert(allof(done2, 1))
+	assert(!missing(queue))
+	assert(!missing(stack))
+
+	if (save_subgraphs) subgraph_id = subgraph_id[(*PF2).levels]
+	
+	if (verbose) printf("{txt}   - disjoint subgraphs found: {res}%g{txt}\n", num_subgraphs)
+	return(num_subgraphs)
+}
+
+
+// --------------------------------------------------------------------------
+// compute_cores()
+// --------------------------------------------------------------------------
+// 	  Computes vertex core numbers, which allows k-core pruning
+//	  Algorithm used is listed here: https://arxiv.org/abs/cs/0310049
+// --------------------------------------------------------------------------
+// Note:
+//    maybe use the k-cores for something useful? eg:
+//    we might want to weight the core numbers by the strength (# of obs together)
+//    https://arxiv.org/pdf/1611.02756.pdf --> # of butterflies in bipartite graph
+//    this paper also has useful data sources for benchmarks
+//    # of primary and secondary vertices, edges
+// --------------------------------------------------------------------------
+
+`Void' BipartiteGraph::compute_cores()
+{
+	`Factor'				Fbin
+	`Boolean'				is_firm
+	`Integer'				M, ND, j, jj
+	`Integer'				i_v, i_u, i_w
+	`Integer'				pv, pu, pw
+	`Integer'				v, u, w
+	`Integer'				dv, du
+	`Vector'				bin, deg, pos, invpos, vert, neighbors
+
+	if (verbose) printf("\n{txt}## Computing vertex core numbers\n\n")
+
+	// v, u, w are vertices; <0 for CEOs and >0 for firms
+	// vert is sorted by degree; deg is unsorted
+	// pos[i] goes from sorted to unsorted, so:
+	// 		vert[i] === original_vert[ pos[i] ]
+	// invpos goes from unsorted to sorted, so:
+	//		vert[invpos[j]] === original_vert[j]
+
+	// i_u represents the pos. of u in the sorted tables
+	// pu represents the pos. of u in the unsorted/original tables
+
+	assert(F12_1.panel_is_setup==1)
+	assert(F12_2.panel_is_setup==1)
+	assert(rows(queue)==N12)
+	assert(rows(keys1_by_2)==F12.num_levels)
+	assert(rows(keys2_by_1)==F12.num_levels)
+
+	deg = F12_1.counts \ F12_2.counts
+	ND = max(deg) // number of degrees
+
+	Fbin = _factor(deg, 1, 0)
+	Fbin.panelsetup()
+
+	bin = J(ND, 1, 0)
+	bin[Fbin.keys] = Fbin.counts
+	bin = rows(bin) > 1 ? runningsum(1 \ bin[1..ND-1]) : 1
+	
+	pos = Fbin.p
+	invpos = invorder(Fbin.p)
+
+	vert = Fbin.sort(( (1::N1) \ (-1::-N2) ))
+
+	for (i_v=1; i_v<=N12; i_v++) {
+		v = vert[i_v]
+		is_firm = (v > 0)
+
+		neighbors = is_firm ? panelsubmatrix(keys2_by_1, v, F12_1.info) : panelsubmatrix(keys1_by_2, -v, F12_2.info)
+		M = rows(neighbors)
+		
+		for (j=1; j<=M; j++) {	
+			pv = pos[i_v]
+			jj = neighbors[j]
+			pu = is_firm ? N1 + jj : jj // is_firm is *not* for the neighbor
+			dv = deg[pv]
+			du = deg[pu]
+		
+			if (dv < du) {
+				i_w = bin[du]
+				w = vert[i_w]
+				u = is_firm ? -jj : jj // is_firm is *not* for the neighbor
+				if (u != w) {
+					pw = pos[i_w]
+					i_u = invpos[pu]
+					pos[i_u] = pw
+					pos[i_w] = pu
+					vert[i_u] = w
+					vert[i_w] = u
+					invpos[pu] = i_w
+					invpos[pw] = i_u
+				}
+				bin[du] = bin[du] + 1
+				deg[pu] = deg[pu] - 1
+			}
+		} // end for neighbor u (u ~ v)
+	} // end for each node v
+	
+	if (verbose) {
+		//printf("{txt}      Table: core numbers and vertex count\n")
+		Fbin = _factor(deg, 1, 0)
+		//printf("\n")
+		mm_matlist(Fbin.counts, "%-8.0gc", 2, strofreal(Fbin.keys), "Freq.", "Core #")
+		printf("\n")
+	}
+
+	// ((F1.keys \ F2.keys), (F12_1.keys \ -F12_2.keys))[selectindex(deg:==1), .]		
+	
+	// Store the values in the class
+	swap(drop_order, vert)
+	swap(cores, deg)
+}
+
+// --------------------------------------------------------------------------
+// prune_1core()
+// --------------------------------------------------------------------------
+//    Prune edges with degree-1
+//    That is, recursively remove CEOs that only worked at one firm,
+//    and firms that only had one CEO in the sample, until every agent
+//    in the dataset has at least two matches
+// --------------------------------------------------------------------------
+`Void' BipartiteGraph::prune_1core(| `Variable' weight)
+{
+	`Integer'               N_drop2, i, j, i1, i2, j1, j2, K_drop2
+	`Vector'                drop1, drop2
+	`Vector'                tmp_mask
+	`Vector'                proj1, proj2
+	`Variable'              w, tmp_weight
+
+	has_weights = (args()>0 & rows(weight) > 1)
+	if (has_weights) sorted_true_weight = (*PF1).sort(weight)
+	tmp_weight = has_weights ? weight : J(N, 1, 1)
+
+	N_drop = sum(cores :== 1)
+	if (!N_drop) {
+	    if (verbose) printf("{txt}   - no 1-core vertices found\n")
+	    prune = 0
+	    return
+	}
+	if (verbose) printf("{txt}   - 1-core vertices found: {res}%g{txt}\n", N_drop)
+
+	drop_order = drop_order[1..N_drop]
+	drop1 = `selectindex'(cores[1..N1] :== 1)
+	cores = .
+	drop1 = (1::N1)[drop1]
+	drop2 = -select(drop_order, drop_order:<0)
+	
+	K_drop2 = rows(drop2)
+	N_drop2 = K_drop2 ? sum((*PF2).info[drop2, 2] :- (*PF2).info[drop2, 1] :+ 1) : 0
+
+	tmp_mask = J(N1, 1, 0)
+	if (rows(drop1)) tmp_mask[drop1] = J(rows(drop1), 1, 1)
+	mask = tmp_mask[(*PF1).levels, 1]
+	tmp_mask = J(N2, 1, 0)
+	if (K_drop2) tmp_mask[drop2] = J(K_drop2, 1, 1)
+	mask = mask :| tmp_mask[(*PF2).levels, 1]
+	tmp_mask = .
+
+	drop2idx = J(N_drop2, 1, .)
+	drop2info = J(N2, 2, .)
+
+	j1 = 1
+	for (i=1; i<=K_drop2; i++) {
+	    j = drop2[i]
+	    i1 = (*PF2).info[j, 1]
+	    i2 = (*PF2).info[j, 2]
+
+	    j2 = j1 + i2 - i1
+	    drop2idx[j1::j2] = i1::i2
+	    drop2info[j, .] = (j1, j2)
+	    j1 = j2 + 1
+	}
+
+	if (!(*PF2).is_sorted) {
+	    assert(((*PF2).p != J(0, 1, .)))
+	    drop2idx = (*PF2).p[drop2idx, .]
+	}
+
+	if (!(*PF1).is_sorted) {
+	    assert(((*PF1).inv_p != J(0, 1, .)))
+	    drop2idx = invorder((*PF1).p)[drop2idx, .]
+	}
+
+	// To undo pruning, I need (*PF1).info[drop1, .] & drop2info & drop2idx
+
+	// Set weights of pruned obs. to zero
+	tmp_weight[`selectindex'(mask)] = J(sum(mask), 1, 0)
+
+	// Update sorted weights for g=1,2
+	w = (*PF1).sort(tmp_weight)
+	asarray((*PF1).extra, "has_weights", 1)
+	asarray((*PF1).extra, "weights", w)
+	asarray((*PF1).extra, "weighted_counts", `panelsum'(w, (*PF1).info))
+	w = .
+
+	w = (*PF2).sort(tmp_weight)
+	tmp_weight = . // cleanup
+	asarray((*PF2).extra, "has_weights", 1)
+	asarray((*PF2).extra, "weights", w)
+	asarray((*PF2).extra, "weighted_counts", `panelsum'(w, (*PF2).info))
+	w = .
+	
+	// Select obs where both FEs are degree-1 (and thus omitted)
+	sorted_w = J(N, 1, 1)
+	
+	proj1 = panelmean((*PF1).sort(sorted_w), *PF1)[(*PF1).levels, .]
+	proj2 = panelmean((*PF2).sort(sorted_w), *PF2)[(*PF2).levels, .]
+	sorted_w = ((sorted_w - proj1) :!= 1) :| ((sorted_w - proj2) :!= 1)
+	proj1 = proj2 = .
+	sorted_w = (*PF1).sort(sorted_w)
+
+	prune = 1
+}
+
+// --------------------------------------------------------------------------
+// prune_1core()
+// --------------------------------------------------------------------------
+//    Prune edges with degree-1
+//    That is, recursively remove CEOs that only worked at one firm,
+//    and firms that only had one CEO in the sample, until every agent
+//    in the dataset has at least two matches
+// --------------------------------------------------------------------------
+`Variables' BipartiteGraph::expand_1core(`Variables' y)
+{
+    `Boolean'               zero_weights
+    `Variable'              sorted_y
+    `Integer'               i, j, j1, j2, i2, k1, k2, nk
+    `Matrix'                tmp_y
+    `Vector'                tmp_w, tmp_idx, new_w
+    `RowVector'             tmp_mean
+
+    if (prune==0) return(y)
+    if (verbose) printf("\n{txt}## Expanding 2-core into original dataset\n\n")
+    assert(N_drop == rows(drop_order))
+
+    sorted_y = (*PF1).sort(y)
+
+    i2 = 0
+    for (i=N_drop; i>=1; i--) {
+        j = drop_order[i]
+        if (j > 0) {
+            j1 = (*PF1).info[j, 1]
+            j2 = (*PF1).info[j, 2]
+
+            tmp_y = sorted_y[| j1 , 1 \ j2 , . |] // panelsubmatrix(sorted_y, j, (*PF1).info)
+            tmp_w = sorted_w[|j1, 1 \ j2, .|] // panelsubmatrix(sorted_w, j, (*PF1).info)
+            new_w = has_weights ? sorted_true_weight[|j1, 1 \ j2, .|] : J(j2-j1+1, 1, 1)
+            zero_weights = !sum(tmp_w)
+            if (!zero_weights) {
+                tmp_mean = mean(tmp_y, tmp_w)
+                assert(!missing(tmp_mean)) // bugbug remove later
+                sorted_y[| j1 , 1 \ j2 , . |] = tmp_y :- tmp_mean
+            }
+            sorted_w[| j1 , 1 \ j2 , 1 |] = new_w
+        }
+        else {
+            ++i2
+            j1 = drop2info[-j, 1]
+            j2 = drop2info[-j, 2]
+            tmp_idx = drop2idx[| j1 , 1 \ j2 , 1 |]
+            tmp_y = sorted_y[tmp_idx, .]
+            tmp_w = sorted_w[tmp_idx]
+            zero_weights = !sum(tmp_w)
+            if (zero_weights) {
+                tmp_w = has_weights ? sorted_true_weight[tmp_idx] : J(j2-j1+1, 1, 1)
+            }
+            tmp_mean = mean(tmp_y, tmp_w)
+            assert(!missing(tmp_mean)) // bugbug remove later
+            nk = rows(tmp_idx)
+            for (k1=1; k1<=nk; k1++) {
+               k2 = tmp_idx[k1]
+               sorted_y[k2, .] = sorted_y[k2, .] - tmp_mean
+               sorted_w[k2] = has_weights ? sorted_true_weight[k2] : 1
+            }
+        }
+    }
+
+    if (verbose) printf("{txt}   - number of coefficients solved triangularly: {res}%s{txt}\n", strofreal(rows(drop_order)))
+    return((*PF1).invsort(sorted_y))
+}
+
+
+`Variables' BipartiteGraph::partial_out(`Variables' y)
+{
+
+}
+
+
+`Variables' BipartiteGraph::__partial_out_map(`Variables' y)
+{
+
+}
+
+
+`Variables' BipartiteGraph::__partial_out_laplacian(`Variables' y)
+{
+
+}
+
+end

30/replication_package/Adofiles/reghdfe_2019/reghdfe_class.mata

@@ -0,0 +1,1384 @@
+// --------------------------------------------------------------------------
+// FixedEffects main class
+// --------------------------------------------------------------------------
+
+mata:
+
+class FixedEffects
+{
+	// Factors
+	`Integer'               G                   // Number of sets of FEs
+	`Integer'               N                   // number of obs
+	`Integer'               M                   // Sum of all possible FE coefs
+	`Factors'               factors
+	`Vector'                sample
+	`Varlist'               absvars
+	`Varlist'               ivars
+	`Varlist'               cvars
+	`Boolean'               has_intercept
+	`RowVector'             intercepts
+	`RowVector'             num_slopes
+	`Integer'               num_singletons
+	`Boolean'               save_any_fe
+	`Boolean'               save_all_fe
+	`Varlist'               targets
+	`RowVector'             save_fe
+
+	// Constant-related (also see -has_intercept-)
+	`Boolean'               report_constant
+	`Boolean'               compute_constant
+
+	// Optimization options
+	`Real'                  tolerance
+	`Real'                  extra_tolerance		// Try to achieve this tol if it only takes a few more iters: ceil(10%)
+	`Integer'               maxiter
+	`String'                transform           // Kaczmarz Cimmino Symmetric_kaczmarz (k c s)
+	`String'                acceleration        // Acceleration method. None/No/Empty is none\
+	`Integer'               accel_start         // Iteration where we start to accelerate // set it at 6? 2?3?
+	`string'                slope_method
+	`Boolean'               prune               // Whether to recursively prune degree-1 edges
+	`Boolean'               abort               // Raise error if convergence failed?
+	`Integer'               accel_freq          // Specific to Aitken's acceleration
+	`Boolean'               storing_alphas      // 1 if we should compute the alphas/fes
+	`Real'                  conlim              // specific to LSMR
+	`Real'                  btol                // specific to LSMR
+	`Boolean'				always_run_lsmr_preconditioner
+	`Integer'				min_ok
+
+	// Optimization objects
+	`BipartiteGraph'        bg                  // Used when pruning 1-core vertices
+	`Vector'                pruned_weight       // temp. weight for the factors that were pruned
+	`Integer'               prune_g1            // Factor 1/2 in the bipartite subgraph that gets pruned
+	`Integer'               prune_g2            // Factor 2/2 in the bipartite subgraph that gets pruned
+	`Integer'               num_pruned          // Number of vertices (levels) that were pruned
+
+	// Misc
+	`Integer'               verbose
+	`Boolean'               timeit
+	`Boolean'               compact
+	`Integer'               poolsize
+	`Boolean'               store_sample
+	`Real'                  finite_condition
+	`Real'                  compute_rre         // Relative residual error: || e_k - e || / || e ||
+	`Real'                  rre_depvar_norm
+	`Vector'                rre_varname
+	`Vector'                rre_true_residual
+	`String'                panelvar
+	`String'                timevar
+
+	`RowVector'             not_basevar         // Boolean vector indicating whether each regressor is or not a basevar
+	`String'                fullindepvars       // indepvars including basevars
+
+	// Weight-specific
+	`Boolean'               has_weights
+	`Variable'              weight              // unsorted weight
+	`String'                weight_var          // Weighting variable
+	`String'                weight_type         // Weight type (pw, fw, etc)
+
+	// Absorbed degrees-of-freedom computations
+	`Integer'               G_extended          // Number of intercepts plus slopes
+	`Integer'               df_a_redundant      // e(mobility)
+	`Integer'               df_a_initial
+	`Integer'               df_a                // df_a_inital - df_a_redundant
+	`Vector'                doflist_M
+	`Vector'                doflist_K
+	`Vector'                doflist_M_is_exact
+	`Vector'                doflist_M_is_nested
+	`Vector'                is_slope
+	`Integer'               df_a_nested // Redundant due to bein nested; used for: r2_a r2_a_within rmse
+
+	// VCE and cluster variables
+	`String'                vcetype
+	`Integer'               num_clusters
+	`Varlist'               clustervars
+	`Varlist'               base_clustervars
+	`String'                vceextra
+
+	// Regression-specific
+	`String'                varlist             // y x1 x2 x3
+	`String'                depvar              // y
+	`String'                indepvars           // x1 x2 x3
+	`String'                tousevar
+	
+	`Boolean'               drop_singletons
+	`String'                absorb              // contents of absorb()
+	`String'                select_if           // If condition
+	`String'                select_in           // In condition
+	`String'                model               // ols, iv
+	`String'                summarize_stats
+	`Boolean'               summarize_quietly
+	`StringRowVector'       dofadjustments // firstpair pairwise cluster continuous
+	`Varname'               groupvar
+	`String'                residuals
+	`Variable'              residuals_vector
+	`RowVector'             kept // 1 if the regressors are not deemed as omitted (by partial_out+cholsolve+invsym)
+	`String'                diopts
+
+	// Output
+	`String'                cmdline
+	`String'                subcmd
+	`String'                title
+	`Boolean'               converged
+	`Integer'               iteration_count // e(ic)
+	`Varlist'               extended_absvars
+	`String'                notes
+	`Integer'               df_r
+	`Integer'               df_m
+	`Integer'               N_clust
+	`Integer'               N_clust_list
+	`Real'                  rss
+	`Real'                  rmse
+	`Real'                  F
+	`Real'                  tss
+	`Real'                  tss_within
+	`Real'                  sumweights
+	`Real'                  r2
+	`Real'                  r2_within
+	`Real'                  r2_a
+	`Real'                  r2_a_within
+	`Real'                  ll
+	`Real'                  ll_0
+	`Real'                  accuracy
+	`RowVector'             means
+	`RowVector'				all_stdevs
+
+	// Methods
+	`Void'                  new()
+	`Void'                  destroy()
+	`Void'                  load_weights() // calls update_sorted_weights, etc.
+	`Void'                  update_sorted_weights()
+	`Void'                  update_cvar_objects()
+	`Matrix'                partial_out()
+	`Matrix'                partial_out_pool()
+	`Void'                  _partial_out()
+	`Variables'             project_one_fe()
+	`Void'                  prune_1core()
+	`Void'                  _expand_1core()
+	`Void'                  estimate_dof()
+	`Void'                  estimate_cond()
+	`Void'                  save_touse()
+	`Void'                  store_alphas()
+	`Void'                  save_variable()
+	`Void'                  post_footnote()
+	`Void'                  post()
+	`FixedEffects'          reload() // create new instance of object
+
+	// LSMR-Specific Methods
+	`Real'                  lsmr_norm()
+	`Vector'                lsmr_A_mult()
+	`Vector'                lsmr_At_mult()
+}    
+
+
+// Set default value of properties
+`Void' FixedEffects::new()
+{
+	num_singletons = .
+	sample = J(0, 1, .)
+	weight = 1 // set to 1 so cross(x, S.weight, y)==cross(x, y)
+
+	verbose = 0
+	timeit = 0
+	compact = 0
+	poolsize = .
+	finite_condition = .
+	residuals = ""
+	residuals_vector = .
+	panelvar = timevar = ""
+	iteration_count = 0
+	accuracy = -1 // Epsilon at the time of convergence
+
+	// Optimization defaults
+	slope_method = "invsym"
+	maxiter = 1e4
+	tolerance = 1e-8
+	transform = "symmetric_kaczmarz"
+	acceleration = "conjugate_gradient"
+	accel_start = 6
+	conlim = 1e+8 // lsmr only
+	btol = 1e-8 // lsmr only (note: atol is just tolerance)
+	always_run_lsmr_preconditioner = 0
+	min_ok = 1
+
+	prune = 0
+	converged = 0
+	abort = 1
+	storing_alphas = 0
+	report_constant = compute_constant = 1
+
+	// Specific to Aitken:
+	accel_freq = 3
+
+	not_basevar = J(1, 0, .)
+
+	means = all_stdevs = J(1, 0, .) // necessary with pool() because we append to it
+	kept = J(1, 0, .) // necessary with pool() because we append to it
+}
+
+
+`Void' FixedEffects::destroy()
+{
+	// stata(sprintf("cap drop %s", tousevar))
+}
+
+
+// This adds/removes weights or changes their type
+`Void' FixedEffects::load_weights(`String' weighttype, `String' weightvar, `Variable' weight, `Boolean' verbose)
+{
+	`Integer'				g
+	`FactorPointer'         pf
+	`Matrix'                precond // used for lsmr
+	`Varname'               cvars_g
+   
+	this.has_weights = (weighttype != "" & weightvar != "")
+	if (this.verbose > 0 & verbose > 0 & this.has_weights) printf("{txt}## Loading weights [%s=%s]\n", weighttype, weightvar)
+
+	// Update main properties
+	this.weight_var = weightvar
+	this.weight_type = weighttype
+
+	// Update booleans
+	for (g=1; g<=this.G; g++) {
+		asarray(this.factors[g].extra, "has_weights", this.has_weights)
+	}
+
+	// Optionally load weight from dataset
+	if (this.has_weights & weight==J(0,1,.)) {
+		weight = st_data(this.sample, this.weight_var)
+	}
+
+	// Update weight vectors
+	if (this.has_weights) {
+		if (this.verbose > 0 & verbose > 0) printf("{txt}## Sorting weights for each absvar\n")
+		this.update_sorted_weights(weight)
+	}
+	else {
+		// If no weights, clear this up
+		this.weight = 1 // same as defined by new()
+		for (g=1; g<=this.G; g++) {
+			asarray(this.factors[g].extra, "weights", .)
+			asarray(this.factors[g].extra, "weighted_counts", .)
+		}
+	}
+	
+	// Update cvar objects (do AFTER updating weights!)
+	// (this is meaningless with iweights)
+	if (weighttype != "iweight") this.update_cvar_objects()
+
+	// Preconditioners for LSMR
+	if (acceleration=="lsmr" | always_run_lsmr_preconditioner) {
+
+		// Compute M
+		M = 0
+		for (g=1; g<=G; g++) {
+			M = M + factors[g].num_levels * (intercepts[g] + num_slopes[g])
+		}
+
+		// Preconditioner
+		for (g=1; g<=G; g++) {
+			pf = &(factors[g])
+			if (intercepts[g]) {
+				precond = has_weights ? asarray((*pf).extra, "weighted_counts") : (*pf).counts
+				asarray((*pf).extra, "precond_intercept", sqrt(1 :/ precond))
+			}
+
+			if (num_slopes[g]) {
+				cvars_g = tokens(this.cvars[g])
+				precond = st_data(this.sample, cvars_g)
+				precond = reghdfe_panel_precondition(precond, (*pf))
+				asarray((*pf).extra, "precond_slopes", precond)
+			}
+
+			precond = .
+		}
+	}
+
+}
+
+
+// This just updates the weight but doesn't change the type or variable of the weight
+`Void' FixedEffects::update_sorted_weights(`Variable' weight)
+{
+	`Integer'               g
+	`Real'                  min_w
+	`Variable'              w
+	`FactorPointer'         pf
+
+	assert_msg(!hasmissing(weight), "weights can't be missing")
+	this.weight = weight
+	assert(rows(weight)==rows(sample))
+	if (verbose > 0) printf("{txt}   - loading %s weight from variable %s\n", weight_type, weight_var)
+	for (g=1; g<=G; g++) {
+		if (verbose > 0) printf("{txt}   - sorting weight for factor {res}%s{txt}\n", absvars[g])
+		pf = &(factors[g])
+		w = (*pf).sort(weight)
+
+		// Rescale weights so there are no weights below 1
+		if (weight_type != "fweight") {
+			min_w = colmin(w)
+			if (min_w < 1e-6) min_w = 1e-6 // Prevent bugs if a weight is very close to zero
+			//assert_msg(min_w > 0, "weights must be positive")
+			//if (min_w <= 0) printf("{err} not all weights are positive\n")
+			if (0 < min_w & min_w < 1) {
+				w = w :/ min_w
+			}
+		}
+
+		asarray((*pf).extra, "weights", w)
+		asarray((*pf).extra, "weighted_counts", `panelsum'(w, (*pf).info))
+	}
+}
+
+
+`Void' FixedEffects::update_cvar_objects()
+{
+	`Integer'               g
+	`FactorPointer'         pf
+
+	for (g=1; g<=G; g++) {
+		pf = &(factors[g])
+		// Update mean(z; w) and inv(z'z; w) where z is a slope variable and w is the weight
+		if (num_slopes[g]) {
+			if (verbose > 0) printf("{txt}   - precomputing cvar objects for factor {res}%s{txt}\n", absvars[g])
+			if (intercepts[g]) {
+			    asarray((*pf).extra, "xmeans",
+			            panelmean(asarray((*pf).extra, "x"), *pf))
+			}
+			asarray((*pf).extra, "inv_xx", precompute_inv_xx(*pf, intercepts[g]))
+		}
+	}
+}
+
+
+`Variables' FixedEffects::partial_out(`Anything' data,
+									| `Boolean' save_tss,
+									  `Boolean' standardize_data,
+									  `Boolean' first_is_depvar)
+{
+	// -data- is either a varlist or a matrix
+	`Variables'             y
+	`Varlist'               vars
+	`Integer'               i
+	`Integer'               k
+
+	if (args()<2 | save_tss==.) save_tss = 0
+	if (args()<3 | standardize_data==.) standardize_data = 1
+	if (args()<4 | first_is_depvar==.) first_is_depvar = 1
+
+	if (eltype(data) == "string") {
+		vars = tokens(invtokens(data)) // tweak to allow string scalars and string vectors
+		k = cols(vars)
+
+		if (poolsize < k) {
+			if (verbose > 0) printf("\n{txt}## Loading and partialling out %g variables in blocks of %g\n\n", k, poolsize)
+			if (timeit) timer_on(50)
+			partial_out_pool(vars, save_tss, standardize_data, first_is_depvar, poolsize, y=.)
+			if (timeit) timer_off(50)
+		}
+		else {
+			if (verbose > 0) printf("\n{txt}## Partialling out %g variables: {res}%s{txt}\n\n", cols(vars), invtokens(vars))
+			if (verbose > 0) printf("{txt}   - Loading variables into Mata\n")
+			if (timeit) timer_on(50)
+			_st_data_wrapper(sample, invtokens(vars), y=., verbose)
+			if (timeit) timer_off(50)
+
+			// Workaround to odd Stata quirk
+			if (timeit) timer_on(51)
+			if (cols(y) > cols(vars)) {
+				printf("{err}(some empty columns were added due to a bug/quirk in {bf:st_data()}; %g cols created instead of %g for {it:%s}; running slower workaround)\n", cols(y), cols(vars), invtokens(vars))
+				partial_out_pool(vars, save_tss, standardize_data, first_is_depvar, 1, y=.)
+			}
+			else {
+				_partial_out(y, save_tss, standardize_data, first_is_depvar)
+			}
+			if (timeit) timer_off(51)
+			
+		}
+	}
+	else {
+		if (verbose > 0) printf("\n{txt}## Partialling out %g variables\n\n", cols(data))
+		if (timeit) timer_on(54)
+		_partial_out(y=data, save_tss, standardize_data, first_is_depvar)
+		if (timeit) timer_off(54)
+	}
+
+	if (verbose==0) printf(`"{txt}({browse "http://scorreia.com/research/hdfe.pdf":MWFE estimator} converged in %s iteration%s)\n"', strofreal(iteration_count), iteration_count > 1 ? "s" : "s")
+	return(y)
+}
+
+
+
+`Variables' FixedEffects::partial_out_pool(`Anything' vars,
+										   `Boolean' save_tss,
+										   `Boolean' standardize_data,
+										   `Boolean' first_is_depvar,
+										   `Integer' step,
+										   `Variables' y)
+{
+	`Variables'             part_y
+	`Integer'               i, j, ii
+	`Integer'               k
+	`StringRowVector'       keepvars
+
+	k = cols(vars)
+	assert(step > 0)
+	assert(step < k)
+	y = J(rows(sample), 0, .)
+
+	for (i=1; i<=k; i=i+step) {
+		
+		j = i + step - 1
+		if (j>k) j = k
+
+		// Load data
+		_st_data_wrapper(sample, vars[i..j], part_y=., verbose)
+
+		if (cols(part_y) > j - i + 1) {
+			printf("{err}(some empty columns were added due to a bug/quirk in {bf:st_data()}; running slower workaround)\n")
+			if (timeit) timer_on(51)
+			part_y = J(rows(sample), 0, .)
+			for (ii=i; ii<=j; ii++) {
+				part_y = part_y, st_data(sample, vars[ii])
+			}
+			if (timeit) timer_off(51)
+		}
+
+		// Drop loaded vars as quickly as possible
+		if (compact) {
+			// st_dropvar(vars[i..j]) // bugbug what if repeated??
+			keepvars = base_clustervars , timevar, panelvar, (j == k ? "" : vars[j+1..k])
+			keepvars = tokens(invtokens(keepvars))
+			if (cols(keepvars)) {
+				stata(sprintf("fvrevar %s, list", invtokens(keepvars)))
+				stata(sprintf("keep %s", st_global("r(varlist)")))
+			}
+			else {
+				stata("clear")
+			}
+		}
+
+		_partial_out(part_y, save_tss, standardize_data, first_is_depvar)
+		y = y, part_y
+		part_y = .
+	}
+}
+
+
+`Void' FixedEffects::store_alphas(`Anything' d_varname)
+{
+	`Integer'               g, i, j
+	`StringRowVector'       varlabel
+	`Variable'              d
+	`RowVector'             tmp_stdev
+
+	if (verbose > 0) printf("\n{txt}## Storing estimated fixed effects\n\n")
+
+	// -d- can be either the data or the variable name
+
+	// Load -d- variable
+	if (eltype(d_varname) == "string") {
+		if (verbose > 0) printf("{txt}   - Loading d = e(depvar) - xb - e(resid)\n")
+		d = st_data(sample, d_varname)
+	}
+	else {
+		d = d_varname
+	}
+	assert(!missing(d))
+
+	// Create empty alphas
+	if (verbose > 0) printf("{txt}   - Initializing alphas\n")
+	for (g=j=1; g<=G; g++) {
+		if (!save_fe[g]) continue
+		asarray(factors[g].extra, "alphas", J(factors[g].num_levels, intercepts[g] + num_slopes[g], 0))
+		asarray(factors[g].extra, "tmp_alphas", J(factors[g].num_levels, intercepts[g] + num_slopes[g], 0))
+	}
+
+	// Fill out alphas
+	if (verbose > 0) printf("{txt}   - Computing alphas\n")
+	storing_alphas = 1
+	converged = 0
+	d = accelerate_sd(this, d, &transform_kaczmarz())
+	storing_alphas = 0
+
+	if (verbose > 0) printf("{txt}   - SSR of d wrt FEs: %g\n", quadcross(d,d))
+
+	// Store alphas in dataset
+	if (verbose > 0) printf("{txt}   - Creating varlabels\n")
+	for (g=j=1; g<=G; g++) {
+		if (!save_fe[g]) {
+			j = j + intercepts[g] + num_slopes[g]
+			continue
+		}
+		varlabel = J(1, intercepts[g] + num_slopes[g], "")
+		for (i=1; i<=cols(varlabel); i++) {
+			varlabel[i] = sprintf("[FE] %s", extended_absvars[j])
+			j++
+		}
+
+		if (num_slopes[g]) {
+			if (verbose > 0) printf("{txt}   - Recovering unstandardized variables\n")
+			tmp_stdev = asarray(factors[g].extra, "x_stdevs")
+			if (intercepts[g]) tmp_stdev = 1, tmp_stdev
+
+			// We need to *divide* the coefs by the stdev, not multiply!
+			asarray(factors[g].extra, "alphas",
+				asarray(factors[g].extra, "alphas") :/ tmp_stdev
+			)
+		}
+
+		if (verbose > 0) printf("{txt}   - Storing alphas in dataset\n")
+		save_variable(targets[g], asarray(factors[g].extra, "alphas")[factors[g].levels, .], varlabel)
+		asarray(factors[g].extra, "alphas", .)
+		asarray(factors[g].extra, "tmp_alphas", .)
+	}
+}
+
+
+`Void' FixedEffects::_partial_out(`Variables' y,
+								| `Boolean' save_tss,
+								  `Boolean' standardize_data,
+								  `Boolean' first_is_depvar,
+								  `Boolean' flush)
+{
+	`RowVector'             stdevs, needs_zeroing, kept2
+	`FunctionP'             funct_transform, func_accel // transform
+	`Real'                  y_mean, collinear_tol
+	`Vector'                lhs
+	`Vector'                alphas
+	`StringRowVector'       vars
+	`Integer'               i
+
+	if (args()<2 | save_tss==.) save_tss = 0
+	if (args()<3 | standardize_data==.) standardize_data = 1
+	if (args()<4 | first_is_depvar==.) first_is_depvar = 1
+	if (args()<5 | flush==.) flush = 0 // whether or not to flush the values of means & kept
+
+	assert(anyof((0, 1, 2), standardize_data)) // 0=Don't standardize; 1=Std. and REVERT after partial; 2=Std., partial, and KEEP STANDARDIZED
+
+	if (flush) {
+		iteration_count = 0
+		accuracy = -1
+		means = stdevs = J(1, 0, .)
+		kept = J(1, 0, .)
+	}
+
+	// Shortcut for trivial case (1 FE)
+	if (G==1) acceleration = "none"
+
+	// Solver Warnings
+	if (transform=="kaczmarz" & acceleration=="conjugate_gradient") {
+		printf("{err}(WARNING: convergence is {bf:unlikely} with transform=kaczmarz and accel=CG)\n")
+	}
+
+	// Load transform pointer
+	if (transform=="cimmino") funct_transform = &transform_cimmino()
+	if (transform=="kaczmarz") funct_transform = &transform_kaczmarz()
+	if (transform=="symmetric_kaczmarz") funct_transform = &transform_sym_kaczmarz()
+	if (transform=="random_kaczmarz") funct_transform = &transform_rand_kaczmarz()
+
+	// Pointer to acceleration routine
+	if (acceleration=="test") func_accel = &accelerate_test()
+	if (acceleration=="none") func_accel = &accelerate_none()
+	if (acceleration=="conjugate_gradient") func_accel = &accelerate_cg()
+	if (acceleration=="steepest_descent") func_accel = &accelerate_sd()
+	if (acceleration=="aitken") func_accel = &accelerate_aitken()
+	if (acceleration=="hybrid") func_accel = &accelerate_hybrid()
+
+	// Compute TSS of depvar
+	if (timeit) timer_on(60)
+	if (save_tss & tss==.) {
+		lhs = y[., 1]
+		if (has_intercept) {
+			y_mean = mean(lhs, weight)
+			tss = crossdev(lhs, y_mean, weight, lhs, y_mean) // Sum of w[i] * (y[i]-y_mean) ^ 2
+		}
+		else {
+			tss = cross(lhs, weight, lhs) // Sum of w[i] * y[i] ^ 2
+		}
+		lhs = .
+		if (weight_type=="aweight" | weight_type=="pweight") tss = tss * rows(y) / sum(weight)
+	}
+	if (timeit) timer_off(60)
+
+
+	// Compute 2-norm of each var, to see if we need to drop as regressors
+	kept2 = diagonal(cross(y, y))'
+
+	// Compute and save means of each var
+	means = means , ( compute_constant ? mean(y, weight) : J(1, cols(y), 1) )
+
+	// Intercept LSMR case
+	if (acceleration=="lsmr") {
+		// RRE benchmarking
+		if (compute_rre) rre_depvar_norm = norm(y[., 1])
+		if (cols(y)==1) {
+			y = lsmr(this, y, alphas=.)
+			alphas = . // or return them!
+		}
+		else {
+			for (i=1; i<=cols(y); i++) {
+				y[., i] = lsmr(this, y[., i], alphas=.)
+			}
+			alphas = .
+		}
+	}
+	else {
+
+		// Standardize variables
+		if (timeit) timer_on(61)
+		if (standardize_data) {
+			if (verbose > 0) printf("{txt}   - Standardizing variables\n")
+			stdevs = reghdfe_standardize(y)
+			all_stdevs = all_stdevs, stdevs
+			kept2 = kept2 :/ stdevs :^ 2
+		}
+		if (timeit) timer_off(61)
+
+		// RRE benchmarking
+		if (compute_rre) {
+			rre_true_residual = rre_true_residual / (standardize_data ? stdevs[1] : 1)
+			rre_depvar_norm = norm(y[., 1])
+		}
+
+		// Solve
+		if (verbose>0) printf("{txt}   - Running solver (acceleration={res}%s{txt}, transform={res}%s{txt} tol={res}%-1.0e{txt})\n", acceleration, transform, tolerance)
+		if (verbose==1) printf("{txt}   - Iterating:")
+		if (verbose>1) printf("{txt}      ")
+		converged = 0 // converged will get updated by check_convergence()
+
+		if (timeit) timer_on(62)
+		if (G==1 & factors[1].method=="none" & num_slopes[1]==0 & !(storing_alphas & save_fe[1])) {
+			// Speedup for constant-only case (no fixed effects)
+			assert(factors[1].num_levels == 1)
+			iteration_count = 1
+			accuracy = 0
+			if (standardize_data == 1) {
+				y = stdevs :* y :- stdevs :* mean(y, has_weights ? asarray(factors[1].extra, "weights") : 1) // Undoing standardization
+			}
+			else {
+				y = y :- mean(y, has_weights ? asarray(factors[1].extra, "weights") : 1)
+			}
+		}
+		else {
+			if (standardize_data == 1) {
+				y = (*func_accel)(this, y, funct_transform) :* stdevs // Undoing standardization
+			}
+			else {
+				y = (*func_accel)(this, y, funct_transform) // 'this' is like python's self
+			}
+		}
+		if (timeit) timer_off(62)
+		
+		if (prune) {
+			assert_msg(G==2, "prune option requires only two FEs")
+			if (timeit) timer_on(63)
+			_expand_1core(y)
+			if (timeit) timer_off(63)
+		}
+	}
+
+	assert_msg(!hasmissing(y), "error partialling out; missing values found")
+
+	// Standardizing makes it hard to detect values that are perfectly collinear with the absvars
+	// in which case they should be 0.00 but they end up as e.g. 1e-16
+	// EG: reghdfe price ibn.foreign , absorb(foreign)
+
+	// This will edit to zero entire columns where *ALL* values are very close to zero
+	if (timeit) timer_on(64)
+	vars = cols(varlist) > 1 ? varlist : tokens(varlist)
+	if (cols(vars)!=cols(y)) vars ="variable #" :+ strofreal(1..cols(y))
+	collinear_tol = min(( 1e-6 , tolerance / 10))
+
+	kept2 = (diagonal(cross(y, y))' :/ kept2) :> (collinear_tol)
+	if (first_is_depvar & kept2[1]==0) {
+		kept2[1] = 1
+		if (verbose > -1) printf("{txt}warning: %s might be perfectly explained by fixed effects (tol =%3.1e)\n", vars[1], collinear_tol)
+	}
+	needs_zeroing = `selectindex'(!kept2)
+	if (cols(needs_zeroing)) {
+		y[., needs_zeroing] = J(rows(y), cols(needs_zeroing), 0)
+		for (i=1; i<=cols(vars); i++) {
+			if (!kept2[i] & verbose>-1 & (i > 1 | !first_is_depvar)) {
+				printf("{txt}note: {res}%s{txt} is probably collinear with the fixed effects (all partialled-out values are close to zero; tol =%3.1e)\n", vars[i], collinear_tol)
+			}
+		}
+	}
+
+	kept = kept, kept2
+	if (timeit) timer_off(64)
+}
+
+
+`Variables' FixedEffects::project_one_fe(`Variables' y, `Integer' g)
+{
+	`Factor'                f
+	`Boolean'               store_these_alphas
+	`Matrix'                alphas, proj_y
+
+	// Cons+K+W, Cons+K, K+W, K, Cons+W, Cons = 6 variants
+
+	f = factors[g]
+	store_these_alphas = storing_alphas & save_fe[g]
+	if (store_these_alphas) assert(cols(y)==1)
+
+	if (num_slopes[g]==0) {
+		if (store_these_alphas) {
+			alphas = panelmean(f.sort(y), f)
+			asarray(factors[g].extra, "tmp_alphas", alphas)
+			return(alphas[f.levels, .])
+		}
+		else {
+			if (cols(y)==1 & f.num_levels > 1) {
+				return(panelmean(f.sort(y), f)[f.levels])
+			}
+			else {
+				return(panelmean(f.sort(y), f)[f.levels, .])
+			}
+		}
+	}
+	else {
+		// This includes both cases, with and w/out intercept (## and #)
+		if (store_these_alphas) {
+			alphas = J(f.num_levels, intercepts[g] + num_slopes[g], .)
+			proj_y = panelsolve_invsym(f.sort(y), f, intercepts[g], alphas)
+			asarray(factors[g].extra, "tmp_alphas", alphas)
+			return(proj_y)
+		}
+		else {
+			return(panelsolve_invsym(f.sort(y), f, intercepts[g]))
+		}
+	}
+}
+
+
+`Void' FixedEffects::estimate_dof()
+{
+	`Boolean'               has_int
+	`Integer'               g, h                        // index FEs (1..G)
+	`Integer'               num_intercepts              // Number of absvars with an intercept term
+	`Integer'               i_cluster, i_intercept, j_intercept
+	`Integer'               i                           // index 1..G_extended
+	`Integer'               j
+	`Integer'               bg_verbose                  // verbose level when calling BipartiteGraph()
+	`Integer'               m                           // Mobility groups between a specific pair of FEs
+	`RowVector'             SubGs
+	`RowVector'             offsets, idx, zeros, results
+	`Matrix'                tmp
+	`Variables'             data
+	`DataCol'               cluster_data
+	`String'                absvar, clustervar
+	`Factor'                F
+	`BipartiteGraph'        BG
+	`Integer'               pair_count
+	
+	if (verbose > 0) printf("\n{txt}## Estimating degrees-of-freedom absorbed by the fixed effects\n\n")
+
+	// Count all FE intercepts and slopes
+	SubGs = intercepts + num_slopes
+	G_extended = sum(SubGs)
+	num_intercepts = sum(intercepts)
+	offsets = runningsum(SubGs) - SubGs :+ 1 // start of each FE within the extended list
+	idx = `selectindex'(intercepts) // Select all FEs with intercepts
+	if (verbose > 0) printf("{txt}   - there are %f fixed intercepts and slopes in the %f absvars\n", G_extended, G)
+
+	// Initialize result vectors and scalars
+	doflist_M_is_exact = J(1, G_extended, 0)
+	doflist_M_is_nested = J(1, G_extended, 0)
+	df_a_nested = 0
+
+	// (1) M will hold the redundant coefs for each extended absvar (G_extended, not G)
+	doflist_M = J(1, G_extended, 0)
+	assert(0 <= num_clusters & num_clusters <= 10)
+	if (num_clusters > 0 & anyof(dofadjustments, "clusters")) {
+
+		// (2) (Intercept-Only) Look for absvars that are clustervars
+		for (i_intercept=1; i_intercept<=length(idx); i_intercept++) {
+			g = idx[i_intercept]
+			i = offsets[g]
+			absvar = invtokens(tokens(ivars[g]), "#")
+			if (anyof(clustervars, absvar)) {
+				doflist_M[i] = factors[g].num_levels
+				df_a_nested = df_a_nested + doflist_M[i]
+				doflist_M_is_exact[i] = doflist_M_is_nested[i] = 1
+				idx[i_intercept] = 0
+				if (verbose > 0) printf("{txt} - categorical variable {res}%s{txt} is also a cluster variable, so it doesn't reduce DoF\n", absvar)
+			}
+		}
+		idx = select(idx, idx)
+
+		// (3) (Intercept-Only) Look for absvars that are nested within a clustervar
+		for (i_cluster=1; i_cluster<= num_clusters; i_cluster++) {
+			cluster_data = .
+			if (!length(idx)) break // no more absvars to process
+			for (i_intercept=1; i_intercept<=length(idx); i_intercept++) {
+
+				g = idx[i_intercept]
+				i = offsets[g]
+				absvar = invtokens(tokens(ivars[g]), "#")
+				clustervar = clustervars[i_cluster]
+				if (doflist_M_is_exact[i]) continue // nothing to do
+
+				if (cluster_data == .) {
+					if (strpos(clustervar, "#")) {
+						clustervar = subinstr(clustervars[i_cluster], "#", " ", .)
+						F = factor(clustervar, sample, ., "", 0, 0, ., 0)
+						cluster_data = F.levels
+						F = Factor() // clear
+					}
+					else {
+						cluster_data = __fload_data(clustervar, sample, 0)
+					}
+				}
+
+				if (factors[g].nested_within(cluster_data)) {
+					doflist_M[i] = factors[g].num_levels
+					doflist_M_is_exact[i] = doflist_M_is_nested[i] = 1
+					df_a_nested = df_a_nested + doflist_M[i]
+					idx[i_intercept] = 0
+					if (verbose > 0) printf("{txt} - categorical variable {res}%s{txt} is nested within a cluster variable, so it doesn't reduce DoF\n", absvar)
+				}
+			}
+			idx = select(idx, idx)
+		}
+		cluster_data = . // save memory
+	} // end of the two cluster checks (absvar is clustervar; absvar is nested within clustervar)
+
+
+	// (4) (Intercept-Only) Every intercept but the first has at least one redundant coef.
+	if (length(idx) > 1) {
+		if (verbose > 0) printf("{txt}   - there is at least one redundant coef. for every set of FE intercepts after the first one\n")
+		doflist_M[offsets[idx[2..length(idx)]]] = J(1, length(idx)-1, 1) // Set DoF loss of all intercepts but the first one to 1
+	}
+
+	// (5) (Intercept-only) Mobility group algorithm
+	// Excluding those already solved, the first absvar is exact
+
+	if (length(idx)) {
+		i = idx[1]
+		doflist_M_is_exact[i] = 1
+	}
+
+	// Compute number of dijsoint subgraphs / mobility groups for each pair of remaining FEs
+	if (anyof(dofadjustments, "firstpair") | anyof(dofadjustments, "pairwise")) {
+		BG = BipartiteGraph()
+		bg_verbose = max(( verbose - 1 , 0 ))
+		pair_count = 0
+
+		for (i_intercept=1; i_intercept<=length(idx)-1; i_intercept++) {
+			for (j_intercept=i_intercept+1; j_intercept<=length(idx); j_intercept++) {
+				g = idx[i_intercept]
+				h = idx[j_intercept]
+				i = offsets[h]
+				BG.init(&factors[g], &factors[h], bg_verbose)
+				m = BG.init_zigzag()
+				++pair_count
+				if (verbose > 0) printf("{txt}   - mobility groups between FE intercepts #%f and #%f: {res}%f\n", g, h, m)
+				doflist_M[i] = max(( doflist_M[i] , m ))
+				if (j_intercept==2) doflist_M_is_exact[i] = 1
+				if (pair_count & anyof(dofadjustments, "firstpair")) break
+			}
+			if (pair_count & anyof(dofadjustments, "firstpair")) break
+		}
+		BG = BipartiteGraph() // clear
+	}
+	// TODO: add group3hdfe
+
+	// (6) See if cvars are zero (w/out intercept) or just constant (w/intercept)
+	if (anyof(dofadjustments, "continuous")) {
+		for (i=g=1; g<=G; g++) {
+			// If model has intercept, redundant cvars are those that are CONSTANT
+			// Without intercept, a cvar has to be zero within a FE for it to be redundant
+			// Since S.fes[g].x are already demeaned IF they have intercept, we don't have to worry about the two cases
+			has_int = intercepts[g]
+			if (has_int) i++
+			if (!num_slopes[g]) continue
+
+			data = asarray(factors[g].extra, "x")
+			assert(num_slopes[g]==cols(data))
+			results = J(1, cols(data), 0)
+			// float(1.1) - 1 == 2.384e-08 , so let's pick something bigger, 1e-6
+			zeros = J(1, cols(data), 1e-6)
+			// This can be speed up by moving the -if- outside the -for-
+			for (j = 1; j <= factors[g].num_levels; j++) {
+				tmp = colminmax(panelsubmatrix(data, j, factors[g].info))
+				if (has_int) {
+					results = results + ((tmp[2, .] - tmp[1, .]) :<= zeros)
+				}
+				else {
+					results = results + (colsum(abs(tmp)) :<= zeros)
+				}
+			}
+			data = .
+			if (sum(results)) {
+				if (has_int  & verbose) printf("{txt}   - the slopes in the FE #%f are constant for {res}%f{txt} levels, which don't reduce DoF\n", g, sum(results))
+				if (!has_int & verbose) printf("{txt}   - the slopes in the FE #%f are zero for {res}%f{txt} levels, which don't reduce DoF\n", g, sum(results))
+				doflist_M[i..i+num_slopes[g]-1] = results
+			}
+			i = i + num_slopes[g]
+		}
+	}
+
+	// Store results (besides doflist_..., etc.)
+	doflist_K = J(1, G_extended, .)
+	for (g=1; g<=G; g++) {
+		i = offsets[g]
+		j = g==G ? G_extended : offsets[g+1]
+		doflist_K[i..j] = J(1, j-i+1, factors[g].num_levels)
+	}
+	df_a_initial = sum(doflist_K)
+	df_a_redundant = sum(doflist_M)
+	df_a = df_a_initial - df_a_redundant
+}
+
+
+
+`Void' FixedEffects::prune_1core()
+{
+	// Note that we can't prune degree-2 nodes, or the graph stops being bipartite
+	`Integer'               i, j, g
+	`Vector'                subgraph_id
+	
+	`Vector'                idx
+	`RowVector'             i_prune
+
+	// For now; too costly to use prune for G=3 and higher
+	// (unless there are *a lot* of degree-1 vertices)
+	if (G!=2) return //assert_msg(G==2, "G==2") // bugbug remove?
+
+	// Abort if the user set HDFE.prune = 0
+	if (!prune) return
+
+	// Pick two factors, and check if we really benefit from pruning
+	prune = 0
+	i_prune = J(1, 2, 0)
+	for (g=i=1; g<=2; g++) {
+		//if (intercepts[g] & !num_slopes[g] & factors[g].num_levels>100) {
+		if (intercepts[g] & !num_slopes[g]) {
+			i_prune[i++] = g // increments at the end
+			if (i > 2) { // success!
+				prune = 1
+				break
+			}
+		}
+	}
+
+	if (!prune) return
+
+	// for speed, the factor with more levels goes first
+	i = i_prune[1]
+	j = i_prune[2]
+	//if (factors[i].num_levels < factors[j].num_levels) swap(i, j) // bugbug uncomment it!
+	prune_g1 = i
+	prune_g2 = j
+
+	bg = BipartiteGraph()
+	bg.init(&factors[prune_g1], &factors[prune_g2], verbose)
+	(void) bg.init_zigzag(1) // 1 => save subgraphs into bg.subgraph_id
+	bg.compute_cores()
+	bg.prune_1core(weight)
+	num_pruned = bg.N_drop
+}
+
+// bugbug fix or remove this fn altogether
+`Void' FixedEffects::_expand_1core(`Variables' y)
+{
+	y = bg.expand_1core(y)
+}
+
+
+`Void' FixedEffects::save_touse(| `Varname' touse, `Boolean' replace)
+{
+	`Integer'               idx
+	`Vector'                mask
+
+	// Set default arguments
+	if (args()<1 | touse=="") {
+		assert(tousevar != "")
+		touse = tousevar
+	}
+	// Note that args()==0 implies replace==1 (else how would you find the name)
+	if (args()==0) replace = 1
+	if (args()==1 | replace==.) replace = 0
+
+	if (verbose > 0) printf("\n{txt}## Saving e(sample)\n")
+
+	// Compute dummy vector
+	mask = create_mask(st_nobs(), 0, sample, 1)
+
+	// Save vector as variable
+	if (replace) {
+		st_store(., touse, mask)
+	}
+	else {
+		idx = st_addvar("byte", touse, 1)
+		st_store(., idx, mask)
+	}
+}
+
+
+`Void' FixedEffects::save_variable(`Varname' varname,
+								   `Variables' data,
+								 | `Varlist' varlabel)
+{
+	`RowVector'               idx
+	`Integer'               i
+	idx = st_addvar("double", tokens(varname))
+	st_store(sample, idx, data)
+	if (args()>=3 & varlabel!="") {
+		for (i=1; i<=cols(data); i++) {
+			st_varlabel(idx[i], varlabel[i])
+		}
+	}
+
+}
+
+
+
+`Void' FixedEffects::post_footnote()
+{
+	`Matrix'                table
+	`StringVector'          rowstripe
+	`StringRowVector'       colstripe
+	`String'                text
+
+	assert(!missing(G))
+	st_numscalar("e(N_hdfe)", G)
+	st_numscalar("e(N_hdfe_extended)", G_extended)
+	st_numscalar("e(df_a)", df_a)
+	st_numscalar("e(df_a_initial)", df_a_initial)
+	st_numscalar("e(df_a_redundant)", df_a_redundant)
+	st_numscalar("e(df_a_nested)", df_a_nested)
+	st_global("e(dofmethod)", invtokens(dofadjustments))
+
+	if (absvars == "") {
+		absvars = extended_absvars = "_cons"
+	}
+
+	st_global("e(absvars)", invtokens(absvars))
+	text = invtokens(extended_absvars)
+	text = subinstr(text, "1.", "")
+	st_global("e(extended_absvars)", text)
+
+	// Absorbed degrees-of-freedom table
+	table = (doflist_K \ doflist_M \ (doflist_K-doflist_M) \ !doflist_M_is_exact \ doflist_M_is_nested)'
+	rowstripe = extended_absvars'
+	rowstripe = J(rows(table), 1, "") , extended_absvars' // add equation col
+	colstripe = "Categories" \ "Redundant" \ "Num Coefs" \ "Exact?" \ "Nested?" // colstripe cannot have dots on Stata 12 or earlier
+	colstripe = J(cols(table), 1, "") , colstripe // add equation col
+	st_matrix("e(dof_table)", table)
+	st_matrixrowstripe("e(dof_table)", rowstripe)
+	st_matrixcolstripe("e(dof_table)", colstripe)
+
+	st_numscalar("e(ic)", iteration_count)
+	st_numscalar("e(drop_singletons)", drop_singletons)
+	st_numscalar("e(num_singletons)", num_singletons)
+	st_numscalar("e(N_full)", st_numscalar("e(N)") + num_singletons)
+
+	// Prune specific
+	if (prune==1) {
+		st_numscalar("e(pruned)", 1)
+		st_numscalar("e(num_pruned)", num_pruned)
+	}
+
+	if (!missing(finite_condition)) st_numscalar("e(finite_condition)", finite_condition)
+}
+
+
+`Void' FixedEffects::post()
+{
+	`String'        text
+	`Integer'       i
+
+	post_footnote()
+
+	// ---- constants -------------------------------------------------------
+
+	st_global("e(predict)", "reghdfe_p")
+	st_global("e(estat_cmd)", "reghdfe_estat")
+	st_global("e(footnote)", "reghdfe_footnote")
+	//st_global("e(marginsok)", "")
+	st_global("e(marginsnotok)", "Residuals SCore")
+	st_numscalar("e(df_m)", df_m)
+
+
+	assert(title != "")
+	text = sprintf("HDFE %s", title)
+	st_global("e(title)", text)
+	
+	text = sprintf("Absorbing %g HDFE %s", G, plural(G, "group"))
+	st_global("e(title2)", text)
+	
+	st_global("e(model)", model)
+	st_global("e(cmdline)", cmdline)
+
+	st_numscalar("e(tss)", tss)
+	st_numscalar("e(tss_within)", tss_within)
+	st_numscalar("e(rss)", rss)
+	st_numscalar("e(mss)", tss - rss)
+	st_numscalar("e(rmse)", rmse)
+	st_numscalar("e(F)", F)
+
+	st_numscalar("e(ll)", ll)
+	st_numscalar("e(ll_0)", ll_0)
+
+	st_numscalar("e(r2)", r2)
+	st_numscalar("e(r2_within)", r2_within)
+	st_numscalar("e(r2_a)", r2_a)
+	st_numscalar("e(r2_a_within)", r2_a_within)
+	
+	if (!missing(N_clust)) {
+		st_numscalar("e(N_clust)", N_clust)
+		for (i=1; i<=num_clusters; i++) {
+			text = sprintf("e(N_clust%g)", i)
+			st_numscalar(text, N_clust_list[i])
+		}
+		text = "Statistics robust to heteroskedasticity"
+		st_global("e(title3)", text)
+	}
+
+	if (!missing(sumweights)) st_numscalar("e(sumweights)", sumweights)
+
+	st_numscalar("e(report_constant)", compute_constant & report_constant)
+
+
+	// ---- .options properties ---------------------------------------------
+
+	st_global("e(depvar)", depvar)
+	st_global("e(indepvars)", invtokens(indepvars))
+
+	if (!missing(N_clust)) {
+		st_numscalar("e(N_clustervars)", num_clusters)
+		st_global("e(clustvar)", invtokens(clustervars))
+		for (i=1; i<=num_clusters; i++) {
+			text = sprintf("e(clustvar%g)", i)
+			st_global(text, clustervars[i])
+		}
+	}
+
+	if (residuals != "") {
+		st_global("e(resid)", residuals)
+	}
+
+	// Stata uses e(vcetype) for the SE column headers
+	// In the default option, leave it empty.
+	// In the cluster and robust options, set it as "Robust"
+	text = strproper(vcetype)
+	if (text=="Cluster") text = "Robust"
+	if (text=="Unadjusted") text = ""
+	assert(anyof( ("", "Robust", "Jackknife", "Bootstrap") , text))
+	if (text!="") st_global("e(vcetype)", text)
+
+	text = vcetype
+	if (text=="unadjusted") text = "ols"
+	st_global("e(vce)", text)
+
+	// Weights
+	if (weight_type != "") {
+		st_global("e(wexp)", "= " + weight_var)
+		st_global("e(wtype)", weight_type)
+	}
+}
+
+
+// --------------------------------------------------------------------------
+// Recreate HDFE object
+// --------------------------------------------------------------------------
+`FixedEffects' FixedEffects::reload(`Boolean' copy)
+{
+	`FixedEffects' ans
+	assert(copy==0 | copy==1)
+	
+	// Trim down current object as much as possible
+	// this. is optional but useful for clarity
+	if (copy==0) {
+		this.factors = Factor()
+		this.sample = .
+		this.bg = BipartiteGraph()
+		this.pruned_weight = .
+		this.rre_varname = .
+		this.rre_true_residual = .
+	}
+
+	// Initialize new object
+	ans = fixed_effects(this.absorb, this.tousevar, this.weight_type, this.weight_var, this.drop_singletons, this.verbose)
+
+	// Fill out new object with values of current one
+	ans.depvar = this.depvar
+	ans.indepvars = this.indepvars
+	ans.varlist = this.varlist
+	ans.model = this.model
+	ans.vcetype = this.vcetype
+	ans.num_clusters = this.num_clusters
+	ans.clustervars = this.clustervars
+	ans.base_clustervars = this.base_clustervars
+	ans.vceextra = this.vceextra
+	ans.summarize_stats = this.summarize_stats
+	ans.summarize_quietly = this.summarize_quietly
+	ans.notes = this.notes
+	ans.store_sample = this.store_sample
+	ans.timeit = this.timeit
+	ans.compact = this.compact
+	ans.poolsize = this.poolsize
+	ans.diopts = this.diopts
+
+	ans.fullindepvars = this.fullindepvars
+	ans.not_basevar = this.not_basevar
+
+	ans.compute_constant = this.compute_constant
+	ans.report_constant = this.report_constant
+	ans.tolerance = this.tolerance
+	ans.save_any_fe = this.save_any_fe
+
+	ans.slope_method = this.slope_method
+	ans.maxiter = this.maxiter
+	ans.transform = this.transform
+	ans.acceleration = this.acceleration
+	ans.accel_start = this.accel_start
+	ans.conlim = this.conlim
+	ans.btol = this.btol
+	ans.min_ok = this.min_ok
+	ans.prune = this.prune
+	ans.always_run_lsmr_preconditioner = this.always_run_lsmr_preconditioner
+
+	return(ans)
+}
+
+
+// --------------------------------------------------------------------------
+// Estimate finite condition number of the graph Laplacian
+// --------------------------------------------------------------------------
+`Void' FixedEffects::estimate_cond()
+{
+	`Matrix'                D1, D2, L
+	`Vector'                lambda
+	`RowVector'             tmp
+	`Factor'                F12
+
+	if (finite_condition!=-1) return
+
+	if (verbose > 0) printf("\n{txt}## Computing finite condition number of the Laplacian\n\n")
+
+	if (verbose > 0) printf("{txt}   - Constructing vectors of levels\n")
+	F12 = join_factors(factors[1], factors[2], ., ., 1)
+	
+	// Non-sparse (lots of memory usage!)
+	if (verbose > 0) printf("{txt}   - Constructing design matrices\n")
+	D1 = designmatrix(F12.keys[., 1])
+	D2 = designmatrix(F12.keys[., 2])
+	assert_msg(rows(D1)<=2000, "System is too big!")
+	assert_msg(rows(D2)<=2000, "System is too big!")
+
+	if (verbose > 0) printf("{txt}   - Constructing graph Laplacian\n")
+	L =   D1' * D1 , - D1' * D2 \
+		- D2' * D1 ,   D2' * D2
+	if (verbose > 0) printf("{txt}   - L is %g x %g \n", rows(L), rows(L))
+		
+	if (verbose > 0) printf("{txt}   - Computing eigenvalues\n")
+	assert_msg(rows(L)<=2000, "System is too big!")
+	eigensystem(L, ., lambda=.)
+	lambda = Re(lambda')
+
+	if (verbose > 0) printf("{txt}   - Selecting positive eigenvalues\n")
+	lambda = edittozerotol(lambda, 1e-8)
+	tmp = select(lambda,  edittozero(lambda, 1))
+	tmp = minmax(tmp)
+	finite_condition = tmp[2] / tmp[1]
+
+	if (verbose > 0) printf("{txt}   - Finite condition number: {res}%s{txt}\n", strofreal(finite_condition))
+}
+
+
+`Real' FixedEffects::lsmr_norm(`Matrix' x)
+{
+	assert(cols(x)==1 | rows(x)==1)
+	// BUGBUG: what if we have a corner case where there are as many obs as params?
+	if (has_weights & cols(x)==1 & rows(x)==rows(weight)) {
+		return(sqrt(quadcross(x, weight, x)))
+	}
+	else if (cols(x)==1) {
+		return(sqrt(quadcross(x, x)))
+	}
+	else {
+		return(sqrt(quadcross(x', x')))
+	}
+}
+
+
+// Ax: given the coefs 'x', return the projection 'Ax'
+`Vector' FixedEffects::lsmr_A_mult(`Vector' x)
+{
+	`Integer' g, k, idx_start, idx_end, i
+	`Vector' ans
+	`FactorPointer'         pf
+
+	ans = J(N, 1, 0)
+	idx_start = 1
+
+	for (g=1; g<=G; g++) {
+		pf = &(factors[g])
+		k = (*pf).num_levels
+
+		if (intercepts[g]) {
+			idx_end = idx_start + k - 1
+			ans = ans + (x[|idx_start, 1 \ idx_end , 1 |] :* asarray((*pf).extra, "precond_intercept") )[(*pf).levels, .]
+			idx_start = idx_end + 1
+		}
+
+		if (num_slopes[g]) {
+			for (i=1; i<=num_slopes[g]; i++) {
+				idx_end = idx_start + k - 1
+				ans = ans + x[|idx_start, 1 \ idx_end , 1 |][(*pf).levels] :* asarray((*pf).extra, "precond_slopes")
+				idx_start = idx_end + 1
+			}
+		}
+
+	}
+	//assert(!missing(ans))
+	return(ans)
+}
+
+
+// A'x: Compute the FEs and store them in a big stacked vector
+`Vector' FixedEffects::lsmr_At_mult(`Vector' x)
+{
+	`Integer' m, g, i, idx_start, idx_end, k
+	`Vector' ans
+	`FactorPointer'         pf
+	`Vector' alphas
+	`Matrix' tmp_alphas
+
+	alphas = J(M, 1, .)
+	idx_start = 1
+
+	for (g=1; g<=G; g++) {
+		pf = &(factors[g])
+		k = (*pf).num_levels
+
+		if (intercepts[g]) {
+			idx_end = idx_start + k - 1
+			if (has_weights) {
+				alphas[| idx_start , 1 \ idx_end , 1 |] = `panelsum'((*pf).sort(x :* weight), (*pf).info) :* asarray((*pf).extra, "precond_intercept")
+			}
+			else {
+				alphas[| idx_start , 1 \ idx_end , 1 |] = `panelsum'((*pf).sort(x), (*pf).info) :* asarray((*pf).extra, "precond_intercept")
+			}
+			idx_start = idx_end + 1
+		}
+
+		if (num_slopes[g]) {
+			idx_end = idx_start + k * num_slopes[g] - 1
+			if (has_weights) {
+				tmp_alphas = `panelsum'((*pf).sort(x :* weight :* asarray((*pf).extra, "precond_slopes")), (*pf).info)
+			}
+			else {
+				tmp_alphas = `panelsum'((*pf).sort(x :* asarray((*pf).extra, "precond_slopes")), (*pf).info)
+			}
+			alphas[| idx_start , 1 \ idx_end , 1 |] = vec(tmp_alphas)
+			idx_start = idx_end + 1
+		}
+	}
+	//assert(!missing(alphas))
+	return(alphas)
+}
+
+end

30/replication_package/Adofiles/reghdfe_2019/reghdfe_common.mata

@@ -0,0 +1,838 @@
+// Common functions ---------------------------------------------------------
+mata:
+
+// --------------------------------------------------------------------------
+// BUGBUG: not sure if this is still used...
+// --------------------------------------------------------------------------
+`StringRowVector' clean_tokens(`String' vars)
+{
+	`StringRowVector' 		ans
+	`Integer'				i
+	ans = tokens(vars)
+	for (i=1; i<=cols(ans); i++) {
+		ans[i] = invtokens(tokens(ans[i]))
+	}
+	return(ans)
+}
+
+
+// --------------------------------------------------------------------------
+// Workaround to st_data's odd behavior
+// --------------------------------------------------------------------------
+// This does three things:
+// 1) Wrap up interactions in parens (up to four) to avoid Stata's quirk/bug
+// 2) If issue persists, load columns one-by-one
+// 1) Instead of returning it reuses existing matrices (might use less mem?)
+//
+// Example of the issue:
+// 	sysuse auto, clear
+//	mata: cols(st_data(., "1.rep78 2.rep78 3.rep78#1.foreign")) // expected 3, got 6
+// Happens b/c st_data doesn't work variable by variable but expands the interactions
+// We can partly fix it by surrounding interactions with parens
+// But st_data() only supports up to 4 parens
+
+
+`Void' _st_data_wrapper(`Variables' index, `StringRowVector' vars, `Variables' data, `Boolean' verbose)
+{
+	`RowVector'			is_interaction
+	`StringRowVector'	fixed_vars
+	`Integer'			i, k
+
+	vars = tokens(invtokens(vars))
+
+	// Add parenthesis only for Stata 11-14, as on Stata 15+ they are i) not needed and ii) corrupt output
+	// For i) see "help set fvtrack"
+	// For ii) see "test/stdata3.do" on Github
+	if (st_numscalar("c(stata_version)") < 15) {
+		is_interaction = strpos(vars, "#") :> 0
+		is_interaction = is_interaction :& (runningsum(is_interaction) :<= 4) // Only up to 4 parenthesis supported
+		fixed_vars = subinstr(strofreal(is_interaction), "0", "")
+		fixed_vars = subinstr(fixed_vars, "1", "(") :+ vars :+ subinstr(fixed_vars, "1", ")")
+	}
+	else {
+		fixed_vars = vars
+	}
+
+	// Override code above, to minimize any risk of incorrect data
+	// Since this is an undocumented feature, it might or might not work on some older versions of Stata
+	// (See also email from [email protected])
+	fixed_vars = vars
+
+	data = st_data(index, fixed_vars)
+	k = cols(vars)
+
+	if (cols(data) > k) {
+	    if (verbose > 0) printf("{err}(some empty columns were added due to a bug/quirk in {bf:st_data()}; %g cols created instead of %g for {it:%s}; running slower workaround)\n", cols(data), k, invtokens(vars))
+	    data = J(rows(data), 0, .)
+	    for (i=1; i<=k; i++) {
+	        data = data, st_data(index, vars[i])
+	    }
+	}
+	assert(cols(data)==k)
+}
+	
+
+// --------------------------------------------------------------------------
+// Each col of A will have stdev of 1 unless stdev is quite close to 0
+// --------------------------------------------------------------------------
+`RowVector' function reghdfe_standardize(`Matrix' A)
+{
+	`RowVector'				stdevs, means
+	`Integer'				K, N // i, 
+
+	// We don't need to good accuracy for the stdevs, so we have a few alternatives:
+	// Note: cross(1,A) is the same as colsum(A), but faster
+	// Note: cross(A, A) is very fast, but we only need the main diagonals
+	// [A: 1sec] stdevs = sqrt( (colsum(A:*A) - (cross(1, A) :^ 2 / N)) / (N-1) )
+	// [B: .61s] stdevs = sqrt( (diagonal(cross(A, A))' - (cross(1, A) :^ 2 / N)) / (N-1) )
+	// [C: .80s] stdevs = diagonal(sqrt(variance(A)))'
+	// [D: .67s] means = cross(1, A) / N; stdevs =  sqrt(diagonal(crossdev(A, means, A, means))' / (N-1))
+
+	assert_msg(!isfleeting(A), "input cannot be fleeting")
+	N = rows(A)
+	K = cols(A)
+
+	stdevs = J(1, K, .)
+
+	// (A) Very precise
+
+	// (B) Precise
+	// means = cross(1, A) / N
+	// stdevs =  sqrt(diagonal(quadcrossdev(A, means, A, means))' / (N-1))
+
+	// (C) 20% faster; don't use it if you care about accuracy
+	stdevs = sqrt( (diagonal(cross(A, A))' - (cross(1, A) :^ 2 / N)) / (N-1) )
+	assert_msg(!missing(stdevs), "stdevs are missing; is N==1?") // Shouldn't happen as we don't expect N==1
+	stdevs = colmax(( stdevs \ J(1, K, 1e-3) ))
+	A = A :/ stdevs
+
+	// (D) Equilibrate matrix columns instead of standardize (i.e. just divide by column max)
+	// _perhapsequilc(A, stdevs=.)
+	// stdevs = 1 :/ stdevs
+	// assert_msg(!missing(stdevs), "stdevs are missing; is N==1?")
+
+	// (E) Don't do anything
+	// stdevs = J(1, cols(A), 1)
+
+	return(stdevs)
+}
+
+
+// --------------------------------------------------------------------------
+// Divide two row vectors but adjust the denominator if it's too small
+// --------------------------------------------------------------------------
+`RowVector' safe_divide(`RowVector' numerator, `RowVector' denominator, | `Real' epsi) {
+	 // If the numerator goes below machine precision, we lose accuracy
+	 // If the denominator goes below machine precision, the division explodes
+	 if (args()<3 | epsi==.) epsi = epsilon(1)
+	return( numerator :/ colmax(denominator \ J(1,cols(denominator),epsi)) )
+}
+
+
+// If X is not square...
+// `Matrix' R
+// real colvector tau, p
+
+// _hqrdp(A, tau, R, p=.)
+// B = hqrdmultq1t(A, tau, B)
+// rank = _solveupper(R, B, tol)
+// B = B[invorder(p),.]
+// +- +-
+
+// invsym(makesymmetric(..))
+
+
+
+
+
+// --------------------------------------------------------------------------
+// Robust solver for Ax=b
+// --------------------------------------------------------------------------
+// Mata utility for sequential use of solvers
+// Default is cholesky;
+// if that fails, use QR;
+// if overridden, use QR.
+// Author: Schaffer, Mark E <[email protected]>
+// --------------------------------------------------------------------------
+// Warning:
+// cholqrsolve calls qrsolve which calls _qrsolve which calls ...
+// Does all the indirection makes it too slow to use within a panel?
+// --------------------------------------------------------------------------
+`Matrix' function reghdfe_cholqrsolve(`Matrix' A,
+                                      `Matrix' B,
+                                    | `Boolean' useqr)
+{
+	`Matrix' C
+	if (args()<3 | useqr==.) useqr = 0
+	
+	if (!useqr) {
+		C = cholsolve(A, B)
+		if (hasmissing(C)) useqr = 1
+	}
+
+	if (useqr) {
+		C = qrsolve(A, B)
+	}
+
+	return(C)
+}
+
+
+// --------------------------------------------------------------------------
+// OLS Regression
+// --------------------------------------------------------------------------
+`Void' function reghdfe_post_ols(`FixedEffects' S,
+                                 `Variables' X,
+                                 `String' bname,
+                                 `String' Vname,
+                                 `String' nname,
+                                 `String' rname,
+                                 `String' dfrname)
+{
+	`Integer'				N
+	`Integer'				rank
+	`Integer'				df_r
+	`Vector'				b
+	`Matrix'				V
+	`Variable'				resid
+	`Real'					eps
+	`Integer'				i
+	`RowVector'				kept
+	`Vector'				not_basevar
+
+
+	`Vector'				idx
+	`Vector'				temp_b
+	`Matrix'				temp_V
+	`Integer'				k
+
+	if (S.timeit) timer_on(90)
+	reghdfe_solve_ols(S, X, b=., V=., N=., rank=., df_r=., resid=., kept=., "vce_small")
+	assert(cols(X) - 1 == rows(b) - S.compute_constant) // The 1st column of X is actually Y
+	assert((rows(b) == rows(V)) & (rows(b) == cols(V)))
+	if (S.timeit) timer_off(90)
+
+	// Add base vars
+	if (S.compute_constant) {
+		if (S.verbose > 1) printf("\n{txt}## Adding _cons to varlist\n")
+		assert_msg(rows(S.not_basevar) == 1, "rows(S.not_basevar) == 1")
+		S.not_basevar = S.not_basevar, 1
+		S.fullindepvars = S.fullindepvars + " _cons"
+		S.indepvars = S.indepvars + " _cons"
+	}
+	if (S.not_basevar != J(1, 0, .)) {
+		if (S.verbose > 1) printf("\n{txt}## Adding base variables to varlist\n")
+		k = cols(S.not_basevar)
+		assert_msg(cols(S.not_basevar) == k, "cols(S.not_basevar) == k")
+		idx = `selectindex'(S.not_basevar)
+		swap(b, temp_b)
+		swap(V, temp_V)
+		b = J(k, 1, 0)
+		V = J(k, k, 0)
+		b[idx, 1] = temp_b
+		V[idx, idx] = temp_V
+	}
+
+	st_matrix(bname, b')
+
+	if (S.verbose > 1) printf("\n{txt}## Reporting omitted variables\n")
+	// Add "o." prefix to omitted regressors
+	eps = sqrt(epsilon(1))
+	for (i=1; i<=rows(b); i++) {
+		if (b[i]==0 & S.not_basevar[i] & S.verbose > -1) {
+			printf("{txt}note: %s omitted because of collinearity\n", tokens(S.fullindepvars)[i])
+			//stata(sprintf("_ms_put_omit %s", indepvars[i]))
+			//indepvars[i] = st_global("s(ospec)")
+			// This is now one in reghdfe.ado with -_ms_findomitted-
+		}
+	}
+
+	st_matrix(Vname, V)
+	st_numscalar(nname, N)
+	st_numscalar(rname, rank)
+	st_numscalar(dfrname, df_r)
+
+	// Need to save resids if saving FEs, even if temporarily
+	if (S.residuals == "" & S.save_any_fe) {
+		S.residuals = "__temp_reghdfe_resid__"
+	}
+
+	if (S.residuals != "") {
+		if (S.verbose > 0) printf("\n{txt}## Storing residuals in {res}%s{txt}\n\n", S.residuals)
+		if (S.compact == 1) {
+			S.residuals_vector = resid
+		}
+		else {
+			S.save_variable(S.residuals, resid, "Residuals")
+		}
+	}
+}
+
+
+`Void' function reghdfe_solve_ols(`FixedEffects' S,
+                                  `Variables' X,
+                                  `Vector' b,
+                                  `Matrix' V,
+                                  `Integer' N,
+                                  `Integer' rank,
+                                  `Integer' df_r,
+                                  `Vector' resid,
+                                  `RowVector' kept,
+                                  `String' vce_mode,
+                                | `Variable' true_w)
+{
+	// Hack: the first col of X is actually y!
+	`Integer'				K, KK, tmp_N
+	`Matrix'				xx, inv_xx, W, inv_V, just_X
+	`Vector' 				w
+	`Integer'				used_df_r
+	`Integer'				dof_adj
+	
+	`Boolean'				is_standardized
+	`Real'					stdev_y
+	`RowVector'				stdev_x
+
+	if (true_w == . | args() < 11) true_w = J(0, 1, .)
+	if (S.vcetype == "unadjusted" & S.weight_type=="pweight") S.vcetype = "robust"
+	if (S.verbose > 0) printf("\n{txt}## Solving least-squares regression of partialled-out variables\n\n")
+	assert_in(vce_mode, ("vce_none", "vce_small", "vce_asymptotic"))
+
+	is_standardized = S.all_stdevs != J(1, 0, .)
+	if (is_standardized) S.means = S.means :/ S.all_stdevs
+
+	// Weight FAQ:
+	// - fweight: obs. i represents w[i] duplicate obs. (there is no loss of info wrt to having the "full" dataset)
+	// - aweight: obs. i represents w[i] distinct obs. that were mean-collapsed (so there is loss of info and hetero)
+	//	 soln: normalize them so they sum to N (the true number of obs in our sample), and then treat them as fweight
+	// - pweight: each obs. represents only one obs. from the pop, that was drawn from w[i] individuals
+	//	          we want to make inference on the population, so if we interviewed 100% of the men and only 10% of women,
+	//            then without weighting we would be over-representing men, which leads to a loss of efficiency +-+-
+	// 			  it is the same as aweight + robust
+	// We need to pick N and w
+	N = rows(X) // Default; will change with fweights
+	S.sumweights = S.weight_type != "" ? quadsum(S.weight) : N
+	assert(rows(S.means) == 1)
+	assert(cols(S.means) == cols(X))
+
+	w = 1
+	if (rows(true_w)) {
+		// Custom case for IRLS (ppmlhdfe) where S.weight = mu * true_w
+		assert_msg(S.weight_type == "aweight")
+		N = sum(true_w)
+		w = S.weight * sum(true_w) / sum(S.weight)
+	}
+	else if (S.weight_type=="fweight") {
+		N = S.sumweights
+		w = S.weight
+	}
+	else if (S.weight_type=="aweight" | S.weight_type=="pweight") {
+		w = S.weight * (N / S.sumweights)
+	}
+
+	// Build core matrices
+	if (S.timeit) timer_on(91)
+
+	K = cols(X) - 1
+	xx = quadcross(X, w, X)
+	S.tss_within = xx[1,1]
+	xx = K ? xx[| 2 , 2 \ K+1 , K+1 |] : J(0, 0, .)
+	if (S.timeit) timer_off(91)
+
+	// This matrix indicates what regressors are not collinear
+	assert_msg(cols(S.kept)==K+1, "partial_out() was run with a different set of vars")
+
+	// Bread of the robust VCV matrix
+	// Compute this early so we can update the list of collinear regressors
+	if (S.timeit) timer_on(95)
+	assert_msg( cols(tokens(invtokens(S.indepvars)))==cols(xx) , "HDFE.indepvars is missing or has the wrong number of columns")
+	inv_xx = reghdfe_rmcoll(tokens(invtokens(S.indepvars)), xx, kept) // this modifies -kept-
+
+	// // Workaround for case with extremely high weights, where ivnsym loses precision and incorrectly excludes vars
+	// if (S.has_weights) {
+	// 	if (max(S.weight) > 1e5) {
+	// 		kept = (1..K)
+	// 	}
+	// }
+
+	S.df_m = rank = K - diag0cnt(inv_xx)
+	KK = S.df_a + S.df_m
+	S.df_r = N - KK // replaced when clustering
+	if (S.timeit) timer_off(95)
+
+	// Compute betas
+	// - There are two main options
+	//	 a) Use cholqrsolve on xx and xy. Faster but numerically inaccurate
+	//      See: http://www.stata.com/statalist/archive/2012-02/msg00956.html
+	//   b) Use qrsolve. More accurate but doesn't handle weights easily
+	// - Ended up doing (b) with a hack for weights
+	b = J(K, 1, 0)
+	if (cols(kept)) {
+		if (S.has_weights) {
+			b[kept] = qrsolve(X[., 1:+kept] :* sqrt(S.weight), X[., 1] :* sqrt(S.weight))
+		}
+		else {
+			b[kept] = qrsolve(X[., 1:+kept], X[., 1])
+		}
+	}
+
+	if (S.timeit) timer_on(92)
+	if (!isfleeting(resid) | vce_mode != "vce_none") resid = X * (1 \ -b) // y - X * b
+	if (S.timeit) timer_off(92)
+
+	if (S.compute_constant) {
+		tmp_N = (S.weight_type=="aweight" | S.weight_type=="pweight") ? N : S.sumweights
+		if (rows(true_w)) tmp_N = N
+		reghdfe_extend_b_and_inv_xx(S.means, tmp_N, b, inv_xx)
+	}
+
+	// Stop if no VCE/R2/RSS needed
+	if (vce_mode == "vce_none") {
+		assert(!is_standardized)
+		return
+	}
+
+	if (S.timeit) timer_on(93)
+	if (S.vcetype != "unadjusted") {
+		if (S.compute_constant) {
+			if (isfleeting(X)) {
+				// Save some memory... unsure if it helps
+				swap(just_X, X)
+				just_X = K ? just_X[., 2..K+1] :+ S.means[2..cols(S.means)] : J(rows(just_X), 0, .)
+			}
+			else {
+				just_X = K ? X[., 2..K+1] :+ S.means[2..cols(S.means)] : J(rows(X), 0, .)
+			}
+		}
+		else {
+			just_X = K ? X[., 2..K+1] : J(rows(X), 0, .)
+		}
+	}
+	if (S.timeit) timer_off(93)
+
+	if (S.timeit) timer_on(94)
+	S.rss = quadcross(resid, w, resid) // do before reghdfe_robust() modifies w
+	if (S.timeit) timer_off(94)
+
+	// Compute full VCE
+	if (S.timeit) timer_on(96)
+	assert_msg(anyof( ("unadjusted", "robust", "cluster") , S.vcetype), "invalid vcetype" + S.vcetype)
+	if (S.vcetype == "unadjusted") {
+		if (S.verbose > 0) {
+			printf("{txt}   - Small-sample-adjustment: q = N / (N-df_m-df_a) = %g / (%g - %g - %g) = %g\n", N, N, rank, S.df_a, N / S.df_r )
+		}
+		dof_adj = N / S.df_r
+		if (vce_mode == "vce_asymptotic") dof_adj = N / (N-1) // 1.0
+		V = (S.rss / N) * dof_adj * inv_xx
+	}
+	else if (S.vcetype == "robust") {
+		V = reghdfe_robust(S, just_X, inv_xx, resid, w, N, KK, vce_mode, true_w)
+	}
+	else {
+		V = reghdfe_cluster(S, just_X, inv_xx, resid, w, N, KK, vce_mode)
+	}
+	if (S.timeit) timer_off(96)
+
+	// Wald test: joint significance
+	if (S.timeit) timer_on(97)
+	inv_V = invsym(V[kept, kept]) // this might not be of full rank but numerical inaccuracies hide it
+	if (diag0cnt(inv_V)) {
+		if (S.verbose > -1) printf("{txt}warning: missing F statistic; dropped variables due to collinearity or too few clusters\n")
+		W = .
+	}
+	else if (length(b[kept])==0) {
+		W = .
+	}
+	else {
+		// We could probably do this with the simpler formula instead of Wald
+		W = b[kept]' * inv_V * b[kept] / S.df_m
+		if (missing(W) & S.verbose > -1) printf("{txt}warning: missing F statistic\n")
+	}
+	if (S.timeit) timer_off(97)
+
+	// V can be missing if b is completely absorbed by the FEs
+	if (missing(V)) {
+		if (S.verbose > 0) printf("{txt}   - VCE has missing values, setting it to zeroes (are your regressors all collinear?)\n")
+		V = J(rows(V), rows(V), 0)
+	}
+
+	// Undo standardization
+	if (is_standardized) {
+		// Sanity checks
+		assert(rows(S.all_stdevs)==1)
+		assert(cols(S.all_stdevs) - 1 == rows(b) - S.compute_constant) // Subtract "y" on left; subtract "_cons" on right
+		
+		// Recover stdevs
+		stdev_y = S.all_stdevs[1]
+		stdev_x = K ? S.all_stdevs[2..cols(S.all_stdevs)] : J(1, 0, .)
+		if (S.compute_constant) stdev_x = stdev_x, 1
+		stdev_x = stdev_x :/ stdev_y
+		
+		// Transform output (note that S.tss is already ok)
+		S.rss = S.rss * stdev_y ^ 2
+		S.tss_within = S.tss_within * stdev_y ^ 2
+		resid = resid * stdev_y
+		V = V :/ (stdev_x' * stdev_x)
+		b = b :/ stdev_x'
+	}
+
+	// Results
+	S.title = "Linear regression"
+	// S.model = "ols"
+	used_df_r = N - KK - S.df_a_nested
+	S.r2 = 1 - S.rss / S.tss
+	S.r2_a = 1 - (S.rss / used_df_r) / (S.tss / (N - S.has_intercept ) )
+	S.r2_within = 1 - S.rss / S.tss_within
+	S.r2_a_within = 1 - (S.rss / used_df_r) / (S.tss_within / (used_df_r + rank))
+
+	S.ll = - 0.5 * N * (1 + ln(2 * pi()) + ln(S.rss / N))
+	S.ll_0 = - 0.5 * N * (1 + ln(2 * pi()) + ln(S.tss_within / N))
+
+	S.rmse = sqrt(S.rss / used_df_r)
+	if (used_df_r==0) S.rmse = sqrt(S.rss)
+	S.F = W
+	df_r = S.df_r // reghdfe_cluster might have updated it (this gets returned to the caller function)
+}
+
+
+// --------------------------------------------------------------------------
+// Robust VCE
+// --------------------------------------------------------------------------
+// Advice: Delegate complicated regressions to -avar- and specialized routines
+// BUGBUG: do we standardize X again? so V is well behaved?
+// Notes:
+// - robust is the same as cluster robust where cluster==_n
+// - cluster just "collapses" X_i * e_i for each group, and builds M from that
+
+`Matrix' reghdfe_robust(`FixedEffects' S,
+                        `Variables' X,
+						`Matrix' D,
+						`Variable' resid,
+						`Variable' w,
+						`Integer' N,
+						`Integer' K,
+						`String' vce_mode,
+					    `Variable' true_w)
+{
+	`Matrix'				M, V
+	`Integer'				dof_adj
+
+	if (S.verbose > 0) printf("\n{txt}## Estimating Robust Variance-Covariance Matrix of the Estimators (VCE)\n\n")
+	if (S.verbose > 0) printf("{txt}   - VCE type: {res}%s{txt}\n", S.vcetype)
+	if (S.verbose > 0) printf("{txt}   - Weight type: {res}%s{txt}\n", S.weight_type=="" ? "<none>" : S.weight_type)
+
+	if (rows(true_w)) {
+		assert(S.weight_type=="aweight")
+		w = (resid :* w) :^ 2 :/ true_w // resid^2 * aw^2 * fw
+	}
+	else if (S.weight_type=="") {
+		w = resid :^ 2
+	}
+	else if (S.weight_type=="fweight") {
+		w = resid :^ 2 :* w
+	}
+	else if (S.weight_type=="aweight" | S.weight_type=="pweight") {
+		w = (resid :* w) :^ 2
+	}
+
+	dof_adj = N / (N - K)
+	if (vce_mode == "vce_asymptotic") dof_adj = N / (N-1) // 1.0
+	M = S.compute_constant ? quadcross(X, 1, w, X, 1) : quadcross(X, w, X)
+	if (S.verbose > 0) {
+		printf("{txt}   - Small-sample-adjustment: q = N / (N-df_m-df_a) = %g / (%g - %g - %g) = %g\n", N, N, K-S.df_a, S.df_a, N / (N-K) )
+	}
+	V = D * M * D * dof_adj
+	return(V)
+}
+
+`Matrix' reghdfe_cluster(`FixedEffects' S,
+                        `Variables' X,
+						`Matrix' D,
+						`Variable' resid,
+						`Variable' w,
+						`Integer' N,
+						`Integer' K,
+						`String' vce_mode)
+{
+	`Matrix' 				M, V
+	`Integer'				dof_adj, N_clust, df_r, nested_adj
+	`Integer'				Q, q, g, sign, i, j
+	pointer(`Factor') rowvector FPlist
+	`FactorPointer'			FP
+	`Varlist'				vars
+	`String'				var, var_with_spaces
+	`Boolean'				clustervar_is_absvar, required_fix
+	`Matrix'				tuples
+	`RowVector'				tuple
+	`RowVector'				N_clust_list
+	`Matrix'				joined_levels
+	`Integer'				Msize
+
+	w = resid :* w
+	Msize = cols(X) + S.compute_constant
+
+	vars = S.clustervars
+	Q = cols(vars)
+	if (S.verbose > 0) printf("\n{txt}## Estimating Cluster Robust Variance-Covariance Matrix of the Estimators (VCE)\n\n")
+	if (S.verbose > 0) printf("{txt}   - VCE type: {res}%s{txt} (%g-way clustering)\n", S.vcetype, Q)
+	if (S.verbose > 0) printf("{txt}   - Cluster variables: {res}%s{txt}\n", invtokens(vars))
+	if (S.verbose > 0) printf("{txt}   - Weight type: {res}%s{txt}\n", S.weight_type=="" ? "<none>" : S.weight_type)
+	assert_msg(0 < Q & Q < 10)
+
+	// Get or build factors associated with the clustervars
+	FPlist = J(1, Q, NULL)
+	N_clust_list = J(1, Q, .)
+	for (q=1; q<=Q; q++) {
+		var = vars[q]
+		clustervar_is_absvar = 0
+		for (g=1; g<=S.G; g++) {
+			if (invtokens(S.factors[g].varlist, "#") == var) {
+				clustervar_is_absvar = 1
+				FP = &(S.factors[g])
+				break
+			}
+		}
+		var_with_spaces = subinstr(var, "#", " ")
+		if (!clustervar_is_absvar) FP = &(factor(var_with_spaces, S.sample, ., "", ., ., ., 0))
+		N_clust_list[q] = (*FP).num_levels
+		if (S.verbose > 0) printf("{txt}   - {res}%s{txt} has {res}%g{txt} levels\n", var, N_clust_list[q])
+		FPlist[q] = FP
+	}
+
+	// Build the meat part of the V matrix
+	if (S.verbose > 0) printf("{txt}   - Computing the 'meat' of the VCE\n")
+	M = J(Msize, Msize, 0)
+	tuples = .
+	for (q=1; q<=Q; q++) {
+		tuples = reghdfe_choose_n_k(Q, q, tuples)
+		sign = mod(q, 2) ? 1 : -1 // + with odd number of variables, - with even
+		for (j=1; j<=rows(tuples); j++) {
+			tuple = tuples[j, .]
+			if (S.verbose > 0) printf("{txt}      - Level %g/%g; sublevel %g/%g; M = M %s ClusterVCE(%s)\n", q, Q, j, rows(tuples), sign > 0 ? "+" : "-" , invtokens(strofreal(tuple)))
+			if (q==1) {
+				assert(tuple==j)
+				FP =  FPlist[j]
+			}
+			else if (q==2) {
+				FP = &join_factors( *FPlist[tuple[1]] , *FPlist[tuple[2]] , ., ., 1)
+			}
+			else {
+				joined_levels = (*FPlist[tuple[1]]).levels
+				for (i=2; i<=cols(tuple); i++) {
+					joined_levels = joined_levels, (*FPlist[tuple[i]]).levels
+				}
+				FP = &_factor(joined_levels, ., ., "", ., ., ., 0)
+			}
+			M = M + sign * reghdfe_vce_cluster_meat(FP, X, w, Msize, S.compute_constant)
+		}
+	}
+
+	// Build VCE
+	N_clust = min(N_clust_list)
+	nested_adj = (S.df_a==0) // minor adj. so we match xtreg when the absvar is nested within cluster
+	// (when ..nested.., df_a is zero so we divide N-1 by something that can potentially be N (!))
+	// so we either add the 1 back, or change the numerator (and the N_clust-1 factor!)
+	dof_adj = (N - 1) / (N - nested_adj - K) * N_clust / (N_clust - 1) // adjust for more than 1 cluster
+	if (vce_mode == "vce_asymptotic") dof_adj = N_clust / (N_clust - 1)  // 1.0
+	if (S.verbose > 0) {
+		printf("{txt}   - Small-sample-adjustment: q = (%g - 1) / (%g - %g) * %g / (%g - 1) = %g\n", N, N, K+nested_adj, N_clust, N_clust, dof_adj)
+	}
+	V = D * M * D * dof_adj
+	if (Q > 1) {
+		required_fix = reghdfe_fix_psd(V)
+		if (required_fix) printf("{txt}Warning: VCV matrix was non-positive semi-definite; adjustment from Cameron, Gelbach & Miller applied.\n")
+	}
+
+	// Store e()
+	assert(!missing(S.df_r))
+	df_r = N_clust - 1
+	if (S.df_r > df_r) {
+		S.df_r = df_r
+	}
+	else if (S.verbose > 0) {
+		printf("{txt}   - Unclustered df_r (N - df_m - df_a = %g) are {it:lower} than clustered df_r (N_clust-1 = %g)\n", S.df_r, df_r)
+		printf("{txt}     Thus, we set e(df_r) as the former.\n")
+		printf("{txt}     This breaks consistency with areg but ensures internal consistency\n")
+		printf("{txt}     between vce(robust) and vce(cluster _n)\n")
+	}
+	
+	S.N_clust = N_clust
+	S.N_clust_list = N_clust_list
+
+	return(V)
+}
+
+
+`Matrix' reghdfe_vce_cluster_meat(`FactorPointer' FP,
+                                  `Variables' X,
+                                  `Variable' resid,
+                                  `Integer' Msize,
+                                  `Boolean' compute_constant)
+{
+	`Integer'				i, N_clust
+	`Variables'				X_sorted
+	`Variable'				resid_sorted
+	`Matrix'				X_tmp
+	`Vector'				resid_tmp
+	`RowVector'				Xe_tmp
+	`Matrix'				M
+
+	if (cols(X)==0 & !compute_constant) return(J(0,0,0))
+
+	N_clust = (*FP).num_levels
+	(*FP).panelsetup()
+	X_sorted = (*FP).sort(X)
+	resid_sorted = (*FP).sort(resid)
+	M = J(Msize, Msize, 0)
+
+	if (cols(X)) {
+		for (i=1; i<=N_clust; i++) {
+			X_tmp = panelsubmatrix(X_sorted, i, (*FP).info)
+			resid_tmp = panelsubmatrix(resid_sorted, i, (*FP).info)
+			Xe_tmp = quadcross(1, 0, resid_tmp, X_tmp, compute_constant) // Faster than colsum(e_tmp :* X_tmp)
+			M = M + quadcross(Xe_tmp, Xe_tmp)
+		}		
+	}
+	else {
+		// Workaround for when there are no Xs except for _cons
+		assert(compute_constant)
+		for (i=1; i<=N_clust; i++) {
+			resid_tmp = panelsubmatrix(resid_sorted, i, (*FP).info)
+			M = M + quadsum(resid_tmp) ^ 2
+		}
+	}
+
+	return(M)
+}
+
+
+// Enumerate all combinations of K integers from N integers
+// Kroneker approach based on njc's tuples.ado
+`Matrix' reghdfe_choose_n_k(`Integer' n, `Integer' k, `Matrix' prev_ans)
+{
+	`RowVector' v
+	`Integer' q
+	`Matrix' candidate
+	`Matrix' ans
+	v = 1::n
+	if (k==1) return(v)
+
+	q = rows(prev_ans)
+	assert(q==comb(n, k-1))
+	assert(cols(prev_ans)==k-1)
+	candidate = v # J(q, 1, 1)
+	candidate = candidate , J(n, 1, prev_ans)	
+	ans = select(candidate, candidate[., 1] :< candidate[., 2])
+	return(ans)
+}
+
+
+// --------------------------------------------------------------------------
+// Fix non-positive VCV
+// --------------------------------------------------------------------------
+// If the VCV matrix is not positive-semidefinite, use the fix from
+// Cameron, Gelbach & Miller - Robust Inference with Multi-way Clustering (JBES 2011)
+// 1) Use eigendecomposition V = U Lambda U' where U are the eigenvectors and Lambda = diag(eigenvalues)
+// 2) Replace negative eigenvalues into zero and obtain FixedLambda
+// 3) Recover FixedV = U * FixedLambda * U'
+`Boolean' function reghdfe_fix_psd(`Matrix' V) {
+	`Matrix'				U
+	`Matrix'				lambda
+	`Boolean' 				required_fix
+
+	if (!issymmetric(V)) _makesymmetric(V)
+	if (!issymmetric(V)) exit(error(505))
+	symeigensystem(V, U=., lambda=.)
+	if (min(lambda)<0) {
+		lambda = lambda :* (lambda :>= 0)
+		// V = U * diag(lambda) * U'
+		V = quadcross(U', lambda, U')
+		required_fix = 1
+	}
+	else {
+		required_fix = 0
+	}
+	return(required_fix)
+}
+
+
+// --------------------------------------------------------------------------
+// Remove collinear variables
+// --------------------------------------------------------------------------
+// Based on ivreg2's s_rmcoll2
+`Matrix' reghdfe_rmcoll(`Varlist' varnames,
+                        `Matrix' xx,
+                        `RowVector' kept)
+{
+	`Integer'				K, num_dropped
+	`Matrix'				inv_xx, smat, alt_inv_xx
+	`RowVector'				vl_drop, vl_keep
+
+	assert(rows(xx)==cols(xx))
+	K = cols(xx)
+	inv_xx = K ? invsym(xx, 1..K) : J(0, 0, .)
+	
+	// Specifying the sweep order in invsym() can lead to incorrectly dropped regressors
+	// (EG: with very VERY high weights)
+	// We'll double check in this case
+	num_dropped = diag0cnt(inv_xx)
+	if (K & num_dropped) {
+		alt_inv_xx = invsym(xx)
+		if (num_dropped != diag0cnt(alt_inv_xx)) {
+			inv_xx = alt_inv_xx
+			num_dropped = diag0cnt(alt_inv_xx)
+		}
+	}
+
+	st_numscalar("r(k_omitted)", num_dropped)
+	smat = (diagonal(inv_xx) :== 0)'
+	vl_drop = select(varnames, smat)
+	vl_keep = select(varnames, !smat)
+	if (cols(vl_keep)) st_global("r(varlist)", invtokens(vl_keep))
+	if (cols(vl_drop)) st_global("r(omitted)", invtokens(vl_drop))
+	kept = `selectindex'(!smat) // Return it, so we can exclude these variables from the joint Wald test
+	return(inv_xx)
+}
+
+
+// --------------------------------------------------------------------------
+// Use regression-through-mean and block partition formula to enlarge b and inv(XX)
+// --------------------------------------------------------------------------
+`Void' reghdfe_extend_b_and_inv_xx(
+	`RowVector' 	means,
+	`Integer'		N,
+	`Vector'		b,
+	`Matrix' 		inv_xx)
+{
+	// How to add back _cons:
+	// 1) To recover coefficient, apply "regression through means formula":
+	//	  b0 = mean(y) - mean(x) * b1
+
+	// 2) To recover variance ("full_inv_xx")
+	//	  apply formula for inverse of partitioned symmetric matrix
+	//    http://fourier.eng.hmc.edu/e161/lectures/gaussianprocess/node6.html
+	//    http://www.cs.nthu.edu.tw/~jang/book/addenda/matinv/matinv/
+	//
+	//    Given A = [X'X X'1]		B = [B11 B21']		B = inv(A)
+	//              [1'X 1'1]			[B21 B22 ]
+	//
+	//	  B11 is just inv(xx) (because of Frisch-Waugh)
+	//	  B21 ("side") = means * B11
+	//	  B22 ("corner") = 1 / sumweights * (1 - side * means')
+	//
+	//	- Note that means is NOT A12, but A12/N or A12 / (sum_weights)
+
+	//  - Note: aw and pw (and unweighted) use normal weights,
+	//	  but for fweights we expected S.sumweights
+
+	`RowVector'		means_x, side
+	`Real'			corner
+
+	means_x = cols(means) > 1 ? means[2..cols(means)] : J(1, 0, .)
+	b = b \ means[1] - means_x * b // means * (1 \ -b)
+	corner = (1 / N) + means_x * inv_xx * means_x'
+	side = - means_x * inv_xx
+	inv_xx = (inv_xx , side' \ side , corner)
+
+}
+
+end

30/replication_package/Adofiles/reghdfe_2019/reghdfe_constructor.mata

@@ -0,0 +1,286 @@
+// --------------------------------------------------------------------------
+// FixedEffects constructor (also precomputes factors)
+// --------------------------------------------------------------------------
+
+mata:
+
+`FixedEffects' fixed_effects(`Varlist' absvars,
+						   | `Varname' touse,
+							 `String' weighttype,
+							 `Varname' weightvar,
+							 `Boolean' drop_singletons,
+							 `Boolean' verbose)
+{
+	`FixedEffects'          S
+	`Varname'               absvar, cvars
+	`Integer'               i, j, g, gg, remaining
+	`Vector'                idx
+	`Integer'               spaces
+	`Integer'               num_singletons_i
+	`Variables'             cvar_data
+	`FactorPointer'         pf
+
+	// Set default value of arguments
+	if (args()<2) touse = ""
+	if (args()<3) weighttype = ""
+	if (args()<4) weightvar = ""
+	if (args()<5 | drop_singletons==.) drop_singletons = 1
+	if (args()<6 | verbose==.) verbose = 0
+	
+	S = FixedEffects()
+	S.verbose = verbose
+	S.drop_singletons = drop_singletons
+
+	// Parse absvars
+	if (S.verbose > 0) printf("\n{txt}## Parsing absvars and HDFE options\n")
+	
+	if (touse == "") touse = st_tempname()
+	st_global("reghdfe_touse", touse)
+	stata(`"reghdfe_parse "' + absvars)
+	S.sample = `selectindex'(st_data(., touse))
+	S.tousevar = touse // useful if later on we want to clone the HDFE object
+	st_global("reghdfe_touse", "")
+
+	if (st_global("s(residuals)") != "") S.residuals = st_global("s(residuals)")
+	if (st_global("s(verbose)")!="") S.verbose = verbose = strtoreal(st_global("s(verbose)"))
+	if (st_global("s(drop_singletons)")!="") S.drop_singletons = drop_singletons = strtoreal(st_global("s(drop_singletons)"))
+	assert(S.verbose < .)
+	assert(S.drop_singletons==0 | S.drop_singletons==1)
+
+	if (S.verbose > 0) stata("sreturn list")
+	S.G = strtoreal(st_global("s(G)"))
+	S.absorb = absvars // useful if later on we want to clone the HDFE object
+	S.absvars = tokens(st_global("s(absvars)"))
+	S.has_intercept = strtoreal(st_global("s(has_intercept)"))
+	S.save_any_fe = strtoreal(st_global("s(save_any_fe)"))
+	S.save_all_fe = strtoreal(st_global("s(save_all_fe)"))
+	S.ivars = tokens(st_global("s(ivars)"))
+	S.cvars = tokens(st_global("s(cvars)"))
+	S.targets = strtrim(tokens(st_global("s(targets)")))
+	S.intercepts = strtoreal(tokens(st_global("s(intercepts)")))
+	S.num_slopes = strtoreal(tokens(st_global("s(num_slopes)")))
+	S.save_fe = S.targets :!= ""
+	S.report_constant = strtoreal(st_global("s(report_constant)"))
+	S.always_run_lsmr_preconditioner = strtoreal(st_global("s(precondition)"))
+
+	// Ensure that S.report_constant and S.has_intercept are 0/1
+	assert(anyof((0,1), S.has_intercept))
+	assert(anyof((0,1), S.report_constant))
+	S.compute_constant = S.has_intercept & S.report_constant
+
+	if (st_global("s(tolerance)") != "") S.tolerance = strtoreal(st_global("s(tolerance)"))
+	if (st_global("s(maxiter)") != "") S.maxiter = strtoreal(st_global("s(maxiter)"))
+	if (st_global("s(prune)") != "") S.prune = strtoreal(st_global("s(prune)"))
+	if (st_global("s(transform)") != "") S.transform = st_global("s(transform)")
+	if (st_global("s(acceleration)") != "") S.acceleration = st_global("s(acceleration)")
+
+	// Override LSMR if G=1
+	if (S.G==1 & S.acceleration=="lsmr") S.acceleration = "conjugate_gradient"
+
+	S.dofadjustments = tokens(st_global("s(dofadjustments)"))
+	S.groupvar = st_global("s(groupvar)")
+	if (st_global("s(finite_condition)")=="1") S.finite_condition = -1 // signal to compute it
+	S.compute_rre = (st_global("s(compute_rre)")=="1")
+	if (S.compute_rre) S.rre_varname = st_global("s(rre)")
+	
+	S.poolsize = strtoreal(st_global("s(poolsize)"))
+
+	if (S.verbose > -1 & !S.has_intercept) printf("{txt}(warning: no intercepts terms in absorb(); regression lacks constant term)\n")
+
+	S.extended_absvars = tokens(st_global("s(extended_absvars)"))
+	S.tss = .
+
+	assert(1<=S.G)
+	if (S.G>10) printf("{txt}(warning: absorbing %2.0f dimensions of fixed effects; check that you really want that)\n", S.G)
+	assert(S.G == cols(S.ivars))
+	assert(S.G == cols(S.cvars))
+	assert(S.G == cols(S.targets))
+	assert(S.G == cols(S.intercepts))
+	assert(S.G == cols(S.num_slopes))
+
+	// Fill out object
+	S.G = cols(S.absvars)
+	S.factors = Factor(S.G)
+
+	assert_msg(anyof(("", "fweight", "pweight", "aweight", "iweight"), weighttype), "wrong weight type")
+	S.weight_type = weighttype
+	S.weight_var = weightvar
+
+	S.num_singletons = 0
+	if (drop_singletons) {
+		num_singletons_i = 0
+		if (weighttype=="fweight" | weighttype=="iweight") {
+			S.weight = st_data(S.sample, weightvar) // just to use it in F.drop_singletons()
+		}
+	}
+
+
+	// (1) create the factors and remove singletons
+	remaining = S.G
+	i = 0
+	if (S.verbose > 0) {
+		printf("\n{txt}## Initializing Mata object for %g fixed effects\n\n", S.G)
+		spaces = max((0, max(strlen(S.absvars))-4))
+		printf("{txt}   {c TLC}{hline 4}{c TT}{hline 3}{c TT}{hline 1}%s{hline 6}{c TT}{hline 6}{c TT}{hline 9}{c TT}{hline 11}{c TT}{hline 12}{c TT}{hline 9}{c TT}{hline 14}{c TRC}\n", "{hline 1}" * spaces)
+		printf("{txt}   {c |}  i {c |} g {c |} %s Name {c |} Int? {c |} #Slopes {c |}    Obs.   {c |}   Levels   {c |} Sorted? {c |} #Drop Singl. {c |}\n", " " * spaces)
+		printf("{txt}   {c LT}{hline 4}{c +}{hline 3}{c +}{hline 1}%s{hline 6}{c +}{hline 6}{c +}{hline 9}{c +}{hline 11}{c +}{hline 12}{c +}{hline 9}{c +}{hline 14}{c RT}\n", "{hline 1}" * spaces)
+		displayflush()
+	}
+
+	while (remaining) {
+		++i
+		g = 1 + mod(i-1, S.G)
+		absvar = S.absvars[g]
+		
+		if (S.verbose > 0) {
+			printf("{txt}   {c |} %2.0f {c |} %1.0f {c |} {res}%s{txt} {c |} ", i, g, (spaces+5-strlen(absvar)) * " " + absvar)
+			printf("{txt}{%s}%3s{txt}  {c |}    %1.0f    {c |}", S.intercepts[g] ? "txt" : "err", S.intercepts[g] ? "Yes" : "No", S.num_slopes[g])
+			displayflush()
+		}
+
+		if (S.verbose > 0) {
+			printf("{res}%10.0g{txt} {c |}", rows(S.sample))
+			displayflush()
+		}
+
+		if (rows(S.sample) < 2) {
+			if (S.verbose > 0) printf("\n")
+			exit(error(2001))
+		}
+
+		if (i<=S.G) {
+			if (S.ivars[g] == "_cons" & S.G == 1) {
+				// Special case without any fixed effects
+
+				S.factors[g] = Factor()
+				pf = &(S.factors[g])
+				(*pf).num_obs = (*pf).counts = rows(S.sample)
+				(*pf).num_levels = 1
+				//(*pf).levels = . // Not filled to save space
+				(*pf).levels = J(rows(S.sample), 1, 1)
+				(*pf).is_sorted = 1
+				(*pf).method = "none"
+
+				// The code below is equivalent but 3x slower
+				// S.factors[g] = _factor(J(rows(S.sample),1,1), 1, ., "hash0", ., 1, ., 0)
+			}
+			else {
+				// We don't need to save keys (or sort levels but that might change estimates of FEs)
+				S.factors[g] = factor(S.ivars[g], S.sample, ., "", ., 1, ., 0)
+			}
+		}
+
+		if (S.verbose > 0) {
+			printf(" {res}%10.0g{txt} {c |} %7s {c |}", S.factors[g].num_levels, S.factors[g].is_sorted ? "Yes" : "No")
+			displayflush()
+		}
+ 
+		if (drop_singletons) {
+			
+			if (weighttype=="fweight") {
+				idx = S.factors[g].drop_singletons(S.weight)
+			}
+			else if (weighttype=="iweight") {
+				idx = S.factors[g].drop_singletons(S.weight, 1) // zero_threshold==1
+			}
+			else {
+				idx = S.factors[g].drop_singletons()
+			}
+
+			num_singletons_i = rows(idx)
+			S.num_singletons = S.num_singletons + num_singletons_i
+			if (S.verbose > 0) {
+				printf(" %10.0g   {c |}", num_singletons_i)
+				displayflush()
+			}
+
+			if (num_singletons_i==0) {
+				--remaining
+			}
+			else {
+				remaining = S.G - 1
+				
+				// sample[idx] = . // not allowed in Mata; instead, make 0 and then select()
+				S.sample[idx] = J(rows(idx), 1, 0)
+				S.sample = select(S.sample, S.sample)
+
+				for (j=i-1; j>=max((1, i-remaining)); j--) {
+					gg = 1 + mod(j-1, S.G)
+					S.factors[gg].drop_obs(idx)
+					if (S.verbose > 0) printf("{res} .")
+				}
+			}
+		}
+		else {
+			if (S.verbose > 0) printf("      n/a     {c |}")
+			--remaining
+		}
+		if (S.verbose > 0) printf("\n")
+	}
+	if (S.verbose > 0) {
+		printf("{txt}   {c BLC}{hline 4}{c BT}{hline 3}{c BT}{hline 1}%s{hline 6}{c BT}{hline 6}{c BT}{hline 9}{c BT}{hline 11}{c BT}{hline 12}{c BT}{hline 9}{c BT}{hline 14}{c BRC}\n", "{hline 1}" * spaces)
+	}
+
+	if ( drop_singletons & S.num_singletons>0 & S.verbose>-1 | S.factors[1].num_obs<2) {
+		if (weighttype=="iweight") {
+			// PPML-specific
+			printf(`"{txt}(dropped %s observations that are either {browse "http://scorreia.com/research/singletons.pdf":singletons} or {browse "http://scorreia.com/research/separation.pdf":separated} by a fixed effect)\n"', strofreal(S.num_singletons))
+		}
+		else {
+			printf(`"{txt}(dropped %s {browse "http://scorreia.com/research/singletons.pdf":singleton observations})\n"', strofreal(S.num_singletons))
+		}
+	}
+
+	if (S.factors[1].num_obs < 2) {
+		exit(error(2001))
+	}
+
+	S.N = S.factors[1].num_obs // store number of obs.
+	assert(S.N = S.factors[S.G].num_obs)
+	assert(S.N > 1)
+
+
+	// (2) run *.panelsetup() after the sample is defined
+	if (S.verbose > 0) printf("\n{txt}## Initializing panelsetup() for each fixed effect\n\n")
+	for (g=1; g<=S.G; g++) {
+		absvar = S.absvars[g]
+		if (S.verbose > 0) printf("{txt}   - panelsetup({res}%s{txt})\n", absvar)
+		S.factors[g].panelsetup()
+	}
+
+	// (3) load cvars
+	if (sum(S.num_slopes)) {
+		if (S.verbose > 0) printf("\n{txt}## Loading slope variables\n\n")
+		for (g=1; g<=S.G; g++) {
+			cvars = tokens(S.cvars[g])
+			if (S.num_slopes[g]) {
+				// Load, standardize, sort by factor and store
+				// Don't precompute aux objects (xmeans, inv_xx) as they depend on the weights
+				// and will be computed on step (5)
+				if (S.verbose > 0) printf("{txt}   - cvars({res}%s{txt})\n", invtokens(cvars))
+				pf = &(S.factors[g])
+				cvar_data = (*pf).sort(st_data(S.sample, cvars))
+				asarray((*pf).extra, "x_stdevs", reghdfe_standardize(cvar_data))
+				asarray((*pf).extra, "x", cvar_data)
+			}
+		}
+		cvar_data = .
+	}
+
+	// (4) prune edges of degree-1
+	// S.prune = 0 // bugbug
+	if (S.prune) S.prune_1core()
+
+	// (5) load weight
+	S.load_weights(weighttype, weightvar, J(0,1,.), 1) // update S.has_weights, S.factors, etc.
+
+	// Save "true" residuals for RRE
+	if (S.compute_rre) {
+		assert_msg(S.rre_varname != "")
+		S.rre_true_residual = st_data(S.sample, S.rre_varname)
+	}
+
+	return(S)
+}
+
+end

30/replication_package/Adofiles/reghdfe_2019/reghdfe_estat.ado

@@ -0,0 +1,36 @@
+program reghdfe_estat, rclass
+	version `=cond(c(version)<14, c(version), 13)'
+	if !inlist("`e(cmd)'", "reghdfe", "ppmlhdfe") {
+		error 301
+	}
+	
+	gettoken key 0 : 0, parse(", ")
+	local lkey = length(`"`key'"')
+
+	if `"`key'"' == substr("summarize",1,max(2,`lkey')) {
+
+		local 0 `rest'
+		syntax [anything] , [*] [noheader] // -noheader- gets silently ignored b/c it will always be -on-
+
+		**if ("`anything'"=="") {
+		**	* By default include the instruments
+		**	local anything // `e(depvar)' `e(indepvars)' `e(endogvars)' `e(instruments)'
+		**}
+
+		* Need to use -noheader- as a workaround to the bug in -estat_summ-
+		estat_summ `anything' , `options' noheader
+
+	}
+	else if `"`key'"' == "vce" {
+		vce `0'
+	}
+	else if `"`key'"' == "ic" {
+		syntax, [*]
+		estat_default ic, df(`=e(df_m)+1') `options'
+	}
+	else {
+		di as error `"invalid subcommand `key'"'
+		exit 321
+	}
+	return add // ?
+end

30/replication_package/Adofiles/reghdfe_2019/reghdfe_footnote.ado

@@ -0,0 +1,60 @@
+// -------------------------------------------------------------
+// Display Regression Footnote
+// -------------------------------------------------------------
+program reghdfe_footnote
+syntax [, width(int 13)]
+
+	if (`"`e(absvars)'"' == "_cons") {
+		exit
+	}
+
+	tempname table
+	matrix `table' = e(dof_table)
+	mata: st_local("var_width", strofreal(max(strlen(st_matrixrowstripe("`table'")[., 2]))))
+	if (`var_width' > `width') loc width = `var_width'
+	loc rows = rowsof("`table'")
+	loc cols = rowsof("`table'")
+	local vars : rownames `table'
+
+	// Setup table
+	di as text _n "Absorbed degrees of freedom:"
+	tempname mytab
+	.`mytab' = ._tab.new, col(5) lmargin(0)
+	.`mytab'.width	 `width'  | 12  	    12    		14 			1 |
+	.`mytab'.pad		.		 1     		 1		   	 1			0
+	.`mytab'.numfmt		.		%9.0g		%9.0g		%9.0g	  	.
+	.`mytab'.numcolor	.		text 		text		result		.
+	.`mytab'.sep, top
+
+	local explain_exact 0
+	local explain_nested 0
+	
+	// Header
+	.`mytab'.titles "Absorbed FE" "Categories" " - Redundant" "  = Num. Coefs" ""
+	.`mytab'.sep, middle
+
+	// Body	
+	forval i = 1/`rows' {
+		local var : word `i' of `vars'
+		loc var = subinstr("`var'", "1.", "", .)
+		loc note " "
+		if (`=`table'[`i', 4]'==1) {
+			loc note "?"
+			loc explain_exact 1
+		}
+		if (`=`table'[`i', 5]'==1) {
+			loc note "*"
+			loc explain_nested 1
+		}
+
+		// noabsorb
+		if (`rows'==1 & `=`table'[`i', 1]'==1 & strpos("`var'", "__")==1) loc var "_cons"
+
+		.`mytab'.row "`var'" `=`table'[`i', 1]' `=`table'[`i', 2]' `=`table'[`i', 3]' "`note'"
+	}
+
+	// Bottom
+	.`mytab'.sep, bottom
+	if (`explain_exact') di as text "? = number of redundant parameters may be higher"
+	if (`explain_nested') di as text `"* = FE nested within cluster; treated as redundant for DoF computation"'
+end

30/replication_package/Adofiles/reghdfe_2019/reghdfe_header.ado

@@ -0,0 +1,181 @@
+* (Modified from _coef_table_header.ado)
+
+program reghdfe_header
+	if !c(noisily) exit
+
+	tempname left right
+	.`left' = {}
+	.`right' = {}
+
+	local width 78
+	local colwidths 1 30 51 67
+	local i 0
+	foreach c of local colwidths {
+		local ++i
+		local c`i' `c'
+		local C`i' _col(`c')
+	}
+
+	local c2wfmt 10
+	local c4wfmt 10
+	local max_len_title = `c3' - 2
+	local c4wfmt1 = `c4wfmt' + 1
+	local title  `"`e(title)'"'
+	local title2 `"`e(title2)'"'
+	local title3 `"`e(title3)'"'
+	local title4 `"`e(title4)'"'
+	local title5 `"`e(title5)'"'
+
+	// Right hand header ************************************************
+
+	*N obs
+	.`right'.Arrpush `C3' "Number of obs" `C4' "= " as res %`c4wfmt'.0fc e(N)
+
+	* Ftest
+	if `"`e(chi2)'"' != "" | "`e(df_r)'" == "" {
+		Chi2test `right' `C3' `C4' `c4wfmt'
+	}
+	else {
+		Ftest `right' `C3' `C4' `c4wfmt'
+	}
+
+	* display R-squared
+	if !missing(e(r2)) {
+		.`right'.Arrpush `C3' "R-squared" `C4' "= " as res %`c4wfmt'.4f e(r2)
+	}
+	*if !missing(e(r2_p)) {
+	*	.`right'.Arrpush `C3' "Pseudo R2" `C4' "= " as res %`c4wfmt'.4f e(r2_p)
+	*}
+	if !missing(e(r2_a)) {
+		.`right'.Arrpush `C3' "Adj R-squared" `C4' "= " as res %`c4wfmt'.4f e(r2_a)
+	}
+	if !missing(e(r2_within)) {
+		.`right'.Arrpush `C3' "Within R-sq." `C4' "= " as res %`c4wfmt'.4f e(r2_within)
+	}
+	if !missing(e(rmse)) {
+		.`right'.Arrpush `C3' "Root MSE" `C4' "= " as res %`c4wfmt'.4f e(rmse)
+	}
+
+	// Left hand header *************************************************
+
+	* make title line part of the header if it fits
+	local len_title : length local title
+	forv i=2/5 {
+		if (`"`title`i''"'!="") {
+			local len_title = max(`len_title',`:length local title`i'')
+		}
+	}
+	
+	if `len_title' < `max_len_title' {
+		.`left'.Arrpush `"`"`title'"'"'
+		local title
+		forv i=2/5 {
+			if `"`title`i''"' != "" {
+					.`left'.Arrpush `"`"`title`i''"'"'
+					local title`i'
+			}
+		}
+		.`left'.Arrpush "" // Empty
+	}
+
+	* Clusters
+	local kr = `.`right'.arrnels' // number of elements in the right header
+	local kl = `.`left'.arrnels' // number of elements in the left header
+	local N_clustervars = e(N_clustervars)
+	if (`N_clustervars'==.) local N_clustervars 0
+	local space = `kr' - `kl' - `N_clustervars'
+	local clustvar = e(clustvar)
+	forv i=1/`space' {
+		.`left'.Arrpush ""
+	}
+	forval i = 1/`N_clustervars' {
+		gettoken cluster clustvar : clustvar
+		local num = e(N_clust`i')
+		.`left'.Arrpush `C1' "Number of clusters (" as res "`cluster'" as text  ") " `C2' as text "= " as res %`c2wfmt'.0fc `num'
+	}
+	
+	HeaderDisplay `left' `right' `"`title'"' `"`title2'"' `"`title3'"' `"`title4'"' `"`title5'"'
+end
+
+program HeaderDisplay
+		args left right title1 title2 title3 title4 title5
+
+		local nl = `.`left'.arrnels'
+		local nr = `.`right'.arrnels'
+		local K = max(`nl',`nr')
+
+		di
+		if `"`title1'"' != "" {
+				di as txt `"`title'"'
+				forval i = 2/5 {
+					if `"`title`i''"' != "" {
+							di as txt `"`title`i''"'
+					}
+				}
+				if `K' {
+						di
+				}
+		}
+
+		local c _c
+		forval i = 1/`K' {
+				di as txt `.`left'[`i']' as txt `.`right'[`i']'
+		}
+end
+
+program Ftest
+		args right C3 C4 c4wfmt is_svy
+
+		local df = e(df_r)
+		if !missing(e(F)) {
+				.`right'.Arrpush                                ///
+						 `C3' "F("                              ///
+				   as res %4.0f e(df_m)                         ///
+				   as txt ","                                   ///
+				   as res %7.0f `df' as txt ")" `C4' "= "       ///
+				   as res %`c4wfmt'.2f e(F)
+				.`right'.Arrpush                                ///
+						 `C3' "Prob > F" `C4' "= "              ///
+				   as res %`c4wfmt'.4f Ftail(e(df_m),`df',e(F))
+		}
+		else {
+				local dfm_l : di %4.0f e(df_m)
+				local dfm_l2: di %7.0f `df'
+				local j_robust "{help j_robustsingular##|_new:F(`dfm_l',`dfm_l2')}"
+				.`right'.Arrpush                                ///
+						  `C3' "`j_robust'"                     ///
+				   as txt `C4' "= " as result %`c4wfmt's "."
+				.`right'.Arrpush                                ///
+						  `C3' "Prob > F" `C4' "= " as res %`c4wfmt's "."
+		}
+end
+
+program Chi2test
+
+		args right C3 C4 c4wfmt
+
+		local type `e(chi2type)'
+		if `"`type'"' == "" {
+				local type Wald
+		}
+		if !missing(e(chi2)) {
+				.`right'.Arrpush                                ///
+						  `C3' "`type' chi2("                   ///
+				   as res e(df_m)                               ///
+				   as txt ")" `C4' "= "                         ///
+				   as res %`c4wfmt'.2f e(chi2)
+				.`right'.Arrpush                                ///
+						  `C3' "Prob > chi2" `C4' "= "          ///
+				   as res %`c4wfmt'.4f chi2tail(e(df_m),e(chi2))
+		}
+		else {
+				local j_robust                                  ///
+				"{help j_robustsingular##|_new:`type' chi2(`e(df_m)')}"
+				.`right'.Arrpush                                ///
+						  `C3' "`j_robust'"                     ///
+				   as txt `C4' "= " as res %`c4wfmt's "."
+				.`right'.Arrpush                                ///
+						  `C3' "Prob > chi2" `C4' "= "          ///
+				   as res %`c4wfmt's "."
+		}
+end

30/replication_package/Adofiles/reghdfe_2019/reghdfe_lsmr.mata

@@ -0,0 +1,235 @@
+mata:
+
+// --------------------------------------------------------------------------
+// LSMR estimation: Solve Ax=b with LS (ignore consistent case) (A?=y) (Z=D?)
+// --------------------------------------------------------------------------
+// Source: http://web.stanford.edu/group/SOL/software/lsmr/
+// Code based on https://github.com/timtylin/lsmr-SLIM/blob/master/lsmr.m
+// Copyright (BSD2): https://github.com/timtylin/lsmr-SLIM/blob/master/license.txt
+
+// Requirements
+// A(x, 1) = Ax     Projections "xβ"
+// A(x, 2) = A'x    Sum of y by group; panelmean() if dummies and w/precond
+
+`Vector' lsmr(`FixedEffects' S, `Vector' b, `Vector' x) {
+    `Real' eps
+    `Integer' iter // m, n
+    `Real' beta, zetabar, alphabar, rho, rhobar, cbar, sbar
+    `Real' betadd, betad, rhodold, tautildeold, thetatilde, zeta, d
+    `Real' normA2, maxrbar, minrbar
+    `Real' normb, normr
+    `Real' test1, test2, test3
+    `Vector' u, v, h, hbar
+
+    `Real' alpha, alphahat, lambda, chat, shat, rhoold, c, s, thetanew, rhobarold, zetaold, stildeold
+    `Real' thetabar, rhotemp, betaacute, betacheck, betahat, thetatildeold, rhotildeold, ctildeold, taud
+    `Real' normA, normAr, condA, normx, rtol
+
+    assert(cols(b)==1)
+    if (S.verbose > 0) printf("\n{txt}## Computing LSMR\n\n")
+
+    // Constants
+    eps = epsilon(1)
+    
+    lambda = 0 // not used
+    S.converged = 0
+
+    beta = S.lsmr_norm(b)
+    assert_msg(beta < . , "beta is missing")
+    u = (beta > eps) ? (b / beta) : b
+    v = S.lsmr_At_mult(u) // v = (*A)(u, 2)
+    assert_msg(!missing(v), "-v- missing")
+    // m = rows(v) // A is m*n
+    // n = rows(u)
+
+    alpha = S.lsmr_norm(v)
+    assert_msg(alpha < . , "alpha is missing")
+    if (alpha > eps) v = v / alpha
+
+    // Initialize variables for 1st iteration.
+    zetabar = alpha * beta
+    alphabar = alpha
+    rho = rhobar = cbar = 1
+    sbar = 0
+
+    h = v
+    hbar = J(rows(h), 1, 0) // remove this
+    //x = J(rows(h), 1, 0)
+
+    // Initialize variables for estimation of ||r||
+    betadd = beta
+    betad = 0
+    rhodold = 1
+    tautildeold = 0
+    thetatilde = 0
+    zeta = 0
+    d = 0
+
+    // Initialize variables for estimation of ||A|| and cond(A)
+    normA2  = alpha ^ 2
+    maxrbar = 0
+    minrbar = 1e+100
+
+    // Items for use in stopping rules.
+    normb = beta
+    normr = beta
+
+    // Exit if b=0 or A'b = 0.
+    normAr = alpha * beta
+    if (normAr == 0) {
+        "DONE -> UPDATE THIS STOPPING CONDITION"
+        return
+    }
+
+    if (S.verbose > 1) {
+        "< < < <"
+        test1 = 1
+        test2 = alpha / beta
+        printf(" %10.3e %10.3e\n", normr, normAr )
+        printf("  %8.1e %8.1e\n" , test1, test2  )
+        "> > > > "
+    }
+
+    // Main loop
+
+    for (iter=1; iter<=S.maxiter; iter++) {
+
+        // Update (1) βu = Av - αu (2) αv = A'u - βv
+        u = S.lsmr_A_mult(v) - alpha * u // u = (*A)(v, 1) - alpha * u
+
+        //"hash of u"
+        //hash1(round(u*1e5))
+        //u[1..5]
+
+        beta = S.lsmr_norm(u)
+        if (beta > eps) u = u / beta
+
+        v = S.lsmr_At_mult(u) - beta * v // v = (*A)(u, 2) - beta * v
+        alpha  = S.lsmr_norm(v)
+        if (alpha > eps) v = v / alpha
+        
+        // α and β are now on iteration {k+1}
+
+        // Construct rotation Qhat_{k, 2k+1}
+        alphahat = S.lsmr_norm((alphabar, lambda))
+        assert_msg(alphahat < . , "alphahat is missing")
+        chat = alphabar / alphahat
+        shat = lambda / alphahat
+
+        // Use a plane rotation (Q_i) to turn B_i to R_i.
+        rhoold = rho
+        rho = norm((alphahat, beta))
+        c = alphahat / rho
+        s = beta / rho
+        thetanew = s * alpha
+        alphabar = c * alpha
+
+        // Use a plane rotation (Qbar_i) to turn R_i^T to R_i^bar.
+        rhobarold = rhobar
+        zetaold = zeta
+        thetabar = sbar * rho
+        rhotemp = cbar * rho
+        rhobar = norm((cbar * rho, thetanew))
+        cbar = cbar * rho / rhobar
+        sbar = thetanew / rhobar
+        zeta =   cbar * zetabar
+        zetabar = -sbar * zetabar
+
+        // Update h, h_hat, x
+        hbar = iter > 1 ? h - (thetabar * rho / (rhoold * rhobarold)) * hbar : h
+        assert_msg(!missing(hbar), "hbar missing")
+        x = iter > 1 ? x + (zeta / (rho * rhobar)) * hbar  : (zeta / (rho * rhobar)) * hbar
+        assert_msg(!missing(x), "x missing")
+        h = v - (thetanew / rho) * h
+
+        // Estimate of ||r||
+        
+        // Apply rotation Qhat_{k,2k+1}
+        betaacute =  chat * betadd
+        betacheck = -shat * betadd
+
+        // Apply rotation Q_{k,k+1}
+        betahat   =  c * betaacute;
+        betadd    = -s * betaacute;
+          
+        // Apply rotation Qtilde_{k-1}
+        // betad = betad_{k-1} here
+        thetatildeold = thetatilde
+        rhotildeold = norm((rhodold, thetabar))
+        ctildeold = rhodold / rhotildeold
+        stildeold = thetabar / rhotildeold
+        thetatilde = stildeold * rhobar
+        rhodold = ctildeold * rhobar
+        betad = -stildeold * betad + ctildeold * betahat
+    
+        // betad   = betad_k here
+        // rhodold = rhod_k  here
+        tautildeold   = (zetaold - thetatildeold * tautildeold) / rhotildeold
+        taud          = (zeta - thetatilde * tautildeold) / rhodold
+        d             = d + betacheck^2
+        normr         = sqrt(d + (betad - taud)^2 + betadd^2)
+        
+        // Estimate ||A||.
+        normA2        = normA2 + beta^2
+        normA         = sqrt(normA2)
+        normA2        = normA2 + alpha^2
+    
+        // Estimate cond(A)
+        maxrbar = max((maxrbar,rhobarold))
+        if (iter > 1) minrbar = min((minrbar,rhobarold))
+        condA = max((maxrbar,rhotemp)) / min((minrbar,rhotemp))
+
+        // Test for convergence.
+
+        // Compute norms for convergence testing.
+        normAr  = abs(zetabar)
+        normx   = S.lsmr_norm(x)
+
+        // Now use these norms to estimate certain other quantities,
+        // some of which will be small near a solution.
+        test1   = normr  / normb
+        test2   = normAr / (normA*normr)
+        test3   =      1 / condA
+        rtol    = S.btol + S.tolerance *normA*normx / normb
+    
+        // The following tests guard against extremely small values of
+        // atol, btol or ctol.  (The user may have set any or all of
+        // the parameters atol, btol, conlim  to 0.)
+        // The effect is equivalent to the normAl tests using
+        // atol = eps,  btol = eps,  conlim = 1/eps.
+
+        // Allow for tolerances set by the user.
+
+        if  (test3 <= 1 / S.conlim) S.converged = 3
+        if  (test2 <= S.tolerance) S.converged = 2
+        if  (test1 <= rtol) S.converged = 1
+
+        if (S.verbose > 1) {
+            printf(" - Convergence: %g\n", S.converged)
+            "iter normr normAr"
+            iter, normr, normAr
+            "test1 test2 test3"
+            test1, test2, test3
+            "criteria1 criteria2 criteria3"
+            1/S.conlim , S.tolerance, rtol
+            ">>>"
+        }
+        
+        if (S.compute_rre & !S.prune) {
+            reghdfe_rre_benchmark(b - S.lsmr_A_mult(x), S.rre_true_residual, S.rre_depvar_norm)
+        }
+        
+        if (S.converged) break
+    }
+
+    if (!S.converged) {
+        printf("\n{err}convergence not achieved in %g iterations (last error=%e); try increasing maxiter() or decreasing tol().\n", S.maxiter, test2)
+        exit(430)
+    }
+
+    S.iteration_count = max((iter, S.iteration_count))
+
+    u = b - S.lsmr_A_mult(x)
+    return(u)
+}
+end

30/replication_package/Adofiles/reghdfe_2019/reghdfe_mata.sthlp

@@ -0,0 +1,346 @@
+{smcl}
+{* *! version 4.4.0 11sep2017}{...}
+{vieweralsosee "reghdfe" "help reghdfe"}{...}
+{vieweralsosee "ftools" "help ftools"}{...}
+{viewerjumpto "Syntax" "ftools##syntax"}{...}
+{viewerjumpto "Creation" "ftools##creation"}{...}
+{viewerjumpto "Properties and methods" "ftools##properties"}{...}
+{viewerjumpto "Description" "ftools##description"}{...}
+{viewerjumpto "Usage" "ftools##usage"}{...}
+{viewerjumpto "Example" "ftools##example"}{...}
+{viewerjumpto "Remarks" "ftools##remarks"}{...}
+{viewerjumpto "Using functions from collapse" "ftools##collapse"}{...}
+{viewerjumpto "Experimental/advanced" "ftools##experimental"}{...}
+{viewerjumpto "Source code" "ftools##source"}{...}
+{viewerjumpto "Author" "ftools##contact"}{...}
+
+{title:Title}
+
+{p2colset 5 22 22 2}{...}
+{p2col :{cmd:FixedEffects} {hline 2}}Mata class behind {cmd:reghdfe}{p_end}
+{p2colreset}{...}
+
+{marker syntax}{...}
+{title:Syntax}
+
+{pstd}
+{it}To construct the object:
+
+
+{p 8 16 2}
+{it:class FixedEffects}
+{cmd:fixed_effects(}{space 1}{it:absvars} [
+{cmd:,}
+{it:touse}{cmd:,} 
+{it:weighttype}{cmd:,} 
+{it:weightvar}{cmd:,} 
+{it:drop_singletons}{cmd:,} 
+{it:verbose}]{cmd:)}
+
+{marker arguments}{...}
+{synoptset 38 tabbed}{...}
+{synopthdr}
+{synoptline}
+{p2coldent:* {it:string} absvars}names of variables that identify each set of fixed effects{p_end}
+{synopt:{it:string} touse}name of dummy {help mark:touse} variable{p_end}
+{synopt:{it:string} weighttype}type of weight (fweight, pweight, aweight, iweight){p_end}
+{synopt:{it:string} weightvar}name of weight variable{p_end}
+{synopt:{it:string} drop_singletons}whether to drop singleton groups or not{p_end}
+{synopt:{it:string} verbose}how much information to report
+(0: report warnings, 1 to 4 reports more details, -1 is silent){p_end}
+{p2colreset}{...}
+
+
+{marker usage}{...}
+{title:Standard usage}
+
+{pstd}(optional) First, you can declare the FixedEffects object:
+
+{p 8 8 2}
+{cmd:class FixedEffects}{it: HDFE}{break}
+
+{pstd}Then, you create the object from categorical variables, categorical-continuous interactions, etc.:
+
+{p 8 8 2}
+{it:HDFE }{cmd:=}{bind: }{cmd:fixed_effects(}{it:varnames}{cmd:)}
+
+{pstd}
+Then you can modify the object and add important properties:
+
+{p 8 8 2}{it:HDFE.varlist }{cmd:=}{bind: }{it:varlist} // used to report messages about all demeaned variables{p_end}
+{p 8 8 2}{it:HDFE.indepvars }{cmd:=}{bind: }{it:indepvars} // used to report messages about demeaned regressors{p_end}
+{p 8 8 2}{it:HDFE.num_clusters }{cmd:=}{bind: }{it:#} // Number of clusters{p_end}
+
+{p 8 8 2}
+{it: ... see reghdfe.ado for more options and how to combine them}
+
+
+{marker properties}{...}
+{title:Properties and Methods}
+
+{marker arguments}{...}
+{synoptset 38 tabbed}{...}
+
+{synopthdr:properties (factors)}
+{synoptline}
+
+{synopt:{it:Integer} {cmd:N}}number of obs{p_end}
+{synopt:{it:Integer} {cmd:M}}Sum of all possible FE coefs{p_end}
+{synopt:{it:Factors} {cmd:factors}}{p_end}
+{synopt:{it:Vector} {cmd:sample}}{p_end}
+{synopt:{it:Varlist} {cmd:absvars}}{p_end}
+{synopt:{it:Varlist} {cmd:ivars}}{p_end}
+{synopt:{it:Varlist} {cmd:cvars}}{p_end}
+{synopt:{it:Boolean} {cmd:has_intercept}}{p_end}
+{synopt:{it:RowVector} {cmd:intercepts}}{p_end}
+{synopt:{it:RowVector} {cmd:num_slopes}}{p_end}
+{synopt:{it:Integer} {cmd:num_singletons}}{p_end}
+{synopt:{it:Boolean} {cmd:save_any_fe}}{p_end}
+{synopt:{it:Boolean} {cmd:save_all_fe}}{p_end}
+{synopt:{it:Varlist} {cmd:targets}}{p_end}
+{synopt:{it:RowVector} {cmd:save_fe}}{p_end}
+
+{synopthdr:properties (optimization options)}
+{synoptline}
+
+{synopt:{it:Real} {cmd:tolerance}}{p_end}
+{synopt:{it:Integer} {cmd:maxiter}}{p_end}
+{synopt:{it:String} {cmd:transform}}Kaczmarz Cimmino Symmetric_kaczmarz (k c s){p_end}
+{synopt:{it:String} {cmd:acceleration}}Acceleration method. None/No/Empty is none\{p_end}
+{synopt:{it:Integer} {cmd:accel_start}}Iteration where we start to accelerate /set it at 6? 2?3?{p_end}
+{synopt:{it:string} {cmd:slope_method}}{p_end}
+{synopt:{it:Boolean} {cmd:prune}}Whether to recursively prune degree-1 edges{p_end}
+{synopt:{it:Boolean} {cmd:abort}}Raise error if convergence failed?{p_end}
+{synopt:{it:Integer} {cmd:accel_freq}}Specific to Aitken's acceleration{p_end}
+{synopt:{it:Boolean} {cmd:storing_alphas}}1 if we should compute the alphas/fes{p_end}
+{synopt:{it:Real} {cmd:conlim}}specific to LSMR{p_end}
+{synopt:{it:Real} {cmd:btol}}specific to LSMR{p_end}
+
+{synopthdr:properties (optimization objects)}
+{synoptline}
+
+
+{synopt:{it:BipartiteGraph} {cmd:bg}}Used when pruning 1-core vertices{p_end}
+{synopt:{it:Vector} {cmd:pruned_weight}}temp. weight for the factors that were pruned{p_end}
+{synopt:{it:Integer} {cmd:prune_g1}}Factor 1/2 in the bipartite subgraph that gets pruned{p_end}
+{synopt:{it:Integer} {cmd:prune_g2}}Factor 2/2 in the bipartite subgraph that gets pruned{p_end}
+{synopt:{it:Integer} {cmd:num_pruned}}Number of vertices (levels) that were pruned{p_end}
+
+{synopthdr:properties (misc)}
+{synoptline}
+
+{synopt:{it:Integer} {cmd:verbose}}{p_end}
+{synopt:{it:Boolean} {cmd:timeit}}{p_end}
+{synopt:{it:Boolean} {cmd:store_sample}}{p_end}
+{synopt:{it:Real} {cmd:finite_condition}}{p_end}
+{synopt:{it:Real} {cmd:compute_rre}}Relative residual error: || e_k - e || / || e ||{p_end}
+{synopt:{it:Real} {cmd:rre_depvar_norm}}{p_end}
+{synopt:{it:Vector} {cmd:rre_varname}}{p_end}
+{synopt:{it:Vector} {cmd:rre_true_residual}}{p_end}
+
+{synopthdr:properties (weight-specific)}
+{synoptline}
+
+{synopt:{it:Boolean} {cmd:has_weights}}{p_end}
+{synopt:{it:Variable} {cmd:weight}}unsorted weight{p_end}
+{synopt:{it:String} {cmd:weight_var}}Weighting variable{p_end}
+{synopt:{it:String} {cmd:weight_type}}Weight type (pw, fw, etc){p_end}
+
+{synopthdr:properties (absorbed degrees-of-freedom computations)}
+{synoptline}
+
+{synopt:{it:Integer} {cmd:G_extended}}Number of intercepts plus slopes{p_end}
+{synopt:{it:Integer} {cmd:df_a_redundant}}e(mobility){p_end}
+{synopt:{it:Integer} {cmd:df_a_initial}}{p_end}
+{synopt:{it:Integer} {cmd:df_a}}df_a_inital - df_a_redundant{p_end}
+{synopt:{it:Vector} {cmd:doflist_M}}{p_end}
+{synopt:{it:Vector} {cmd:doflist_K}}{p_end}
+{synopt:{it:Vector} {cmd:doflist_M_is_exact}}{p_end}
+{synopt:{it:Vector} {cmd:doflist_M_is_nested}}{p_end}
+{synopt:{it:Vector} {cmd:is_slope}}{p_end}
+{synopt:{it:Integer} {cmd:df_a_nested}}Redundant due to bein nested; used for: r2_a r2_a_within rmse{p_end}
+
+{synopthdr:properties (VCE and cluster variables)}
+{synoptline}
+
+{synopt:{it:String} {cmd:vcetype}}{p_end}
+{synopt:{it:Integer} {cmd:num_clusters}}{p_end}
+{synopt:{it:Varlist} {cmd:clustervars}}{p_end}
+{synopt:{it:Varlist} {cmd:base_clustervars}}{p_end}
+{synopt:{it:String} {cmd:vceextra}}{p_end}
+
+{synopthdr:properties (regression-specific)}
+{synoptline}
+
+{synopt:{it:String} {cmd:varlist}}y x1 x2 x3 x4 z1 z2 z3{p_end}
+{synopt:{it:String} {cmd:depvar}}y{p_end}
+{synopt:{it:String} {cmd:indepvars}}x1 x2{p_end}
+    
+{synopt:{it:Boolean} {cmd:drop_singletons}}{p_end}
+{synopt:{it:String} {cmd:absorb}}contents of absorb(){p_end}
+{synopt:{it:String} {cmd:select_if}}If condition{p_end}
+{synopt:{it:String} {cmd:select_in}}In condition{p_end}
+{synopt:{it:String} {cmd:model}}ols, iv{p_end}
+{synopt:{it:String} {cmd:summarize_stats}}{p_end}
+{synopt:{it:Boolean} {cmd:summarize_quietly}}{p_end}
+{synopt:{it:StringRowVector} {cmd:dofadjustments}}firstpair pairwise cluster continuous{p_end}
+{synopt:{it:Varname} {cmd:groupvar}}{p_end}
+{synopt:{it:String} {cmd:residuals}}{p_end}
+{synopt:{it:RowVector} {cmd:kept}}1 if the regressors are not deemed as omitted (by partial_out+cholsolve+invsym){p_end}
+{synopt:{it:String} {cmd:diopts}}{p_end}
+
+{synopthdr:properties (output)}
+{synoptline}
+
+{synopt:{it:String} {cmd:cmdline}}{p_end}
+{synopt:{it:String} {cmd:subcmd}}{p_end}
+{synopt:{it:String} {cmd:title}}{p_end}
+{synopt:{it:Boolean} {cmd:converged}}{p_end}
+{synopt:{it:Integer} {cmd:iteration_count}}e(ic){p_end}
+{synopt:{it:Varlist} {cmd:extended_absvars}}{p_end}
+{synopt:{it:String} {cmd:notes}}{p_end}
+{synopt:{it:Integer} {cmd:df_r}}{p_end}
+{synopt:{it:Integer} {cmd:df_m}}{p_end}
+{synopt:{it:Integer} {cmd:N_clust}}{p_end}
+{synopt:{it:Integer} {cmd:N_clust_list}}{p_end}
+{synopt:{it:Real} {cmd:rss}}{p_end}
+{synopt:{it:Real} {cmd:rmse}}{p_end}
+{synopt:{it:Real} {cmd:F}}{p_end}
+{synopt:{it:Real} {cmd:tss}}{p_end}
+{synopt:{it:Real} {cmd:tss_within}}{p_end}
+{synopt:{it:Real} {cmd:sumweights}}{p_end}
+{synopt:{it:Real} {cmd:r2}}{p_end}
+{synopt:{it:Real} {cmd:r2_within}}{p_end}
+{synopt:{it:Real} {cmd:r2_a}}{p_end}
+{synopt:{it:Real} {cmd:r2_a_within}}{p_end}
+{synopt:{it:Real} {cmd:ll}}{p_end}
+{synopt:{it:Real} {cmd:ll_0}}{p_end}
+
+{synopthdr:methods}
+{synoptline}
+
+{synopt:{it:Void} {cmd:update_sorted_weights}()}{p_end}
+{synopt:{it:Matrix} {cmd:partial_out}()}{p_end}
+{synopt:{it:Void} {cmd:_partial_out}()}in-place alternative to {cmd:partial_out()}{p_end}
+{synopt:{it:Variables} {cmd:project_one_fe}()}{p_end}
+{synopt:{it:Void} {cmd:prune_1core}()}{p_end}
+{synopt:{it:Void} {cmd:_expand_1core}()}{p_end}
+{synopt:{it:Void} {cmd:estimate_dof}()}{p_end}
+{synopt:{it:Void} {cmd:estimate_cond}()}{p_end}
+{synopt:{it:Void} {cmd:save_touse}()}{p_end}
+{synopt:{it:Void} {cmd:store_alphas}()}{p_end}
+{synopt:{it:Void} {cmd:save_variable}()}{p_end}
+{synopt:{it:Void} {cmd:post_footnote}()}{p_end}
+{synopt:{it:Void} {cmd:post}()}{p_end}
+{synopt:{it:Void} {cmd:reload}(copy=0)}{p_end} (run this if e.g. touse changes)
+
+{synopthdr:methods (LSMR-specific)}
+{synoptline}
+
+{synopt:{it:Real} {cmd:lsmr_norm}()}{p_end}
+{synopt:{it:Vector} {cmd:lsmr_A_mult}()}{p_end}
+{synopt:{it:Vector} {cmd:lsmr_At_mult}()}{p_end}
+
+
+{marker functions}{...}
+{title:Additional functions}
+
+{pstd}
+Several useful Mata functions are included. For instance,
+
+{p 8 16 2}
+{it:void}
+{cmd:reghdfe_solve_ols(}{it:HDFE}
+{cmd:,}
+{it:X}{cmd:,}
+{it:...}
+{cmd:)}
+
+{pstd}
+See {stata "mata: mata desc using lreghdfe"} for full list of functions and classes.
+
+
+{marker description}{...}
+{title:Description}
+
+{pstd}
+TBD
+
+
+{marker example}{...}
+{title:Example: OLS regression}
+
+{pstd}
+TBD
+
+
+{inp}
+    {hline 60}
+	sysuse auto, clear
+	local depvar price
+	local indepvars weight gear
+	mata: HDFE = fixed_effects("turn", "", "fweight", "trunk", 0, 2)
+	mata: HDFE.varlist = "`depvar' `indepvars'"
+	mata: HDFE.indepvars = "`indepvars'"
+	mata: data = HDFE.partial_out("`depvar' `indepvars'")
+	mata: reghdfe_solve_ols(HDFE, data, b=., V=., N=., rank=., df_r=., resid=., kept=., "vce_none")
+	mata: b
+    {hline 60}
+{text}
+
+
+{marker remarks}{...}
+{title:Remarks}
+
+{pstd}
+TBD
+
+{marker experimental}{...}
+{title:Experimental/advanced functions}
+
+{pstd}
+TBD (LSMR, Prune, Bipartite?)
+
+{marker source}{...}
+{title:Source code}
+
+{pstd}
+{view reghdfe.mata, adopath asis:reghdfe.mata};
+{view reghdfe_bipartite.mata, adopath asis:reghdfe_bipartite.mata};
+{view reghdfe_class.mata, adopath asis:reghdfe_class.mata};
+{view reghdfe_constructor.mata, adopath asis:reghdfe_constructor.mata};
+{view reghdfe_common.mata, adopath asis:reghdfe_common.mata};
+{view reghdfe_projections.mata, adopath asis:reghdfe_projections.mata};
+{view reghdfe_transforms.mata, adopath asis:reghdfe_transforms.mata};
+{view reghdfe_accelerations.mata, adopath asis:reghdfe_accelerations.mata};
+{view reghdfe_lsmr.mata, adopath asis:reghdfe_lsmr.mata}
+{p_end}
+
+{pstd}
+Also, the latest version is available online: {browse "https://github.com/sergiocorreia/reghdfe/tree/master/src"}
+
+
+{marker author}{...}
+{title:Author}
+
+{pstd}Sergio Correia{break}
+{break}
+{browse "http://scorreia.com"}{break}
+{browse "mailto:[email protected]":[email protected]}{break}
+{p_end}
+
+
+{marker project}{...}
+{title:More Information}
+
+{pstd}{break}
+To report bugs, contribute, ask for help, etc. please see the project URL in Github:{break}
+{browse "https://github.com/sergiocorreia/reghdfe"}{break}
+{p_end}
+
+
+{marker acknowledgment}{...}
+{title:Acknowledgment}
+
+{pstd}
+TBD

30/replication_package/Adofiles/reghdfe_2019/reghdfe_old.sthlp

@@ -0,0 +1,872 @@
+{smcl}
+{* *! version 3.2.9 21feb2016}{...}
+{vieweralsosee "[R] areg" "help areg"}{...}
+{vieweralsosee "[R] xtreg" "help xtreg"}{...}
+{vieweralsosee "[R] ivregress" "help ivregress"}{...}
+{vieweralsosee "" "--"}{...}
+{vieweralsosee "ivreg2" "help ivreg2"}{...}
+{vieweralsosee "ivregress" "help ivregress"}{...}
+{vieweralsosee "reg2hdfe" "help reg2hdfe"}{...}
+{vieweralsosee "a2reg" "help a2reg"}{...}
+{viewerjumpto "Syntax" "reghdfe##syntax"}{...}
+{viewerjumpto "Description" "reghdfe##description"}{...}
+{viewerjumpto "Options" "reghdfe##options"}{...}
+{viewerjumpto "Postestimation Syntax" "reghdfe##postestimation"}{...}
+{viewerjumpto "Remarks" "reghdfe##remarks"}{...}
+{viewerjumpto "Examples" "reghdfe##examples"}{...}
+{viewerjumpto "Stored results" "reghdfe##results"}{...}
+{viewerjumpto "Author" "reghdfe##contact"}{...}
+{viewerjumpto "Updates" "reghdfe##updates"}{...}
+{viewerjumpto "Acknowledgements" "reghdfe##acknowledgements"}{...}
+{viewerjumpto "References" "reghdfe##references"}{...}
+{title:Title}
+
+{p2colset 5 18 20 2}{...}
+{p2col :{cmd:reghdfe} {hline 2}}Linear and instrumental-variable/GMM regression absorbing multiple levels of fixed effects{p_end}
+{p2colreset}{...}
+
+{marker syntax}{...}
+{title:Syntax}
+
+{p 8 15 2} {cmd:reghdfe}
+{depvar} [{indepvars}] [{cmd:(}{it:{help varlist:endogvars}} {cmd:=} {it:{help varlist:iv_vars}}{cmd:)}]
+{ifin} {it:{weight}} {cmd:,} {opth a:bsorb(reghdfe##absvar:absvars)} [{help reghdfe##options:options}] {p_end}
+
+{marker opt_summary}{...}
+{synoptset 22 tabbed}{...}
+{synopthdr}
+{synoptline}
+{syntab:Model {help reghdfe##opt_model:[+]}}
+{p2coldent:* {opth a:bsorb(reghdfe##absvar:absvars)}}identifiers of the absorbed fixed effects; each {help reghdfe##absvar:absvar} represents one set of fixed effects{p_end}
+{synopt: {cmdab:a:bsorb(}{it:...}{cmd:,} {cmdab:save:fe)}}save all fixed effect estimates ({it:__hdfe*} prefix); useful for a subsequent {help reghdfe##postestimation:predict}.
+However, see also the {it:resid} option.{p_end}
+{synopt : {opth res:iduals(newvar)}}save residuals; more direct and much faster than saving the fixed effects and then running predict{p_end}
+{synopt :{opth su:mmarize(tabstat##statname:stats)}}equivalent to {help reghdfe##postestimation:estat summarize} after the regression,
+but more flexible, compatible with the {opt fast:} option, and saves results on {it:e(summarize)}{p_end}
+{synopt : {opt subopt:ions(...)}}additional options that will be passed to the regression command (either {help regress}, {help ivreg2}, or {help ivregress}){p_end}
+	
+{syntab:SE/Robust {help reghdfe##opt_vce:[+]}}
+{p2coldent:+ {opt vce}{cmd:(}{help reghdfe##opt_vce:vcetype} [{cmd:,}{it:opt}]{cmd:)}}{it:vcetype}
+may be {opt un:adjusted} (default), {opt r:obust} or {opt cl:uster} {help fvvarlist} (allowing two- and multi-way clustering){p_end}
+{synopt :}suboptions {opt bw(#)}, {opt ker:nel(str)}, {opt dkraay(#)} and {opt kiefer} allow for AC/HAC estimates; see the {help avar} package{p_end}
+
+{syntab:Instrumental-Variable/2SLS/GMM {help reghdfe##opt_iv:[+]}}
+{synopt :{opt est:imator(str)}}either {opt 2sls} (default), {opt gmm:2s} (two-stage GMM),
+{opt liml} (limited-information maximum likelihood) or {opt cue} (which gives approximate results, see discussion below){p_end}
+{synopt :{opt stage:s(list)}}estimate additional regressions; choose any of {opt first} {opt ols} {opt reduced} {opt acid} (or {opt all}){p_end}
+{synopt :{opt ff:irst}}compute first-stage diagnostic and identification statistics{p_end}
+{synopt :{opth iv:suite(subcmd)}}package used in the IV/GMM regressions;
+options are {opt ivreg2} (default; needs installing) and {opt ivregress}{p_end}
+
+{syntab:Diagnostic {help reghdfe##opt_diagnostic:[+]}}
+{synopt :{opt v:erbose(#)}}amount of debugging information to show (0=None, 1=Some, 2=More, 3=Parsing/convergence details, 4=Every iteration){p_end}
+{synopt :{opt time:it}}show elapsed times by stage of computation{p_end}
+
+{syntab:Optimization {help reghdfe##opt_optimization:[+]}}
+{p2coldent:+ {opth tol:erance(#)}}criterion for convergence (default=1e-8){p_end}
+{synopt :{opth maxit:erations(#)}}maximum number of iterations (default=10,000); if set to missing ({cmd:.}) it will run for as long as it takes.{p_end}
+{synopt :{opth pool:size(#)}}apply the within algorithm in groups of {it:#} variables (default 10). a large poolsize is usually faster but uses more memory{p_end}
+{synopt :{opt accel:eration(str)}}acceleration method; options are conjugate_gradient (cg), steep_descent (sd), aitken (a), and none (no){p_end}
+{synopt :{opt transf:orm(str)}}transform operation that defines the type of alternating projection; options are Kaczmarz (kac), Cimmino (cim), Symmetric Kaczmarz (sym){p_end}
+
+{syntab:Speedup Tricks {help reghdfe##opt_speedup:[+]}}
+{synopt :{cmd: cache(save} [,opt]{cmd:)}}absorb all variables without regressing (destructive; combine it with {help preserve:preserve/restore}){p_end}
+{synopt :}suboption {opth keep(varlist)} adds additional untransformed variables to the resulting dataset{p_end}
+{synopt :{cmd: cache(use)}}run regressions on cached data; {it:vce()} must be the same as with {cmd: cache(save)}.{p_end}
+{synopt :{cmd: cache(clear)}}delete Mata objects to clear up memory; no more regressions can be run after this{p_end}
+{synopt :{opt fast}}will not create {it:e(sample)}; disabled when saving fixed effects, residuals or mobility groups{p_end}
+
+{syntab:Degrees-of-Freedom Adjustments {help reghdfe##opt_dof:[+]}}
+{synopt :{opt dof:adjustments(list)}}allows selecting the desired adjustments for degrees of freedom;
+rarely used{p_end}
+{synopt: {opth groupv:ar(newvar)}}unique identifier for the first mobility group{p_end}
+
+{syntab:Reporting {help reghdfe##opt_reporting:[+]}}
+{synopt :{opt version:}}reports the version number and date of reghdfe, and saves it in e(version). standalone option{p_end}
+{synopt :{opt l:evel(#)}}set confidence level; default is {cmd:level(95)}{p_end}
+{synopt :{it:{help reghdfe##display_options:display_options}}}control column formats, row spacing, line width, display of omitted variables and base and empty cells, and factor-variable labeling.{p_end}
+{synopt :}particularly useful are the {opt noomit:ted} and {opt noempty} options to hide regressors omitted due to collinearity{p_end}
+
+{syntab:Undocumented}
+{synopt :{opt keepsin:gletons}}do not drop singleton groups{p_end}
+{synopt :{opt old}}will call the latest 2.x version of reghdfe instead (see the {help reghdfe_old:old help file}){p_end}
+{synoptline}
+{p2colreset}{...}
+{p 4 6 2}* {opt absorb(absvars)} is required.{p_end}
+{p 4 6 2}+ indicates a recommended or important option.{p_end}
+{p 4 6 2}{it:indepvars}, {it:endogvars} and {it:iv_vars} may contain factor variables; see {help fvvarlist}.{p_end}
+{p 4 6 2}all the regression variables may contain time-series operators; see {help tsvarlist}.{p_end}
+{p 4 6 2}{cmd:fweight}s, {cmd:aweight}s and {cmd:pweight}s are allowed; see {help weight}.{p_end}
+
+
+{marker absvar}{...}
+{title:Absvar Syntax}
+
+{synoptset 22}{...}
+{synopthdr:absvar}
+{synoptline}
+{synopt:{cmd:i.}{it:varname}}categorical variable to be absorbed (the {cmd:i.} prefix is tacit){p_end}
+{synopt:{cmd:i.}{it:var1}{cmd:#i.}{it:var2}}absorb the interactions of multiple categorical variables{p_end}
+{synopt:{cmd:i.}{it:var1}{cmd:#}{cmd:c.}{it:var2}}absorb heterogeneous slopes, where {it:var2} has a different slope coef. depending on the category of {it:var1}{p_end}
+{synopt:{it:var1}{cmd:##}{cmd:c.}{it:var2}}equivalent to "{cmd:i.}{it:var1} {cmd:i.}{it:var1}{cmd:#}{cmd:c.}{it:var2}", but {it:much} faster{p_end}
+{synopt:{it:var1}{cmd:##c.(}{it:var2 var3}{cmd:)}}multiple heterogeneous slopes are allowed together. Alternative syntax: {it:var1}{cmd:##(c.}{it:var2} {cmd:c.}{it:var3}{cmd:)}{p_end}
+{synopt:{it:v1}{cmd:#}{it:v2}{cmd:#}{it:v3}{cmd:##c.(}{it:v4 v5}{cmd:)}}factor operators can be combined{p_end}
+{synoptline}
+{p2colreset}{...}
+{p 4 6 2}To save the estimates specific absvars, write {newvar}{inp:={it:absvar}}.{p_end}
+{p 4 6 2}Please be aware that in most cases these estimates are neither consistent nor econometrically identified.{p_end}
+{p 4 6 2}Using categorical interactions (e.g. {it:x}{cmd:#}{it:z}) is faster than running {it:egen group(...)} beforehand.{p_end}
+{p 4 6 2}Singleton obs. are dropped iteratively until no more singletons are found (see ancilliary article for details).{p_end}
+{p 4 6 2}Slope-only absvars ("state#c.time") have poor numerical stability and slow convergence.
+If you need those, either i) increase tolerance or
+ii) use slope-and-intercept absvars ("state##c.time"), even if the intercept is redundant.
+For instance if absvar is "i.zipcode i.state##c.time" then i.state is redundant given i.zipcode, but
+convergence will still be {it:much} faster.{p_end}
+
+{marker description}{...}
+{title:Description}
+
+{pstd}
+{cmd:reghdfe} is a generalization of {help areg} (and {help xtreg:xtreg,fe}, {help xtivreg:xtivreg,fe}) for multiple levels of fixed effects
+(including heterogeneous slopes), alternative estimators (2sls, gmm2s, liml), and additional robust standard errors (multi-way clustering, HAC standard errors, etc).{p_end}
+
+{pstd}Additional features include:{p_end}
+
+{p2col 8 12 12 2: a)}A novel and robust algorithm to efficiently absorb the fixed effects (extending the work of Guimaraes and Portugal, 2010).{p_end}
+{p2col 8 12 12 2: b)}Coded in Mata, which in most scenarios makes it even faster than {it:areg} and {it:xtreg} for a single fixed effect (see benchmarks on the Github page).{p_end}
+{p2col 8 12 12 2: c)}Can save the point estimates of the fixed effects ({it:caveat emptor}: the fixed effects may not be identified, see the {help reghdfe##references:references}).{p_end}
+{p2col 8 12 12 2: d)}Calculates the degrees-of-freedom lost due to the fixed effects
+(note: beyond two levels of fixed effects, this is still an open problem, but we provide a conservative approximation).{p_end}
+{p2col 8 12 12 2: e)}Iteratively removes singleton groups by default, to avoid biasing the standard errors (see ancillary document).{p_end}
+
+{marker options}{...}
+{title:Options}
+
+{marker opt_model}{...}
+{dlgtab:Model and Miscellanea}
+
+{phang}
+{opth a:bsorb(reghdfe##absvar:absvars)} list of categorical variables (or interactions) representing the fixed effects to be absorbed.
+this is equivalent to including an indicator/dummy variable for each category of each {it:absvar}. {cmd:absorb()} is required.
+
+{pmore}
+To save a fixed effect, prefix the absvar with "{newvar}{cmd:=}".
+For instance, the option {cmd:absorb(firm_id worker_id year_coefs=year_id)} will include firm,
+worker and year fixed effects, but will only save the estimates for the year fixed effects (in the new variable {it:year_coefs}).
+
+{pmore}
+If you want to {help reghdfe##postestimation:predict} afterwards but don't care about setting the names of each fixed effect, use the {cmdab:save:fe} suboption.
+This will delete all variables named {it:__hdfe*__} and create new ones as required.
+Example: {it:reghdfe price weight, absorb(turn trunk, savefe)}
+
+{phang}
+{opth res:iduals(newvar)} will save the regression residuals in a new variable.
+
+{pmore}
+This is a superior alternative than running {cmd:predict, resid} afterwards as it's faster and doesn't require saving the fixed effects.
+
+{phang}
+{opth su:mmarize(tabstat##statname:stats)} will report and save a table of summary of statistics of the regression
+variables (including the instruments, if applicable), using the same sample as the regression.
+
+{pmore} {opt su:mmarize} (without parenthesis) saves the default set of statistics: {it:mean min max}.
+
+{pmore} The complete list of accepted statistics is available in the {help tabstat##statname:tabstat help}. The most useful are {it:count range sd median p##}.
+
+{pmore} The summary table is saved in {it:e(summarize)}
+
+{pmore} To save the summary table silently (without showing it after the regression table), use the {opt qui:etly} suboption. You can use it by itself ({cmd:summarize(,quietly)}) or with custom statistics ({cmd:summarize(mean, quietly)}).
+
+{phang}
+{opt subopt:ions(...)}
+options that will be passed directly to the regression command (either {help regress}, {help ivreg2}, or {help ivregress})
+
+{marker opt_vce}{...}
+{dlgtab:SE/Robust}
+
+{phang}
+{opth vce:(reghdfe##vcetype:vcetype, subopt)}
+specifies the type of standard error reported.
+Note that all the advanced estimators rely on asymptotic theory, and will likely have poor performance with small samples
+(but again if you are using reghdfe, that is probably not your case)
+
+{pmore}
+{opt un:adjusted}/{opt ols:} estimates conventional standard errors, valid even in small samples
+under the assumptions of homoscedasticity and no correlation between observations
+
+{pmore}
+{opt r:obust} estimates heteroscedasticity-consistent standard errors (Huber/White/sandwich estimators), but still assuming independence between observations
+
+{pmore}Warning: in a FE panel regression, using {opt r:obust} will
+lead to inconsistent standard errors if for every fixed effect, the {it:other} dimension is fixed.
+For instance, in an standard panel with individual and time fixed effects, we require both the number of
+individuals and time periods to grow asymptotically.
+If that is not the case, an alternative may be to use clustered errors,
+which as discussed below will still have their own asymptotic requirements.
+For a discussion, see
+{browse "http://www.princeton.edu/~mwatson/papers/ecta6489.pdf":Stock and Watson, "Heteroskedasticity-robust standard errors for fixed-effects panel-data regression," Econometrica 76 (2008): 155-174}
+
+{pmore}
+{opt cl:uster} {it:clustervars} estimates consistent standard errors even when the observations
+are correlated within groups.
+
+{pmore}
+Multi-way-clustering is allowed. Thus, you can indicate as many {it:clustervar}s as desired
+(e.g. allowing for intragroup correlation across individuals, time, country, etc).
+
+{pmore}
+Each {it:clustervar} permits interactions of the type {it:var1{cmd:#}var2}
+(this is faster than using {cmd:egen group()} for a one-off regression).
+
+{pmore} Warning: The number of clusters, for all of the cluster variables, must go off to infinity.
+A frequent rule of thumb is that each cluster variable must have at least 50 different categories
+(the number of categories for each clustervar appears on the header of the regression table).
+
+{pstd}
+The following suboptions require either the {help ivreg2} or the {help avar} package from SSC.
+For a careful explanation, see the {help ivreg2##s_robust:ivreg2 help file}, from which the comments below borrow.
+
+{pmore}
+{opt u:nadjusted}{cmd:, }{opt bw(#)} (or just {cmd:, }{opt bw(#)}) estimates autocorrelation-consistent standard errors (Newey-West).
+
+{pmore}
+{opt r:obust}{cmd:, }{opt bw(#)} estimates autocorrelation-and-heteroscedasticity consistent standard errors (HAC).
+
+{pmore}
+{opt cl:uster} {it:clustervars}{cmd:, }{opt bw(#)} estimates standard errors consistent to common autocorrelated disturbances (Driscoll-Kraay). At most two cluster variables can be used in this case.
+
+{pmore}
+{cmd:, }{opt kiefer} estimates standard errors consistent under arbitrary intra-group autocorrelation (but not heteroskedasticity) (Kiefer).
+
+{pmore}
+{opt kernel(str)} is allowed in all the cases that allow {opt bw(#)}
+The default kernel is {it:bar} (Bartlett). Valid kernels are Bartlett (bar); Truncated (tru); Parzen (par);
+Tukey-Hanning (thann); Tukey-Hamming (thamm); Daniell (dan); Tent (ten); and Quadratic-Spectral (qua or qs). 
+
+{pstd}
+Advanced suboptions:
+
+{pmore}
+{cmd:, }{opt suite(default|mwc|avar)} overrides the package chosen by reghdfe to estimate the VCE.
+{it:default} uses the default Stata computation (allows unadjusted, robust, and at most one cluster variable).
+{it:mwc} allows multi-way-clustering (any number of cluster variables), but without the {it:bw} and {it:kernel} suboptions.
+{it:avar} uses the avar package from SSC. Is the same package used by ivreg2, and allows the {it:bw}, {it:kernel}, {it:dkraay} and {it:kiefer} suboptions.
+This is useful almost exclusively for debugging.
+
+{pmore}
+{cmd:, }{opt twice:robust} will compute robust standard errors not only on the first but on the second step of the gmm2s estimation. Requires {opt ivsuite(ivregress)}, but will not give the exact same results as ivregress.
+
+{pmore}{it:Explanation:} When running instrumental-variable regressions with the {cmd:ivregress} package,
+robust standard errors, and a gmm2s estimator, reghdfe will translate
+{opt vce(robust)} into {opt wmatrix(robust)} {opt vce(unadjusted)}.
+This maintains compatibility with {cmd:ivreg2} and other packages, but may unadvisable as described in {help ivregress} (technical note). Specifying this option will instead use {opt wmatrix(robust)} {opt vce(robust)}.
+
+{pmore}However, computing the second-step vce matrix requires computing updated estimates (including updated fixed effects).
+Since reghdfe currently does not allow this, the resulting standard errors
+{hi:will not be exactly the same as with ivregress}.
+This issue is similar to applying the CUE estimator, described further below.
+
+{pmore}Note: The above comments are also appliable to clustered standard error.
+
+{marker opt_iv}{...}
+{dlgtab:IV/2SLS/GMM}
+
+{phang}
+{opt est:imator}{cmd:(}{opt 2sls}|{opt gmm:2s}|{opt liml}|{opt cue}{cmd:)}
+estimator used in the instrumental-variable estimation
+
+{pmore}
+{opt 2sls} (two-stage least squares, default), {opt gmm:2s} (two-stage efficient GMM), {opt liml} (limited-information maximum likelihood), and
+{opt cue} ("continuously-updated" GMM) are allowed.{p_end}
+
+{pmore}
+Warning: {opt cue} will not give the same results as ivreg2. See the discussion in
+{browse "http://www.stata-journal.com/sjpdf.html?articlenum=st0030_3": Baum, Christopher F., Mark E. Schaffer, and Steven Stillman. "Enhanced routines for instrumental variables/GMM estimation and testing." Stata Journal 7.4 (2007): 465-506}
+(page 484).
+Note that even if this is not exactly {opt cue}, it may still be a desirable/useful alternative to standard cue, as explained in the article.
+
+{phang}
+{opt stage:s(list)}
+adds and saves up to four auxiliary regressions useful when running instrumental-variable regressions:
+
+{phang2}{cmd:first} all first-stage regressions{p_end}
+{phang2}{cmd:ols} ols regression (between dependent variable and endogenous variables; useful as a benchmark){p_end}
+{phang2}{cmd:reduced} reduced-form regression (ols regression with included and excluded instruments as regressors){p_end}
+{phang2}{cmd:acid} an "acid" regression that includes both instruments and endogenous variables as regressors; in this setup, excluded instruments should not be significant.{p_end}
+
+{pmore}
+You can pass suboptions not just to the iv command but to all stage regressions with a comma after the list of stages. Example:{break}
+{cmd:reghdfe price (weight=length), absorb(turn) subopt(nocollin) stages(first, eform(exp(beta)) )}
+
+{pmore}
+By default all stages are saved (see {help estimates dir}).
+The suboption {cmd:,nosave} will prevent that.
+However, future {cmd:replay}s will only replay the iv regression.
+
+{phang}
+{opt ffirst}
+compute and report first stage statistics ({help ivreg2##s_relevance:details}); requires the ivreg2 package.
+
+{pmore}
+These statistics will be saved on the {it:e(first)} matrix. 
+If the first-stage estimates are also saved (with the {cmd:stages()} option), the respective statistics will be copied to {cmd:e(first_*)}.
+
+{phang}
+{opth iv:suite(subcmd)}
+allows the IV/2SLS regression to be run either using {opt ivregress} or {opt ivreg2}.
+
+{pmore} {opt ivreg2} is the default, but needs to be installed for that option to work.
+
+{marker opt_diagnostic}{...}
+{dlgtab:Diagnostic}
+
+{phang}
+{opt v:erbose(#)} orders the command to print debugging information.
+
+{pmore}
+Possible values are 0 (none), 1 (some information), 2 (even more), 3 (adds dots for each iteration, and reportes parsing details), 4 (adds details for every iteration step)
+
+{pmore}
+For debugging, the most useful value is 3. For simple status reports, set verbose to 1.
+
+{phang}
+{opt time:it} shows the elapsed time at different steps of the estimation. Most time is usually spent on three steps: map_precompute(), map_solve() and the regression step.
+ 
+{marker opt_dof}{...}
+{dlgtab:Degrees-of-Freedom Adjustments}
+
+{phang}
+{opt dof:adjustments(doflist)} selects how the degrees-of-freedom, as well as e(df_a), are adjusted due to the absorbed fixed effects.
+
+{pmore}
+Without any adjustment, we would assume that the degrees-of-freedom used by the fixed effects is equal to the count of all the fixed effects
+(e.g. number of individuals + number of years in a typical panel).
+However, in complex setups (e.g. fixed effects by individual, firm, job position, and year),
+there may be a huge number of fixed effects collinear with each other, so we want to adjust for that.
+
+{pmore}
+Note: changing the default option is rarely needed, except in benchmarks, and to obtain a marginal speed-up by excluding the {opt pair:wise} option.
+
+{pmore}
+{opt all} is the default and almost always the best alternative. It is equivalent to {opt dof(pairwise clusters continuous)}
+
+{pmore}
+{opt none} assumes no collinearity across the fixed effects (i.e. no redundant fixed effects). This is overtly conservative, although it is the faster method by virtue of not doing anything.
+
+{pmore}
+{opt first:pair} will exactly identify the number of collinear fixed effects across the first two sets of fixed effects
+(i.e. the first absvar and the second absvar).
+The algorithm used for this is described in Abowd et al (1999), and relies on results from graph theory
+(finding the number of connected sub-graphs in a bipartite graph).
+It will not do anything for the third and subsequent sets of fixed effects.
+
+{pmore}
+For more than two sets of fixed effects, there are no known results that provide exact degrees-of-freedom as in the case above.
+One solution is to ignore subsequent fixed effects (and thus oversestimate e(df_a) and understimate the degrees-of-freedom).
+Another solution, described below, applies the algorithm between pairs of fixed effects to obtain a better (but not exact) estimate:
+
+{pmore}
+{opt pair:wise} applies the aforementioned connected-subgraphs algorithm between pairs of fixed effects.
+For instance, if there are four sets of FEs, the first dimension will usually have no redundant coefficients (i.e. e(M1)==1), since we are running the model without a constant.
+For the second FE, the number of connected subgraphs with respect to the first FE will provide an exact estimate of the degrees-of-freedom lost, e(M2).
+
+{pmore}
+For the third FE, we do not know exactly.
+However, we can compute the number of connected subgraphs between the first and third {it:G(1,3)},
+and second and third {it:G(2,3)} fixed effects, and choose the higher of those as the closest estimate for e(M3).
+For the fourth FE, we compute {it:G(1,4)}, {it:G(2,4)} and {it:G(3,4)} and again choose the highest for e(M4).
+
+{pmore}
+Finally, we compute e(df_a) = e(K1) - e(M1) + e(K2) - e(M2) + e(K3) - e(M3) + e(K4) - e(M4);
+where e(K#) is the number of levels or dimensions for the #-th fixed effect (e.g. number of individuals or years).
+Note that e(M3) and e(M4) are only conservative estimates and thus we will usually be overestimating the standard errors. However, given the sizes of the datasets typically used with reghdfe, the difference should be small. 
+
+{pmore}
+Since the gain from {opt pair:wise} is usually {it:minuscule} for large datasets, and the computation is expensive, it may be a good practice to exclude this option for speedups.
+
+{pmore}
+{opt cl:usters}
+will check if a fixed effect is nested within a {it:clustervar}.
+In that case, it will set e(K#)==e(M#) and no degrees-of-freedom will be lost due to this fixed effect.
+The rationale is that we are already assuming that the number of effective observations is the number of cluster levels.
+This is the same adjustment that {cmd:xtreg, fe} does, but {cmd:areg} does not use it.
+
+{pmore}
+{opt cont:inuous}
+Fixed effects with continuous interactions (i.e. individual slopes, instead of individual intercepts) are dealt with differently.
+In an i.categorical#c.continuous interaction, we will do one check: we count the number of categories where c.continuous is always zero.
+In an i.categorical##c.continuous interaction, we do the above check but replace zero for any particular constant.
+In the case where continuous is constant for a level of categorical, we know it is collinear with the intercept, so we adjust for it.
+
+{pmore}
+Additional methods, such as {opt bootstrap} are also possible but not yet implemented.
+Some preliminary simulations done by the author showed a very poor convergence of this method.
+
+{phang}
+{opth groupv:ar(newvar)} name of the new variable that will contain the first mobility group.
+Requires {opt pair:wise}, {opt first:pair}, or the default {opt all}.
+
+{marker opt_speedup}{...}
+{dlgtab:Speeding Up Estimation}
+
+{phang}
+{cmd:reghdfe} {varlist} {ifin}{cmd:,} {opt a:bsorb(absvars)} {cmd:save(cache)} [{it:options}]
+
+{pmore}
+This will transform {it:varlist}, absorbing the fixed effects indicated by {it:absvars}.
+It is useful when running a series of alternative specifications with common variables, as the variables will only be transformed once instead of every time a regression is run.
+
+{pmore}
+It replaces the current dataset, so it is a good idea to precede it with a {help preserve} command
+
+{pmore}
+To keep additional (untransformed) variables in the new dataset, use the {opth keep(varlist)} suboption.
+
+{phang}
+{cmd:cache(use)} is used when running reghdfe after a {it:save(cache)} operation. Both the {it:absorb()} and {it:vce()} options must be the same as when the cache was created (the latter because the degrees of freedom were computed at that point).
+
+{phang}
+{cmd:cache(clear)} will delete the Mata objects created by {it:reghdfe} and kept in memory after the {it:save(cache)} operation. These objects may consume a lot of memory, so it is a good idea to clean up the cache. Additionally, if you previously specified {it:preserve}, it may be a good time to {it:restore}.
+
+{pmore}Example:{p_end}
+{phang2}{cmd:. sysuse auto}{p_end}
+{phang2}{cmd:. preserve}{p_end}
+{phang2}{cmd:.}{p_end}
+{phang2}{cmd:. * Save the cache}{p_end}
+{phang2}{cmd:. reghdfe price weight length, a(turn rep) vce(turn) cache(save, keep(foreign))}{p_end}
+{phang2}{cmd:.}{p_end}
+{phang2}{cmd:. * Run regressions}{p_end}
+{phang2}{cmd:. reghdfe price weight, a(turn rep) cache(use)}{p_end}
+{phang2}{cmd:. reghdfe price length, a(turn rep) cache(use)}{p_end}
+{phang2}{cmd:.}{p_end}
+{phang2}{cmd:. * Clean up}{p_end}
+{phang2}{cmd:. reghdfe, cache(clear)}{p_end}
+{phang2}{cmd:. restore}{p_end}
+
+{phang}
+{opt fast} avoids saving {it:e(sample)} into the regression.
+Since saving the variable only involves copying a Mata vector, the speedup is currently quite small.
+Future versions of reghdfe may change this as features are added.
+
+{pmore}
+Note that {opt fast} will be disabled when adding variables to the dataset (i.e. when saving residuals, fixed effects, or mobility groups), and is incompatible with most postestimation commands.
+
+{pmore}
+If you wish to use {opt fast} while reporting {cmd:estat summarize}, see the {opt summarize} option.
+
+{marker opt_optimization}{...}
+{dlgtab:Optimization}
+
+{phang}
+{opth tol:erance(#)} specifies the tolerance criterion for convergence; default is {cmd:tolerance(1e-8)}
+
+{pmore}
+Note that for tolerances beyond 1e-14, the limits of the {it:double} precision are reached and the results will most likely not converge.
+
+{pmore}
+At the other end, is not tight enough, the regression may not identify perfectly collinear regressors. However, those cases can be easily spotted due to their extremely high standard errors.
+
+{pmore}
+Warning: when absorbing heterogeneous slopes without the accompanying heterogeneous intercepts, convergence is quite poor and a tight tolerance is strongly suggested (i.e. higher than the default). In other words, an absvar of {it:var1##c.var2} converges easily, but an absvar of {it:var1#c.var2} will converge slowly and may require a tighter tolerance.
+
+{phang}
+{opth maxit:erations(#)}
+specifies the maximum number of iterations; the default is {cmd:maxiterations(10000)}; set it to missing ({cmd:.}) to run forever until convergence.
+
+{phang}
+{opth pool:size(#)}
+Number of variables that are {it:pooled together} into a matrix that will then be transformed.
+The default is to pool variables in groups of 5. Larger groups are faster with more than one processor, but may cause out-of-memory errors. In that case, set poolsize to 1.
+
+{phang}
+{it:Advanced options:}
+
+{phang}
+{opt acceleration(str)} allows for different acceleration techniques, from the simplest case of 
+no acceleration ({opt no:ne}), to steep descent ({opt st:eep_descent} or {opt sd}), Aitken ({opt a:itken}),
+and finally Conjugate Gradient ({opt co:njugate_gradient} or {opt cg}).
+
+{pmore}
+Note: Each acceleration is just a plug-in Mata function, so a larger number of acceleration techniques are available, albeit undocumented (and slower).
+
+{phang}
+{opt transf:orm(str)} allows for different "alternating projection" transforms. The classical transform is Kaczmarz ({opt kac:zmarz}), and more stable alternatives are Cimmino ({opt cim:mino}) and Symmetric Kaczmarz ({opt sym:metric_kaczmarz})
+
+{pmore}
+Note: Each transform is just a plug-in Mata function, so a larger number of acceleration techniques are available, albeit undocumented (and slower).
+
+{pmore}
+Note: The default acceleration is Conjugate Gradient and the default transform is Symmetric Kaczmarz. Be wary that different accelerations often work better with certain transforms. For instance, do not use conjugate gradient with plain Kaczmarz, as it will not converge.
+
+{phang}
+{opt precondition} {it:(currently disabled)}
+
+{marker opt_reporting}{...}
+{dlgtab:Reporting}
+
+{phang}
+{opt l:evel(#)} sets confidence level; default is {cmd:level(95)}
+
+{marker display_options}{...}
+{phang}
+{it:display_options}:
+{opt noomit:ted},
+{opt vsquish},
+{opt noempty:cells},
+{opt base:levels},
+{opt allbase:levels},
+{opt nofvlabel},
+{opt fvwrap(#)},
+{opt fvwrapon(style)},
+{opth cformat(%fmt)},
+{opt pformat(%fmt)},
+{opt sformat(%fmt)}, and
+{opt nolstretch};
+    see {helpb estimation options##display_options:[R] estimation options}.
+    {p_end}
+
+
+{marker postestimation}{...}
+{title:Postestimation Syntax}
+
+Only {cmd:estat summarize}, {cmd:predict} and {cmd:test} are currently supported and tested.
+
+{p 8 13 2}
+{cmd:estat summarize}
+{p_end}{col 23}Summarizes {it:depvar} and the variables described in {it:_b} (i.e. not the excluded instruments)
+
+{p 8 16 2}
+{cmd:predict} 
+{newvar} 
+{ifin}
+[{cmd:,} {it:statistic}]
+{p_end}{col 23}May require you to previously save the fixed effects (except for option {opt xb}).
+{col 23}To see how, see the details of the {help reghdfe##absvar:absorb} option
+{col 23}Equation: y = xb + d_absorbvars + e
+
+{synoptset 20 tabbed}{...}
+{synopthdr:statistic}
+{synoptline}
+{syntab :Main}
+{p2coldent: {opt xb}}xb fitted values; the default{p_end}
+{p2coldent: {opt xbd}}xb + d_absorbvars{p_end}
+{p2coldent: {opt d}}d_absorbvars{p_end}
+{p2coldent: {opt r:esiduals}}residual{p_end}
+{p2coldent: {opt sc:ore}}score; equivalent to {opt residuals}{p_end}
+{p2coldent: {opt stdp}}standard error of the prediction (of the xb component){p_end}
+{synoptline}
+{p2colreset}{...}
+{p 4 6 2}although {cmd:predict} {help data_types:type} {help newvar} is allowed,
+the resulting variable will always be of type {it:double}.{p_end}
+
+
+{col 8}{cmd:test}{col 23}Performs significance test on the parameters, see the {help test:stata help}
+
+{col 8}{cmd:suest}{col 23}Do not use {cmd:suest}. It will run, but the results will be incorrect. See workaround below
+
+{pmore}If you want to perform tests that are usually run with {cmd:suest},
+such as non-nested models, tests using alternative specifications of the variables,
+or tests on different groups, you can replicate it manually, as described 
+{browse "http://www.stata.com/statalist/archive/2009-11/msg01485.html":here}.
+{p_end}
+
+{marker remarks}{...}
+
+{title:Possible Pitfalls and Common Mistakes}
+
+{p2col 8 12 12 2: 1.}(note: as of version 2.1, the constant is no longer reported) Ignore the constant; it doesn't tell you much. If you want to use descriptive stats, that's what the {opt sum:marize()} and {cmd:estat summ} commands are for.
+Even better, use {opt noconstant} to drop it (although it's not really dropped as it never existed on the first place!){p_end}
+{p2col 8 12 12 2: 2.}Think twice before saving the fixed effects. They are probably inconsistent / not identified and you will likely be using them wrong.{p_end}
+{p2col 8 12 12 2: 3.}(note: as of version 3.0 singletons are dropped by default) It's good practice to drop singletons. {opt dropsi:ngleton} is your friend.{p_end}
+{p2col 8 12 12 2: 4.}If you use {opt vce(robust)}, be sure that your {it:other} dimension is not "fixed" but grows with N, or your SEs will be wrong.{p_end}
+{p2col 8 12 12 2: 5.}If you use {opt vce(cluster ...)}, check that your number of clusters is high enough (50+ is a rule of thumb). If not, you are making the SEs even worse!{p_end}
+{p2col 8 12 12 2: 6.}The panel variables (absvars) should probably be nested within the clusters (clustervars) due to the within-panel correlation induced by the FEs.
+(this is not the case for *all* the absvars, only those that are treated as growing as N grows){p_end}
+{p2col 8 12 12 2: 7.}If you run analytic or probability weights,
+you are responsible for ensuring that the weights stay
+constant within each unit of a fixed effect (e.g. individual),
+or that it is correct to allow varying-weights for that case.
+{p_end}
+{p2col 8 12 12 2: 8.}Be aware that adding several HDFEs is not a panacea.
+The first limitation is that it only uses within variation (more than acceptable if you have a large enough dataset).
+The second and subtler limitation occurs if the fixed effects are themselves outcomes of the variable of interest (as crazy as it sounds).
+For instance, imagine a regression where we study the effect of past corporate fraud on future firm performance.
+We add firm, CEO and time fixed-effects (standard practice). This introduces a serious flaw: whenever a fraud event is discovered,
+i) future firm performance will suffer, and ii) a CEO turnover will likely occur.
+Moreover, after fraud events, the new CEOs are usually specialized in dealing with the aftershocks of such events
+(and are usually accountants or lawyers).
+The fixed effects of these CEOs will also tend to be quite low, as they tend to manage firms with very risky outcomes.
+Therefore, the regressor (fraud) affects the fixed effect (identity of the incoming CEO).
+Adding particularly low CEO fixed effects will then overstate the performance of the firm,
+and thus {it:understate} the negative effects of fraud on future firm performance.{p_end}
+
+{title:Missing Features}
+
+{phang}(If you are interested in discussing these or others, feel free to {help reghdfe##contact:contact me})
+
+{phang}Code, medium term:
+
+{p2col 8 12 12 2: -}Complete GT preconditioning (v4){p_end}
+{p2col 8 12 12 2: -}Improve algorithm that recovers the fixed effects (v5){p_end}
+{p2col 8 12 12 2: -}Improve statistics and tests related to the fixed effects (v5){p_end}
+{p2col 8 12 12 2: -}Implement a -bootstrap- option in DoF estimation (v5){p_end}
+
+{phang}Code, long term:
+
+{p2col 8 12 12 2: -}The interaction with cont vars (i.a#c.b) may suffer from numerical accuracy issues, as we are dividing by a sum of squares{p_end}
+{p2col 8 12 12 2: -}Calculate exact DoF adjustment for 3+ HDFEs (note: not a problem with cluster VCE when one FE is nested within the cluster){p_end}
+{p2col 8 12 12 2: -}More postestimation commands (lincom? margins?){p_end}
+
+{phang}Theory:
+
+{p2col 8 12 12 2: -}Add a more thorough discussion on the possible identification issues{p_end}
+{p2col 8 12 12 2: -}Find out a way to use reghdfe iteratively with CUE
+(right now only OLS/2SLS/GMM2S/LIML give the exact same results){p_end}
+{p2col 8 12 12 2: -}Not sure if I should add an F-test for the absvars in the vce(robust) and vce(cluster) cases.
+Discussion on e.g. -areg- (methods and formulas) and textbooks suggests not;
+on the other hand, there may be alternatives:
+{it:{browse "http://www.socialsciences.manchester.ac.uk/disciplines/economics/research/discussionpapers/pdf/EDP-1124.pdf" :A Heteroskedasticity-Robust F-Test Statistic for Individual Effects}}{p_end}
+
+{marker examples}{...}
+{title:Examples}
+
+{hline}
+{pstd}Setup{p_end}
+{phang2}{cmd:. sysuse auto}{p_end}
+
+{pstd}Simple case - one fixed effect{p_end}
+{phang2}{cmd:. reghdfe price weight length, absorb(rep78)}{p_end}
+{hline}
+
+{pstd}As above, but also compute clustered standard errors{p_end}
+{phang2}{cmd:. reghdfe price weight length, absorb(rep78) vce(cluster rep78)}{p_end}
+{hline}
+
+{pstd}Two and three sets of fixed effects{p_end}
+{phang2}{cmd:. webuse nlswork}{p_end}
+{phang2}{cmd:. reghdfe ln_w grade age ttl_exp tenure not_smsa south , absorb(idcode year)}{p_end}
+{phang2}{cmd:. reghdfe ln_w grade age ttl_exp tenure not_smsa south , absorb(idcode year occ)}{p_end}
+{hline}
+
+{title:Advanced examples}
+
+{pstd}Save the FEs as variables{p_end}
+{phang2}{cmd:. reghdfe ln_w grade age ttl_exp tenure not_smsa south , absorb(FE1=idcode FE2=year)}{p_end}
+
+{pstd}Report nested F-tests{p_end}
+{phang2}{cmd:. reghdfe ln_w grade age ttl_exp tenure not_smsa south , absorb(idcode year) nested}{p_end}
+
+{pstd}Do AvgE instead of absorb() for one FE{p_end}
+{phang2}{cmd:. reghdfe ln_w grade age ttl_exp tenure not_smsa south , absorb(idcode year) avge(occ)}{p_end}
+{phang2}{cmd:. reghdfe ln_w grade age ttl_exp tenure not_smsa south , absorb(idcode year) avge(AvgByOCC=occ)}{p_end}
+
+{pstd}Check that FE coefs are close to 1.0{p_end}
+{phang2}{cmd:. reghdfe ln_w grade age ttl_exp tenure not_smsa , absorb(idcode year) check}{p_end}
+
+{pstd}Save first mobility group{p_end}
+{phang2}{cmd:. reghdfe ln_w grade age ttl_exp tenure not_smsa , absorb(idcode occ) group(mobility_occ)}{p_end}
+
+{pstd}Factor interactions in the independent variables{p_end}
+{phang2}{cmd:. reghdfe ln_w i.grade#i.age ttl_exp tenure not_smsa , absorb(idcode occ)}{p_end}
+
+{pstd}Interactions in the absorbed variables (notice that only the {it:#} symbol is allowed){p_end}
+{phang2}{cmd:. reghdfe ln_w grade age ttl_exp tenure not_smsa , absorb(idcode#occ)}{p_end}
+
+{pstd}Interactions in both the absorbed and AvgE variables (again, only the {it:#} symbol is allowed){p_end}
+{phang2}{cmd:. reghdfe ln_w grade age ttl_exp not_smsa , absorb(idcode#occ) avge(tenure#occ)}{p_end}
+
+{pstd}IV regression{p_end}
+{phang2}{cmd:. sysuse auto}{p_end}
+{phang2}{cmd:. reghdfe price weight (length=head), absorb(rep78)}{p_end}
+{phang2}{cmd:. reghdfe price weight (length=head), absorb(rep78) first}{p_end}
+{phang2}{cmd:. reghdfe price weight (length=head), absorb(rep78) ivsuite(ivregress)}{p_end}
+
+{pstd}Factorial interactions{p_end}
+{phang2}{cmd:. reghdfe price weight (length=head), absorb(rep78)}{p_end}
+{phang2}{cmd:. reghdfe price weight length, absorb(rep78 turn##c.price)}{p_end}
+
+
+{marker results}{...}
+{title:Stored results}
+
+{pstd}
+{cmd:reghdfe} stores the following in {cmd:e()}:
+
+{pstd}
+{it:Note: it also keeps most e() results placed by the regression subcommands (ivreg2, ivregress)}
+
+{synoptset 24 tabbed}{...}
+{syntab:Scalars}
+{synopt:{cmd:e(N)}}number of observations{p_end}
+{synopt:{cmd:e(N_hdfe)}}number of absorbed fixed-effects{p_end}
+{synopt:{cmd:e(tss)}}total sum of squares{p_end}
+{synopt:{cmd:e(rss)}}residual sum of squares{p_end}
+{synopt:{cmd:e(r2)}}R-squared{p_end}
+{synopt:{cmd:e(r2_a)}}adjusted R-squared{p_end}
+{synopt:{cmd:e(r2_within)}}Within R-squared{p_end}
+{synopt:{cmd:e(r2_a_within)}}Adjusted Within R-squared{p_end}
+{synopt:{cmd:e(df_a)}}degrees of freedom lost due to the fixed effects{p_end}
+{synopt:{cmd:e(rmse)}}root mean squared error{p_end}
+{synopt:{cmd:e(ll)}}log-likelihood{p_end}
+{synopt:{cmd:e(ll_0)}}log-likelihood of fixed-effect-only regression{p_end}
+{synopt:{cmd:e(F)}}F statistic{p_end}
+{synopt:{cmd:e(F_absorb)}}F statistic for absorbed effect {it:note: currently disabled}{p_end}
+{synopt:{cmd:e(rank)}}rank of {cmd:e(V)}{p_end}
+{synopt:{cmd:e(N_clustervars)}}number of cluster variables{p_end}
+        
+{synopt:{cmd:e(clust}#{cmd:)}}number of clusters for the #th cluster variable{p_end}
+{synopt:{cmd:e(N_clust)}}number of clusters; minimum of {it:e(clust#)}{p_end}
+
+{synopt:{cmd:e(K}#{cmd:)}}Number of categories of the #th absorbed FE{p_end}
+{synopt:{cmd:e(M}#{cmd:)}}Number of redundant categories of the #th absorbed FE{p_end}
+{synopt:{cmd:e(mobility)}}Sum of all {cmd:e(M#)}{p_end}
+{synopt:{cmd:e(df_m)}}model degrees of freedom{p_end}
+{synopt:{cmd:e(df_r)}}residual degrees of freedom{p_end}
+
+{synoptset 24 tabbed}{...}
+{syntab:Macros}
+{synopt:{cmd:e(cmd)}}{cmd:reghdfe}{p_end}
+{synopt:{cmd:e(subcmd)}}either {cmd:regress}, {cmd:ivreg2} or {cmd:ivregress}{p_end}
+{synopt:{cmd:e(model)}}{cmd:ols}, {cmd:iv}, {cmd:gmm2s}, {cmd:liml} or {cmd:cue}{p_end}
+{synopt:{cmd:e(cmdline)}}command as typed{p_end}
+{synopt:{cmd:e(dofmethod)}}dofmethod employed in the regression{p_end}
+{synopt:{cmd:e(depvar)}}name of dependent variable{p_end}
+{synopt:{cmd:e(indepvars)}}names of independent variables{p_end}
+{synopt:{cmd:e(endogvars)}}names of endogenous right-hand-side variables{p_end}
+{synopt:{cmd:e(instruments)}}names of excluded instruments{p_end}
+{synopt:{cmd:e(absvars)}}name of the absorbed variables or interactions{p_end}
+{synopt:{cmd:e(title)}}title in estimation output{p_end}
+{synopt:{cmd:e(clustvar)}}name of cluster variable{p_end}
+{synopt:{cmd:e(clustvar}#{cmd:)}}name of the #th cluster variable{p_end}
+{synopt:{cmd:e(vce)}}{it:vcetype} specified in {cmd:vce()}{p_end}
+{synopt:{cmd:e(vcetype)}}title used to label Std. Err.{p_end}
+{synopt:{cmd:e(stage)}}stage within an IV-regression; only if {it:stages()} was used{p_end}
+{synopt:{cmd:e(properties)}}{cmd:b V}{p_end}
+
+{synoptset 24 tabbed}{...}
+{syntab:Matrices}
+{synopt:{cmd:e(b)}}coefficient vector{p_end}
+{synopt:{cmd:e(V)}}variance-covariance matrix of the estimators{p_end}
+
+{synoptset 24 tabbed}{...}
+{syntab:Functions}
+{synopt:{cmd:e(sample)}}marks estimation sample{p_end}
+{p2colreset}{...}
+
+{marker contact}{...}
+{title:Author}
+
+{pstd}Sergio Correia{break}
+Fuqua School of Business, Duke University{break}
+Email: {browse "mailto:[email protected]":[email protected]}
+{p_end}
+
+{marker user_guide}{...}
+{title:User Guide}
+
+{pstd}
+A copy of this help file, as well as a more in-depth user guide is in development and will be available at {browse "http://scorreia.com/reghdfe"}.{p_end}
+
+{marker updates}{...}
+{title:Latest Updates}
+
+{pstd}
+{cmd:reghdfe} is updated frequently, and upgrades or minor bug fixes may not be immediately available in SSC.
+To check or contribute to the latest version of reghdfe, explore the
+{browse "https://github.com/sergiocorreia/reghdfe":Github repository}.
+Bugs or missing features can be discussed through email or at the {browse "https://github.com/sergiocorreia/reghdfe/issues":Github issue tracker}.{p_end}
+
+{pstd}
+To see your current version and installed dependencies, type {cmd:reghdfe, version}
+{p_end}
+
+{marker acknowledgements}{...}
+{title:Acknowledgements}
+
+{pstd}
+This package wouldn't have existed without the invaluable feedback and contributions of Paulo Guimaraes,  Amine Ouazad, Mark Schaffer and Kit Baum. Also invaluable are the great bug-spotting abilities of many users.{p_end}
+
+{pstd}In addition, {it:reghdfe} is build upon important contributions from the Stata community:{p_end}
+
+{phang}{browse "https://ideas.repec.org/c/boc/bocode/s457101.html":reg2hdfe}, from Paulo Guimaraes,
+and {browse "https://ideas.repec.org/c/boc/bocode/s456942.html":a2reg} from Amine Ouazad,
+ were the inspiration and building blocks on which reghdfe was built.{p_end}
+ 
+{phang}{browse "http://www.repec.org/bocode/i/ivreg2.html":ivreg2}, by Christopher F Baum, Mark E Schaffer and Steven Stillman, is the package used by default for instrumental-variable regression.{p_end}
+
+{phang}{browse "https://ideas.repec.org/c/boc/bocode/s457689.html":avar} by Christopher F Baum and Mark E Schaffer, is the package used for estimating the HAC-robust standard errors of ols regressions.{p_end}
+
+{phang}{browse "http://econpapers.repec.org/software/bocbocode/s456797.htm":tuples} by Joseph Lunchman and Nicholas Cox, is used when computing standard errors with multi-way clustering (two or more clustering variables).{p_end}
+
+{marker references}{...}
+{title:References}
+
+{p 0 0 2}
+The algorithm underlying reghdfe is a generalization of the works by:
+
+{phang}
+Paulo Guimaraes and Pedro Portugal. "A Simple Feasible Alternative Procedure to Estimate
+Models with High-Dimensional Fixed Effects".
+{it:Stata Journal, 10(4), 628-649, 2010.}
+{browse "http://www.stata-journal.com/article.html?article=st0212":[link]}
+{p_end}
+
+{phang}
+Simen Gaure. "OLS with Multiple High Dimensional Category Dummies".
+{it:Memorandum 14/2010, Oslo University, Department of Economics, 2010.}
+{browse "https://ideas.repec.org/p/hhs/osloec/2010_014.html":[link]}
+{p_end}
+
+{p 0 0 2}
+It addresses many of the limitation of previous works, such as possible lack of convergence, arbitrary slow convergence times,
+and being limited to only two or three sets of fixed effects (for the first paper).
+The paper explaining the specifics of the algorithm is a work-in-progress and available upon request.
+
+{p 0 0 0}
+If you use this program in your research, please cite either
+the {browse "https://ideas.repec.org/c/boc/bocode/s457874.html":REPEC entry}
+or the aforementioned papers.{p_end}
+
+{title:Additional References}
+
+{p 0 0 0}
+For details on the Aitken acceleration technique employed, please see "method 3" as described by:
+
+{phang}
+Macleod, Allan J. "Acceleration of vector sequences by multi-dimensional Delta-2 methods."
+{it:Communications in Applied Numerical Methods 2.4 (1986): 385-392.}
+{p_end}
+
+{p 0 0 0}
+For the rationale behind interacting fixed effects with continuous variables, see:
+
+{phang}
+Duflo, Esther. "The medium run effects of educational expansion: Evidence from a large school construction program in Indonesia."
+{it:Journal of Development Economics 74.1 (2004): 163-197.}{browse "http://www.sciencedirect.com/science/article/pii/S0304387803001846": [link]}
+{p_end}
+
+{p 0 0 0}
+Also see:
+
+{phang}Abowd, J. M., R. H. Creecy, and F. Kramarz 2002.
+Computing person and firm effects using linked longitudinal employer-employee data.
+{it:Census Bureau Technical Paper TP-2002-06.}
+{p_end}
+
+{phang}
+Cameron, A. Colin & Gelbach, Jonah B. & Miller, Douglas L., 2011.
+"Robust Inference With Multiway Clustering,"
+{it:Journal of Business & Economic Statistics, American Statistical Association, vol. 29(2), pages 238-249.}
+{p_end}
+
+{phang}
+Gormley, T. & Matsa, D. 2014.
+"Common errors: How to (and not to) control for unobserved heterogeneity."
+{it:The Review of Financial Studies, vol. 27(2), pages 617-661.}
+{p_end}
+
+{phang}
+Mittag, N. 2012.
+"New methods to estimate models with large sets of fixed effects with an application to matched employer-employee data from Germany."
+{it:{browse "http://doku.iab.de/fdz/reporte/2012/MR_01-12_EN.pdf":FDZ-Methodenreport 02/2012}.} 
+{p_end}

30/replication_package/Adofiles/reghdfe_2019/reghdfe_old_estat.ado

@@ -0,0 +1,32 @@
+program reghdfe_old_estat, rclass
+	version `=cond(c(version)<14, c(version), 13)'
+	if "`e(cmd)'" != "reghdfe" {
+		error 301
+	}
+	
+	gettoken key 0 : 0, parse(", ")
+	local lkey = length(`"`key'"')
+
+	if `"`key'"' == substr("summarize",1,max(2,`lkey')) {
+
+		local 0 `rest'
+		syntax [anything] , [*] [noheader] // -noheader- gets silently ignored b/c it will always be -on-
+
+		if ("`anything'"=="") {
+			* By default include the instruments
+			local anything `e(depvar)' `e(indepvars)' `e(endogvars)' `e(instruments)'
+		}
+
+		* Need to use -noheader- as a workaround to the bug in -estat_summ-
+		estat_summ `anything' , `options' noheader
+
+	}
+	else if `"`key'"' == "vce" {
+		vce `0'
+	}
+	else {
+		di as error `"invalid subcommand `key'"'
+		exit 321
+	}
+	return add // ?
+end

30/replication_package/Adofiles/reghdfe_2019/reghdfe_old_footnote.ado

@@ -0,0 +1,113 @@
+// -------------------------------------------------------------
+// Display Regression Footnote
+// -------------------------------------------------------------
+
+program reghdfe_old_footnote
+syntax [, linesize(int 79)]
+
+	local skip1 = max(`s(width_col1)'-1, 12) // works with both _coef_table, ivreg2 and ivregress
+
+if ("`e(model)'"=="ols" & inlist("`e(vce)'", "unadjusted", "ols")) {
+	local dfa1  = e(df_a) + 1
+	local todisp `"F(`=e(df_a)-1', `e(df_r)') = "'
+	local skip3 = max(23-length(`"`todisp'"')-2,0)
+	local skip2 = max(14-length(`"`dfa1'"')-2,0)
+	local skip0 `skip1'
+
+	foreach fe in `e(extended_absvars)' {
+		local skip1 = max(`skip1', length("`fe'"))
+	}
+
+	di as text %`skip0's "Absorbed" " {c |}" ///
+		_skip(`skip3') `"`todisp'"' ///
+		as res %10.3f e(F_absorb) %8.3f fprob(e(df_a),e(df_r),e(F_absorb)) ///
+		as text _skip(13) `"(Joint test)"'
+
+	* Col width
+	local WX = `skip1' + 1
+
+	* Show by-fe FStats
+	* Relevant macros: NUM_FE, FE1, .., FE_TARGET1, .., FE_VARLIST
+	local r2 = 1 - e(rss0)/e(tss)
+	local r2_report %4.3f `r2'
+	forval i = 1/`e(N_hdfe_extended)' {
+		local fe : word `i' of `e(extended_absvars)'
+		if (e(F_absorb`i')<.) {
+			di as text %`skip1's "`fe'" " {c |}" _continue
+			
+			local df_a_i = e(df_a`i') - (`i'==1)
+			local df_r_i = e(df_r`i')
+			local todisp `"F(`df_a_i', `df_r_i') = "'
+			local skip3 = max(23-length(`"`todisp'"')-2,0)
+			di as text _skip(`skip3') `"`todisp'"' _continue
+			
+			di as res %10.3f e(F_absorb`i') %8.3f fprob(e(df_a`i'),e(df_r`i'),e(F_absorb`i')) _continue
+			di as text _skip(12) `"(Nested test)"'
+
+			local r2 = 1 - e(rss`i')/e(tss)
+			local r2_report `r2_report' " -> " %4.3f `r2'
+			*local cats = e(K`i') - e(M`i')
+			*local data = "`e(K`i')' categories, `e(M`i')' collinear, `cats' unique"
+			*local skip = 62 - length("`data'")
+			*di as text _skip(`skip') `"(`data')"'
+		}
+	}
+	di as text "{hline `=1+`skip0''}{c BT}{hline 64}"
+	if (e(rss0)<.) di as text " R-squared as we add HDFEs: " `r2_report'
+} // regress-unadjusted specific
+else {
+	foreach fe in `e(absvars)' {
+		local skip1 = max(`skip1', length("`fe'"))
+	}
+	local WX = `skip1' + 1
+}
+
+* Show category data
+di as text
+di as text "Absorbed degrees of freedom:"
+di as text "{hline `WX'}{c TT}{hline 49}{c TRC}"   // {c TT}{hline 14}"
+di as text %`skip1's "Absorbed FE" " {c |}" ///
+	%13s "Num. Coefs." ///
+	%16s "=   Categories" ///
+	%15s "-   Redundant" ///
+	"     {c |} " _continue
+
+// if ("`e(corr1)'"!="") di as text %13s "Corr. w/xb" _continue
+di as text _n "{hline `WX'}{c +}{hline 49}{c RT}"  // {c +}{hline 14}"
+
+	local i 0
+	local explain_exact 0
+	local explain_nested 0
+
+	forval i = 1/`e(N_hdfe_extended)' {
+		local fe : word `i' of `e(extended_absvars)'
+
+
+		di as text %`skip1's "`fe'" " {c |}" _continue
+		local numcoefs = e(K`i') - e(M`i')
+		assert `numcoefs'<. & `numcoefs'>=0
+		local note = cond(`e(M`i'_exact)'==0, "?", " ")
+		if ("`note'"=="?") {
+			local explain_exact 1
+		}
+		else if (`e(M`i'_nested)'==1) {
+			local note *
+			local explain_nested 1
+		}
+		
+		di as text %13s "`numcoefs'" _continue
+		di as text %16s "`e(K`i')'" _continue
+		
+		di as text %15s "`e(M`i')'" _continue
+		di as text %2s "`note'" "   {c |} " _continue
+		//if ("`e(corr`i')'"!="") {
+		//	di as text %13.4f `e(corr`i')' _continue
+		//}
+		di
+	}
+di as text "{hline `WX'}{c BT}{hline 49}{c BRC}" // {c BT}{hline 14}"
+if (`explain_exact') di as text "? = number of redundant parameters may be higher"
+if (`explain_nested') di as text `"* = fixed effect nested within cluster; treated as redundant for DoF computation"'
+// di as text _skip(4) "Fixed effect indicators: " in ye "`e(absvars)'"
+
+end

30/replication_package/Adofiles/reghdfe_2019/reghdfe_old_p.ado

@@ -0,0 +1,99 @@
+program define reghdfe_old_p
+	* (Maybe refactor using _pred_se ??)
+
+	local version `clip(`c(version)', 11.2, 13.1)' // 11.2 minimum, 13+ preferred
+	qui version `version'
+	
+	*if "`e(cmd)'" != "reghdfe" {
+	*	error 301
+	*}
+	syntax anything [if] [in] , [XB XBD D Residuals SCores STDP]
+	if (`"`scores'"' != "") {
+		_score_spec	`anything'
+		local varlist `s(varlist)'
+	}
+	else {
+		local 0 `anything'
+		syntax newvarname  // [if] [in] , [XB XBD D Residuals SCores]
+	}
+
+	local weight "[`e(wtype)'`e(wexp)']" // After -syntax-!!!
+	local option `xb' `xbd' `d' `residuals' `scores' `stdp'
+	if ("`option'"=="") local option xb // The default, as in -areg-
+	local numoptions : word count `option'
+	if (`numoptions'!=1) {
+		di as error "(predict reghdfe) syntax error; specify one and only one option"
+		exit 112
+	}
+	if ("`option'"=="scores") local option residuals
+
+	local fixed_effects "`e(absvars)'"
+
+	* Intercept stdp call
+	if ("`option'"=="stdp") {
+		_predict double `varlist' `if' `in', stdp
+		* la var `varlist' "STDP"
+		exit
+	}
+
+	* We need to have saved FEs and AvgEs for every option except -xb-
+	if ("`option'"!="xb") {
+		
+		* Only estimate using e(sample) except when computing xb (when we don't need -d- and can predict out-of-sample)
+		if (`"`if'"'!="") {
+			local if `if' & e(sample)==1
+		}
+		else {
+			local if "if e(sample)==1"
+		}
+
+		* Construct -d- (sum of FEs)
+		tempvar d
+		if ("`e(equation_d)'"=="") {
+				di as error "In order to predict, all the FEs need to be saved with the absorb option (#`g' was not)"
+				di as error "For instance, instead of {it:absorb(i.year i.firm)}, set absorb(FE_YEAR=i.year FE_FIRM=i.firm)"
+				exit 112
+		}
+		qui gen double `d' = `e(equation_d)' `if' `in'
+
+	} // Finished creating `d' if needed
+
+	tempvar xb // XB will eventually contain XBD and RESID if that's the output
+	_predict double `xb' `if' `in', xb
+
+	if ("`option'"=="xb") {
+		rename `xb' `varlist'
+	}
+	else {
+		* Make residual have mean zero (and add that to -d-)
+		su `e(depvar)' `if' `in' `weight', mean
+		local mean = r(mean)
+		su `xb' `if' `in' `weight', mean
+		local mean = `mean' - r(mean)
+		su `d' `if' `in' `weight', mean
+		local mean = `mean' - r(mean)
+		qui replace `d' = `d' + `mean' `if' `in'
+
+		if ("`option'"=="d") {
+			rename `d' `varlist'
+			la var `varlist' "d[`fixed_effects']"
+		}
+		else if ("`option'"=="xbd") {
+			qui replace `xb' = `xb' + `d' `if' `in'
+			rename `xb' `varlist'
+			la var `varlist' "Xb + d[`fixed_effects']"
+		}
+		else if ("`option'"=="residuals") {
+			qui replace `xb' = `e(depvar)' - `xb' - `d' `if' `in'
+			rename `xb' `varlist'
+			la var `varlist' "Residuals"
+		}
+		else {
+			error 112
+		}
+	}
+
+	fvrevar `e(depvar)', list
+	local format : format `r(varlist)'
+	format `format' `varlist'
+end

30/replication_package/Adofiles/reghdfe_2019/reghdfe_p.ado

@@ -0,0 +1,78 @@
+program define reghdfe_p, rclass
+	* Note: we IGNORE typlist and generate the newvar as double
+	* Note: e(resid) is missing outside of e(sample), so we don't need to condition on e(sample)
+
+	* HACK: Intersect -score- and replace with -residuals-
+	cap syntax anything [if] [in], SCore
+	loc was_score = !c(rc)
+	if (`was_score') {
+		* Call _score_spec to get newvarname; discard type
+		* - This resolves wildcards that -margins- sends to predict (e.g. var* -> var1)
+		* - Do we really need to pass it `if' and `in' ?
+		_score_spec `anything', score
+		loc 0 `s(varlist)' `if' `in' , residuals
+	}
+
+	syntax newvarname [if] [in] [, XB STDP Residuals D XBD DResiduals]
+
+	* Ensure there is only one option
+	opts_exclusive "`xb' `stdp' `residuals' `d' `xbd' `dresiduals'"
+
+	* Default option is xb
+	cap opts_exclusive "`xb' `stdp' `residuals' `d' `xbd' `dresiduals' placeholder"
+	if (!c(rc)) {
+		di as text "(option xb assumed; fitted values)"
+		loc xb "xb"
+	}
+
+	local fixed_effects "`e(absvars)'"
+
+	* Except for xb and stdp, we need the previously computed residuals
+	if ("`xb'" == "" & "`stdp'" == "") {
+		_assert ("`e(resid)'" != ""), msg("you must add the {bf:resid} option to reghdfe before running this prediction")
+		conf numeric var `e(resid)', exact
+	}
+
+	if ("`xb'" != "" | "`stdp'" != "") {
+		* xb: normal treatment
+		PredictXB `varlist' `if' `in', `xb' `stdp'
+	}
+	else if ("`residuals'" != "") {
+		* resid: just return the preexisting variable
+		gen double `varlist' = `e(resid)' `if' `in'
+		la var `varlist' "Residuals"
+		if (`was_score') return local scorevars `varlist'
+	}
+	else if ("`d'" != "") {
+		* d: y - xb - resid
+		tempvar xb
+		PredictXB `xb' `if' `in', xb
+		gen double `varlist' = `e(depvar)' -  `xb' - `e(resid)' `if' `in'
+		la var `varlist' "d[`fixed_effects']"
+	}
+	else if ("`xbd'" != "") {
+		* xbd: y - resid
+		gen double `varlist' = `e(depvar)' - `e(resid)' `if' `in'
+		la var `varlist' "Xb + d[`fixed_effects']"
+	}
+	else if ("`dresiduals'" != "") {
+		* dresid:	y - xb
+		tempvar xb
+		PredictXB `xb' `if' `in', xb
+		gen double `varlist' = `e(depvar)' -  `xb' `if' `in'
+	}
+	else {
+		error 100
+	}
+end
+
+program PredictXB
+	syntax newvarname [if] [in], [*]
+	cap matrix list e(b) // if there are no regressors, _predict fails
+	if (c(rc)) {
+		gen double `varlist' = 0 `if' `in'
+	}
+	else {
+		_predict double `varlist' `if' `in', `options'
+	}
+end

30/replication_package/Adofiles/reghdfe_2019/reghdfe_parse.ado

@@ -0,0 +1,139 @@
+* This program should only be called by fixed_effects()
+program reghdfe_parse, sclass
+
+* Parse absorb
+	cap drop __hdfe* // destructive!
+	ms_parse_absvars `0'
+	loc extended_absvars `"`s(extended_absvars)'"'
+	mata: st_local("unquoted_absvars", subinstr(st_global("s(absvars)"), `"""', ""))
+	loc 0, `s(options)'
+	loc G = `s(G)'
+
+* Main syntax
+	#d;
+	syntax, [
+
+		/* Model */
+		RESiduals(name) RESiduals2 /* use _reghdfe_resid */
+
+		/* Optimization (defaults are handled within Mata) */
+		TOLerance(real -1)
+		MAXITerations(real -1)
+		ALGorithm(string) /* map gt lsmr cg */
+		TRAnsform(string)
+		ACCELeration(string)
+		SLOPEmethod(string)
+		PRUNE
+		PRECONDition /* always compute LSMR preconditioner */
+
+		/* Memory usage (also see -compact- option) */ 
+		POOLsize(integer 0) /* Process variables in batches of # ; 0 turns it off */
+
+		/* Degrees-of-freedom Adjustments */
+		DOFadjustments(string)
+		GROUPVar(name) /* var with the first connected group between FEs */
+
+		CONDition // Report finite condition number; SLOW!
+		RRE(varname) // Report relative residual error
+		noCONstant // Report constant; enabled by default as otherwise -margins- fails
+
+		/* Duplicated options */
+		KEEPSINgletons
+		Verbose(numlist min=1 max=1 >=-1 <=5 integer)
+
+		] [*] /* capture display options, etc. */
+		;
+	#d cr
+
+	if ("`keepsingletons'"!="") sreturn loc drop_singletons = 0
+	if ("`verbose'"!="") sreturn loc verbose = `verbose'
+	sreturn loc report_constant = "`constant'" != "noconstant"
+
+	sreturn loc options `"`options'"'
+
+	assert "$reghdfe_touse" != ""
+	cap conf var $reghdfe_touse
+	if (c(rc)) gen byte $reghdfe_touse = 1
+	markout $reghdfe_touse `unquoted_absvars', strok
+
+* Optimization
+	loc maxiterations = int(`maxiterations')
+	if (`tolerance' > 0) sreturn loc tolerance = `tolerance'
+	if (`maxiterations' > 0) sreturn loc maxiter = `maxiterations'
+
+	* Transforms: allow abbreviations (cim --> cimmino)
+	if ("`transform'" != "") {
+		loc transform = lower("`transform'")
+		loc valid_transforms cimmino kaczmarz symmetric_kaczmarz rand_kaczmarz
+		foreach x of local valid_transforms {
+			if (strpos("`x'", "`transform'")==1) loc transform `x'
+		}
+		_assert (`: list transform in valid_transforms'), msg("invalid transform: `transform'")
+		sreturn loc transform "`transform'"
+	}
+
+	* Accelerations
+	if ("`acceleration'" != "") {
+		loc acceleration = lower("`acceleration'")
+		if ("`acceleration'"=="cg") loc acceleration conjugate_gradient
+		if ("`acceleration'"=="sd") loc acceleration steepest_descent
+		if ("`acceleration'"=="off") loc acceleration none
+		loc valid_accelerations conjugate_gradient steepest_descent aitken none hybrid lsmr
+		foreach x of local valid_accelerations {
+			if (strpos("`x'", "`acceleration'")==1) loc acceleration `x'
+		}
+		_assert (`: list acceleration in valid_accelerations'), msg("invalid acceleration: `acceleration'")
+		sreturn loc acceleration "`acceleration'"
+	}
+
+	* Disable prune of degree-1 edges
+	if ("`prune'" == "prune") sreturn loc prune = 1
+
+* Parse DoF Adjustments
+	if ("`dofadjustments'"=="") local dofadjustments all
+	loc 0 , `dofadjustments'
+	syntax, [ALL NONE] [FIRSTpair PAIRwise] [CLusters] [CONTinuous]
+	local opts `pairwise' `firstpair' `clusters' `continuous'
+	local n : word count `opts'
+	local first_opt : word 1 of `opt'
+	opts_exclusive "`all' `none'" dofadjustments
+	opts_exclusive "`pairwise' `firstpair'" dofadjustments
+	opts_exclusive "`all' `first_opt'" dofadjustments
+	opts_exclusive "`none' `first_opt'" dofadjustments
+	if ("`none'" != "") local opts
+	if ("`all'" != "") local opts pairwise clusters continuous
+	//if (`: list posof "three" in opts') {
+	//	cap findfile group3hdfe.ado
+	//	_assert !_rc , msg("error: -group3hdfe- not installed, please run {stata ssc install group3hdfe}")
+	//}
+	if ("`groupvar'"!="") conf new var `groupvar'
+	sreturn local dofadjustments "`opts'"
+	sreturn loc groupvar "`s(groupvar)'"
+
+* Residuals
+	if ("`residuals2'" != "") {
+		_assert ("`residuals'" == ""), msg("residuals() syntax error")
+		cap drop _reghdfe_resid // destructive!
+		sreturn loc residuals _reghdfe_resid
+	}
+	else if ("`residuals'"!="") {
+		conf new var `residuals'
+		sreturn loc residuals `residuals'
+	}
+
+* Misc
+	if ("`condition'"!="") {
+		_assert `G'==2, msg("Computing finite condition number requires two FEs")
+		sreturn loc finite_condition 1
+	}
+
+	sreturn loc compute_rre = ("`rre'" != "")
+	if ("`rre'" != "") {
+		sreturn loc rre `rre'
+	}
+
+	if (`poolsize' < 1) loc poolsize .
+	sreturn loc poolsize `poolsize'
+
+	sreturn loc precondition = "`precondition'" != ""
+end

30/replication_package/Adofiles/reghdfe_2019/reghdfe_projections.mata

@@ -0,0 +1,166 @@
+// Code that partials out (demean) a specific fixed effect
+mata:
+
+`Variables' panelmean(`Variables' y,
+                      `Factor' f)
+{
+    pointer(`Variable')              Pw, Pcounts
+    `Boolean' has_weights
+    has_weights = asarray(f.extra, "has_weights") == J(0,0,.) ? 0 : asarray(f.extra, "has_weights")
+    assert(has_weights==0 | has_weights==1)
+
+    if (has_weights) {
+        Pw = &asarray(f.extra, "weights")
+        Pcounts = &asarray(f.extra, "weighted_counts")
+        return(editmissing(`panelsum'(y, *Pw, f.info) :/ *Pcounts, 0))
+    }
+    else {
+        return(`panelsum'(y, f.info) :/ f.counts)
+    }
+}
+
+
+`Matrix' precompute_inv_xx(`Factor' f,
+                           `Boolean' has_intercept)
+{
+    `Integer'               i, L, K, offset
+    `Variables'             x, tmp_x
+    `Variable'              w, tmp_w
+    `Matrix'                xmeans, inv_xx
+    `RowVector'             tmp_xmeans
+    `Matrix'                tmp_inv_xx
+    `Boolean'               has_weights
+
+    has_weights = asarray(f.extra, "has_weights")
+
+    // x and w must be already sorted by the factor f
+    x = asarray(f.extra, "x")
+    L = f.num_levels
+    K = cols(x)
+    inv_xx = J(L * K, K, .)
+
+    if (has_weights) w = asarray(f.extra, "weights")
+    if (has_intercept) xmeans = asarray(f.extra, "xmeans")
+    
+    for (i = 1; i <= L; i++) {
+            tmp_x = panelsubmatrix(x, i, f.info)
+            tmp_w = has_weights ? panelsubmatrix(w, i, f.info) : 1
+            if (has_intercept) {
+                tmp_xmeans = K > 1 ? xmeans[i, .] : xmeans[i]
+                tmp_inv_xx = invsym(quadcrossdev(tmp_x, tmp_xmeans, tmp_w, tmp_x, tmp_xmeans))
+            }
+            else {
+                tmp_inv_xx = invsym(quadcross(tmp_x, tmp_w, tmp_x))
+            }
+            offset = K * (i - 1)
+            inv_xx[|offset + 1, 1 \ offset + K , . |] = tmp_inv_xx
+    }
+    return(inv_xx)
+}
+
+
+`Variables' panelsolve_invsym(`Variables' y,
+                              `Factor' f,
+                              `Boolean' has_intercept,
+                            | `Matrix' alphas)
+{
+    `Integer'               i, L, K, offset
+    `Variables'             x, tmp_x, tmp_y, xbd, tmp_xbd
+    `Variable'              w, tmp_w
+    `Matrix'                xmeans, inv_xx
+    `RowVector'             tmp_xmeans, tmp_ymeans
+    `Matrix'                tmp_xy, tmp_inv_xx
+    `Boolean'               has_weights
+    `Boolean'               save_alphas
+    `Vector'                b
+
+    has_weights = asarray(f.extra, "has_weights")
+    save_alphas = args()>=4 & alphas!=J(0,0,.)
+    // assert(has_weights==0 | has_weights==1)
+    if (save_alphas) assert(cols(y)==1)
+   
+    // x, y and w must be already sorted by the factor f
+    L = f.num_levels
+    xbd = J(rows(y), cols(y), .)
+    x = asarray(f.extra, "x")
+    inv_xx = asarray(f.extra, "inv_xx")
+    K = cols(x)
+
+    if (has_weights) w = asarray(f.extra, "weights")
+    if (has_intercept) xmeans = asarray(f.extra, "xmeans")
+    
+    for (i = 1; i <= L; i++) {
+            tmp_y = panelsubmatrix(y, i, f.info)
+            tmp_x = panelsubmatrix(x, i, f.info)
+            tmp_w = has_weights ? panelsubmatrix(w, i, f.info) : 1
+            offset = K * (i - 1)
+            tmp_inv_xx = inv_xx[|offset + 1, 1 \ offset + K , . |]
+
+            if (has_intercept) {
+                tmp_ymeans = mean(tmp_y, tmp_w)
+                tmp_xmeans = K > 1 ? xmeans[i, .] : xmeans[i]
+                tmp_xy = quadcrossdev(tmp_x, tmp_xmeans, tmp_w, tmp_y, tmp_ymeans)
+                if (save_alphas) {
+                    b = tmp_inv_xx * tmp_xy
+                    alphas[i, .] = tmp_ymeans - tmp_xmeans * b, b'
+                    tmp_xbd = (tmp_x :- tmp_xmeans) * b :+ tmp_ymeans
+                }
+                else {
+                    tmp_xbd = (tmp_x :- tmp_xmeans) * (tmp_inv_xx * tmp_xy) :+ tmp_ymeans
+                }
+            }
+            else {
+                tmp_xy = quadcross(tmp_x, tmp_w, tmp_y)
+                if (save_alphas) {
+                    b = tmp_inv_xx * tmp_xy
+                    alphas[i, .] = b'
+                    tmp_xbd = tmp_x * b
+                }
+                else {
+                    tmp_xbd = tmp_x * (tmp_inv_xx * tmp_xy)
+                }
+            }
+            xbd[|f.info[i,1], 1 \ f.info[i,2], .|] = tmp_xbd
+    }
+    return(f.invsort(xbd))
+}
+
+/*
+`Variables' panelsolve_qrsolve(`Variables' Y, `Variables' X, `Factor' f)
+{
+    `Integer'               i
+    `Variables'             x, y, betas
+
+    betas = J(f.num_levels, 1 + cols(X), .)
+    
+    for (i = 1; i <= f.num_levels; i++) {
+            y = panelsubmatrix(Y, i, F.info)
+            x = panelsubmatrix(X, i, F.info) , J(rows(y), 1, 1)
+            betas[i, .] = qrsolve(x, y)'
+    }
+    return(betas)
+}
+
+*/
+
+// used with lsmr if we have fixed slopes
+`Variables' reghdfe_panel_precondition(`Variables' y, `Factor' f)
+{
+    `Vector' ans
+    pointer(`Variable')              Pw
+    `Boolean' has_weights
+
+    has_weights = asarray(f.extra, "has_weights")
+    if (has_weights) {
+        Pw = &asarray(f.extra, "weights")
+        ans = `panelsum'(y:^2, *Pw, f.info)
+    }
+    else {
+        ans = `panelsum'(y, f.info)
+    }
+
+    ans = y :/ sqrt(ans)[f.levels]
+    return(ans)
+}
+end
+

30/replication_package/Adofiles/reghdfe_2019/reghdfe_store_alphas.ado

@@ -0,0 +1,29 @@
+program define reghdfe_store_alphas, eclass
+	mata: st_local("save_any_fe", strofreal(HDFE.save_any_fe))
+	assert inlist(`save_any_fe', 0, 1)
+	if (`save_any_fe') {
+		_assert e(depvar) != "", msg("e(depvar) is empty")
+		_assert e(resid) != "", msg("e(resid) is empty")
+		// we can't use -confirm var- because it might have TS operators
+		fvrevar `e(depvar)', list
+		confirm numeric var `e(resid)', exact
+		tempvar d
+		if (e(rank)) {
+			qui _predict double `d' if e(sample), xb
+		}
+		else if (e(report_constant)) {
+			gen double `d' = _b[_cons] if e(sample)
+		}
+		else {
+			gen double `d' = 0 if e(sample)
+		}
+		qui replace `d' = `e(depvar)' - `d' - `e(resid)' if e(sample)
+
+		mata: HDFE.store_alphas("`d'")
+		drop `d'
+
+		// Drop resid if we don't want to save it; and update e(resid)
+		cap drop __temp_reghdfe_resid__
+		if (!c(rc)) ereturn local resid
+	}
+end