fwildclusterboot

https://s3alfisc.github.io/fwildclusterboot/
Admin
fwildclusterboot is an R package implementing fast wild cluster bootstrap algorithms for statistical...
Tokens:33,948
Snippets:326
Trust Score:9.7
Update:2 months ago
Show doc for...
Tokens:
Raw
### Setup fwildclusterboot and fixest

Source: https://s3alfisc.github.io/fwildclusterboot/articles/Multiple-Estimations-with-fixest.html

Load necessary libraries and initialize seeds for reproducibility.

```R
library(fwildclusterboot)
library(fixest)
set.seed(34345)
dqrng::dqset.seed(123)

data(voters)
```

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

### Install fwildclusterboot

Source: https://s3alfisc.github.io/fwildclusterboot/index.html

Installation instructions for the package from CRAN, R-universe, or GitHub.

```R
# from CRAN 
install.packages("fwildclusterboot")

# from r-universe (windows & mac, compiled R > 4.0 required)
install.packages('fwildclusterboot', repos ='https://s3alfisc.r-universe.dev')
# dev version from github
# note: installation requires Rtools
library(devtools)
install_github("s3alfisc/fwildclusterboot")
```

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

### Configure bootstrap parameters

Source: https://s3alfisc.github.io/fwildclusterboot/news/index.html

Example of setting bootstrap parameters including type and iterations.

```R
  bootstrap_type = "31"
)
```

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

### Example usage of glance.boottest

Source: https://s3alfisc.github.io/fwildclusterboot/reference/glance.boottest.html

Demonstrates running a wild cluster bootstrap and summarizing the result with glance.

```R
if (FALSE) {
requireNamespace("fwildclusterboot")
data(voters)
lm_fit <- lm(
proposition_vote ~ treatment + ideology1 + log_income + Q1_immigration,
  data = voters
)
boot <- boottest(lm_fit,
  B = 9999,
  param = "treatment",
  clustid = "group_id1"
)
generics::glance(boot)
}
```

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

### Examples of boot_ssc Usage

Source: https://s3alfisc.github.io/fwildclusterboot/reference/boot_ssc.html

Demonstrates creating configuration objects with default and custom cluster degrees of freedom settings.

```R
boot_ssc(adj = TRUE, cluster.adj = TRUE)
#> $adj
#> [1] TRUE
#> 
#> $fixef.K
#> [1] "none"
#> 
#> $cluster.adj
#> [1] TRUE
#> 
#> $cluster.df
#> [1] "conventional"
#> 
#> attr(,"class")
#> [1] "boot_ssc.type"
```

```R
boot_ssc(adj = TRUE, cluster.adj = TRUE, cluster.df = "min")
#> $adj
#> [1] TRUE
#> 
#> $fixef.K
#> [1] "none"
#> 
#> $cluster.adj
#> [1] TRUE
#> 
#> $cluster.df
#> [1] "min"
#> 
#> attr(,"class")
#> [1] "boot_ssc.type"
```

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

### Configure boottest with WildBootTests.jl engine

Source: https://s3alfisc.github.io/fwildclusterboot/news/index.html

Example of calling boottest using the WildBootTests.jl engine.

```R
boottest(
  lm_fit, 
  param = ~treatment, 
  clustid = ~group_id1,
  B = 9999, 
  impose_null = TRUE,
  engine = "WildBootTests.jl", 
  bootstrap_type = "11"
)
```

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

### Example of printing boottest results

Source: https://s3alfisc.github.io/fwildclusterboot/reference/print.boottest.html

Demonstrates running a wild cluster bootstrap and printing the resulting object.

```R
requireNamespace("fwildclusterboot")
data(voters)
lm_fit <- lm(
  proposition_vote ~ treatment + ideology1 + log_income + Q1_immigration,
  data = voters
)
boot <- boottest(lm_fit,
  B = 9999,
  param = "treatment",
  clustid = "group_id1"
)
print(boot)
#> boottest.lm(object = lm_fit, param = "treatment", B = 9999, clustid = "group_id1")
#>  
#> p value: 0.0011 
#> confidence interval: 0.0329 0.1136 
#> test statistic 3.7094
```

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

### Install Julia and WildBootTests.jl

Source: https://s3alfisc.github.io/fwildclusterboot/articles/WildBootTests.html

Use JuliaConnectoR.utils to link R with Julia and install the required WildBootTests.jl package.

```R
devtools::install_github("s3alfisc/JuliaConnectoR.utils")
library(JuliaConnectoR.utils)
connect_julia_r() # instructions to connect Julia and R
install_julia_packages("WildBootTests.jl") # install WildBootTests.jl
```

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

### Set Bootstrap Engine Examples

Source: https://s3alfisc.github.io/fwildclusterboot/reference/setBoottest_engine.html

Demonstrates setting the engine to either the native R implementation or the Julia-based WildBootTests.jl.

```R
if (FALSE) {
setBoottest_engine(engine = "R")
setBoottest_engine(engine = "WildBootTests.jl")
}
```

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

### Example of printing mboottest results

Source: https://s3alfisc.github.io/fwildclusterboot/reference/print.mboottest.html

Demonstrates how to run a bootstrap test and print the resulting object.

```R
if (FALSE) {
requireNamespace("clubSandwich")
R <- clubSandwich::constrain_zero(2:3, coef(lm_fit))
wboottest <-
  mboottest(
    object = lm_fit,
    clustid = "group_id1",
    B = 999,
    R = R
  )
print(wboottest)
}
```

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

### Initialize development environment and pull requests

