Stata 15 help for mf_robust

Title

[M-5] robust() -- Robust variance estimates

Syntax

Initialization

R = robust_init()

Estimation sample and subpopulation specifications

(varies) robust_init_touse(R, touse)

(varies) robust_init_subpop(R, subpop)

Model specification

Note: In all the following robust_init_*() functions, the last argument is optional. Not specifying this argument causes the current, unchanged setting to be returned.

(varies) robust_init_scores(R, S)

(varies) robust_init_covmat(R, D)

(varies) robust_init_eq_n(R, neq)

(varies) robust_init_eq_indepvars(R, i, X)

(varies) robust_init_eq_cons(R, i, { "on" | "off" } )

(varies) robust_init_minus(R, m)

Sampling design specification

(varies) robust_init_svyset(R, { "off" | "on" } )

(varies) robust_init_nstages(R, K)

(varies) robust_init_stage_units(R, k, units)

(varies) robust_init_stage_strata(R, k, strata)

(varies) robust_init_stage_fpc(R, k, fpc)

(varies) robust_init_weight(R, w)

(varies) robust_init_weighttype(R, { "" | "pweight" | "fweight" | "aweight" } )

(varies) robust_init_poststrata(R, P)

(varies) robust_init_singleunit(R, singleunit)

Miscellaneous settings

(varies) robust_init_V_srs(R, { "off" | "on" } )

(varies) robust_init_verbose(R, { "on" | "off" } )

Variance computation

real matrix robust(R)

real scalar _robust(R)

Results

real matrix robust_result_V(R)

real matrix robust_result_V_srs(R)

real matrix robust_result_V_srssub(R)

real matrix robust_result_V_srswr(R)

real matrix robust_result_V_srswrsub(R)

real matrix robust_result_stage_strata(R)

real matrix robust_result_stage_certain(R)

real matrix robust_result_stage_single(R)

real matrix robust_result_postsize(R)

real matrix robust_result_postsum(R)

real scalar robust_result_N(R)

real scalar robust_result_sum_w(R)

real scalar robust_result_N_sub(R)

real scalar robust_result_sum_wsub(R)

real scalar robust_result_N_clust(R)

real scalar robust_result_N_strata(R)

real scalar robust_result_N_strata_omit(R)

real scalar robust_result_census(R)

real scalar robust_result_singleton(R)

real scalar robust_result_errorcode(R)

string scalar robust_result_errortext(R)

real scalar robust_result_returncode(R)

Query status of robust specification

void robust_query(R)

where R, if it is declared, should be declared

transmorphic R

and where singleunit, optionally specified in robust_init_singleunit(), is

singleunit Description -------------------------------------------------------------- "missing" return a robust matrix of zeros if there are strata with only one sampling unit "certainty" treat strata with only one sampling unit as certainty units "scaled" use a scale version of "certainty" "centered" center strata with only one sampling unit at the grand mean -------------------------------------------------------------- The default is "missing".

Arguments S, X, touse, units, strata, fpc, w, and P are assumed to be real matrices (or views) of the appropriate dimension or string scalars identifying Stata variables. A view matrix is generated when these arguments identify Stata variables. The Stata variable identified by the touse setting (if one was specified) is used to auto-generate the views.

The subpop argument is assumed to be a column vector with the correct number of rows or a string scalar identifying the subpopulation observations according to the subpop() option of the svy prefix command.

No copy of the matrix arguments to the robust_init_*() functions is made; a pointer is stored in R, so any changes to the specified matrix will be reflected from within robust() and the robust_result_*() functions.

Description

These functions compute a robust variance estimate based on equation-level scores, a covariance matrix, and a sampling design. Equation-level scores are expanded according to the chain rule when equation-level predictor variables are specified. The sampling designs covered include simple random sampling with and without replacement, clustered sampling, stratified sampling, and complex survey designs consisting of multiple stages of clustered sampling with stratification at any stage.

robust_init() begins the definition of a robust problem and returns R, a problem-description handle that contains default values.

The robust_init_*(R, ...) functions then allow you to modify those defaults. You use these functions to describe your particular problem: to set the equations, to set the equation-level scores, to specify the covariance matrix, to specify the sampling design, and the like.

robust(R) then performs the robust variance calculations.

The robust_result_*(R) functions can then be used to access the computed results.

Usually you would stop there. In other cases, you could compute variance estimates using a different sampling design.

