regmedint

https://kaz-yos.github.io/regmedint/
Admin
regmedint is an R package for regression-based causal mediation analysis that supports multiple...
Tokens:48,607
Snippets:224
Trust Score:9.7
Update:6 months ago
Show doc for...
Tokens:
Raw
### Load Data Example

Source: https://kaz-yos.github.io/regmedint/index.html

Load the regmedint library and the vv2015 demonstration dataset.

```R
library(regmedint)
data(vv2015)
```

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

### Example: Summarize regmedint Object

Source: https://kaz-yos.github.io/regmedint/reference/summary.regmedint.html

This example demonstrates how to create a regmedint object using sample data and then apply the summary method to view the detailed mediation analysis results.

```R
library(regmedint)
data(vv2015)
regmedint_obj <- regmedint(data = vv2015,
                           ## Variables
                           yvar = "y",
                           avar = "x",
                           mvar = "m",
                           cvar = c("c"),
                           eventvar = "event",
                           ## Values at which effects are evaluated
                           a0 = 0,
                           a1 = 1,
                           m_cde = 1,
                           c_cond = 0.5,
                           ## Model types
                           mreg = "logistic",
                           yreg = "survAFT_weibull",
                           ## Additional specification
                           interaction = TRUE,
                           casecontrol = FALSE)
## Detailed result with summary
summary(regmedint_obj)
```

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

### Install regmedint from GitHub

Source: https://kaz-yos.github.io/regmedint/index.html

Use devtools to install the developmental version of the package from GitHub.

```R
# install.packages("devtools") # If you do not have devtools already.
devtools::install_github("kaz-yos/regmedint")
```

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

### Load Libraries and Prepare Dataset

Source: https://kaz-yos.github.io/regmedint/articles/vig_01_introduction.html

Loads the regmedint and tidyverse libraries and prepares the example dataset 'vv2015'. Ensure all variables are numerical; categorical variables may need conversion to dummy variables.

```R
library(regmedint)
library(tidyverse)
## Prepare dataset
data(vv2015)
```

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

### Install regmedint from CRAN

Source: https://kaz-yos.github.io/regmedint/index.html

Install the stable version of the package from CRAN.

```R
install.packages("regmedint")
```

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

### Parallel Computing Setup

Source: https://kaz-yos.github.io/regmedint/articles/vig_06_delta_boot.html

Configures parallel computing by detecting the number of available CPU cores. This is useful for speeding up bootstrap processes.

```R
library(parallel)
library(MASS)
numCores <- detectCores()
numCores
```

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

### Example: Running and Printing a Mediation Analysis

Source: https://kaz-yos.github.io/regmedint/reference/print.regmedint.html

Demonstrates how to perform a mediation analysis using the regmedint function with specified variables and model types, and then how to print the results both implicitly and explicitly.

```R
library(regmedint)
data(vv2015)
regmedint_obj <- regmedint(data = vv2015,
                           ## Variables
                           yvar = "y",
                           avar = "x",
                           mvar = "m",
                           cvar = c("c"),
                           eventvar = "event",
                           ## Values at which effects are evaluated
                           a0 = 0,
                           a1 = 1,
                           m_cde = 1,
                           c_cond = 0.5,
                           ## Model types
                           mreg = "logistic",
                           yreg = "survAFT_weibull",
                           ## Additional specification
                           interaction = TRUE,
                           casecontrol = FALSE)
## Implicit printing
regmedint_obj
```

```R
## Explicit printing
print(regmedint_obj)
```

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

### GET /confint

Source: https://kaz-yos.github.io/regmedint/articles/vig_01_introduction.html

Calculates the confidence intervals for the mediation effects.

```APIDOC
## GET /confint

### Description
Computes confidence intervals for the mediation effects stored in the regmedint object.

### Method
GET

### Response
#### Success Response (200)
- **lower** (numeric) - Lower bound of the confidence interval.
- **upper** (numeric) - Upper bound of the confidence interval.
```

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

### Calculating Confidence Intervals with regmedint

Source: https://kaz-yos.github.io/regmedint/reference/confint.regmedint.html

Examples demonstrating how to compute confidence intervals, evaluate effects at specific covariate values, and adjust the confidence level.

```R
library(regmedint)
data(vv2015)
regmedint_obj <- regmedint(data = vv2015,
                           ## Variables
                           yvar = "y",
                           avar = "x",
                           mvar = "m",
                           cvar = c("c"),
                           eventvar = "event",
                           ## Values at which effects are evaluated
                           a0 = 0,
                           a1 = 1,
                           m_cde = 1,
                           c_cond = 0.5,
                           ## Model types
                           mreg = "logistic",
                           yreg = "survAFT_weibull",
                           ## Additional specification
                           interaction = TRUE,
                           casecontrol = FALSE)
confint(regmedint_obj)

## Evaluate at different values
confint(regmedint_obj, m_cde = 0, c_cond = 1)

## Change confidence level
confint(regmedint_obj, m_cde = 0, c_cond = 1, level = 0.99)
```

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

### GET /datasets/vv2015

Source: https://kaz-yos.github.io/regmedint/reference/vv2015.html

Retrieves the structure and variable definitions for the vv2015 dataset.