Source: https://s3alfisc.github.io/fwildclusterboot/CONTRIBUTING.html

Commands to set up the repository, install dependencies, and manage pull request branches using the usethis package.

```R
usethis::create_from_github("s3alfisc/fwildclusterboot", fork = TRUE)
```

```R
devtools::install_dev_deps()
```

```R
devtools::check()
```

```R
usethis::pr_init("brief-description-of-change")
```

```R
usethis::pr_push()
```

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

### Configure boottest with R engine

Source: https://s3alfisc.github.io/fwildclusterboot/news/index.html

Example of calling boottest using the R engine with specific bootstrap parameters.

```R
boottest(
  lm_fit, 
  param = ~treatment, 
  clustid = ~group_id1,
  B = 9999, 
  impose_null = TRUE,
  engine = "R", 
  bootstrap_type = "11"
)
```

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

### Example usage of glance.mboottest

Source: https://s3alfisc.github.io/fwildclusterboot/reference/glance.mboottest.html

Demonstrates how to perform a bootstrap test and retrieve a summary using the glance generic.

```R
if (FALSE) {
requireNamespace("fwildclusterboot")
data(voters)
lm_fit <- lm(
proposition_vote ~ treatment + ideology1 + log_income + Q1_immigration,
  data = voters
)
mboot <- mboottest(
    object = lm_fit,
    clustid = "group_id1",
    B = 999,
    R = R
)
generics::glance(mboot)
}
```

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

### Configure boottest for WCR13 variant

Source: https://s3alfisc.github.io/fwildclusterboot/news/index.html

Example of calling boottest to run the WCR13 bootstrap variant.

```R
boottest(
  lm_fit, 
  param = ~treatment, 
  clustid = ~group_id1,
  B = 9999, 
  impose_null = TRUE,
  engine = "R", 
```

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

### Example of boottest execution

Source: https://s3alfisc.github.io/fwildclusterboot/reference/confint.boottest.html

Demonstrates fitting a linear model and performing a wild cluster bootstrap test using the fwildclusterboot package.

```R
requireNamespace("fwildclusterboot")
data(voters)
lm_fit <- lm(
  proposition_vote ~ treatment + ideology1 + log_income + Q1_immigration,
  data = voters
)
boot <- boottest(lm_fit,
  B = 9999,
  param = "treatment",
  clustid = "group_id1"
)
teststat(boot)
#> [1] 3.709435
```

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

### Verify Julia System Requirements

Source: https://s3alfisc.github.io/fwildclusterboot/articles/WildBootTests.html

Check if the installed Julia environment meets the requirements for fwildclusterboot.

```R
check_julia_system_requirements("fwildclusterboot")
```

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

### Interactive Mode Startup Notice

Source: https://s3alfisc.github.io/fwildclusterboot/LICENSE.html

Short notice to display when a program starts in interactive mode to inform users of license terms.

```text
<program>  Copyright (C) <year>  <name of author>
This program comes with ABSOLUTELY NO WARRANTY; for details type 'show w'.
This is free software, and you are welcome to redistribute it
under certain conditions; type 'show c' for details.
```

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

### Example: Calculating and extracting bootstrap results

Source: https://s3alfisc.github.io/fwildclusterboot/reference/pval.boottest.html

Demonstrates fitting a linear model, running a wild cluster bootstrap, and extracting confidence intervals.

```R
requireNamespace("fwildclusterboot")
data(voters)
lm_fit <- lm(
  proposition_vote ~ treatment + ideology1 + log_income + Q1_immigration,
  data = voters
)
boot <- boottest(lm_fit,
  B = 9999,
  param = "treatment",
  clustid = "group_id1"
)
confint(boot)
#> [1] 0.03273541 0.11325149
```

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

### Example of calculating and extracting p-values

Source: https://s3alfisc.github.io/fwildclusterboot/reference/pval.mboottest.html

Demonstrates how to perform a wild cluster bootstrap test using mboottest and retrieve the resulting p-value.

```R
if (FALSE) {
requireNamespace("clubSandwich")
R <- clubSandwich::constrain_zero(2:3, coef(lm_fit))
wboottest <-
  mboottest(
    object = lm_fit,
    clustid = "group_id1",
    B = 999,
    R = R
  )
pval(wboottest)
}
```

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

### Source File License Header

Source: https://s3alfisc.github.io/fwildclusterboot/LICENSE.html

Standard copyright and license notice template to be placed at the start of each source file.

```text
<one line to give the program's name and a brief idea of what it does.>
Copyright (C) <year>  <name of author>

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.
```

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

### Check for language installation

Source: https://s3alfisc.github.io/fwildclusterboot/reference/find_proglang.html

Verifies if the specified language is available on the system PATH. Returns TRUE if found, otherwise FALSE.

```R
find_proglang(lang)
```

```R
if (FALSE) {
find_proglang(lang = "julia")
}
```

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

### Example of extracting the test statistic

Source: https://s3alfisc.github.io/fwildclusterboot/reference/teststat.mboottest.html

Demonstrates how to retrieve the non-bootstrapped t-statistic after running a wild cluster bootstrap.

```R
if (FALSE) {
requireNamespace("clubSandwich")
R <- clubSandwich::constrain_zero(2:3, coef(lm_fit))
wboottest <-
  mboottest(
    object = lm_fit,
    clustid = "group_id1",
    B = 999,
    R = R
  )
teststat(wboottest)
}
```

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

### Perform wild cluster bootstrap inference