Aside:

The robust_init_*(R, ...) functions have two modes of operation. Each has an optional argument that you specify to set the value and that you omit to query the value. For instance, the full syntax of robust_init_scores() is

void robust_init_scores(R, S)

real matrix robust_init_scores(R)

The first syntax sets the equation-level scores and returns nothing. The second syntax returns a real matrix containing the specified equation-level scores.

All the robust_init_*(R, ...) functions work the same way.

Remarks

Remarks are presented under the following headings:

Example

Functions robust_init() robust_init_touse() robust_init_subpop() robust_init_scores() robust_init_covmat() robust_init_eq_n() robust_init_eq_indepvars() robust_init_eq_cons() robust_init_minus() robust_init_svyset() robust_init_nstages() robust_init_stage_units() robust_init_stage_strata() robust_init_stage_fpc() robust_init_weight() robust_init_weighttype() robust_init_poststrata() robust_init_singleunit() robust_init_V_srs() robust_init_verbose()

robust() _robust()

robust_result_V() robust_result_V_srs() robust_result_V_srssub() robust_result_V_srswr() robust_result_V_srswrsub() robust_result_stage_strata() robust_result_stage_certain() robust_result_stage_single() robust_result_postsize() robust_result_postsum() robust_result_N() robust_result_sum_w() robust_result_N_sub() robust_result_sum_wsub() robust_result_N_clust() robust_result_N_strata() robust_result_N_strata_omit() robust_result_census() robust_result_singleton() robust_result_errorcode() robust_result_errortext() robust_result_returncode()

robust_query()

Example

The robust variance functions may be used interactively.

Let's start by pulling some variables from the auto dataset into Mata:

: stata("sysuse auto") : st_view(y=., ., "price")

: st_view(X=., ., "mpg")

: st_view(strata=., ., "foreign")

From within Mata, we fit a linear regression model of y (price) on X (mpg) and use robust() to compute a variance, assuming the cars were sampled using stratified simple random sampling, where strata (foreign) identifies our strata.

: D = invsym(cross(X, 1, X, 1))

: b = D*cross(X, 1, y, 0)

: e = y - X*b[1] :- b[2]

: R = robust_init()

: robust_init_scores(R, e)

: robust_init_covmat(R, D)

: robust_init_eq_indepvars(R, 1, X)

: robust_init_stage_strata(R, 1, strata)

: V = robust(R)

: b, sqrt(diagonal(V)) 1 2 +-------------------------------+ 1 | -238.8943456 57.13929874 | 2 | 11253.06066 1375.65857 | +-------------------------------+

Here is the equivalent example using Stata variables:

Stata

. regress price mpg, mse1 (output omitted)

. gen byte touse = e(sample)

. predict double score, score

Mata

: b = st_matrix("e(b)")'

: R = robust_init()

: robust_init_touse(R, "touse")

: robust_init_scores(R, "score")

: robust_init_eq_indepvars(R, 1, "mpg")

: robust_init_stage_strata(R, 1, "foreign")

: robust_init_covmat(R, st_matrix("e(V)"))

: V = robust(R)

: b, sqrt(diagonal(V)) 1 2 +-------------------------------+ 1 | -238.8943456 57.13929874 | 2 | 11253.06066 1375.65857 | +-------------------------------+

Functions

robust_init()

transmorphic robust_init()

robust_init() is used to begin a robust variance problem. Store the returned result in a variable name of your choosing; we have used R in this documentation. You pass R as the first argument to the other robust_*() functions.

robust_init() sets all robust_init_*() values to their defaults. You may use the query form of robust_init_*() to determine an individual default, or you can use robust_query() to see them all.

The query form of robust_init_*() can be used before or after calling robust().

robust_init_touse()

void robust_init_touse(R, touse)

real colvector robust_init_touse(R)

robust_init_touse(R, touse) specifies the column vector or Stata variable that identifies the estimation sample. If touse is a column vector, it is assumed to be a vector of 1s. robust() will reset the values of touse to 0 for observations within any omitted strata.

Technical note: If touse identifies a Stata variable, it will be used to produce views from all Stata variables that were specified.

robust_init_touse(R) returns the vector that identifies the estimation sample. A 0 x 1 matrix is returned if nothing was specified.

robust_init_subpop()

void robust_init_subpop(R, subpop)

real colvector robust_init_subpop(R)