```APIDOC
## GET /datasets/vv2015

### Description
Retrieves the vv2015 dataset, a tibble containing 100 rows and 7 variables used in mediation analysis.

### Method
GET

### Endpoint
/datasets/vv2015

### Response
#### Success Response (200)
- **id** (integer) - Positive integer id.
- **x** (binary) - Treatment assignment variable.
- **m** (binary) - Mediator variable.
- **y** (numeric) - Time to event outcome variable.
- **cens** (binary) - Censoring indicator (1 = Censored).
- **c** (numeric) - Continuous confounder variable.
- **event** (binary) - Event indicator (1 = Event).

#### Response Example
{
  "id": 1,
  "x": 0,
  "m": 1,
  "y": 12.5,
  "cens": 0,
  "c": 0.45,
  "event": 1
}
```

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

### Run mediation analysis with regmedint

Source: https://kaz-yos.github.io/regmedint/reference/print.summary_regmedint.html

This example demonstrates how to perform a mediation analysis using the `regmedint` function. It specifies the data, outcome and mediator variables, event variable, evaluation points for treatment and mediator, covariate conditions, and regression models for the mediator and outcome. It also shows how to enable interaction effects.

```R
library(regmedint)
data(vv2015)
regmedint_obj <- regmedint(data = vv2015,
                           ## Variables
                           yvar = "y",
                           avar = "x",
                           mvar = "m",
                           cvar = c("c"),
                           eventvar = "event",
                           ## Values at which effects are evaluated
                           a0 = 0,
                           a1 = 1,
                           m_cde = 1,
                           c_cond = 0.5,
                           ## Model types
                           mreg = "logistic",
                           yreg = "survAFT_weibull",
                           ## Additional specification
                           interaction = TRUE,
                           casecontrol = FALSE)
```

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

### Implement Bootstrapping with the boot Package

Source: https://kaz-yos.github.io/regmedint/articles/vig_03_bootstrap.html

This snippet demonstrates how to use the boot package in R to perform bootstrapping for the regmedint function. It requires defining a wrapper function that takes a subset of data and returns the coefficients. Parallel processing is supported.

```r
library(boot)
## Define a wrapper function
regmedint_boot <- function(data, ind)  {
    ## Note the change in the data argument.
    regmedint_obj <- regmedint(data = data[ind,],
                               ## Variables
                               yvar = "y",
                               avar = "x",
                               mvar = "m",
                               cvar = c("c"),
                               eventvar = "event",
                               ## Values at which effects are evaluated
                               a0 = 0,
                               a1 = 1,
                               m_cde = 1,
                               c_cond = 0.5,
                               ## Model types
                               mreg = "logistic",
                               yreg = "survAFT_weibull",
                               ## Additional specification
                               interaction = TRUE,
                               casecontrol = FALSE)
    coef(regmedint_obj)
}
## Run bootstrapping
ncpus <- 1
## For parallization, use the following instead.
## ncpus <- parallel::detectCores()
boot_obj <- boot(data = vv2015, statistic = regmedint_boot, R = 1000,
                 ## For palatalization
                 ## See https://cran.r-project.org/package=boot
                 parallel = "multicore",
                 ncpus = ncpus)
## Confidence interval for the pm
boot.ci(boot_obj, type = "basic", index = 7)
```

```text
## BOOTSTRAP CONFIDENCE INTERVAL CALCULATIONS
## Based on 1000 bootstrap replicates
## 
## CALL : 
## boot.ci(boot.out = boot_obj, type = "basic", index = 7)
## 
## Intervals : 
## Level      Basic         
## 95%   (-0.4322,  0.4106 )  
## Calculations and Intervals on Original Scale
```

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

### Bootstrap Configuration

Source: https://kaz-yos.github.io/regmedint/articles/vig_06_delta_boot.html

Sets up the number of bootstrap trials and a seed for reproducibility. Adjust 'trials' for desired accuracy vs. computation time.

```R
# Number of bootstrap
trials <- 1:5000
seed <-  3104
```

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

### GET /vcov

Source: https://kaz-yos.github.io/regmedint/articles/vig_01_introduction.html

Retrieves the variance-covariance matrix for the mediation effects estimated in the regmedint object.

```APIDOC
## GET /vcov

### Description
Returns the variance-covariance matrix of the mediation effect estimates.

### Method
GET

### Parameters
#### Query Parameters
- **m_cde** (numeric) - Optional - The mediator value used for the evaluation.
- **c_cond** (numeric) - Optional - The covariate value used for the evaluation.

### Response
#### Success Response (200)
- **vcov_matrix** (array) - The variance-covariance matrix of the estimated effects.
```

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

### Initialize modelr and future for Parallel Processing

Source: https://kaz-yos.github.io/regmedint/articles/vig_03_bootstrap.html

This snippet sets up the modelr and future packages for potentially more flexible workflows within the tidyverse ecosystem. It initializes the parallel processing plan.

```r
library(modelr)

library(future)
future::plan(sequential)
## For parallization, use the following instead.
## future::plan(multiprocess)
library(furrr)
```

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

### Load Libraries and Define Helper Function

Source: https://kaz-yos.github.io/regmedint/articles/vig_06_delta_boot.html

Loads necessary libraries and defines the expit function for logistic transformations. Ensure these are available before running other code.

