R: Estimations table (export the results of multiples...

etable {fixest} | R Documentation

## Estimations table (export the results of multiples estimations to a DF or to Latex)

### Description

Aggregates the results of multiple estimations and displays them in the form of either a Latex table or a `data.frame`.

### Usage

    etable(
      ...,
      se = NULL,
      dof = NULL,
      cluster = NULL,
      stage = 2,
      agg = NULL,
      .vcov,
      .vcov_args = NULL,
      digits = 4,
      digits.stats = 5,
      tex,
      fitstat,
      title,
      coefstat = "se",
      ci = 0.95,
      sdBelow = TRUE,
      keep,
      drop,
      order,
      dict,
      file,
      replace = FALSE,
      convergence,
      signifCode,
      label,
      float,
      subtitles = list("auto"),
      fixef_sizes = FALSE,
      fixef_sizes.simplify = TRUE,
      keepFactors = TRUE,
      family,
      powerBelow = -5,
      interaction.combine = " $\\times $ ",
      depvar = TRUE,
      style.tex = NULL,
      style.df = NULL,
      notes = NULL,
      group = NULL,
      extraline = NULL,
      placement = "htbp",
      drop.section = NULL,
      poly_dict = c("", " square", " cube"),
      postprocess.tex = NULL,
      postprocess.df = NULL,
      fit_format = "__var__"
    )

    setFixest_etable(
      digits = 4,
      digits.stats = 5,
      fitstat,
      coefstat = c("se", "tstat", "confint"),
      ci = 0.95,
      sdBelow = TRUE,
      keep,
      drop,
      order,
      dict,
      signifCode,
      float,
      fixef_sizes = FALSE,
      fixef_sizes.simplify = TRUE,
      family,
      powerBelow = -5,
      interaction.combine = " $\\times $ ",
      depvar,
      style.tex = NULL,
      style.df = NULL,
      notes = NULL,
      group = NULL,
      extraline = NULL,
      placement = "htbp",
      drop.section = NULL,
      postprocess.tex = NULL,
      postprocess.df = NULL,
      fit_format = "__var__",
      reset = FALSE
    )

    getFixest_etable()

    esttable(
      ...,
      se = NULL,
      dof = NULL,
      cluster = NULL,
      stage = 2,
      agg = NULL,
      .vcov,
      .vcov_args = NULL,
      digits = 4,
      digits.stats = 5,
      fitstat,
      coefstat = "se",
      ci = 0.95,
      sdBelow = TRUE,
      keep,
      drop,
      order,
      dict,
      file,
      replace = FALSE,
      convergence,
      signifCode,
      subtitles = list("auto"),
      fixef_sizes = FALSE,
      fixef_sizes.simplify = TRUE,
      keepFactors = TRUE,
      family,
      powerBelow = -5,
      interaction.combine = " $\\times $ ",
      depvar = TRUE,
      style.df = NULL,
      group = NULL,
      extraline = NULL,
      drop.section = NULL,
      poly_dict = c("", " square", " cube"),
      postprocess.df = NULL,
      fit_format = "__var__"
    )

    esttex(
      ...,
      se = NULL,
      dof = NULL,
      cluster = NULL,
      stage = 2,
      agg = NULL,
      .vcov,
      .vcov_args = NULL,
      digits = 4,
      digits.stats = 5,
      fitstat,
      title,
      coefstat = "se",
      ci = 0.95,
      sdBelow = TRUE,
      keep,
      drop,
      order,
      dict,
      file,
      replace = FALSE,
      convergence,
      signifCode,
      label,
      float,
      subtitles = list("auto"),
      fixef_sizes = FALSE,
      fixef_sizes.simplify = TRUE,
      keepFactors = TRUE,
      family,
      powerBelow = -5,
      interaction.combine = " $\\times $ ",
      depvar = TRUE,
      style.tex = NULL,
      notes = NULL,
      group = NULL,
      extraline = NULL,
      placement = "htbp",
      drop.section = NULL,
      poly_dict = c("", " square", " cube"),
      postprocess.tex = NULL,
      fit_format = "__var__"
    )

### Arguments

`...` | Used to capture different `fixest` estimation objects (obtained with `femlm`, `feols` or `feglm`). Note that any other type of element is discarded. Note that you can give a list of `fixest` objects.
`se` | Character scalar. Which kind of standard error should be computed: “standard”, “hetero”, “cluster”, “twoway”, “threeway” or “fourway”? By default if there are clusters in the estimation: `se = "cluster"`, otherwise `se = "standard"`. Note that this argument can be implicitly deduced from the argument `cluster`.
`dof` | An object of class `dof.type` obtained with the function `dof`. Represents how the degree of freedom correction should be done.You must use the function `dof` for this argument. The arguments and defaults of the function `dof` are: `adj = TRUE`, `fixef.K="nested"`, `cluster.adj = TRUE`, `cluster.df = "conventional"`, `t.df = "conventional"`, `fixef.force_exact=FALSE)`. See the help of the function `dof` for details.
`cluster` | Tells how to cluster the standard-errors (if clustering is requested). Can be either a list of vectors, a character vector of variable names, a formula or an integer vector. Assume we want to perform 2-way clustering over `var1` and `var2` contained in the data.frame `base` used for the estimation. All the following `cluster` arguments are valid and do the same thing: `cluster = base[, c("var1", "var2")]`, `cluster = c("var1", "var2")`, `cluster = ~var1+var2`. If the two variables were used as clusters in the estimation, you could further use `cluster = 1:2` or leave it blank with `se = "twoway"` (assuming `var1` [resp. `var2`] was the 1st [res. 2nd] cluster). You can interact two variables using `^` with the following syntax: `cluster = ~var1^var2` or `cluster = "var1^var2"`.
`stage` | Can be equal to `2` (default), `1`, `1:2` or `2:1`. Only used if the object is an IV estimation: defines the stage to which `summary` should be applied. If `stage = 1` and there are multiple endogenous regressors or if `stage` is of length 2, then an object of class `fixest_multi` is returned.
`agg` | A character scalar describing the variable names to be aggregated, it is pattern-based. All variables that match the pattern will be aggregated. It must be of the form `"(root)"`, the parentheses must be there and the resulting variable name will be `"root"`. You can add another root with parentheses: `"(root1)regex(root2)"`, in which case the resulting name is `"root1::root2"`. To name the resulting variable differently you can pass a named vector: `c("name" = "pattern")` or `c("name" = "pattern(root2)")`. It's a bit intricate sorry, please see the examples.
`.vcov` | A function to be used to compute the standard-errors of each fixest object. You can pass extra arguments to this function using the argument `.vcov_args`. See the example.
`.vcov_args` | A list containing arguments to be passed to the function `.vcov`.
`digits` | Integer or character scalar. Default is 4 and represents the number of significant digits to be displayed for the coefficients and standard-errors. To apply rounding instead of significance use, e.g., `digits = "r3"` which will round at the first 3 decimals. If character, it must be of the form `"rd"` or `"sd"` with `d` a digit (`r` is for round and `s` is for significance). For the number of digits for the fit statistics, use `digits.stats`. Note that when significance is used it does not exactly display the number of significant digits: see details for its exact meaning.
`digits.stats` | Integer or character scalar. Default is 5 and represents the number of significant digits to be displayed for the fit statistics. To apply rounding instead of significance use, e.g., `digits = "r3"` which will round at the first 3 decimals. If character, it must be of the form `"rd"` or `"sd"` with `d` a digit (`r` is for round and `s` is for significance). Note that when significance is used it does not exactly display the number of significant digits: see details for its exact meaning.
`tex` | Logical: whether the results should be a data.frame or a Latex table. By default, this argument is `TRUE` if the argument `file` (used for exportation) is not missing; it is equal to `FALSE` otherwise.
`fitstat` | A character vector or a one sided formula (both with only lowercase letters). A vector listing which fit statistics to display. The valid types are 'n', 'll', 'aic', 'bic' and r2 types like 'r2', 'pr2', 'war2', etc (see all valid types in `r2`). Also accepts valid types from the function `fitstat`. The default value depends on the models to display. Example of use: `fitstat=c('n', 'cor2', 'ar2', 'war2')`, or `fitstat=~n+cor2+ar2+war2` using a formula. You can use the dot to refer to default values:`~ . + ll` would add the log-likelihood to the default fit statistics.
`title` | (Tex only.) Character scalar. The title of the Latex table.
`coefstat` | One of `"se"` (default), `"tstat"` or `"confint"`. The statistic to report for each coefficient: the standard-error, the t-statistics or the confidence interval. You can adjust the confidence interval with the argument `ci`.
`ci` | Level of the confidence interval, defaults to `0.95`. Only used if `coefstat = confint`.
`sdBelow` | (Tex only.) Logical, default is `TRUE`. Should the standard-errors be displayed below the coefficients?
`keep` | Character vector. This element is used to display only a subset of variables. This should be a vector of regular expressions (see `regex` help for more info). Each variable satisfying any of the regular expressions will be kept. This argument is applied post aliasing (see argument `dict`). Example: you have the variable `x1` to `x55` and want to display only `x1` to `x9`, then you could use `keep = "x[[:digit:]]$"`. If the first character is an exclamation mark, the effect is reversed (e.g. keep = "!Intercept" means: every variable that does not contain “Intercept” is kept). See details.
`drop` | Character vector. This element is used if some variables are not to be displayed. This should be a vector of regular expressions (see `regex` help for more info). Each variable satisfying any of the regular expressions will be discarded. This argument is applied post aliasing (see argument `dict`). Example: you have the variable `x1` to `x55` and want to display only `x1` to `x9`, then you could use `drop = "x[[:digit:]]{2}"`. If the first character is an exclamation mark, the effect is reversed (e.g. drop = "!Intercept" means: every variable that does not contain “Intercept” is dropped). See details.
`order` | Character vector. This element is used if the user wants the variables to be ordered in a certain way. This should be a vector of regular expressions (see `regex` help for more info). The variables satisfying the first regular expression will be placed first, then the order follows the sequence of regular expressions. This argument is applied post aliasing (see argument `dict`). Example: you have the following variables: `month1` to `month6`, then `x1` to `x5`, then `year1` to `year6`. If you want to display first the x's, then the years, then the months you could use: `order = c("x", "year")`. If the first character is an exclamation mark, the effect is reversed (e.g. order = "!Intercept" means: every variable that does not contain “Intercept” goes first). See details.
`dict` | A named character vector or a logical scalar. It changes the original variable names to the ones contained in the `dict`ionary. E.g. to change the variables named `a` and `b3` to (resp.) “$log(a)$” and to “$bonus^3$”, use `dict=c(a="$log(a)$",b3="$bonus^3$")`. By default, it is equal to `getFixest_dict()`, a default dictionary which can be set with `setFixest_dict`. You can use `dict = FALSE` to disable it..
`file` | A character scalar. If provided, the Latex (or data frame) table will be saved in a file whose path is `file`. If you provide this argument, then a Latex table will be exported, to export a regular `data.frame`, use argument `tex = FALSE`.
`replace` | Logical, default is `FALSE`. Only used if option `file` is used. Should the exported table be written in a new file that replaces any existing file?
`convergence` | Logical, default is missing. Should the convergence state of the algorithm be displayed? By default, convergence information is displayed if at least one model did not converge.
`signifCode` | Named numeric vector, used to provide the significance codes with respect to the p-value of the coefficients. Default is `c("***"=0.01, "**"=0.05, "*"=0.10)` for a Latex table and `c("***"=0.001, "**"=0.01, "*"=0.05, "."=0.10)` for a data.frame (to conform with R's default). To suppress the significance codes, use `signifCode=NA` or `signifCode=NULL`. Can also be equal to `"letters"`, then the default becomes `c("a"=0.01, "b"=0.05, "c"=0.10)`.
`label` | (Tex only.) Character scalar. The label of the Latex table.
`float` | (Tex only.) Logical. By default, if the argument `title` or `label` is provided, it is set to `TRUE`. Otherwise, it is set to `FALSE`.
`subtitles` | Character vector or list. The elements should be of length 1 or of the same length as the number of models. If a list, the names of the list will be displayed on the leftmost column. By default it is equal to `list("auto")` which means that if the object is a split sample estimation, the sample will be automatically added as a sub-title.
`fixef_sizes` | (Tex only.) Logical, default is `FALSE`. If `TRUE` and fixed-effects were used in the models, then the number of "individuals" per fixed-effect dimension is also displayed.
`fixef_sizes.simplify` | Logical, default is `TRUE`. Only used if `fixef_sizes = TRUE`. If `TRUE`, the fixed-effects sizes will be displayed in parentheses instead of in a separate line if there is no ambiguity (i.e. if the size is constant across models).
`keepFactors` | Logical, default is `TRUE`. If `FALSE`, then factor variables are displayed as fixed-effects and no coefficient is shown.
`family` | Logical, default is missing. Whether to display the families of the models. By default this line is displayed when at least two models are from different families.
`powerBelow` | (Tex only.) Integer, default is -5. A coefficient whose value is below `10**(powerBelow+1)` is written with a power in Latex. For example `0.0000456` would be written `4.56$\times 10^{-5}$` by default. Setting `powerBelow = -6` would lead to `0.00004` in Latex.
`interaction.combine` | (Tex only.) Character scalar, defaults to `" $\times$ "`. When the estimation contains interactions, then the variables names (after aliasing) are combined with this argument. For example: if `dict = c(x1="Wind", x2="Rain")` and you have the following interaction `x1:x2`, then it will be renamed (by default) `Wind $\times$ Rain` – using `interaction.combine = "*"` would lead to `Wind*Rain`.
`depvar` | Logical, default is `TRUE`. Whether a first line containing the dependent variables should be shown.
`style.tex` | An object created by the function `style.tex`. It represents the style of the Latex table, see the documentation of `style.tex`.
`style.df` | An object created by the function `style.df.` It represents the style of the data frame returned (if `tex = FALSE`), see the documentation of `style.df`.
`notes` | (Tex only.) Character vector. If provided, a `"notes"` section will be added at the end right after the end of the table, containing the text of this argument. Note that if it is a vector, it will be collapsed with new lines.
`group` | A list. The list elements should be vectors of regular expressions. For each elements of this list: A new line in the table is created, all variables that are matched by the regular expressions are discarded (same effect as the argument `drop`) and `TRUE` or `FALSE` will appear in the model cell, depending on whether some of the previous variables were found in the model. Example: `group=list("Controls: personal traits"=c("gender", "height", "weight"))` will create an new line with `"Controls: personal traits"` in the leftmost cell, all three variables gender, height and weight are discared, TRUE appearing in each model containing at least one of the three variables (the style of TRUE/FALSE is governed by the argument `yesNo`). You can control the style with the `title` and `where` keywords in curly brackets. For example `group=list("{title:Controls; where:stats}Personal traits"=c("gender", "height", "weight"))` will add an extra line right before with "Control" written in it, and the group information will appear after the statistics. The keyword where can be equal to either `var` (default), `fixef` or `stats`. Starting the list name with an underscore is equivalent to adding `"{where:stats}"`: eg `list("_Controls"="x")` is equivalent to `list("{where:stats}Controls"="x")`.
`extraline` | A list. The list elements should be either a single logical or a vector of the same length as the number of models. For each elements of this list: A new line in the table is created, the list name being the row name and the vector being the content of the cells. Example: `extraline=list("Sub-sample"=c("<20 yo", "all", ">50 yo"))` will create an new line with `"Sub-sample"` in the leftmost cell, the vector filling the content of the cells for the three models. You can control the style with the `title` and `where` keywords in curly brackets. For example `extraline=list("{title:Sub-sample; where:stats}By age"=c("<20 yo", "all", ">50 yo"))` will add an extra line right before with "Sub-sample" written in it, and the extraline information will appear after the statistics section. The keyword where can be equal to either `var` (default), `fixef` or `stats`. Starting the list name with an underscore is equivalent to adding `"{where:stats}"`: eg `list("_Controls"=TRUE)` is equivalent to `list("{where:stats}Controls"=TRUE)`.
`placement` | (Tex only.) Character string giving the position of the float in Latex. Default is "htbp". It must consist of only the characters 'h', 't', 'b', 'p', 'H' and '!'. Reminder: h: here; t: top; b: bottom; p: float page; H: definitely here; !: prevents Latex to look for other positions. Note that it can be equal to the empty string (and you'll get the default placement).
`drop.section` | Character vector which can be of length 0 (i.e. equal to `NULL`). Can contain the values "fixef", "slopes" or "stats". It would drop, respectively, the fixed-effects section, the variables with varying slopes section or the fit statistics section.
`poly_dict` | Character vector, default is `c("", " square", " cube")`. When raw polynomials (`x^2`, etc) are used, the variables are automatically renamed and `poly_dict` rules the display of the power. For powers greater than the number of elements of the vector, the value displayed is `$^{pow}$` in Latex and `^ pow` in the R console.
`postprocess.tex` | A function that will postprocess the character vector defining the latex table. Only when `tex = TRUE`. By default it is equal to `NULL`, meaning that there is no postprocessing. When `tex = FALSE`, see the argument `postprocess.df`. See details.
`postprocess.df` | A function that will postprocess.tex the resulting data.frame. Only when `tex = FALSE`. By default it is equal to `NULL`, meaning that there is no postprocessing. When `tex = TRUE`, see the argument `postprocess.tex`.
`fit_format` | Character scalar, default is `"__var__"`. Only used in the presence of IVs. By default the endogenous regressors are named `fit_varname` in the second stage. The format of the endogenous regressor to appear in the table is governed by `fit_format`. For instance, by default, the prefix `"fit_"` is removed, leading to only `varname` to appear. If `fit_format = "$\\hat{__var__}$"`, then `"$\hat{varname}$"` will appear in the table.
`reset` | (`setFixest_etable` only.) Logical, default is `FALSE`. If `TRUE`, this will reset all the default values that were already set by the user in previous calls.

### Details

The function `esttex` is equivalent to the function `etable` with argument `tex = TRUE`. This function is deprecated.

The function `esttable` is equivalent to the function `etable` with argument `tex = FALSE`. This function is deprecated.

You can permanently change the way your table looks in Latex by using `setFixest_etable`. The following vignette gives an example as well as illustrates how to use the `style` and postprocessing functions: Exporting estimation tables.

When the argument `postprocessing.tex` is not missing, two additional tags will be included in the character vector returned by `etable`: `"%start:tab\n"` and `"%end:tab\n"`. These can be used to identify the start and end of the tabular and are useful to insert code within the `table` environment.

### Value

If `tex = TRUE`, the lines composing the Latex table are returned invisibly while the table is directly prompted on the console.

If `tex = FALSE`, the data.frame is directly returned. If the argument `file` is not missing, the `data.frame` is printed and returned invisibly.

### Functions

- `esttable`: Exports the results of multiple `fixest` estimations in a Latex table.

- `esttex`: Exports the results of multiple `fixest` estimations in a Latex table.

### How does `digits` handle the number of decimals displayed?

The default display of decimals is the outcome of an algorithm. Let's take the example of `digits = 3` which "kind of" requires 3 significant digits to be displayed.

For numbers greater than 1 (in absolute terms), their integral part is always be displayed and the number of decimals shown is equal to `digits` minus the number of digits in the integral part. This means that `12.345` will be displayed as `12.3`. If the number of decimals should be 0, then a single decimal is displayed to suggest that the number is not whole. This means that `1234.56` will be displayed as `1234.5`. Note that if the number is whole, no decimals are shown.

For numbers lower than 1 (in absolute terms), the number of decimals displayed is equal to `digits` except if there are only 0s in which case the first significant digit is shown. This means that `0.01234` will be displayed as `0.012` (first rule), and that 0.000123 will be displayed as `0.0001` (second rule).

### Arguments keep, drop and order

The arguments `keep`, `drop` and `order` use regular expressions. If you are not aware of regular expressions, I urge you to learn it, since it is an extremely powerful way to manipulate character strings (and it exists across most programming languages).

For example drop = "Wind" would drop any variable whose name contains "Wind". Note that variables such as "Temp:Wind" or "StrongWind" do contain "Wind", so would be dropped. To drop only the variable named "Wind", you need to use `drop = "^Wind$"` (with "^" meaning beginning, resp. "$" meaning end, of the string => this is the language of regular expressions).

Although you can combine several regular expressions in a single character string using pipes, `drop` also accepts a vector of regular expressions.

You can use the special character "!" (exclamation mark) to reverse the effect of the regular expression (this feature is specific to this fonction). For example `drop = "!Wind"` would drop any variable that does not contain "Wind".

You can use the special character "%" (percentage) to make reference to the original variable name instead of the aliased name. For example, you have a variable named `"Month6"`, and use a dictionary `dict = c(Month6="June")`. Thus the variable will be displayed as `"June"`. If you want to delete that variable, you can use either `drop="June"`, or `drop="%Month6"` (which makes reference to its original name).

The argument `order` takes in a vector of regular expressions, the order will follow the elments of this vector. The vector gives a list of priorities, on the left the elements with highest priority. For example, order = c("Wind", "!Inter", "!Temp") would give highest priorities to the variables containing "Wind" (which would then appear first), second highest priority is the variables not containing "Inter", last, with lowest priority, the variables not containing "Temp". If you had the following variables: (Intercept), Temp:Wind, Wind, Temp you would end up with the following order: Wind, Temp:Wind, Temp, (Intercept).

### Author(s)

Laurent Berge

### See Also

See also the main estimation functions `femlm`, `feols` or `feglm`. Use `summary.fixest` to see the results with the appropriate standard-errors, `fixef.fixest` to extract the fixed-effects coefficients.

### Examples

    aq = airquality

    est1 = feols(Ozone ~ i(Month) / Wind + Temp, data = aq)
    est2 = feols(Ozone ~ i(Wind, Month) + Temp | Month, data = aq)

    # Displaying the two results in a single table
    etable(est1, est2)

    # keep/drop: keeping only interactions
    etable(est1, est2, keep = " x ")
    # or using drop  (see regexp help):
    etable(est1, est2, drop = "^(Month|Temp|\\()")

    # keep/drop: dropping interactions
    etable(est1, est2, drop = " x ")
    # or using keep ("!" reverses the effect):
    etable(est1, est2, keep = "! x ")

    # order: Wind variable first, intercept last (note the "!" to reverse the effect)
    etable(est1, est2, order = c("Wind", "!Inter"))
    # Month, then interactions, then the rest
    etable(est1, est2, order = c("^Month", " x "))

    #
    # dict
    #

    # You can rename variables with dict = c(var1 = alias1, var2 = alias2, etc)
    # You can also rename values taken by factors.
    # Here's a full example:
    dict = c(Temp = "Temperature", "Month::5"="May", "6"="Jun")
    etable(est1, est2, dict = dict)
    # Note the difference of treatment between Jun and May

    # Assume the following dictionnary:
    dict = c("Month::5"="May", "Month::6"="Jun", "Month::7"="Jul",
             "Month::8"="Aug", "Month::9"="Sep")

    # We would like to keep only the Months, but now the names are all changed...
    # How to do?
    # We can use the special character '%' to make reference to the original names.

    etable(est1, est2, dict = dict, keep = "%Month")

    #
    # signifCode
    #

    etable(est1, est2, signifCode = c(" A"=0.01, " B"=0.05, " C"=0.1, " D"=0.15, " F"=1))

    #
    # Using the argument style to customize Latex exports
    #

    # If you don't like the default layout of the table, no worries!
    # You can modify many parameters with the argument style

    # To drop the headers before each section, use:
    # Note that a space adds an extra line
    style_noHeaders = style.tex(var.title = "", fixef.title = "", stats.title = " ")
    etable(est1, est2, dict = dict, tex = TRUE, style.tex = style_noHeaders)

    # To change the lines of the table + dropping the table footer
    style_lines = style.tex(line.top = "\\toprule", line.bottom = "\\bottomrule",
                        tablefoot = FALSE)
    etable(est1, est2, dict = dict, tex = TRUE, style.tex = style_lines)

    # Or you have the predefined type "aer"
    etable(est1, est2, dict = dict, tex = TRUE, style.tex = style.tex("aer"))

    #
    # Group and extraline
    #

    # Sometimes it's useful to group control variables into a single line
    # You can achieve that with the group argument

    setFixest_fml(..ctrl = ~ poly(Wind, 2) + poly(Temp, 2))
    est_c0 = feols(Ozone ~ Solar.R, data = aq)
    est_c1 = feols(Ozone ~ Solar.R + ..ctrl, data = aq)
    est_c2 = feols(Ozone ~ Solar.R + Solar.R^2 + ..ctrl, data = aq)

    etable(est_c0, est_c1, est_c2, group = list(Controls = "%poly"))

    # 'group' here does the same as drop = "%poly", but adds an extra line
    # with TRUE/FALSE where the variables were found
    # Note that the "%" is needed because polnomials are automatically renamed
    #  so we need to make reference to the original name.

    # 'extraline' adds an extra line, where you can add the value for each model
    est_all  = feols(Ozone ~ Solar.R + Temp + Wind, data = aq)
    est_sub1 = feols(Ozone ~ Solar.R + Temp + Wind, data = aq[aq$Month %in% 5:6, ])
    est_sub2 = feols(Ozone ~ Solar.R + Temp + Wind, data = aq[aq$Month %in% 7:8, ])
    est_sub3 = feols(Ozone ~ Solar.R + Temp + Wind, data = aq[aq$Month == 9, ])

    etable(est_all, est_sub1, est_sub2, est_sub3,
           extraline = list("Sub-sample" = c("All", "May-June", "Jul.-Aug.", "Sept.")))

    # When exporting to Latex, you can add meta arguments to 'group' and 'extraline'
    # Two keywords are allowed: 'title' and 'where'
    # 'title' adds a line just before with the content of 'title' in the leftmost cell
    # 'where' governs the location of the line. It can be equal to 'var', 'stats' or 'fixef'.
    # The syntax is: {"{title:Controls; where:stats}Group name"}
    # (the enclosing curly braces are only here to make Rd work, please ignore them)
    # You can use the shortcut "_Group name" which is equivalent to {"{where:stats}Group name"}

    # Examples
    etable(est_c0, est_c1, est_c2, tex = TRUE, group = list("{where:stats}Controls" = "poly"))
    etable(est_all, est_sub1, est_sub2, est_sub3, tex = TRUE,
           extraline = list("{title:\\midrule}Sub-sample" =
                              c("All", "May-June", "Jul.-Aug.", "Sept.")))

    #
    # Using custom functions to compute the standard errors
    #

    # You can customize the way you compute the SEs with the argument .vcov
    # Let's use some covariances from the sandwich package

    etable(est_c0, est_c1, est_c2, .vcov = sandwich::vcovHC)

    # To add extra arguments to vcovHC, you need to use .vcov_args
    etable(est_c0, est_c1, est_c2, .vcov = sandwich::vcovHC, .vcov_args = list(type = "HC0"))

    #
    # Customize which fit statistic to display
    #

    # You can change the fit statistics with the argument fitstat
    # and you can rename them with the dictionnary
    etable(est1, est2, fitstat = ~ r2 + n + G)

    # If you use a formula, '.' means the default:
    etable(est1, est2, fitstat = ~ ll + .)

    #
    # Computing a different SE for each model
    #

    est = feols(Ozone ~ Solar.R + Wind + Temp, data = aq)

    #
    # Method 1: use summary

    s1 = summary(est, "standard")
    s2 = summary(est, cluster = ~ Month)
    s3 = summary(est, cluster = ~ Day)
    s4 = summary(est, cluster = ~ Day + Month)

    etable(list(s1, s2, s3, s4))

    #
    # Method 2: using a list in the argument 'cluster'

    est_bis = feols(Ozone ~ Solar.R + Wind + Temp | Month, data = aq)
    etable(list(est, est_bis), cluster = list("standard", ~ Month))

    #
    # Method 3: Using rep()

    etable(rep(est, cluster = list("standard", ~ Month)))

    # When using rep on 2 or more objects, you need to embed them in .l()
    etable(rep(.l(est, est_bis), cluster = list("standard", ~ Month, ~ Day)))

    # Using each to order differently
    etable(rep(.l(est, est_bis), each = 3, cluster = list("standard", ~ Month, ~ Day)))

[Package fixest version 0.8.4 Index]