robust_init_subpop(R, subpop) specifies that subpop identifies the subpopulation sample.

Technical note: If subpop is a string, then it is interpreted like the subpop() option of the svy prefix command. Here either robust_init_svyset() should be set to "on" or the first-stage design settings should be set using Stata variables.

robust_init_subpop(R) returns the vector that identifies the subpopulation sample. A 0 x 1 matrix is returned if nothing was specified.

robust_init_scores()

void robust_init_scores(R, S)

real matrix robust_init_scores(R)

robust_init_scores(R, S) specifies that the equation-level scores are contained in S. Each column of S corresponds to an equation.

robust() uses the chain rule to expand equation-level scores out to parameter-level scores. Use robust_init_eq_n(R, dim) without setting independent variables if you are specifying parameter-level scores instead; here dim is the number of columns in the scores matrix.

robust_init_scores(R) returns the specified scores matrix. A 0 x 0 matrix is returned if nothing was specified.

robust_init_covmat()

void robust_init_covmat(R, real matrix D)

real matrix robust_init_covmat(R)

robust_init_covmat(R, D) sets the covariance matrix to be used in the robust variance calculation.

robust_init_covmat(R) returns the specified covariance matrix. A 0 x 0 matrix is returned if nothing was specified.

robust_init_eq_n() robust_init_eq_indepvars() robust_init_eq_cons()

void robust_init_eq_n(R, neq)

void robust_init_eq_indepvars(R, i, X)

void robust_init_eq_cons(R, i, { "on" | "off" } )

real scalar robust_init_eq_n(R)

real matrix robust_init_eq_indepvars(R, i)

string scalar robust_init_eq_cons(R, i)

robust_init_eq_n(R, neq) sets the number of linear equations. This function is not actually necessary because the number of linear equations is automatically updated as you set them by using the above functions; however, the robust_init_eq_*() functions perform more efficiently when you set the number of equations ahead of time.

robust_init_eq_indepvars(R, i, X) specifies that the independent variables for the ith equation are contained in X.

robust_init_eq_cons(R, i, cons) specifies whether there is a constant term for the ith equation. cons="on" means that the constant term is present; "off" means there is no constant term. cons="on" is the default.

robust_init_eq_n(R) returns the number of equations that were specified. Technically, this is the maximum between neq and the largest i used to specify an equation.

robust_init_eq_indepvars(R, i) specifies the matrix of independent variables for the ith equation. A 0 x 0 matrix is returned if nothing was specified.

robust_init_eq_cons(R, i) returns whether the constant term is "on" or "off" for the ith equation.

robust_init_minus()

void robust_init_minus(R, m)

real scalar robust_init_minus(R)

robust_init_minus(R, m) specifies the value for use in the multiplier n/(n-m) of the robust variance estimator (here n is the sample size). The default is m=1.

robust_init_minus(R) returns the current value of m.

robust_init_svyset()

void robust_init_svyset(R, { "off" | "on" } )

string scalar robust_init_svyset(R)

robust_init_svyset(R, svyset) specifies whether to grab the survey design settings from svyset. svyset="on" means to get the survey design settings from svyset; "off" means not to get them. svyset="off" is the default. Specifying "on" will cause robust() to replace the survey design settings with those from the svyset command.

robust_init_svyset(R) returns the current settings for grabbing the survey design settings from svyset.

robust_init_nstages()

void robust_init_nstages(R, K)

real scalar robust_init_nstages(R)

robust_init_nstages(R, K) sets the number of stages in the sampling design. This function is not actually necessary because the number of stages is automatically updated as you use the robust_init_stage_*() functions; however, the robust_init_stage_*() functions perform more efficiently when you set the number of sampling stages ahead of time.

robust_init_nstages(R) returns the number of sampling stages. Technically, this is the maximum between K and the largest k used to specify a stage.

robust_init_stage_units() robust_init_stage_strata() robust_init_stage_fpc()

void robust_init_stage_units(R, k, units)

void robust_init_stage_strata(R, k, strata)

void robust_init_stage_fpc(R, k, fpc)

real colvector robust_init_stage_units(R, k)

real colvector robust_init_stage_strata(R, k)

real colvector robust_init_stage_fpc(R, k)

robust_init_stage_units(R, k, units) specifies that units identifies the sampling units in the kth stage.

robust_init_stage_strata(R, k, strata) specifies that strata identifies the strata in the kth stage.