```R
library(regmedint)
library(tidyverse)

expit <- function(x){exp(x)/(1 + exp(x))}
```

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

### GET /coef

Source: https://kaz-yos.github.io/regmedint/articles/vig_01_introduction.html

Retrieves the coefficients from a regmedint object. Supports optional parameters to specify the mediator value (m_cde) and covariate values (c_cond) for the calculation.

```APIDOC
## GET /coef

### Description
Retrieves the estimated mediation effects (cde, pnde, tnie, tnde, pnie, te, pm) from a regmedint object.

### Method
GET

### Parameters
#### Query Parameters
- **m_cde** (numeric) - Optional - The intervened value of the mediator variable for the controlled direct effect.
- **c_cond** (numeric) - Optional - The covariate vector value at which to evaluate the effects.

### Response
#### Success Response (200)
- **coefficients** (object) - A named vector of mediation effect estimates.

### Response Example
{
  "cde": 0.440756562,
  "pnde": 0.492306223,
  "tnie": 0.018077074,
  "tnde": 0.501765186,
  "pnie": 0.008618111,
  "te": 0.510383297,
  "pm": 0.044816400
}
```

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

### Bootstrapping for Logistic Mediator and Linear Outcome Model

Source: https://kaz-yos.github.io/regmedint/articles/vig_06_delta_boot.html

Performs bootstrapping for mediation analysis when the mediator is logistic and the outcome is linear. This helps in estimating confidence intervals for mediation effects. Note the fixed number of trials (100) in this specific example.

```R
data2 <- dat_logistic_M_linear_Y
boot2 <- function(trials){
  ind <- sample(5000, 5000, replace = TRUE)
  dat <- data2[ind,]

  regmedint2 <- regmedint(data = dat,
                          yvar = "Y",
                          avar = "A",
                          mvar = "M",
                          cvar = c("C"),
                          emm_ac_mreg = c("C"),
                          emm_ac_yreg = c("C"),
                          emm_mc_yreg = c("C"),
                          eventvar = NULL,
                          a0 = 0,
                          a1 = 1,
                          m_cde = 0,
                          c_cond = -0.0434094,
                          mreg = "logistic",
                          yreg = "linear",
                          interaction = TRUE,
                          casecontrol = FALSE,
                          na_omit = FALSE)

  out <- summary(regmedint2)
  cde.est.boot <- out$summary_myreg[1,1]
  pnde.est.boot <- out$summary_myreg[2,1]
  tnie.est.boot <- out$summary_myreg[3,1]
  tnde.est.boot <- out$summary_myreg[4,1]
  pnie.est.boot <- out$summary_myreg[5,1]
  te.est.boot <- out$summary_myreg[6,1]
  pm.est.boot <- out$summary_myreg[7,1]
  return(c(cde.est.boot,
           pnde.est.boot, tnie.est.boot,
           tnde.est.boot, pnie.est.boot,
           te.est.boot, pm.est.boot))
}

set.seed(seed)
system.time({
  results2 <- mclapply(1:100, boot2, mc.cores = numCores)
})

results2.df <- as.data.frame(do.call(rbind, results2))
apply(results2.df, 2, mean)
apply(results2.df, 2, sd)
```

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

### Extract point estimates from regmedint object

Source: https://kaz-yos.github.io/regmedint/reference/coef.regmedint.html

Demonstrates initializing a regmedint object and extracting point estimates using the default values and custom evaluation points.

```R
library(regmedint)
data(vv2015)
regmedint_obj <- regmedint(data = vv2015,
                           ## Variables
                           yvar = "y",
                           avar = "x",
                           mvar = "m",
                           cvar = c("c"),
                           eventvar = "event",
                           ## Values at which effects are evaluated
                           a0 = 0,
                           a1 = 1,
                           m_cde = 1,
                           c_cond = 0.5,
                           ## Model types
                           mreg = "logistic",
                           yreg = "survAFT_weibull",
                           ## Additional specification
                           interaction = TRUE,
                           casecontrol = FALSE)
coef(regmedint_obj)
#>         cde        pnde        tnie        tnde        pnie          te 
#> 0.541070807 0.488930417 0.018240025 0.498503455 0.008666987 0.507170442 
#>          pm 
#> 0.045436278 
#> attr(,"args")
#> attr(,"args")$a0
#> [1] 0
#> 
#> attr(,"args")$a1
#> [1] 1
#> 
#> attr(,"args")$m_cde
#> [1] 1
#> 
#> attr(,"args")$c_cond
#> [1] 0.5
#> 
## Evaluate at different values
coef(regmedint_obj, m_cde = 0, c_cond = 1)
#>         cde        pnde        tnie        tnde        pnie          te 
#> 0.440756562 0.492306223 0.018077074 0.501765186 0.008618111 0.510383297 
#>          pm 
#> 0.044816400 
#> attr(,"args")
#> attr(,"args")$a0
#> [1] 0
#> 
#> attr(,"args")$a1
#> [1] 1
#> 
#> attr(,"args")$m_cde
#> [1] 0
#> 
#> attr(,"args")$c_cond
#> [1] 1
#>
```

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

### Naive Complete Case Analysis with regmedint

Source: https://kaz-yos.github.io/regmedint/articles/vig_04_mi.html