Source: https://s3alfisc.github.io/fwildclusterboot/reference/boottest.html

Example demonstrating the usage of boottest on a linear model, including summary, printing, plotting, and extracting statistics.

```R
requireNamespace("fwildclusterboot")
data(voters)
lm_fit <- lm(
  proposition_vote ~ treatment + ideology1 + log_income + Q1_immigration,
  data = voters
)
boot <- boottest(lm_fit,
  B = 9999,
  param = "treatment",
  clustid = "group_id1"
)
summary(boot)
print(boot)
plot(boot)

nobs(boot)
pval(boot)
confint(boot)
generics::tidy(boot)
```

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

### Perform Bootstrap Inference with boottest()

Source: https://s3alfisc.github.io/fwildclusterboot/index.html

Example of fitting a linear model and performing bootstrap inference using the boottest() function.

```R
library(fwildclusterboot)

# set seed via dqset.seed for engine = "R" & Rademacher, Webb & Normal weights
dqrng::dqset.seed(2352342)
# set 'familiar' seed for all other algorithms and weight types 
set.seed(23325)

data(voters)

# fit the model via fixest::feols(), lfe::felm() or stats::lm()
lm_fit <- lm(proposition_vote ~ treatment  + log_income + as.factor(Q1_immigration) + as.factor(Q2_defense), data = voters)
# bootstrap inference via boottest()
lm_boot <- boottest(lm_fit, clustid = c("group_id1"), B = 9999, param = "treatment")
summary(lm_boot)
```

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

### Define Starting Values for Inversion

Source: https://s3alfisc.github.io/fwildclusterboot/articles/wild_bootstrap.html

Sets initial search boundaries for the numerical inversion process based on empirical confidence intervals.

```R
epsilon <- 0.01

startset1 <- confint(fit)["X",][1] + c(-epsilon, epsilon)
startset2 <- confint(fit)["X",][2] + c(-epsilon, epsilon)
```

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

### Load fwildclusterboot package

Source: https://s3alfisc.github.io/fwildclusterboot/articles/fwildclusterboot.html

Initializes the package and displays citation information.

```R
library(fwildclusterboot)
#> 
#> Please cite as:
#>  Fischer & Roodman. (2021). fwildclusterboot: Fast Wild Cluster.
#>  Bootstrap Inference for Linear Regression Models.
#>  Available from https://cran.r-project.org/package=fwildclusterboot/.
```

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

### Initialize fwildclusterboot

Source: https://s3alfisc.github.io/fwildclusterboot/articles/WildBootTests.html

Load the package and set a seed for reproducibility.

```R
library(fwildclusterboot)
#>
#> Please cite as:
#>  Fischer & Roodman. (2021). fwildclusterboot: Fast Wild Cluster.
#>  Bootstrap Inference for Linear Regression Models.
#>  Available from https://cran.r-project.org/package=fwildclusterboot/.
set.seed(12312)
```

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

### Run boottest with fixest objects

Source: https://s3alfisc.github.io/fwildclusterboot/news/index.html

Demonstrates using boottest after fitting models with fixest, including handling of syntactic sugar and split samples.

```R
library(fwildclusterboot)
library(fixest)

data(voters)
feols_fit <- feols(proposition_vote ~ i(treatment, ideology1) ,
    data = voters
)
boot1 <- boottest(feols_fit,
    B = 9999,
    param = "treatment::0:ideology1",
    clustid = "group_id1"
)

feols_fits <- fixest::feols(proposition_vote ~ treatment | sw(Q1_immigration, Q2_defense), data = voters)
res <- lapply(feols_fits, \(x) boottest(x, B = 999, param = "treatment", clustid = "group_id1"))  

voters$split <- sample(1:2, nrow(voters), TRUE)
feols_fits <- fixest::feols(proposition_vote ~ treatment, split = ~split, data = voters)

res <- lapply(feols_fits, \(x) boottest(x, B = 999, param = "treatment", clustid = "group_id1"))
```

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

### Execute Bootstrap with Default Engine

Source: https://s3alfisc.github.io/fwildclusterboot/articles/WildBootTests.html

Run boottest() without explicitly specifying the engine after setting the global default.

```R
# after setting setBoottest_engine("WildBootTests.jl"), 
# the code below runs WildBootTests.jl without
# specifying 'engine = "WildBootTests.jl"'
boottest(
  lm_fit, 
  clustid = "group_id1", 
  param = "treatment",
  B = 9999
)
```

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

### Handle formula sugar errors

Source: https://s3alfisc.github.io/fwildclusterboot/news/index.html

Example of a model configuration that may lead to errors when using specific formula sugar.

```R
feols_fit2 <- feols(proposition_vote ~ treatment | Q1_immigration^Q2_defense,
    data = voters
)

boot1 <- boottest(feols_fit2,
    B = 9999,
    param = "treatment",
    clustid = "group_id1"
)
```

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

### Run mboottest on a linear model

Source: https://s3alfisc.github.io/fwildclusterboot/reference/mboottest.lm.html

Example of running a wild cluster bootstrap test on a fitted linear model object.

```R
if (FALSE) {
requireNamespace("clubSandwich")
requireNamespace("fwildclusterboot")
R <- clubSandwich::constrain_zero(2:3, coef(lm_fit))
wboottest <-
  mboottest(
    object = lm_fit,
    clustid = "group_id1",
    B = 999,
    R = R
  )
summary(wboottest)
print(wboottest)
nobs(wboottest)
pval(wboottest)
generics::tidy(wboottest)
}
```

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

### Run mboottest on a felm object