robust_init_stage_fpc(R, k, fpc) specifies that fpc contains the finite population correction (FPC) information for the kth stage.

robust_init_stage_units(R, k) returns the vector that identifies the sampling units in the kth stage. A 0 x 1 matrix is returned if nothing was specified.

robust_init_stage_strata(R, k) returns the vector that identifies the strata in the kth stage. A 0 x 1 matrix is returned if nothing was specified.

robust_init_stage_fpc(R, k) returns the vector containing the FPC information for the kth stage. A 0 x 1 matrix is returned if nothing was specified.

robust_init_weight() robust_init_weighttype()

void robust_init_weight(R, w)

void robust_init_weighttype(R, { "" | "pweight" | "fweight" | "aweight" } )

real colvector robust_init_weight(R)

string scalar robust_init_weighttype(R)

robust_init_weight(R, w) specifies that w contains the weights used in the model fit that produced the scores.

robust_init_weighttype(R, wtype) sets the weight type. wtype="pweight" is the default.

robust_init_weight(R) returns the weight vector. A 0 x 1 matrix is returned if nothing was specified.

robust_init_weighttype(R) returns the weight type.

robust_init_poststrata()

void robust_init_poststrata(R, P)

real matrix robust_init_poststrata(R)

robust_init_poststrata(R, P) sets the poststratification information. P is assumed to have 2 columns or specify 2 Stata variables: the first identifies the poststrata and the second contains the poststratum weights.

Note: The poststratum weights must be constant within the poststrata.

robust_init_poststrata(R) returns a matrix containing the poststratification information. A 0 x 2 matrix is returned if nothing was specified.

robust_init_singleunit()

void robust_init_singleunit(R, singleunit)

string scalar robust_init_singleunit(R)

robust_init_singleunit(R, singleunit) specifies how to handle strata with a single sampling unit.

singleunit="missing" means to return a zero variance matrix, resulting in missing standard errors when the variance matrix is ereturn posted in Stata. This is the default behavior.

singleunit="certainty" means to treat these strata as certainty units.

singleunit="scaled" means to use a scaled version of the variance matrix where these strata were treated as certainty units.

singleunit="centered" means to center these strata at the grand mean instead of at the respective stratum mean.

robust_init_singleunit(R) returns the current setting for singleunit.

robust_init_V_srs()

void robust_init_V_srs(R, { "off" | "on" } )

real scalar robust_init_V_srs(R)

robust_init_V_srs(R, vsrs) sets whether to perform the extra variance calculations, assuming simple random sampling. vsrs="on" means to perform the extra variance calculations; "off" means not to perform them. vsrs="off" is the default.

robust_init_V_srs(R) returns the current setting for vsrs.

robust_init_verbose()

void robust_init_verbose(S, { "on" | "off" } )

real scalar robust_init_verbose(S)

robust_init_verbose(S, verbose) sets whether error messages that arise during the execution of robust() or _robust() are to be displayed. verbose="on" means that they are displayed; "off" means that they are not displayed. The default is "on". Setting verbose to "off" is of interest only to users of _robust().

robust_init_verbose(S) returns 1 if verbose is "on" and 0 if it is "off".

robust()

real matrix robust(R)

robust(R) invokes the robust variance calculations and returns the resulting variance matrix. If something goes wrong, robust() aborts with error.

Before you can invoke robust(), you must have set the equation-level scores and corresponding equations.

R = robust_init() robust_init_scores(R, scores) robust_init_eq_n(R, 1) robust_init_eq_indepvars(R, X1)

You may have coded other robust_init_*(R) functions as well, such as specifying a more complicated sampling design than the default design (with-replacement simple random sampling).

Once robust() completes, you may use the robust_result_*(R) functions. You may also continue to use the robust_init_*(R) functions to access the initial settings, or you may change the settings and reinvoke robust() if you wish.

_robust()

real scalar _robust(R)

_robust(R) performs the same actions as robust(R) except that, rather than returning the resulting variance matrix, _robust() returns a real scalar and, rather than aborting if numerical issues arise, _robust() returns a nonzero value. _robust() returns 0 if all went well. The returned value is called an error code.

robust() returns the robust variance matrix. It can work that way because the robust calculations must have gone well. Had they not gone well, robust() would have aborted execution.