Performs a complete case analysis by filtering out rows with missing mediator values before fitting the mediation model. This can lead to biased results if missingness is not completely at random.

```R
regmedint_cca <- vv2015 %>%
    filter(!is.na(m)) %>%
    regmedint(data = .,
              ## Variables
              yvar = "y",
              avar = "x",
              mvar = "m",
              cvar = c("c"),
              eventvar = "event",
              ## Values at which effects are evaluated
              a0 = 0,
              a1 = 1,
              m_cde = 1,
              c_cond = 0.5,
              ## Model types
              mreg = "logistic",
              yreg = "survAFT_weibull",
              ## Additional specification
              interaction = TRUE,
              casecontrol = FALSE)
summary(regmedint_cca)
```

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

### Generate Simulated Datasets

Source: https://kaz-yos.github.io/regmedint/articles/vig_06_delta_boot.html

Generates four distinct datasets based on the previously defined simulation functions, using a specified seed for reproducibility. These datasets are prepared for model fitting.

```R
set.seed(seed)
dat_linear_M_linear_Y     <- as.data.frame(datamaker.s4.m1(n = 5000, k = 0.3))
dat_logistic_M_linear_Y   <- as.data.frame(datamaker.s4.m2(n = 5000, k = 0.3))
dat_linear_M_logistic_Y   <- as.data.frame(datamaker.s4.m3(n = 5000, k = 0.7))
dat_logistic_M_logistic_Y <- as.data.frame(datamaker.s4.m4(n = 5000, k = 0.3))
```

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

### Compare Bootstrapping with Delta Method

Source: https://kaz-yos.github.io/regmedint/articles/vig_03_bootstrap.html

Appends delta method confidence intervals to the existing bootstrap results for comparison.

```R
tib_obj2 %>%
    mutate(lower_delta = confint(regmedint_obj)[,"lower"],
           upper_delta = confint(regmedint_obj)[,"upper"])
```

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

### Perform Bootstrapping with regmedint

Source: https://kaz-yos.github.io/regmedint/articles/vig_03_bootstrap.html

Uses modelr::bootstrap to resample data and calculate coefficients for each iteration, storing them in a tibble.

```R
tib_obj <- vv2015 %>%
    modelr::bootstrap(n = 1000) %>%
    ## Resampled data objects are in the list column named strap.
    mutate(boot_fit = future_map(strap, function(strap) {
        ## Note the change in the data argument.
        regmedint_obj <- regmedint(data = as_tibble(strap),
                                   ## Variables
                                   yvar = "y",
                                   avar = "x",
                                   mvar = "m",
                                   cvar = c("c"),
                                   eventvar = "event",
                                   ## Values at which effects are evaluated
                                   a0 = 0,
                                   a1 = 1,
                                   m_cde = 1,
                                   c_cond = 0.5,
                                   ## Model types
                                   mreg = "logistic",
                                   yreg = "survAFT_weibull",
                                   ## Additional specification
                                   interaction = TRUE,
                                   casecontrol = FALSE)
        ## Trick to return a row tibble
        mat <- t(matrix(coef(regmedint_obj)))
        colnames(mat) <- names(coef(regmedint_obj))
        as_tibble(mat)
    })) %>%
    select(-strap) %>%
    unnest(cols = c(boot_fit))

tib_obj2 <- tib_obj %>%
    pivot_longer(-.id) %>%
    mutate(name = factor(name, levels = names(coef(regmedint_obj)))) %>%
    group_by(name) %>%
    summarize(lower_boot = quantile(value, probs = 0.025),
              upper_boot = quantile(value, probs = 0.975))
tib_obj2
```

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

### Calculate Mediation Analysis Parameters

Source: https://kaz-yos.github.io/regmedint/articles/vig_02_formulas.html

Calculates Gamma matrices for CDE, PNDE, TNIE, TNDE, and PNIE using conditional parameters. Requires assertthat for validation and assumes existence of model coefficients.