Source: https://s3alfisc.github.io/fwildclusterboot/reference/mboottest.felm.html

Example usage of mboottest with a felm object, including constraint definition and summary output.

```R
if (FALSE) {
requireNamespace("lfe")
requireNamespace("clubSandwich")
R <- clubSandwich::constrain_zero(2:3, coef(lm_fit))
wboottest <-
  mboottest(
    object = lm_fit,
    clustid = "group_id1",
    B = 999,
    R = R
  )
summary(wboottest)
print(wboottest)
nobs(wboottest)
pval(wboottest)
generics::tidy(wboottest)
}
```

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

### Prepare Model for Bootstrap

Source: https://s3alfisc.github.io/fwildclusterboot/articles/WildBootTests.html

Load sample data and estimate a linear model using lm().

```R
# load data set voters included in fwildclusterboot
data(voters)
# estimate the regression model via lm
lm_fit <- lm(
  proposition_vote ~ treatment + ideology1 + log_income + Q1_immigration ,
  data = voters
)
```

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

### Use formulas for boottest arguments

Source: https://s3alfisc.github.io/fwildclusterboot/news/index.html

Demonstrates passing param and clustid as formulas to the boottest function.

```R
data(voters)
feols_fit <- feols(proposition_vote ~ treatment ,
    data = voters
)
boot <- boottest(feols_fit,
    B = 9999,
    param = ~ treatment,
    clustid = ~ group_id1
)
```

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

### Run Bootstrap with WildBootTests.jl Engine

Source: https://s3alfisc.github.io/fwildclusterboot/articles/WildBootTests.html

Execute the boottest() function using the Julia engine. Note that the first call triggers JIT compilation.

```R
boot_lm <- boottest(
  lm_fit,
  clustid = "group_id1",
  param = "treatment",
  B = 9999,
  engine = "WildBootTests.jl"
)
```

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

### Run boottest on felm models

Source: https://s3alfisc.github.io/fwildclusterboot/reference/boottest.felm.html

Demonstrates various bootstrap configurations, including multi-way clustering, fixed effects handling, and hypothesis testing. Requires the lfe package and a fitted felm object.

```R
if (FALSE) {
  requireNamespace("lfe")
  data(voters)
  felm_fit <- felm(proposition_vote ~ treatment + ideology1 + log_income |
    Q1_immigration,
  data = voters
  )
  boot1 <- boottest(felm_fit,
    B = 9999,
    param = "treatment",
    clustid = "group_id1"
  )
  boot2 <- boottest(felm_fit,
    B = 9999,
    param = "treatment",
    clustid = c("group_id1", "group_id2")
  )
  boot3 <- boottest(felm_fit,
    B = 9999,
    param = "treatment",
    clustid = c("group_id1", "group_id2"),
    fe = "Q1_immigration"
  )
  boot4 <- boottest(felm_fit,
    B = 999,
    param = "treatment",
    clustid = c("group_id1", "group_id2"),
    fe = "Q1_immigration",
    sign_level = 0.2,
    r = 2
  )
  # test treatment + ideology1 = 2
  boot5 <- boottest(felm_fit,
    B = 9999,
    clustid = c("group_id1", "group_id2"),
    param = c("treatment", "ideology1"),
    R = c(1, 1),
    r = 2
  )
  summary(boot1)
  print(boot1)
  plot(boot1)
  nobs(boot1)
  pval(boot1)
  confint(boot1)
  generics::tidy(boot1)

# run different bootstrap types following MacKinnon, Nielsen & Webb (2022):

# default: the fnw algorithm
boot_fnw11 <- boottest(lm_fit,
  B = 9999,
  param = "treatment",
  clustid = "group_id1",
  bootstrap_type = "fnw11"
)

# WCR 31
boot_WCR31 <- boottest(lm_fit,
  B = 9999,
  param = "treatment",
  clustid = "group_id1",
  bootstrap_type = "31"
)

# WCU33
boot_WCR31 <- boottest(lm_fit,
  B = 9999,
  param = "treatment",
  clustid = "group_id1",
  bootstrap_type = "33",
  impose_null = FALSE
)
}
```

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

### Run multiple wild cluster bootstrap variants

Source: https://s3alfisc.github.io/fwildclusterboot/articles/Different-Variants-of-the-Wild-Cluster-Bootstrap.html

Demonstrates how to iterate through different bootstrap types using boottest() and summarize the results with modelsummary.

```R
library(fwildclusterboot)
library(modelsummary)
options(modelsummary_factory_default = "gt")

N <- 1000
N_G1 <- 17
data <- fwildclusterboot:::create_data(
  N = N,
  N_G1 = N_G1,
  icc1 = 0.8,
  N_G2 = N_G1,
  icc2 = 0.8,
  numb_fe1 = 10,
  numb_fe2 = 5,
  seed = 41224,
  weights = 1:N / N
)

lm_fit <- lm(
  proposition_vote ~ treatment + log_income, 
  data = data
)

wcr_algos <- c("fnw11","11", "13", "31", "33")

run_all <- 
lapply(wcr_algos, function(x){  
  res <- 
    boottest(
      lm_fit, 
      param = ~treatment, 
      clustid = ~group_id1,
      B = 9999, 
      impose_null = TRUE,
      bootstrap_type = x
    )
  })

names(run_all) <- paste("WCR", 
                        c("11 F&W", "11 F&R", "13 F&R", "31 F&R", "33 F&R"))

msummary(
  run_all, 
  estimate = "{estimate} ({p.value})", 
  statistic = "[{conf.low}, {conf.high}]"
)
```

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