_robust() returns an error code. If it is 0, the robust calculations went well and you can obtain the resulting variance matrix by using robust_result_V(). If the calculations did not go well, you can use the error code to diagnose what went wrong and take the appropriate action.

Programmers implementing advanced systems will want to use _robust() instead of robust(). Everybody else should use robust().

Programmers using _robust() will also be interested in the functions robust_init_verbose(), robust_result_errorcode(), robust_result_errortext(), and robust_result_returncode().

robust_result_V()

real matrix robust_result_V(R)

robust_result_V(R) returns the robust variance matrix.

robust_result_V_srs() robust_result_V_srssub() robust_result_V_srswr() robust_result_V_srswrsub()

real matrix robust_result_V_srs(R)

real matrix robust_result_V_srssub(R)

real matrix robust_result_V_srswr(R)

real matrix robust_result_V_srswrsub(R)

The robust_result_V_srs*() functions return extra variance estimates requested a priori via robust_init_V_srs(R, "on"). If robust_init_V_srs(R, "on") was not specified, these functions return matrices filled with missing values.

robust_result_V_srs(R) returns the variance matrix, assuming the data were collected using a without-replacement simple random sample design. The sampling weights should sum to the population size for the result of this function to be meaningful.

robust_result_V_srssub(R) returns the subpopulation variance matrix, assuming the subpopulation observations were collected using a without-replacement simple random sample design. The sampling weights within the subpopulation sample should sum to the subpopulation size for the result of this function to be meaningful.

robust_result_V_srswr(R) returns the variance matrix, assuming the data were collected using a with-replacement simple random sample design.

robust_result_V_srswrsub(R) returns the subpopulation variance matrix, assuming the data were collected using a with-replacement simple random sample design.

robust_result_stage_strata() robust_result_stage_certain() robust_result_stage_single()

real matrix robust_result_stage_strata(R)

real matrix robust_result_stage_certain(R)

real matrix robust_result_stage_single(R)

robust_result_stage_strata(R) returns a rowvector containing the number of strata within each stage.

robust_result_stage_certain(R) returns a rowvector containing the number of certainty strata within each stage.

robust_result_stage_single(R) returns a rowvector containing the number of single unit strata within each stage.

robust_result_postsize() robust_result_postsum()

real matrix robust_result_postsize(R)

real matrix robust_result_postsum(R)

robust_result_postsize(R) returns a rowvector of the poststratum sizes (the number of individuals in the populations that belong to each poststratum).

robust_result_postsum(R) returns a rowvector of the sum of the unadjusted sampling weights within each poststratum.

robust_result_N() robust_result_sum_w() robust_result_N_sub() robust_result_sum_wsub() robust_result_N_clust() robust_result_N_strata() robust_result_N_strata_omit()

real scalar robust_result_N(R)

real scalar robust_result_sum_w(R)

real scalar robust_result_N_sub(R)

real scalar robust_result_sum_wsub(R)

real scalar robust_result_N_clust(R)

real scalar robust_result_N_strata(R)

real scalar robust_result_N_strata_omit(R)

robust_result_N(R) returns the sample size.

robust_result_sum_w(R) returns the sum of the sampling weights. This value is typically used to estimate the size of the population.

robust_result_N_sub(R) returns the subpopulation sample size.

robust_result_sum_wsub(R) returns the sum of the sampling weights within the subpopulation observations. This value is typically used to estimate the size of the subpopulation.

robust_result_N_clust(R) returns the number of first-stage sampling units, also known as clusters or primary sampling units.

robust_result_N_strata(R) returns the number of first-stage strata.

robust_result_N_strata_omit(R) returns the number of first-stage strata that were omitted because they did not intersect with the subpopulation.

robust_result_census()

real scalar robust_result_census(R)

robust_result_census(R) returns an indicator (0 or 1 value) for whether the first-stage sampling units represent a census. This is the special case where the robust variance matrix consisting of all zeros is interpreted to truly mean no variation.

robust_result_singleton()

real scalar robust_result_singleton(R)

robust_result_singleton(R) returns an indicator (0 or 1 value) for whether there were strata with only one sampling unit in any of the sampling stages.

robust_result_errorcode() robust_result_errortext() robust_result_returncode()

real scalar robust_result_errorcode(R)

string scalar robust_result_errortext(R)

real scalar robust_result_returncode(R)

These functions are for use after _robust().

robust_result_errorcode(R) returns the error code as _robust(). The value will be zero if there were no errors. The possible error codes are listed directly below.