```R
##         beta2_c <- 0
##         }
##         else {
##             assertthat::assert_that(!is.null(c_cond))
##             assertthat::assert_that(length(c_cond) == length(beta2))
##             beta2_c <- sum(t(matrix(beta2)) %*% matrix(c_cond))
##         }
##         if (is.null(beta3)) {
##             beta3_c <- 0
##         }
##         else {
##             assertthat::assert_that(length(c_cond) == length(beta3))
##             beta3_c <- sum(t(matrix(beta3)) %*% matrix(c_cond))
##         }
##         if (is.null(theta4)) {
##             assertthat::assert_that(is.null(c_cond))
##             theta4_c <- 0
##         }
##         else {
##             assertthat::assert_that(!is.null(c_cond))
##             assertthat::assert_that(length(c_cond) == length(theta4))
##             theta4_c <- sum(t(matrix(theta4)) %*% matrix(c_cond))
##         }
##         if (is.null(theta5)) {
##             theta5_c <- 0
##         }
##         else {
##             assertthat::assert_that(length(c_cond) == length(theta5))
##             theta5_c <- sum(t(matrix(theta5)) %*% matrix(c_cond))
##         }
##         if (is.null(theta6)) {
##             theta6_c <- 0
##         }
##         else {
##             assertthat::assert_that(length(c_cond) == length(theta6))
##             theta6_c <- sum(t(matrix(theta6)) %*% matrix(c_cond))
##         }
##         if (is.null(theta5)) {
##             pd_cde_theta5 <- rep(0, length(theta5))
##         }
##         else {
##             pd_cde_theta5 <- c_cond
##         }
##         Gamma_cde <- matrix(c(0, 0, rep(0, length(beta2)), rep(0, 
##             length(beta3)), 0, 1, 0, m_cde, rep(0, length(theta4)), 
##             pd_cde_theta5, rep(0, length(theta6)), 0))
##         if (is.null(beta3)) {
##             pd_pnde_beta3 <- rep(0, length(beta3))
##         }
##         else {
##             pd_pnde_beta3 <- theta3 * a1 * c_cond
##         }
##         if (is.null(theta5)) {
##             pd_pnde_theta5 <- rep(0, length(theta5))
##         }
##         else {
##             pd_pnde_theta5 <- c_cond
##         }
##         if (is.null(theta6)) {
##             pd_pnde_theta6 <- rep(0, length(theta6))
##         }
##         else {
##             pd_pnde_theta6 <- theta3 * sigma_sq * c_cond
##         }
##         Gamma_pnde <- matrix(c(theta3, theta3 * a0, theta3 * 
##             c_cond, pd_pnde_beta3, 0, 1, theta3 * sigma_sq, a0 * 
##             (beta1 + beta3_c) + beta0 + beta2_c + sigma_sq * 
##             ((theta2 + theta6_c) + theta3 * (a0 + a1)), rep(0, 
##             length(theta4)), pd_pnde_theta5, pd_pnde_theta6, 
##             1/2 * theta3 * (2 * (theta2 + theta6_c) + theta3 * 
##                 (a0 + a1))))
##         if (is.null(beta3)) {
##             pd_tnie_beta3 <- rep(0, length(beta3))
##         }
##         else {
##             pd_tnie_beta3 <- c_cond * (theta2 + theta3 * a1 + 
##                 theta6_c)
##         }
##         if (is.null(theta6)) {
##             pd_tnie_theta6 <- rep(0, length(theta6))
##         }
##         else {
##             pd_tnie_theta6 <- c_cond * (beta1 + beta3_c)
##         }
##         Gamma_tnie <- matrix(c(0, theta2 + theta3 * a1 + theta6_c, 
##             rep(0, length(beta2)), pd_tnie_beta3, 0, 0, beta1 + 
##                 beta3_c, a1 * (beta1 + beta3_c), rep(0, length(theta4)), 
##             rep(0, length(theta5)), pd_tnie_theta6, 0))
##         if (is.null(beta3)) {
##             pd_tnde_beta3 <- rep(0, length(beta3))
##         }
##         else {
##             pd_tnde_beta3 <- theta3 * a1 * c_cond
##         }
##         if (is.null(theta5)) {
##             pd_tnde_theta5 <- rep(0, length(theta5))
##         }
##         else {
##             pd_tnde_theta5 <- c_cond
##         }
##         if (is.null(theta6)) {
##             pd_tnde_theta6 <- rep(0, length(theta6))
##         }
##         else {
##             pd_tnde_theta6 <- theta3 * sigma_sq * c_cond
##         }
##         Gamma_tnde <- matrix(c(theta3, theta3 * a1, theta3 * 
##             c_cond, pd_tnde_beta3, 0, 1, theta3 * sigma_sq, a1 * 
##             (beta1 + beta3_c) + beta0 + beta2_c + sigma_sq * 
##             ((theta2 + theta6_c) + theta3 * (a0 + a1)), rep(0, 
##             length(theta4)), pd_tnde_theta5, pd_tnde_theta6, 
##             1/2 * theta3 * (2 * (theta2 + theta6_c) + theta3 * 
##                 (a0 + a1))))
##         if (is.null(beta3)) {
##             pd_pnie_beta3 <- rep(0, length(beta3))
##         }
##         else {
##             pd_pnie_beta3 <- c_cond * (theta2 + theta3 * a0 + 
##                 theta6_c)
##         }
##         if (is.null(theta6)) {
##             pd_pnie_theta6 <- rep(0, length(theta6))
##         }
##         else {
##             pd_pnie_theta6 <- c_cond * (beta1 + beta3_c)
##         }
##         Gamma_pnie <- matrix(c(0, theta2 + theta3 * a0 + theta6_c, 
##             rep(0, length(beta2)), pd_pnie_beta3, 0, 0, beta1 + 
##                 beta3_c, a1 * (beta1 + beta3_c), rep(0, length(theta4)), 
##             rep(0, length(theta5)), pd_pnie_theta6, 0))
```

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

### Initialize regmedint object

Source: https://kaz-yos.github.io/regmedint/reference/new_regmedint.html

Internal constructor for creating a regmedint S3 object with specified model parameters and data.

```R
new_regmedint(
  data,
  yvar,
  avar,
  mvar,
  cvar,
  emm_ac_mreg,
  emm_ac_yreg,
  emm_mc_yreg,
  eventvar,
  a0,
  a1,
  m_cde,
  c_cond,
  yreg,
  mreg,
  interaction,
  casecontrol
)
```

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

### Statistical Extraction Methods

Source: https://kaz-yos.github.io/regmedint/reference/index.html