### Perform wild cluster bootstrap inference on lm objects

Source: https://s3alfisc.github.io/fwildclusterboot/reference/boottest.lm.html

Demonstrates how to run boottest on an lm object with various cluster specifications, hypothesis tests, and bootstrap algorithms.

```R
if (FALSE) {
requireNamespace("fwildclusterboot")
data(voters)
lm_fit <- lm(proposition_vote ~ treatment + ideology1 + log_income +
  Q1_immigration,
data = voters
)
boot1 <- boottest(lm_fit,
  B = 9999,
  param = "treatment",
  clustid = "group_id1"
)
boot2 <- boottest(lm_fit,
  B = 9999,
  param = "treatment",
  clustid = c("group_id1", "group_id2")
)
boot3 <- boottest(lm_fit,
  B = 9999,
  param = "treatment",
  clustid = c("group_id1", "group_id2"),
  sign_level = 0.2,
  r = 2
)
# test treatment + ideology1 = 2
boot4 <- boottest(lm_fit,
  B = 9999,
  clustid = c("group_id1", "group_id2"),
  param = c("treatment", "ideology1"),
  R = c(1, 1),
  r = 2
)
summary(boot1)
print(boot1)
plot(boot1)
nobs(boot1)
pval(boot1)
confint(boot1)
generics::tidy(boot1)

# run different bootstrap types following MacKinnon, Nielsen & Webb (2022):

# default: the fnw algorithm
boot_fnw11 <- boottest(lm_fit,
  B = 9999,
  param = "treatment",
  clustid = "group_id1",
  bootstrap_type = "fnw11"
)

# WCR 31
boot_WCR31 <- boottest(lm_fit,
  B = 9999,
  param = "treatment",
  clustid = "group_id1",
  bootstrap_type = "31"
)

# WCU33
boot_WCR31 <- boottest(lm_fit,
  B = 9999,
  param = "treatment",
  clustid = "group_id1",
  bootstrap_type = "33",
  impose_null = FALSE
)

}
```

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

### Summarize boottest results

Source: https://s3alfisc.github.io/fwildclusterboot/reference/summary.boottest.html

Use the summary method to display the results of a boottest object. Requires an existing boottest object created from a linear model fit.

```R
requireNamespace("fwildclusterboot")
data(voters)
lm_fit <- lm(
proposition_vote ~ treatment + ideology1 + log_income + Q1_immigration,
  data = voters
)
boot <- boottest(lm_fit,
  B = 9999,
  param = "treatment",
  clustid = "group_id1"
)
summary(boot)
```

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

### boot_ssc(adj = TRUE, fixef.K = "none", cluster.adj = TRUE, cluster.df = "conventional")

Source: https://s3alfisc.github.io/fwildclusterboot/reference/boot_ssc.html

Configures the small sample correction settings for the boottest() function. Returns a list containing the correction parameters.

```APIDOC
## boot_ssc

### Description
Sets the small sample correction factor applied in boottest().

### Arguments
- **adj** (logical) - Optional - Defaults to TRUE. Applies a small sample correction of (N-1) / (N-k).
- **fixef.K** (character) - Optional - Defaults to 'none'. Specifies how fixed effects parameters are handled when calculating k.
- **cluster.adj** (logical) - Optional - Defaults to TRUE. If TRUE, a cluster correction G/(G-1) is performed.
- **cluster.df** (character) - Optional - Defaults to 'conventional'. Controls how G is computed for multiway clustering; options are 'conventional' or 'min'.

### Returns
A list with encoded info on how to form small sample corrections.
```

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

### Benchmark Memory-Efficient Bootstrap Implementations

Source: https://s3alfisc.github.io/fwildclusterboot/articles/fwildclusterboot.html

Compares performance and memory usage between standard R, R-lean, and WildBootTests.jl engines.

```R
library(bench)

dt <- fwildclusterboot:::create_data(
  N = 10000, 
  N_G1 = 250, 
  icc1 = 0.01, 
  N_G2 = 10, 
  icc2 = 0.01, 
  numb_fe1 = 10, 
  numb_fe2 = 10, 
  seed = 7645
)

lm_fit <- lm(
  proposition_vote ~ treatment + ideology1 + log_income + Q1_immigration ,
  data = dt
)

res <- 
bench::mark(
  "R" = boottest(lm_fit, 
           clustid = "group_id1", 
           param = "treatment", 
           B = 9999, 
           engine = "R", 
           nthreads = 4), 
  "R-lean" = boottest(lm_fit, 
           clustid = "group_id1", 
           param = "treatment", 
           B = 9999, 
           engine = "R-lean", 
           nthreads = 4),
  "WildBootTests.jl" = 
    boottest(lm_fit, 
           clustid = "group_id1", 
           param = "treatment", 
           B = 9999, 
           engine = "WildBootTests.jl"), 
  iterations = 1, 
  check = FALSE
)

res
```

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

### Run R-lean bootstrap algorithm

Source: https://s3alfisc.github.io/fwildclusterboot/news/index.html

Use the R-lean algorithm to reduce memory usage for larger problems by setting the boot_algo argument to 'R-lean'.

```R
boot_lm <- boottest(
  lm_fit, 
  clustid = "group_id1", 
  param = "treatment", 
  B = 9999, 
  boot_algo = "R-lean"
)
```

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

### Usage of pval method

Source: https://s3alfisc.github.io/fwildclusterboot/reference/pval.boottest.html

Standard syntax for calling the pval method on a boottest object.