robust_result_errortext(R) returns a string containing the error message corresponding to the error code. If the error code is zero, the string will be "".

robust_result_returncode(R) returns the Stata return code corresponding to the error code. The mapping is listed directly below.

In advanced code, these functions might be used as follows:

robust_init_verbose(R, 0) (void) _robust(R) ... if (ec = robust_result_errorcode(R)) { errprintf("{p}\n") errprintf("%s\n", robust_result_errortext(R)) errprintf("{p_end}\n") exit(robust_result_returncode(R)) /*NOTREACHED*/ }

The error codes and their corresponding Stata return codes are listed in the following table.

Error Return code code Error text ---------------------------------------------------------------------- 1 2000 no observations

2 3498 conformability error

3 100 no equations specified

4 198 invalid weight type

5 465 poststratum weights must be >= 0

6 464 poststratum weights must be constant within poststrata

7 460 FPC must be >= 0

8 461 FPC for all observations within a stratum must be the same

9 462 FPC must be <= 1 if a rate, or >= no. sampled units per stratum if unit totals

----------------------------------------------------------------------

robust_query()

void robust_query(R)

robust_query(R) displays a report on the current robust_init_*() values. robust_query(R) may be used before or after robust() and is useful when using robust() interactively or when debugging a program that calls robust() or _robust().

Conformability

All functions have 1 x 1 inputs and have 1 x 1 or void outputs except the following:

robust_init_touse(R, touse): R: transmorphic touse: 1 x 1 (string) N x 1 (real) result: void

robust_init_touse(R): R: transmorphic result: N x 1

robust_init_subpop(R, subpop): R: transmorphic subpop: 1 x 1 (string) N x 1 (real) result: void

robust_init_subpop(R): R: transmorphic result: N x 1

robust_init_scores(R, S): R: transmorphic S: 1 x 1 (string) N x neq (real) result: void

robust_init_scores(R): R: transmorphic result: N x neq

robust_init_covmat(R): R: transmorphic result: np x np

robust_init_eq_indepvars(R, i, X): R: transmorphic i: 1 x 1 X: 1 x 1 (string) N x k_i (real) result: void

robust_init_eq_indepvars(R, i): R: transmorphic i: 1 x 1 result: N x k_i

robust_init_stage_units(R, k, units): R: transmorphic k: 1 x 1 units: 1 x 1 (string) N x 1 (real) result: void

robust_init_stage_units(R, k): R: transmorphic k: 1 x 1 result: N x 1

robust_init_stage_strata(R, k, strata): R: transmorphic k: 1 x 1 strata: 1 x 1 (string) N x 1 (real) result: void

robust_init_stage_strata(R, k): R: transmorphic k: 1 x 1 result: N x 1

robust_init_stage_fpc(R, k, fpc): R: transmorphic k: 1 x 1 fpc: 1 x 1 (string) N x 1 (real) result: void

robust_init_stage_fpc(R, k): R: transmorphic k: 1 x 1 result: N x 1

robust_init_weight(R, w): R: transmorphic k: 1 x 1 w: 1 x 1 (string) N x 1 (real) result: void

robust_init_weight(R): R: transmorphic result: N x 1

robust_init_poststrata(R, P): R: transmorphic P: 1 x 1 (string) N x 2 (real) result: void

robust_init_poststrata(R): R: transmorphic result: N x 2

robust(R): R: transmorphic result: np x np

robust_result_V(R): R: transmorphic result: np x np

robust_result_V_srs(R): R: transmorphic result: np x np

robust_result_V_srssub(R): R: transmorphic result: np x np

robust_result_V_srswr(R): R: transmorphic result: np x np

robust_result_V_srswrsub(R): R: transmorphic result: np x np

robust_result_stage_strata(R): R: transmorphic result: 1 x K

robust_result_stage_certain(R): R: transmorphic result: 1 x K

robust_result_stage_single(R): R: transmorphic result: 1 x K

robust_result_postsize(R): R: transmorphic result: 1 x npost

robust_result_postsum(R): R: transmorphic result: 1 x npost

Diagnostics

All functions abort with error when used incorrectly.

robust() aborts with error if it runs into numerical difficulties.

Source code

robust.mata


© Copyright 1996–2018 StataCorp LLC   |   Terms of use   |   Privacy   |   Contact us   |   What's new   |   Site index