Methods for extracting coefficients, confidence intervals, and variance-covariance matrices from regmedint objects.

```APIDOC
## coef(), confint(), vcov()

### Description
Methods to extract point estimates, confidence intervals, and variance estimates from a regmedint object.

### Method
Function Call

### Endpoint
coef(regmedint), confint(regmedint), vcov(regmedint)
```

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

### Construct conditional effect and SE functions

Source: https://kaz-yos.github.io/regmedint/reference/calc_myreg_mreg_linear_yreg_logistic.html

Initializes the calculation functions for a linear mediator model and a logistic outcome model.

```R
calc_myreg_mreg_linear_yreg_logistic(
  mreg,
  mreg_fit,
  yreg,
  yreg_fit,
  avar,
  mvar,
  cvar,
  emm_ac_mreg,
  emm_ac_yreg,
  emm_mc_yreg,
  interaction
)
```

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

### S3 Method for regmedint_mod_poisson Summary

Source: https://kaz-yos.github.io/regmedint/reference/summary.regmedint_mod_poisson.html

This is an S3 method for the `regmedint_mod_poisson` class, designed to provide a summary of the model. It is a modified version of `summary.glm` that uses the robust `sandwich` variance estimator.

```R
summary(object, ...)
```

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

### Bootstrapping for Linear Mediator and Outcome Model

Source: https://kaz-yos.github.io/regmedint/articles/vig_06_delta_boot.html

Conducts bootstrapping to estimate the uncertainty of mediation effects (CDE, PNDE, TNIE, TNDE, PNIE, TE, PM) for a linear mediator and outcome model. Requires setting seed and specifying the number of cores for parallel processing.

```R
data1 <- dat_linear_M_linear_Y
boot1 <- function(trials){
  ind <- sample(5000, 5000, replace = TRUE)
  dat <- data1[ind,]

  regmedint1 <- regmedint(data = dat,
                          yvar = "Y",
                          avar = "A",
                          mvar = "M",
                          cvar = c("C"),
                          emm_ac_mreg = c("C"),
                          emm_ac_yreg = c("C"),
                          emm_mc_yreg = c("C"),
                          eventvar = NULL,
                          a0 = 0,
                          a1 = 1,
                          m_cde = 0.5012509,
                          c_cond = -0.0434094,
                          mreg = "linear",
                          yreg = "linear",
                          interaction = TRUE,
                          casecontrol = FALSE,
                          na_omit = FALSE)

  out <- summary(regmedint1)
  cde.est.boot <- out$summary_myreg[1,1]
  pnde.est.boot <- out$summary_myreg[2,1]
  tnie.est.boot <- out$summary_myreg[3,1]
  tnde.est.boot <- out$summary_myreg[4,1]
  pnie.est.boot <- out$summary_myreg[5,1]
  te.est.boot <- out$summary_myreg[6,1]
  pm.est.boot <- out$summary_myreg[7,1]
  return(c(cde.est.boot,
           pnde.est.boot, tnie.est.boot,
           tnde.est.boot, pnie.est.boot,
           te.est.boot, pm.est.boot))
}

set.seed(seed)
system.time({
  results1 <- mclapply(trials, boot1, mc.cores = numCores)
})

results1.df <- as.data.frame(do.call(rbind, results1))
apply(results1.df, 2, mean)
apply(results1.df, 2, sd)
```

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

### Extract variance estimates from regmedint object

Source: https://kaz-yos.github.io/regmedint/reference/vcov.regmedint.html

Demonstrates calculating variance estimates using a regmedint object and evaluating them at different mediator and covariate values.

```R
library(regmedint)
data(vv2015)
regmedint_obj <- regmedint(data = vv2015,
                           ## Variables
                           yvar = "y",
                           avar = "x",
                           mvar = "m",
                           cvar = c("c"),
                           eventvar = "event",
                           ## Values at which effects are evaluated
                           a0 = 0,
                           a1 = 1,
                           m_cde = 1,
                           c_cond = 0.5,
                           ## Model types
                           mreg = "logistic",
                           yreg = "survAFT_weibull",
                           ## Additional specification
                           interaction = TRUE,
                           casecontrol = FALSE)
vcov(regmedint_obj)

## Evaluate at different values
vcov(regmedint_obj, m_cde = 0, c_cond = 1)
```

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

### summary.regmedint_mod_poisson

Source: https://kaz-yos.github.io/regmedint/reference/summary.regmedint_mod_poisson.html

Generates a summary for a regmedint_mod_poisson model object using a robust variance estimator.

```APIDOC
## summary.regmedint_mod_poisson

### Description
This is a version of summary.glm modified to use the robust variance estimator 'sandwich' for regmedint_mod_poisson objects.

### Method
S3 Method

### Parameters
#### Arguments
- **object** (regmedint_mod_poisson) - Required - A model object of the class regmedint_mod_poisson.
- **...** (dots) - Optional - Additional arguments for compatibility with the generic.

### Value
- **summary.glm** (object) - Returns an object of the class summary.glm.
```

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

### Fit Mediation Models with regmedint

Source: https://kaz-yos.github.io/regmedint/index.html

Construct a regmedint object to perform mediation analysis and summarize the results.