```R
# S3 method for boottest
pval(object, ...)
```

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

### Run boottest over sw() specifications

Source: https://s3alfisc.github.io/fwildclusterboot/articles/Multiple-Estimations-with-fixest.html

Iterate over a fixest_multi object created by the sw() function using lapply.

```R
feols_fits <- fixest::feols(
  proposition_vote ~ treatment | sw(Q1_immigration, Q2_defense),
  data = voters
)

boot2 <- lapply(
  feols_fits,
  \(x) boottest(
    x,
    B = 999,
    param = "treatment",
    clustid = "group_id1")
) 

boot2
```

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

### Usage of print.boottest

Source: https://s3alfisc.github.io/fwildclusterboot/reference/print.boottest.html

Standard syntax for the S3 print method for boottest objects.

```R
# S3 method for boottest
print(x, ..., digits = 4)
```

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

### Usage of tidy.boottest

Source: https://s3alfisc.github.io/fwildclusterboot/reference/tidy.boottest.html

Standard signature for the S3 method for boottest objects.

```R
# S3 method for boottest
tidy(x, ...)
```

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

### Usage of confint.boottest

Source: https://s3alfisc.github.io/fwildclusterboot/reference/confint.boottest.html

Standard syntax for invoking the confint method on a boottest object.

```R
# S3 method for boottest
confint(object, ...)
```

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

### Run boottest with fixest models

Source: https://s3alfisc.github.io/fwildclusterboot/reference/boottest.fixest.html

Demonstrates how to perform wild cluster bootstrap inference on a feols model, including handling multiple clusters, fixed effects, and custom hypothesis testing.

```R
if (FALSE) {
requireNamespace("fixest")
requireNamespace("fwildclusterboot")
data(voters)
feols_fit <- feols(proposition_vote ~ treatment + ideology1 + log_income,
 fixef = "Q1_immigration",
 data = voters
)
boot1 <- boottest(feols_fit,
 B = 9999,
 param = "treatment",
 clustid = "group_id1"
)
boot2 <- boottest(feols_fit,
 B = 9999,
 param = "treatment",
 clustid = c("group_id1", "group_id2")
)
boot3 <- boottest(feols_fit,
  B = 9999,
  param = "treatment",
  clustid = c("group_id1", "group_id2"),
  fe = "Q1_immigration"
)
boot4 <- boottest(feols_fit,
  B = 9999,
  param = "treatment",
  clustid = c(	extquotedblgroup_id1	extquotedbl, 	extquotedblgroup_id2	extquotedbl),
  fe = 	extquotedblQ1_immigration	extquotedbl,
  sign_level = 0.2,
  r = 2
)
# test treatment + ideology1 = 2
boot5 <- boottest(feols_fit,
  B = 9999,
  clustid = c(	extquotedblgroup_id1	extquotedbl, 	extquotedblgroup_id2	extquotedbl),
  param = c(	extquotedbltreatment	extquotedbl, 	extquotedblideology1	extquotedbl),
  R = c(1, 1),
  r = 2
)
summary(boot1)
print(boot1)
plot(boot1)
nobs(boot1)
pval(boot1)
confint(boot1)
generics::tidy(boot1)

# run different bootstrap types following MacKinnon, Nielsen & Webb (2022):

# default: the fnw algorithm
boot_fnw11 <- boottest(lm_fit,
  B = 9999,
  param = 	extquotedbltreatment	extquotedbl,
  clustid = 	extquotedblgroup_id1	extquotedbl,
  bootstrap_type = 	extquotedblfnw11	extquotedbl
)

# WCR 31
boot_WCR31 <- boottest(lm_fit,
  B = 9999,
  param = 	extquotedbltreatment	extquotedbl,
  clustid = 	extquotedblgroup_id1	extquotedbl,
  bootstrap_type = 	extquotedbl31	extquotedbl
)

# WCU33
boot_WCR31 <- boottest(lm_fit,
  B = 9999,
  param = 	extquotedbltreatment	extquotedbl,
  clustid = 	extquotedblgroup_id1	extquotedbl,
  bootstrap_type = 	extquotedbl33	extquotedbl,
  impose_null = FALSE
)

}
```

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

### glance(x, ...)

Source: https://s3alfisc.github.io/fwildclusterboot/reference/glance.boottest.html

S3 method to glance at objects of class boottest.

```APIDOC
## glance(x, ...)

### Description
A single row summary "glance" of an object of type boottest - lists characteristics of the input regression model.

### Usage
```R
# S3 method for boottest
glance(x, ...)
```

### Arguments
- **x** (boottest) - Required - Object of type boottest.
- **...** (dots) - Optional - Further arguments passed to or from other methods.
```

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

### Estimate Regression and Perform Wild Cluster Bootstrap

Source: https://s3alfisc.github.io/fwildclusterboot/articles/fwildclusterboot.html

Demonstrates fitting a model with fixest and running a wild cluster bootstrap using boottest.

```R
library(fixest)
feols_fit <- feols(
  proposition_vote ~ treatment + ideology1 + log_income | 
    Q1_immigration , 
  data = voters
)
boot_feols <- boottest(
  feols_fit, 
  clustid = "group_id1", 
  param = "treatment", 
  B = 9999, 
  fe = "Q1_immigration"
)
```

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

### Demonstrate R random number generation behavior

Source: https://s3alfisc.github.io/fwildclusterboot/news/index.html

Illustrates the impact of global seed states on random number generation in R.