```R
regmedint_obj1 <- regmedint(data = vv2015,
                            ## Variables
                            yvar = "y",
                            avar = "x",
                            mvar = "m",
                            cvar = c("c"),
                            eventvar = "event",
                            ## Values at which effects are evaluated
                            a0 = 0,
                            a1 = 1,
                            m_cde = 1,
                            c_cond = 3,
                            ## Model types
                            mreg = "logistic",
                            yreg = "survAFT_weibull",
                            ## Additional specification
                            interaction = TRUE,
                            casecontrol = FALSE)
 summary(regmedint_obj1)
```

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

### S3 Method Definition for confint

Source: https://kaz-yos.github.io/regmedint/reference/confint.regmedint.html

The signature for the confint method applied to regmedint objects.

```R
# S3 method for regmedint
confint(
  object,
  parm = NULL,
  level = 0.95,
  a0 = NULL,
  a1 = NULL,
  m_cde = NULL,
  c_cond = NULL,
  ...
)
```

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

### Print summary of regmedint object

Source: https://kaz-yos.github.io/regmedint/articles/vig_01_introduction.html

Displays the summary of a regmedint object using either implicit printing or the explicit print function.

```R
regmedint_summary_obj <- summary(regmedint_obj)
regmedint_summary_obj # Implicit printing
```

```R
print(regmedint_summary_obj)
```

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

### Combine Multiple Imputation Results

Source: https://kaz-yos.github.io/regmedint/articles/vig_04_mi.html

Uses the mitools package to aggregate coefficients and variances from multiple imputation fits.

```R
regmedint_mi <- mitools::MIcombine(results = vv2015_mice_regmedint$coef_fit,
                                   variances = vv2015_mice_regmedint$vcov_fit)
regmedint_mi_summary <- summary(regmedint_mi)
```

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

### new_regmedint Constructor

Source: https://kaz-yos.github.io/regmedint/reference/new_regmedint.html

Internal constructor function for creating a regmedint object.

```APIDOC
## new_regmedint

### Description
Low-level constructor for a regmedint S3 class object. This is an internal function meant to be executed within the regmedint function after validating arguments.

### Parameters
- **data** (data.frame) - Required - Data frame containing the relevant variables.
- **yvar** (character) - Required - Outcome variable name (time variable for survival outcomes).
- **avar** (character) - Required - Treatment variable name.
- **mvar** (character) - Required - Mediator variable name.
- **cvar** (character) - Required - Covariate names.
- **emm_ac_mreg** (character) - Required - Effect modifiers names for treatment-covariate product term in mediator model.
- **emm_ac_yreg** (character) - Required - Effect modifiers names for treatment-covariate product term in outcome model.
- **emm_mc_yreg** (character) - Required - Effect modifiers names for mediator-covariate product term in outcome model.
- **eventvar** (character) - Required - Event variable name for survival models (1 for event, 0 for censoring).
- **a0** (numeric) - Required - Reference level of treatment (untreated/unexposed).
- **a1** (numeric) - Required - Treatment level.
- **m_cde** (numeric) - Required - Mediator level for controlled direct effect evaluation.
- **c_cond** (numeric) - Required - Covariate levels for natural direct and indirect effect evaluation.
- **yreg** (character) - Required - Outcome regression type (e.g., "linear", "logistic", "survCox").
- **mreg** (character) - Required - Mediator regression type ("linear" or "logistic").
- **interaction** (logical) - Required - Presence of treatment-mediator interaction in outcome model.
- **casecontrol** (logical) - Required - Whether data comes from a case-control study.

### Response
- **regmedint object** - A constructed regmedint S3 class object.
```

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

### Summarize and print mediation analysis results

Source: https://kaz-yos.github.io/regmedint/reference/print.summary_regmedint.html

This code snippet shows how to obtain and implicitly print the summary of a `regmedint` object. The output includes detailed information about the mediator model, outcome model, and the mediation analysis results, including various effect estimates and the evaluated settings.

```R
summary(regmedint_obj)
```

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

### Examine Extended Mediation Results with summary()

Source: https://kaz-yos.github.io/regmedint/index.html

Use the summary() method on a regmedint object to view detailed results for mediator and outcome models, along with mediation analysis summaries. The exponentiate option is useful for non-linear outcome models.

```r
summary(regmedint_obj2, exponentiate = TRUE)
```

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

### Print Summary of Regmedint Object

Source: https://kaz-yos.github.io/regmedint/reference/print.summary_regmedint.html

This section describes the S3 print method for `summary_regmedint` objects, which provides a detailed summary of the mediation analysis results.

```APIDOC
## S3 method for summary_regmedint
print(x, ...)

### Description
Print results contained in a `summary_regmedint` object with additional explanation regarding the evaluation settings.

### Arguments
* **x** (summary_regmedint) - An object of the class `summary_regmedint`.
* **...** - For compatibility with the generic function.

### Value
Invisibly return the first argument.

### Examples
```R
library(regmedint)
data(vv2015)
regmedint_obj <- regmedint(data = vv2015,
                           yvar = "y",
                           avar = "x",
                           mvar = "m",
                           cvar = c("c"),
                           eventvar = "event",
                           a0 = 0,
                           a1 = 1,
                           m_cde = 1,
                           c_cond = 0.5,
                           mreg = "logistic",
                           yreg = "survAFT_weibull",
                           interaction = TRUE,
                           casecontrol = FALSE)

## Implicit printing
summary(regmedint_obj)
```
```

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

### Define print method for summary_regmedint objects

Source: https://kaz-yos.github.io/regmedint/reference/print.summary_regmedint.html

This is the S3 method definition for printing summary_regmedint objects. It is used to display mediation analysis results with additional context.

```R
print(x, ...)
```

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

### Fit regmedint Model and Extract Coefficients

Source: https://kaz-yos.github.io/regmedint/articles/vig_03_bootstrap.html

This snippet shows how to fit a regression model for mediation using the regmedint function and then extract the point estimates and their statistics using coef(summary()).

```r
set.seed(138087069)
library(regmedint)
library(tidyverse)
## Prepare dataset
data(vv2015)
## Main fit
regmedint_obj <- regmedint(data = vv2015,
                           ## Variables
                           yvar = "y",
                           avar = "x",
                           mvar = "m",
                           cvar = c("c"),
                           eventvar = "event",
                           ## Values at which effects are evaluated
                           a0 = 0,
                           a1 = 1,
                           m_cde = 1,
                           c_cond = 0.5,
                           ## Model types
                           mreg = "logistic",
                           yreg = "survAFT_weibull",
                           ## Additional specification
                           interaction = TRUE,
                           casecontrol = FALSE)
coef(summary(regmedint_obj))
```

```text
##              est         se         Z          p       lower      upper
## cde  0.541070807 0.29422958 1.8389409 0.06592388 -0.03560858 1.11775019
## pnde 0.488930417 0.21049248 2.3227928 0.02019028  0.07637274 0.90148809
## tnie 0.018240025 0.03706111 0.4921608 0.62260566 -0.05439841 0.09087846
## tnde 0.498503455 0.21209540 2.3503737 0.01875457  0.08280410 0.91420281
## pnie 0.008666987 0.02730994 0.3173565 0.75097309 -0.04485951 0.06219348
## te   0.507170442 0.21090051 2.4047853 0.01618197  0.09381303 0.92052785
## pm   0.045436278 0.09119614 0.4982259 0.61832484 -0.13330488 0.22417743
```

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

### S3 method for vcov in regmedint_mod_poisson

Source: https://kaz-yos.github.io/regmedint/reference/vcov.regmedint_mod_poisson.html

Use this method to obtain a robust variance-covariance matrix for objects of class regmedint_mod_poisson.

```R
# S3 method for regmedint_mod_poisson
vcov(object, ...)
```

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

### Print Regmedint Object Summary

Source: https://kaz-yos.github.io/regmedint/articles/vig_01_introduction.html

The `print` method for a `regmedint` object displays a comprehensive summary including mediator model, outcome model, and mediation analysis results. Implicit printing also shows this summary.

```R
regmedint_obj # Implicit printing
```

```R
print(regmedint_obj)
```

```R
print(regmedint_obj, m_cde = 0, c_cond = 1)
```

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

### Define Summary Method for regmedint Objects

Source: https://kaz-yos.github.io/regmedint/reference/summary.regmedint.html

This function summarizes mediation analysis results from a regmedint object. It accepts arguments to specify values for evaluating effects and controlling the output format.

```R
summary(
  object,
  a0 = NULL,
  a1 = NULL,
  m_cde = NULL,
  c_cond = NULL,
  args_mreg_fit = list(),
  args_yreg_fit = list(),
  exponentiate = FALSE,
  level = 0.95,
  ...
)
```

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

### Extract Coefficients from Summary of Regmedint Object

Source: https://kaz-yos.github.io/regmedint/articles/vig_01_introduction.html

Use the `coef` method on the result of `summary(regmedint_obj)` to extract the mediation analysis results as a matrix, including estimates, standard errors, Z-scores, p-values, and confidence intervals.

```R
coef(summary(regmedint_obj))
```

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

### Compare Mediation Estimates

Source: https://kaz-yos.github.io/regmedint/articles/vig_04_mi.html

Compares true, complete-case analysis, and multiple imputation estimates using a column-bound matrix.

```R
cbind(true = coef(regmedint_true),
      cca = coef(regmedint_cca),
      mi = regmedint_mi_summary$results)
```

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

### calc_myreg()

Source: https://kaz-yos.github.io/regmedint/reference/index.html

Returns mediation analysis functions based on specified mediator and outcome models.

```APIDOC
## calc_myreg()

### Description
Return mediation analysis functions given mediator and outcome models specifications.

### Method
Function Call

### Endpoint
calc_myreg()
```

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

### Survival Regression Model Output

Source: https://kaz-yos.github.io/regmedint/reference/regmedint.html

Output from a survival regression model using the `survival::survreg` function with a Weibull distribution. It includes coefficients, standard errors, p-values, and model fit statistics.

```R
survival::survreg(formula = Surv(y, event) ~ x + m + x:m + c + 
    x:c + m:c, data = data, dist = "weibull")
```

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

### Print Summary of Regmedint Object

Source: https://kaz-yos.github.io/regmedint/reference/print.summary_regmedint.html

Use this function to print a detailed summary of the mediation analysis results from a regmedint object. It displays information about the mediator and outcome models, along with the mediation effect estimates.

```r
print(summary(regmedint_obj))
```
Tokens:
Raw