```R
# [1] -0.5604756
fn_reseed(1)
rnorm(1)
# [1] -0.6264538

set.seed(123)
rnorm(1); rnorm(1)
# [1] -0.5604756
# [1] -0.2301775
```

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

### Usage of glance for boottest

Source: https://s3alfisc.github.io/fwildclusterboot/reference/glance.boottest.html

The standard syntax for invoking the glance method on a boottest object.

```R
# S3 method for boottest
glance(x, ...)
```

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

### Extract p-value from boottest object

Source: https://s3alfisc.github.io/fwildclusterboot/reference/pval.html

Demonstrates how to compute a wild cluster bootstrap and extract the resulting p-value using the pval method.

```R
requireNamespace("fwildclusterboot")
data(voters)
lm_fit <- lm(
proposition_vote ~ treatment + ideology1 + log_income + Q1_immigration,
  data = voters
)
boot <- boottest(lm_fit,
  B = 9999,
  param = "treatment",
  clustid = "group_id1"
)
pval(boot)
```

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

### boottest(object, ...)

Source: https://s3alfisc.github.io/fwildclusterboot/reference/boottest.felm.html

Performs a wild cluster bootstrap on a felm model object.

```APIDOC
## boottest(object, ...)

### Description
Performs wild cluster bootstrap inference for a felm model. It computes confidence intervals by inverting p-values and supports multiple fixed effects and various bootstrap algorithms.

### Parameters
- **object** (felm) - Required - The fitted felm model.
- **B** (integer) - Optional - Number of bootstrap iterations.
- **param** (string/vector) - Required - The parameter(s) to test.
- **clustid** (string/vector) - Required - The cluster ID(s) for the bootstrap.
- **fe** (string) - Optional - Fixed effect to retain.
- **sign_level** (numeric) - Optional - Significance level for confidence intervals.
- **r** (numeric) - Optional - Null hypothesis value.
- **R** (vector) - Optional - Linear combination of parameters.
- **bootstrap_type** (string) - Optional - The bootstrap algorithm type (e.g., "fnw11", "31", "33").
- **impose_null** (boolean) - Optional - Whether to impose the null hypothesis.

### Usage Example
```R
boot1 <- boottest(felm_fit,
  B = 9999,
  param = "treatment",
  clustid = "group_id1"
)
```
```

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

### summary(object, digits = 3, ...)

Source: https://s3alfisc.github.io/fwildclusterboot/reference/summary.boottest.html

Summarizes the results of a boottest object, providing a formatted output of the bootstrap inference results.

```APIDOC
## summary(object, digits = 3, ...)

### Description
Summarizes objects of class boottest. This method provides a concise view of the hypothesis test results, including the estimate, statistic, p-value, and confidence intervals.

### Arguments
- **object** (boottest) - Required - The boottest object to summarize.
- **digits** (numeric) - Optional - Number of decimal places for rounding output. Defaults to 3.
- **...** (dots) - Optional - Further arguments passed to or from other methods.

### Value
Returns a summary of the boottest object, typically printed to the console.

### Example
```R
boot <- boottest(lm_fit, B = 9999, param = "treatment", clustid = "group_id1")
summary(boot)
```
```

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

### Aggregate Bootstrap Results with boot_aggregate

Source: https://s3alfisc.github.io/fwildclusterboot/reference/boot_aggregate.html

Demonstrates how to use boot_aggregate to perform bootstrap aggregation on a fixest model object. Requires the fixest package and a pre-estimated model.

```R
if (FALSE) {
if(requireNamespace("fixest")){
library(fixest)
data(base_stagg)
# The DiD estimation
res_sunab = feols(y ~ x1 + sunab(year_treated, year) | id + year, base_stagg)
res_sunab_3ref = feols(y ~ x1 + sunab(
 year_treated, year, ref.p = c(.F + 0:2, -1)) |
                        id + year, 
                      cluster = "id",
                      base_stagg, 
                      ssc = ssc(adj = FALSE, cluster.adj = FALSE))

aggregate(res_sunab, agg = "ATT")
# test ATT equivalence
boot_att <- 
 boot_aggregate(
   res_sunab, 
   B = 9999, 
   agg = "ATT", 
   clustid = "id" 
 )
head(boot_att)

#'boot_agg2 <- 
 boot_aggregate(
   res_sunab, 
   B = 99999, 
   agg = TRUE,
   ssc = boot_ssc(adj = FALSE, cluster.adj = FALSE)
 )

}
}
```

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

### boottest(object, ...)

Source: https://s3alfisc.github.io/fwildclusterboot/reference/boottest.fixest.html

Performs a wild cluster bootstrap on a fixest model object.

```APIDOC
## boottest(object, B, param, clustid, ...)

### Description
Performs a wild cluster bootstrap test on a model object (e.g., from feols). It computes p-values and confidence intervals by inverting p-values using a numerical root finding procedure.

### Parameters
- **object** (fixest object) - Required - The model object to be tested.
- **B** (integer) - Required - Number of bootstrap iterations.
- **param** (string/vector) - Required - The parameter(s) to test.
- **clustid** (string/vector) - Required - The cluster ID(s) for the bootstrap.
- **fe** (string) - Optional - Fixed effect to be used in the bootstrap.
- **sign_level** (numeric) - Optional - Significance level for confidence interval calculation.
- **r** (numeric) - Optional - The null hypothesis value for the test.
- **R** (vector) - Optional - Linear combination of parameters for hypothesis testing.
- **bootstrap_type** (string) - Optional - The type of bootstrap algorithm to use (e.g., "fnw11", "31", "33").

### Usage Example
```R
boot <- boottest(feols_fit, B = 9999, param = "treatment", clustid = "group_id1")
summary(boot)
print(boot)
plot(boot)
```
```

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

### Run boottest over combined fixest features

Source: https://s3alfisc.github.io/fwildclusterboot/articles/Multiple-Estimations-with-fixest.html

Iterate over a fixest_multi object combining both sw() and split features.

```R
feols_fits <- fixest::feols(
  proposition_vote ~ treatment | sw(Q1_immigration, Q2_defense), 
  split = ~split,
  data = voters
)

boot4 <- lapply(
  feols_fits, 
  \(x) boottest(
    x, 
    B = 999,
    param = "treatment", 
    clustid = "group_id1"
    )
)  

boot4
```

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

### Run boottest over subsetted objects

Source: https://s3alfisc.github.io/fwildclusterboot/articles/Multiple-Estimations-with-fixest.html

Iterate over a fixest_multi object created by the split argument.

```R
voters$split <- sample(1:2, nrow(voters), TRUE)

feols_fits <- fixest::feols(
  proposition_vote ~ treatment, 
  split = ~split, 
  data = voters
)

boot3 <- lapply(
  feols_fits, 
  \(x) boottest(
    x,
    B = 999, 
    param = "treatment",
    clustid = "group_id1"
    )
)  

boot3
```

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

### Retrieve Package Citation

Source: https://s3alfisc.github.io/fwildclusterboot/index.html

Command to display the BibTeX citation for the fwildclusterboot package within an R session.

```R
citation("fwildclusterboot")
```

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

### Usage of teststat method

Source: https://s3alfisc.github.io/fwildclusterboot/reference/teststat.boottest.html

Standard syntax for calling the teststat method on a boottest object.

```R
# S3 method for boottest
teststat(object, ...)
```

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

### Perform Oneway Clustering with fwildclusterboot

Source: https://s3alfisc.github.io/fwildclusterboot/articles/fwildclusterboot.html

Demonstrates fitting a model with fixest and calculating bootstrap t-statistics for multiple parameters.

```R
feols_fit <- fixest::feols(
  proposition_vote ~ treatment + ideology1 + log_income,
  data = data, 
  cluster = ~group_id1, 
  ssc = fixest::ssc(adj = TRUE, 
                    cluster.adj = TRUE, 
                    cluster.df = 'conventional')
  )
        
feols_tstats <- fixest::coeftable(
  feols_fit
  )[c("treatment", "log_income", "ideology1"), 3]

boot_tstats <- 
lapply(c("treatment", "log_income", "ideology1"), function(x){
  boot1 <- fwildclusterboot::boottest(
    feols_fit, 
    clustid = c("group_id1"),
    B = 999, 
    param = x, 
    ssc = fwildclusterboot::boot_ssc(
      adj = TRUE, 
      cluster.adj = TRUE, 
      cluster.df = 'conventional'),  
      impose_null = TRUE)$t_stat
})        

df <- cbind(feols_tstats, unlist(boot_tstats))
colnames(df) <- c("feols tstat", "boottest tstat")
df
```

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

### Bootstrap fixest model with i() syntax

Source: https://s3alfisc.github.io/fwildclusterboot/articles/Multiple-Estimations-with-fixest.html

Fit a model using fixest's i() syntax and perform a wild cluster bootstrap using boottest().

```R
feols_fit <- feols(proposition_vote ~ i(treatment, ideology1) ,
    data = voters
)

boot1 <- boottest(feols_fit,
    B = 9999,
    param = "treatment::0:ideology1",
    clustid = "group_id1"
)
#> Warning: Please note that the seeding behavior for random number generation for
#> `boottest()` has changed with `fwildclusterboot` version 0.13.
#> 
#> It will no longer be possible to exactly reproduce results produced by versions
#> lower than 0.13.
#> 
#> If your prior results were produced under sufficiently many bootstrap
#> iterations, none of your conclusions will change. For more details about this
#> change, please read the notes in
#> [news.md](https://cran.r-project.org/web/packages/fwildclusterboot/news/news.html).
#> This warning is displayed once per session.

boot1
#> boottest.fixest(object = feols_fit, param = "treatment::0:ideology1", 
#>     B = 9999, clustid = "group_id1")
#>  
#> p value: 0.0373 
#> confidence interval: 0.0037 0.1083 
#> test statistic 2.2696
```

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

### Perform bootstrap inference on ivreg objects

Source: https://s3alfisc.github.io/fwildclusterboot/reference/boottest.ivreg.html

Demonstrates how to fit an ivreg model and perform bootstrap inference using boottest, including various summary and diagnostic methods.

```R
if (FALSE) {
requireNamespace("ivreg")
requireNamespace("fwildclusterboot")

# drop all NA values from SchoolingReturns
SchoolingReturns <- na.omit(SchoolingReturns)
ivreg_fit <- ivreg(log(wage) ~ education + age +
  ethnicity + smsa + south + parents14 |
  nearcollege + age + ethnicity + smsa
    + south + parents14,
data = SchoolingReturns
)

boot_ivreg <- boottest(
  object = ivreg_fit,
  B = 999,
  param = "education",
  clustid = "kww",
  type = "mammen",
  impose_null = TRUE
)
summary(boot_ivreg)
print(boot_ivreg)
plot(boot_ivreg)
nobs(boot_ivreg)
pval(boot_ivreg)
confint(boot_ivreg)
generics::tidy(boot_ivreg)
}
```
Tokens:
Raw