Package 'EventStudy'

Description

Computes adjusted p-values for AAR and CAAR test statistics across the event window, correcting for the multiple comparisons problem. Supports all methods available in p.adjust.

Usage

adjust_p_values(task, method = "BH", stat_name = "CSectT", group = NULL)

Arguments

Value

A tibble with columns from the original test statistic result plus p_raw_aar, p_adj_aar, p_raw_caar, p_adj_caar.

See Also

Other eventstudy-statistics: ARTTest, BHARTTest, BMPTest, CARTTest, CSectTTest, CalendarTimePortfolioTest, GeneralizedSignTest, KolariPynnonenTest, MultiEventStatisticsSet, PatellZTest, RankTest, SignTest, SingleEventStatisticsSet, StatisticsSetBase, TestStatisticBase, bootstrap_test(), car_by_group(), car_quantiles(), cross_sectional_regression(), model_diagnostics(), pretrend_test(), simulate_event_study(), validate_task()

Description

A provider that issues POST {base_url}/v1/messages against the native Anthropic Messages API. The request carries the mandatory max_tokens field and the anthropic-version header; when a schema is supplied it adds a tool-use input_schema block (tools + tool_choice) to obtain structured output, and the response extractor prefers that tool call's structured input while falling back to the first text block – so the provider never crashes when the model replies with plain text instead of a tool call.

The API key is resolved at CALL time from ANTHROPIC_API_KEY (never at construction, never stored on the object) and attached with req_headers_redacted("x-api-key" = key), which redacts the key in every print/error path. Note req_auth_bearer_token does NOT redact an x-api-key header – the redacted-headers helper is mandatory here. A missing key, transport/timeout failure, non-2xx status, malformed body, or missing completion text each degrades to exactly one warning() plus an 'es_provider_response' with text = NA_character_ – it never crashes the session and never returns a fabricated completion.

httr2 is required only for this provider and is guarded by requireNamespace() at the top of complete(), so the package installs and R CMD checks cleanly with httr2 absent.

Super class

ProviderBase -> AnthropicProvider

Public fields

Methods

Public methods

• AnthropicProvider$new()

• AnthropicProvider$complete()

• AnthropicProvider$clone()

AnthropicProvider$new()

Construct an AnthropicProvider. Stores non-secret config only; the API key is resolved at call time inside complete().

Usage

AnthropicProvider$new(
  model,
  base_url = "https://api.anthropic.com",
  max_tokens = 1024L,
  ...
)

Arguments

AnthropicProvider$complete()

Complete a prompt via POST {base_url}/v1/messages. Resolves the key at call time; on a missing key or any HTTP/parse failure returns one warning + NA. Structured output is OPTIONAL: when schema is supplied a tool-use input_schema block is added and the extractor prefers the tool call's input, falling back to the first text block.

Usage

AnthropicProvider$complete(prompt, schema = NULL, ...)

Arguments

Returns

An 'es_provider_response' (see ProviderBase$complete).

AnthropicProvider$clone()

The objects of this class are cloneable with this method.

Usage

AnthropicProvider$clone(deep = FALSE)

Arguments

See Also

Other eventstudy-advisor: CustomProvider, OpenAICompatProvider, ProviderBase, es_advise(), es_diagnostics(), es_kb(), flag_robustness(), provider(), recommend_stat()

Examples

## Not run: 
# Reads ANTHROPIC_API_KEY from the environment at call time:
p <- AnthropicProvider$new(model = "claude-opus-4-8")
p$complete("Summarise these event-study diagnostics")

# Structured output via a tool-use input_schema:
schema <- list(type = "object",
               properties = list(advice = list(type = "string")))
p$complete("Recommend a test statistic", schema = schema)

## End(Not run)

Description

The AR t-test is a statistical method used to determine whether the abnormal return of a security on a specific day is significantly different from zero. This test helps researchers identify whether the event of interest has a significant impact on the security's return at a particular point in time.

See also https://eventstudy.de/statistics/ar_car_statistics.html

Super class

TestStatisticBase -> ARTTest

Public fields

Methods

Public methods

• ARTTest$compute()

• ARTTest$clone()

ARTTest$compute()

Computes the test AR test statistics for a single event.

Usage

ARTTest$compute(data_tbl, model)

Arguments

ARTTest$clone()

The objects of this class are cloneable with this method.

Usage

ARTTest$clone(deep = FALSE)

Arguments

See Also

Other eventstudy-statistics: BHARTTest, BMPTest, CARTTest, CSectTTest, CalendarTimePortfolioTest, GeneralizedSignTest, KolariPynnonenTest, MultiEventStatisticsSet, PatellZTest, RankTest, SignTest, SingleEventStatisticsSet, StatisticsSetBase, TestStatisticBase, adjust_p_values(), bootstrap_test(), car_by_group(), car_quantiles(), cross_sectional_regression(), model_diagnostics(), pretrend_test(), simulate_event_study(), validate_task()

Description

Implements Buy-and-Hold Abnormal Returns for long-horizon event studies. BHAR compounds returns over the event window instead of summing:

$BHAR_i = \prod(1 + R_{i,t}) - \prod(1 + R_{benchmark,t})$

The benchmark is the market/index return by default. This model is appropriate for long-horizon studies (months/years) where compounding effects matter.

Super class

ModelBase -> BHARModel

Public fields

Methods

Public methods

• BHARModel$fit()

• BHARModel$abnormal_returns()

• BHARModel$clone()

BHARModel$fit()

Fit the BHAR model. Computes estimation window statistics.

Usage

BHARModel$fit(data_tbl)

Arguments

BHARModel$abnormal_returns()

Calculate abnormal returns using buy-and-hold compounding.

Usage

BHARModel$abnormal_returns(data_tbl)

Arguments

BHARModel$clone()

The objects of this class are cloneable with this method.

Usage

BHARModel$clone(deep = FALSE)

Arguments

See Also

Other eventstudy-models: Carhart4FactorModel, ComparisonPeriodMeanAdjustedModel, DCCGARCHModel, FamaFrench3FactorModel, FamaFrench5FactorModel, GARCHModel, LinearFactorModel, LogReturn, MarketAdjustedModel, MarketModel, ModelBase, ReturnCalculation, RollingWindowModel, SimpleReturn, VolatilityModel, VolumeModel

Description

Tests whether the BHAR for a single event is significantly different from zero. The BHAR is the difference between compounded firm returns and compounded benchmark returns over the event window.

Super class

TestStatisticBase -> BHARTTest

Public fields

Methods

Public methods

• BHARTTest$compute()

• BHARTTest$clone()

BHARTTest$compute()

Computes the BHAR t test for a single event.

Usage

BHARTTest$compute(data_tbl, model)

Arguments

BHARTTest$clone()

The objects of this class are cloneable with this method.

Usage

BHARTTest$clone(deep = FALSE)

Arguments

See Also

Other eventstudy-statistics: ARTTest, BMPTest, CARTTest, CSectTTest, CalendarTimePortfolioTest, GeneralizedSignTest, KolariPynnonenTest, MultiEventStatisticsSet, PatellZTest, RankTest, SignTest, SingleEventStatisticsSet, StatisticsSetBase, TestStatisticBase, adjust_p_values(), bootstrap_test(), car_by_group(), car_quantiles(), cross_sectional_regression(), model_diagnostics(), pretrend_test(), simulate_event_study(), validate_task()

Description

Standardized cross-sectional test that is robust to event-induced variance increases. The BMP test standardizes abnormal returns by each event's MODEL sigma (the estimation-window residual standard deviation, i.e. model$statistics$sigma) – NOT by the forecast-error-corrected sigma – then applies a cross-sectional t-test to these standardized residuals.

Super class

TestStatisticBase -> BMPTest

Public fields

Methods

Public methods

• BMPTest$compute()

• BMPTest$clone()

BMPTest$compute()

Computes the BMP standardized cross-sectional test.

Usage

BMPTest$compute(data_tbl, model)

Arguments

BMPTest$clone()

The objects of this class are cloneable with this method.

Usage

BMPTest$clone(deep = FALSE)

Arguments

See Also

Other eventstudy-statistics: ARTTest, BHARTTest, CARTTest, CSectTTest, CalendarTimePortfolioTest, GeneralizedSignTest, KolariPynnonenTest, MultiEventStatisticsSet, PatellZTest, RankTest, SignTest, SingleEventStatisticsSet, StatisticsSetBase, TestStatisticBase, adjust_p_values(), bootstrap_test(), car_by_group(), car_quantiles(), cross_sectional_regression(), model_diagnostics(), pretrend_test(), simulate_event_study(), validate_task()

Description

Computes bootstrap p-values for AAR and CAAR test statistics using the wild bootstrap approach. Per-firm random weights preserve the cross-sectional dependence structure while randomizing the sign of abnormal returns under the null hypothesis.

Usage

bootstrap_test(
  task,
  n_boot = 999L,
  weight_type = "rademacher",
  statistic = "both",
  group = NULL,
  seed = NULL
)

Arguments

Value

A tibble with columns: relative_index, observed_aar, observed_caar, boot_p_aar, boot_p_caar.

See Also

Other eventstudy-statistics: ARTTest, BHARTTest, BMPTest, CARTTest, CSectTTest, CalendarTimePortfolioTest, GeneralizedSignTest, KolariPynnonenTest, MultiEventStatisticsSet, PatellZTest, RankTest, SignTest, SingleEventStatisticsSet, StatisticsSetBase, TestStatisticBase, adjust_p_values(), car_by_group(), car_quantiles(), cross_sectional_regression(), model_diagnostics(), pretrend_test(), simulate_event_study(), validate_task()

Description

Calculate test statistics

Usage

calculate_statistics(task, parameter_set)

Arguments

Value

task

See Also

run_event_study, prepare_event_study, fit_model

Other eventstudy-pipeline: EventStudyTask, ParameterSet, fit_model(), prepare_event_study(), run_event_study()

Description

Aggregates event-firm returns into calendar-time portfolios and tests whether the portfolio intercept (alpha) is significantly different from zero, using the Brown and Warner (1980, 1985) crude-dependence-adjustment: the standard deviation of the ESTIMATION-window cross-event average abnormal return (AAR) series is used as the (calendar-)time-series standard deviation, so the denominator is independent of the event window and of any event-window shock magnitude.

For each relative event day, the test forms an equal-weighted portfolio of all event firms' abnormal returns and computes $caltime_t = AAR_t / sd(AAR_{estimation})$, with degrees of freedom n_estimation_days - 1 (the number of finite estimation-window AAR observations), exposed as attr(result, "caltime_df").

Super class

TestStatisticBase -> CalendarTimePortfolioTest

Public fields

Methods

Public methods

• CalendarTimePortfolioTest$compute()

• CalendarTimePortfolioTest$clone()

CalendarTimePortfolioTest$compute()

Computes the calendar-time portfolio test.

Usage

CalendarTimePortfolioTest$compute(data_tbl, model)

Arguments

CalendarTimePortfolioTest$clone()

The objects of this class are cloneable with this method.

Usage

CalendarTimePortfolioTest$clone(deep = FALSE)

Arguments

References

Brown, S. J. and Warner, J. B. (1980). Measuring security price performance. Journal of Financial Economics, 8(3), 205–258.

Brown, S. J. and Warner, J. B. (1985). Using daily stock returns: The case of event studies. Journal of Financial Economics, 14(1), 3–31.

See Also

Other eventstudy-statistics: ARTTest, BHARTTest, BMPTest, CARTTest, CSectTTest, GeneralizedSignTest, KolariPynnonenTest, MultiEventStatisticsSet, PatellZTest, RankTest, SignTest, SingleEventStatisticsSet, StatisticsSetBase, TestStatisticBase, adjust_p_values(), bootstrap_test(), car_by_group(), car_quantiles(), cross_sectional_regression(), model_diagnostics(), pretrend_test(), simulate_event_study(), validate_task()

Description

Performs a t-test (two groups) or ANOVA (3+ groups) to test whether CARs differ significantly across groups.

Usage

car_by_group(task, group_var = "group", car_window = NULL)

Arguments

Value

A list with test results and group-level summary statistics.

See Also

Other eventstudy-statistics: ARTTest, BHARTTest, BMPTest, CARTTest, CSectTTest, CalendarTimePortfolioTest, GeneralizedSignTest, KolariPynnonenTest, MultiEventStatisticsSet, PatellZTest, RankTest, SignTest, SingleEventStatisticsSet, StatisticsSetBase, TestStatisticBase, adjust_p_values(), bootstrap_test(), car_quantiles(), cross_sectional_regression(), model_diagnostics(), pretrend_test(), simulate_event_study(), validate_task()

Description

Compute quantiles of the CAR distribution across events.

Usage

car_quantiles(task, probs = c(0.05, 0.25, 0.5, 0.75, 0.95), car_window = NULL)

Arguments

Value

A named numeric vector of quantiles.

See Also

Other eventstudy-statistics: ARTTest, BHARTTest, BMPTest, CARTTest, CSectTTest, CalendarTimePortfolioTest, GeneralizedSignTest, KolariPynnonenTest, MultiEventStatisticsSet, PatellZTest, RankTest, SignTest, SingleEventStatisticsSet, StatisticsSetBase, TestStatisticBase, adjust_p_values(), bootstrap_test(), car_by_group(), cross_sectional_regression(), model_diagnostics(), pretrend_test(), simulate_event_study(), validate_task()

Description

Implements the Carhart (1997) four-factor model, which extends the Fama-French three-factor model with a momentum factor:

$R_i - R_f = \alpha + \beta_m (R_m - R_f) + \beta_s SMB + \beta_h HML + \beta_{mom} MOM + \epsilon$

Requires columns: excess_return, market_excess, smb, hml, mom.

Super classes

ModelBase -> LinearFactorModel -> Carhart4FactorModel

Public fields

Methods

Public methods

• Carhart4FactorModel$new()

• Carhart4FactorModel$abnormal_returns()

• Carhart4FactorModel$clone()

Carhart4FactorModel$new()

Create a new Carhart4FactorModel.

Usage

Carhart4FactorModel$new(use_hac = FALSE, hac_lag = NULL)

Arguments

Carhart4FactorModel$abnormal_returns()

Calculate abnormal returns using the four-factor model.

Usage

Carhart4FactorModel$abnormal_returns(data_tbl)

Arguments

Carhart4FactorModel$clone()

The objects of this class are cloneable with this method.

Usage

Carhart4FactorModel$clone(deep = FALSE)

Arguments

See Also

Other eventstudy-models: BHARModel, ComparisonPeriodMeanAdjustedModel, DCCGARCHModel, FamaFrench3FactorModel, FamaFrench5FactorModel, GARCHModel, LinearFactorModel, LogReturn, MarketAdjustedModel, MarketModel, ModelBase, ReturnCalculation, RollingWindowModel, SimpleReturn, VolatilityModel, VolumeModel

Description

The CAR t-test is a statistical method used to determine whether the cumulative abnormal return of a security over an event window is significantly different from zero. This test helps researchers identify whether the event of interest has a significant impact on the security's return over the entire event window, considering the cumulative effects of the event.

See also https://eventstudy.de/statistics/ar_car_statistics.html

Super class

TestStatisticBase -> CARTTest

Public fields

Methods

Public methods

• CARTTest$compute()

• CARTTest$clone()

CARTTest$compute()

Computes the test CAR test statistics for a single event.

Usage

CARTTest$compute(data_tbl, model)

Arguments

CARTTest$clone()

The objects of this class are cloneable with this method.

Usage

CARTTest$clone(deep = FALSE)

Arguments

See Also

Other eventstudy-statistics: ARTTest, BHARTTest, BMPTest, CSectTTest, CalendarTimePortfolioTest, GeneralizedSignTest, KolariPynnonenTest, MultiEventStatisticsSet, PatellZTest, RankTest, SignTest, SingleEventStatisticsSet, StatisticsSetBase, TestStatisticBase, adjust_p_values(), bootstrap_test(), car_by_group(), car_quantiles(), cross_sectional_regression(), model_diagnostics(), pretrend_test(), simulate_event_study(), validate_task()

Description

The Comparison Period Mean Adjusted Model is another relatively simple approach used in event studies to estimate the expected returns of a stock and calculate its abnormal returns during an event window. This model is based on the assumption that a stock's expected return during the event window is equal to its average return during a comparison period (typically a pre-event period). This model is particularly useful when researchers want to control for a stock's historical performance and do not wish to rely on market return data.

Super class

ModelBase -> ComparisonPeriodMeanAdjustedModel

Public fields

Methods

Public methods

• ComparisonPeriodMeanAdjustedModel$fit()

• ComparisonPeriodMeanAdjustedModel$abnormal_returns()

• ComparisonPeriodMeanAdjustedModel$clone()

ComparisonPeriodMeanAdjustedModel$fit()

Fit the model with given data.

Usage

ComparisonPeriodMeanAdjustedModel$fit(data_tbl)

Arguments

ComparisonPeriodMeanAdjustedModel$abnormal_returns()

Calculate the abnormal returns with given data.

Usage

ComparisonPeriodMeanAdjustedModel$abnormal_returns(data_tbl)

Arguments

ComparisonPeriodMeanAdjustedModel$clone()

The objects of this class are cloneable with this method.

Usage

ComparisonPeriodMeanAdjustedModel$clone(deep = FALSE)

Arguments

See Also

Other eventstudy-models: BHARModel, Carhart4FactorModel, DCCGARCHModel, FamaFrench3FactorModel, FamaFrench5FactorModel, GARCHModel, LinearFactorModel, LogReturn, MarketAdjustedModel, MarketModel, ModelBase, ReturnCalculation, RollingWindowModel, SimpleReturn, VolatilityModel, VolumeModel

Description

Regress cumulative abnormal returns (CARs) on firm characteristics to explain cross-sectional variation in event effects. Supports OLS with heteroskedasticity-consistent (HC) standard errors.

Usage

cross_sectional_regression(
  task,
  formula,
  data,
  car_window = NULL,
  robust = TRUE
)

Arguments

Value

A list with class "es_cross_sectional" containing:

model

The fitted lm object

coefficients

Coefficient table with (robust) standard errors

r_squared

R-squared of the regression

n_obs

Number of observations

car_data

The merged CAR + characteristics data

See Also

Other eventstudy-statistics: ARTTest, BHARTTest, BMPTest, CARTTest, CSectTTest, CalendarTimePortfolioTest, GeneralizedSignTest, KolariPynnonenTest, MultiEventStatisticsSet, PatellZTest, RankTest, SignTest, SingleEventStatisticsSet, StatisticsSetBase, TestStatisticBase, adjust_p_values(), bootstrap_test(), car_by_group(), car_quantiles(), model_diagnostics(), pretrend_test(), simulate_event_study(), validate_task()

Description

The Cross-Sectional Test (CSect T) is a statistical tool employed in event studies to evaluate the null hypothesis that the average abnormal return at the event date is zero. The test statistic is distributed as $t_{N-1}$, where N is the number of events in that group.

See also https://eventstudy.de/statistics/aar_caar_statistics.html

Super class

TestStatisticBase -> CSectTTest

Public fields

Methods

Public methods

• CSectTTest$compute()

• CSectTTest$clone()

CSectTTest$compute()

Computes the AAR/CAAR cross-sectional t test statistics.

Usage

CSectTTest$compute(data_tbl, model)

Arguments

CSectTTest$clone()

The objects of this class are cloneable with this method.

Usage

CSectTTest$clone(deep = FALSE)

Arguments

See Also

Other eventstudy-statistics: ARTTest, BHARTTest, BMPTest, CARTTest, CalendarTimePortfolioTest, GeneralizedSignTest, KolariPynnonenTest, MultiEventStatisticsSet, PatellZTest, RankTest, SignTest, SingleEventStatisticsSet, StatisticsSetBase, TestStatisticBase, adjust_p_values(), bootstrap_test(), car_by_group(), car_quantiles(), cross_sectional_regression(), model_diagnostics(), pretrend_test(), simulate_event_study(), validate_task()

Description

A provider that wraps a user-supplied function(prompt, schema, ...) -> list | character. This is the offline end-to-end seam and the escape hatch for backends the built-in HTTP providers do not cover. It uses NO network and needs neither httr2 nor jsonlite.

The user function is run inside tryCatch: if it errors, the provider degrades to exactly one warning() plus an 'es_provider_response' with text = NA_character_ – it never crashes the session.

Super class

ProviderBase -> CustomProvider

Methods

Public methods

• CustomProvider$new()

• CustomProvider$complete()

• CustomProvider$clone()

CustomProvider$new()

Construct a CustomProvider.

Usage

CustomProvider$new(fn, model = NULL, ...)

Arguments

CustomProvider$complete()

Run the wrapped user function and wrap its result in an 'es_provider_response'. A throwing function degrades to one warning + NA.

Usage

CustomProvider$complete(prompt, schema = NULL, ...)

Arguments

Returns

An 'es_provider_response' (see ProviderBase$complete).

CustomProvider$clone()

The objects of this class are cloneable with this method.

Usage

CustomProvider$clone(deep = FALSE)

Arguments

See Also

Other eventstudy-advisor: AnthropicProvider, OpenAICompatProvider, ProviderBase, es_advise(), es_diagnostics(), es_kb(), flag_robustness(), provider(), recommend_stat()

Examples

# In-process, no network: the user function supplies the completion text.
p <- CustomProvider$new(function(prompt, schema) "canned advice")
res <- p$complete("Summarise these diagnostics")
res$text
res$source

Description

Event study model using Dynamic Conditional Correlation GARCH for time-varying beta estimation. Requires the rmgarch package. The bivariate DCC-GARCH model captures both time-varying volatility and time-varying correlation between firm and market returns, yielding a time-varying beta: $\beta_t = Cov(R_{firm}, R_{market})_t / Var(R_{market})_t$.

Super class

ModelBase -> DCCGARCHModel

Public fields

Methods

Public methods

• DCCGARCHModel$new()

• DCCGARCHModel$fit()

• DCCGARCHModel$abnormal_returns()

• DCCGARCHModel$clone()

DCCGARCHModel$new()

Create a new DCCGARCHModel.

Usage

DCCGARCHModel$new(garch_order = c(1, 1), dcc_order = c(1, 1))

Arguments

DCCGARCHModel$fit()

Fit the DCC-GARCH model on the estimation window.

Usage

DCCGARCHModel$fit(data_tbl)

Arguments

DCCGARCHModel$abnormal_returns()

Calculate abnormal returns using the last conditional beta.

Usage

DCCGARCHModel$abnormal_returns(data_tbl)

Arguments

DCCGARCHModel$clone()

The objects of this class are cloneable with this method.

Usage

DCCGARCHModel$clone(deep = FALSE)

Arguments

See Also

Other eventstudy-models: BHARModel, Carhart4FactorModel, ComparisonPeriodMeanAdjustedModel, FamaFrench3FactorModel, FamaFrench5FactorModel, GARCHModel, LinearFactorModel, LogReturn, MarketAdjustedModel, MarketModel, ModelBase, ReturnCalculation, RollingWindowModel, SimpleReturn, VolatilityModel, VolumeModel

Description

The degenerate-input contract defines how all EventStudy return models behave when the estimation data is degenerate. Two modes are supported:

Lenient (default): The model sets is_fitted = FALSE, emits exactly one warning() per (event_id, firm_symbol) per fit call, and propagates NA through all abnormal returns and downstream statistics. No event is silently dropped; zeros are never substituted for NA.

Strict: The model raises a descriptive stop() error naming the component, event_id, and firm_symbol, plus the specific reason for the degeneracy.

Configuration:

• Via ParameterSet: ParameterSet$new(degenerate_handling = "strict")

• Via package option: options(EventStudy.degenerate_handling = "strict")

The ParameterSet field takes precedence over the package option; if neither is set, the default "lenient" mode is used.

Degenerate conditions covered:

• Fewer than 2 finite observations in the estimation window (insufficient observations for OLS).

• Zero or near-zero variance in index returns (sd < .Machine$double.eps), making OLS estimation undefined.

• Single-event group (relevant for multi-event statistics; applied in Phase 2).

• NA propagation from upstream pipeline steps.

NA propagation semantics: When is_fitted = FALSE, model$abnormal_returns() returns a tibble with abnormal_returns = NA_real_ for all rows. All downstream test statistics that depend on fitted models then receive NA inputs and propagate NA to their outputs. The event is retained in the output tibble – it is never silently dropped.

Multi-event exclusion (2026-09-24 re-evaluation, item A2): A single-event's NA propagation above is not enough for cumulative (CAR-based) multi-event statistics (CSectT, PatellZ, Sign, GeneralizedSign, BMP, KolariPynnonen): an event with ZERO finite event-window abnormal returns must be EXCLUDED from every such statistic's group, not merely NA-propagated, because a cumulative sum that coalesce()s a fully-degenerate event's abnormal returns to 0 would silently understate the true cross-sectional dispersion. The exclusion is applied once per group (see .exclude_all_na_events) before any statistic is computed, and reported exactly once: silently if the excluded event's model already emitted the one contract warning guaranteed by CONTRACT-04 (an unfitted ModelBase instance), or via a single additional warning naming the excluded event_id(s) otherwise. Strict mode errors instead. This exclusion rule leaves the pre-existing STATS-03 convention for a PARTIAL gap unchanged: an event with at least one finite event-window abnormal return, but a missing value on some individual day, still contributes 0 to that event's CAR on the missing day(s) via coalesce(abnormal_returns, 0).

Details

Degenerate-Input Contract for EventStudy Models

See Also

ParameterSet, MarketModel

Description

A small, frozen dataset bundling daily prices for four German automakers and the DAX benchmark index around the 2015 "dieselgate" emissions scandal, ready to drive a complete multi-group event study (prepare_event_study() -> fit_model() -> calculate_statistics()).

Usage

data(dieselgate)

Format

A named list with four elements:

firm

A tibble of daily prices for all four automakers combined, with columns symbol (one of "VOW.DE", "PAH3.DE", "BMW.DE", "MBG.DE"), date (character, "%d.%m.%Y" format), and adjusted (numeric adjusted close). Rows for all firms are stacked (1 440 rows total).

index

A tibble of DAX ("^GDAXI") daily prices with the same symbol / date / adjusted columns, used as the benchmark / reference market for all four events.

request

A four-row tibble giving the event-study request specifications, one row per firm, with the nine columns expected by EventStudyTask: event_id (1L to 4L), firm_symbol, index_symbol, event_date ("18.09.2015"), group ("VW Group" for VOW.DE/PAH3.DE, "Other" for BMW.DE/MBG.DE), event_window_start (-10), event_window_end (10), shift_estimation_window (-11), and estimation_window_length (250). event_id = 1 is VOW.DE for backward compatibility.

meta

A list of provenance metadata: firm_tickers (character vector of all four tickers), groups (named list mapping group labels to tickers), index_ticker, event_date, from, to, source, access_date, and note.

Details

The event is the U.S. Environmental Protection Agency's Notice of Violation issued to Volkswagen on 2015-09-18 (a Friday); the share-price crash lands on the following trading days. The dataset covers two groups: the "VW Group" (VOW.DE, PAH3.DE – directly implicated firms) and "Other" (BMW.DE, MBG.DE – peer automakers). The bundled window layout uses a 250-trading-day estimation window ending 11 days before the event and an event window of [-10, +10] trading days.

Fitting a market model on the "VW Group" events produces a strongly negative cumulative average abnormal return (CAAR approximately -39 roughly -17% and -13% average abnormal returns on the first two trading days after the disclosure, while the "Other" peer automakers show near-zero CAAR (approximately +1%), illustrating the idiosyncratic nature of the shock.

Firms:

• VOW.DE – Volkswagen AG ordinary shares (Xetra), event_id = 1

• PAH3.DE – Porsche Automobil Holding SE (Xetra), event_id = 2

• BMW.DE – BMW AG (Xetra), event_id = 3

• MBG.DE – Mercedes-Benz Group AG (Xetra), event_id = 4

Groups: "VW Group" (VOW.DE, PAH3.DE) vs "Other" (BMW.DE, MBG.DE). Benchmark: DAX performance index (ticker ^GDAXI). Date range: 2014-06-01 to 2015-11-01.

Source

Yahoo Finance daily adjusted prices, retrieved 2026-09-04 via the package's own download_stock_data. This is a small illustrative sample bundled for academic / demonstration use only; see data-raw/dieselgate.R for the reproducible fetch script.

Examples

data(dieselgate)

# Build a multi-group task and run the full pipeline
task <- EventStudyTask$new(dieselgate$firm, dieselgate$index,
                           dieselgate$request)
task <- run_event_study(task, ParameterSet$new())

# Single-firm: VW crash (event_id = 1)
task$get_car(1L)

# Multi-group: CAAR comparison
vw_caar    <- task$aar_caar_tbl[task$aar_caar_tbl$group == "VW Group", ]$CSectT[[1]]
other_caar <- task$aar_caar_tbl[task$aar_caar_tbl$group == "Other", ]$CSectT[[1]]
tail(vw_caar[, c("relative_index", "caar", "caar_t")], 1)
tail(other_caar[, c("relative_index", "caar", "caar_t")], 1)

Description

Downloads Fama-French factor data from the Kenneth French Data Library. No external package dependencies required (uses base R download + CSV parsing).

Usage

download_factor_data(
  model = c("ff3", "ff5", "mom"),
  frequency = c("daily", "monthly"),
  format_for_task = TRUE
)

Arguments

Value

A tibble with factor data.

Description

Downloads risk-free rate data from the Kenneth French Data Library (extracted from the Fama-French factor files).

Usage

download_risk_free_rate(
  frequency = c("daily", "monthly"),
  source = "french",
  format_for_task = TRUE
)

Arguments

Value

A tibble with date and risk_free_rate columns.

Description

Downloads historical stock price data for specified symbols. Uses tidyquant if available, otherwise falls back to quantmod.

Usage

download_stock_data(
  symbols,
  from,
  to = Sys.Date(),
  source = "yahoo",
  format_for_task = TRUE
)

Arguments

Value

A tibble with stock data.

Description

A small, frozen dataset bundling daily prices for three U.S. large-cap firms and the S&P 500 benchmark around the first-calendar-quarter 2023 (Jan-Mar) earnings announcements, reported late April / early May 2023, ready to drive a complete event study pipeline (prepare_event_study() -> fit_model() -> calculate_statistics()).

Usage

data(earnings_surprises)

Format

A named list with four elements:

firm

A tibble of daily prices for all three firms combined, with columns symbol (one of "AAPL", "MSFT", "GOOGL"), date (character, "%d.%m.%Y" format), and adjusted (numeric adjusted close). Rows for all firms are stacked (813 rows total).

index

A tibble of S&P 500 ("^GSPC") daily prices with the same symbol / date / adjusted columns, used as the benchmark for all three events.

request

A three-row tibble giving the event-study request specifications, one row per firm, with the nine columns expected by EventStudyTask: event_id (1L to 3L), firm_symbol, index_symbol, event_date ("04.05.2023" for AAPL, "25.04.2023" for MSFT and GOOGL), group ("Earnings Beat" for all firms), event_window_start (-5), event_window_end (5), shift_estimation_window (-6), and estimation_window_length (200).

meta

A list of provenance metadata: firm_tickers, index_ticker, event_dates, from, to, source, access_date, and note.

Details

All three firms beat consensus EPS estimates for their respective January-to-March 2023 quarters: Apple Inc. reported on 2023-05-04 (its fiscal Q2 FY2023, which runs Jan-Mar) and beat by approximately 8%, driving a strong next-day return; Microsoft Corporation reported on 2023-04-25 (its fiscal Q3 FY2023, which runs Jan-Mar), beating cloud (Azure) estimates with a roughly +7% next-day response; Alphabet Inc. reported on 2023-04-25 (Q1 CY2023, Jan-Mar), with advertising revenue exceeding expectations. The bundled window layout uses a 200-trading-day estimation window ending 6 days before each event and an event window of [-5, +5] trading days. Running a market model on this single-group panel produces a positive cumulative average abnormal return (CAAR) over the event window, reflecting the shared earnings-beat signal across all three firms.

Firms:

• AAPL – Apple Inc. (NASDAQ), event_id = 1

• MSFT – Microsoft Corporation (NASDAQ), event_id = 2

• GOOGL – Alphabet Inc. Class A (NASDAQ), event_id = 3

Group: "Earnings Beat" (all firms). Benchmark: S&P 500 index (ticker ^GSPC). Date range: 2022-06-01 to 2023-06-30.

Source

Yahoo Finance daily adjusted prices, retrieved 2026-09-05 via the package's own download_stock_data. This is a small illustrative sample bundled for academic / demonstration use only; see data-raw/earnings_surprises.R for the reproducible fetch script.

Examples

data(earnings_surprises)

# Build task and run the full pipeline
task <- EventStudyTask$new(earnings_surprises$firm,
                           earnings_surprises$index,
                           earnings_surprises$request)
task <- run_event_study(task, ParameterSet$new())

# Multi-event: AAR/CAAR across all firms
caar_tbl <- task$aar_caar_tbl$CSectT[[1]]
tail(caar_tbl[, c("relative_index", "caar", "caar_t")], 1)

Description

Produces a grounded Advice S3 object by routing through a task-type dispatch, calling an optional LLM provider, parsing the JSON response, and running the runtime grounding guard – which drops any recommendation whose evidence[] cites a diagnostic key absent from the computed diagnostics or a value mismatching beyond numeric tolerance.

Usage

es_advise(
  diagnostics,
  task_type,
  provider = NULL,
  model = NULL,
  section_hint = NULL,
  ...
)

Arguments

Details

Grounding guarantee: Every returned recommendation is provably tied to a value the package actually computed (es_diagnostics()). The guard is enforced in R, independent of the prompt (ADV-04).

Task type routing:

recommend_stat, flag_robustness

No provider: returns the Phase 5 es_advice object (offline KB path – deterministic, is_deterministic = TRUE). With provider: KB produces grounded evidence[], LLM adds prose; returns an Advice object (is_deterministic = FALSE).

interpret, recommend_model, design_discussion, report_writing

LLM-required: stop() when provider = NULL (ADV-06). With provider: LLM produces full advice; guard runs.

Failure discipline: Any provider failure, malformed JSON, or empty response degrades to one warning() + an empty Advice object – never a crash, never a fabricated result (mirrors .handle_degenerate()).

Value

For KB task types without a provider: an es_advice S3 object (Phase 5 offline path, is_deterministic = TRUE). For all other paths: an Advice S3 object with fields source, is_deterministic, task_type, interpretation, recommendations, caveats, n_dropped.

See Also

es_diagnostics, recommend_stat, flag_robustness, provider, run_event_study

Other eventstudy-advisor: AnthropicProvider, CustomProvider, OpenAICompatProvider, ProviderBase, es_diagnostics(), es_kb(), flag_robustness(), provider(), recommend_stat()

Examples

# Offline KB path (no LLM, no network, no credentials):

data(dieselgate)
task    <- EventStudyTask$new(dieselgate$firm, dieselgate$index, dieselgate$request)
task    <- run_event_study(task, ParameterSet$new())
diag    <- es_diagnostics(task)
advice_kb <- es_advise(diag, task_type = "recommend_stat")
print(advice_kb)   # es_advice S3


# LLM-grounded path (requires a network connection and provider credentials):
## Not run: 
p         <- provider("openai")
advice    <- es_advise(diag, task_type = "recommend_stat", provider = p)
print(advice)      # Advice S3 with grounding guarantee

## End(Not run)

Description

A named character vector of hex colours for EventStudy plots, anchored on the Okabe-Ito colorblind-safe (Color Universal Design) qualitative set with the EventStudy brand primary blue as the leading colour.

Usage

es_colours

Format

A named character vector of length 12. Every value is a six-digit hex colour (^#[0-9A-Fa-f]{6}$).

Details

Semantic roles: primary (main series line/point/fill), event (event-date marker), reference (zero lines, ACF baseline), ci_band (confidence ribbon fill; apply alpha at the geom level), and group1–group8 (qualitative multi-series palette in Okabe-Ito order).

See Also

theme_eventstudy, plot_event_study

Other eventstudy-plots: plot_car_distribution(), plot_diagnostics(), plot_event_study(), plot_stocks(), theme_eventstudy()

Description

Extracts already-computed statistical signals from a fitted EventStudyTask into a flat, JSON-ready S3 list. This is the always-available grounding foundation for the knowledge base and offline advice layer – it recomputes nothing; all signals already exist in the fitted task.

Usage

es_diagnostics(task, max_events = 20L)

Arguments

Value

A named list of class "es_diagnostics" with six sections:

meta

List: n_events_total (integer), n_events_shown (integer), n_events_summarized (integer), event_ids_shown (integer vector).

estimation_window

List of plain numeric vectors (length n_events_shown): r2, sigma, degree_of_freedom, shapiro_p, dw_stat, ljung_box_p, acf1. Each entry is NA_real_ when the model was not fitted or residuals are insufficient for the test.

event_window

List of plain numeric vectors (length n_events_shown): ar_t (last event-window day AR t-stat), ar_p (two-sided p-value), car_t (full-window CAR t-stat), car_p (two-sided p-value), final_car. All NA_real_ when the ART/CART columns are absent.

cross_sectional

List of scalars aggregated across ALL events: n_events (total), n_valid_events (fitted count), car_iqr, car_sd, n_overlap_pairs, any_overlap. Multi-event fields degrade to NA when task$aar_caar_tbl is NULL.

contract_state

List of logical/numeric vectors (length n_events_shown): is_fitted, na_ar_count, na_est_count, insufficient_obs, zero_var_index.

aggregate_summary

Named list summarising remainder events (those beyond max_events): n_summarized, mean_r2, median_r2, mean_final_car, n_fitted, n_degenerate. NULL when no events are summarised (all shown).

See Also

model_diagnostics, recommend_stat, flag_robustness, run_event_study

Other eventstudy-advisor: AnthropicProvider, CustomProvider, OpenAICompatProvider, ProviderBase, es_advise(), es_kb(), flag_robustness(), provider(), recommend_stat()

Description

Returns EVENTSTUDY_KB, the package-level pure-R list of rule records that maps diagnostic conditions to grounded methodological recommendations. Each rule carries a structured academic citation and can be evaluated against an es_diagnostics object.

Usage

es_kb()

Details

The KB is the correctness-critical layer consumed by recommend_stat and flag_robustness, and exported here so that Phase 7 can inject its contents into an LLM system prompt without accessing an internal package object.

KB-04 note: This function delivers the structure only – exported and serializable, ready for Phase 7 system-prompt injection. The actual prompt-injection behavior is a Phase 7 deliverable and is deliberately out of scope here.

Value

A named list of rule records, each with fields: id, category, condition, recommendation, citation (list of author/year/key/venue), and severity.

Note

Each rule's condition field is an R function closure and is therefore not JSON-serializable. Any consumer that serializes the KB (e.g. Phase 7 system-prompt injection) must drop the condition field from each rule record before encoding to JSON.

See Also

recommend_stat, flag_robustness, es_diagnostics

Other eventstudy-advisor: AnthropicProvider, CustomProvider, OpenAICompatProvider, ProviderBase, es_advise(), es_diagnostics(), flag_robustness(), provider(), recommend_stat()

Examples

kb <- es_kb()
length(kb)             # number of rules
kb[[1]]$id             # id of first rule
kb[[1]]$citation       # citation list

Description

Generates a complete event study report in a single call: deep-clones the task (non-mutation guarantee, REPORT-04), harvests diagnostics via es_diagnostics(), and delegates rendering to generate_report(). Returns the output file path(s) VISIBLY so the path prints at the REPL without an explicit print().

Usage

es_report(
  task,
  output_file = "event_study_report.html",
  format = "html",
  sections = c("exec_summary", "data_methods", "results", "diagnostics", "robustness",
    "references"),
  provider = NULL,
  title = "Event Study Report",
  author = NULL,
  confidence_level = 0.95,
  interactive = TRUE,
  verbose = getOption("eventstudy.verbose", TRUE),
  ...
)

Arguments

Details

The narrative is assembled ONCE inside generate_report() (NARR-01): es_report() does NOT call assemble_report_narrative() or es_advise() directly. A provider argument is forwarded to generate_report(), which assembles the narrative once before the format loop. When provider = NULL (default), the report is fully offline with no network or API key required.

Value

A named character vector of output file path(s), one per rendered format, returned visibly (the path prints at the REPL). Keyed by format name, e.g. c(html = "/tmp/report.html"). A single-format call returns a length-1 named vector; result[["html"]] and result[[1L]] both resolve.

See Also

generate_report, es_diagnostics, run_event_study

Other eventstudy-export: export_results(), generate_report(), tidy.EventStudyTask()

Examples

data(dieselgate)
task <- EventStudyTask$new(dieselgate$firm, dieselgate$index, dieselgate$request)
task <- run_event_study(task, ParameterSet$new())

# Offline single-format report written to a temporary directory
out  <- file.path(tempdir(), "event_study_report.html")
path <- es_report(task, output_file = out, format = "html")
path[["html"]]

Description

Estimate a panel event study using two-way fixed effects (TWFE) or dynamic TWFE. Returns event-time coefficient estimates suitable for event study plots.

Usage

estimate_panel_event_study(
  task,
  method = c("static_twfe", "dynamic_twfe", "sun_abraham", "callaway_santanna",
    "dechaisemartin_dhaultfoeuille", "borusyak_jaravel_spiess"),
  leads = 5,
  lags = 5,
  base_period = -1,
  cluster = NULL,
  verbose = getOption("eventstudy.verbose", TRUE),
  ...
)

Arguments

Value

The task with results populated, containing:

coefficients

Tibble of event-time coefficients with std errors

model

The fitted model object

method

The estimation method used

See Also

Other eventstudy-tasks: IntradayEventStudyTask, PanelEventStudyTask, SyntheticControlTask, estimate_synthetic_control(), nonparametric_intraday_test(), plot_panel_event_study(), plot_synthetic_control(), prepare_intraday_event_study(), sc_placebo_test()

Description

Estimate synthetic control weights by minimizing the pre-treatment mean squared prediction error. Weights are non-negative and sum to one.

Usage

estimate_synthetic_control(
  task,
  method = c("quadprog", "optim"),
  covariates = NULL,
  verbose = getOption("eventstudy.verbose", TRUE)
)

Arguments

Value

The task with results populated.

See Also

Other eventstudy-tasks: IntradayEventStudyTask, PanelEventStudyTask, SyntheticControlTask, estimate_panel_event_study(), nonparametric_intraday_test(), plot_panel_event_study(), plot_synthetic_control(), prepare_intraday_event_study(), sc_placebo_test()

Description

Policy: warn, never silently break.

Deprecated argument names and function names in EventStudy continue to work and emit exactly one deprecation warning per call, pointing the user to the replacement. Deprecated surfaces are never removed in a patch or minor release; removal (the "defunct" stage) is reserved for a future major version and will be announced in NEWS.md.

Mechanism: Every renamed public argument has an explicit old-name shim that calls .deprecate_arg() and then forwards the supplied value under the new name. The shim fires before any computation, so the old name is fully-equivalent to the new name for all valid inputs.

Warning source: Deprecation warnings always use base .Deprecated() so they work without any additional package dependency. When the optional lifecycle package is installed (Suggests), the warning is also routed through lifecycle::deprecate_warn() for richer IDE integration; lifecycle is never a hard Imports dependency.

NEWS discipline: Every deprecation and rename is documented in NEWS.md under the release heading in which it was introduced.

See Also

run_event_study, plot_stocks

Description

The shape-contract system locks the column names and types of the EventStudy pipeline's result tibbles against accidental structural drift. It is designed for development and CI use only.

Default: OFF. When the option is unset (the default) the entire shape-contract path is a strict no-op — every existing caller and the full test suite are completely unaffected.

Opt-in: options(EventStudy.shape_contracts = TRUE)

Philosophy (mirrors the degenerate-input contract): On a column-name or type mismatch the contract emits exactly one warning(), naming the context and the specific drift, and then returns invisibly. It never calls stop(). The correctly-shaped is_fitted = FALSE degenerate output (same column names, NA-propagated values) is treated as a valid shape and produces no warning.

Coverage:

• Single-event statistics tibbles: ART (ARTTest) and CART (CARTTest), including their is_fitted = FALSE degenerate variants.

• Multi-event AAR/CAAR statistics tibble: CSectT (CSectTTest) and all other multi-event result tibbles, including their is_fitted = FALSE degenerate variants.

Configuration:

• Via package option: options(EventStudy.shape_contracts = TRUE)

• Default is FALSE (off).

Details

Return-Shape Contracts for EventStudy Pipeline Results

See Also

degenerate-input-contract, ParameterSet

Description

Event Study Task

The Event Study task contains all necessary data for performing an event study. Furthermore, all calculations are saved in the internal dataframe named data_tbl.

Public fields

Active bindings

Methods

Public methods

• EventStudyTask$new()

• EventStudyTask$print()

• EventStudyTask$summary()

• EventStudyTask$get_ar()

• EventStudyTask$get_car()

• EventStudyTask$get_aar()

• EventStudyTask$get_model_stats()

• EventStudyTask$clone()

EventStudyTask$new()

Create a new EventStudyTask from stock data, reference market data, and an event request specification.

Usage

EventStudyTask$new(
  firm_stock_data_tbl,
  reference_tbl,
  request_tbl,
  factor_tbl = NULL
)

Arguments

EventStudyTask$print()

Print a summary of the EventStudyTask.

Usage

EventStudyTask$print(...)

EventStudyTask$summary()

Summarize the event study results.

Usage

EventStudyTask$summary()

Returns

A list with summary information about the event study results.

EventStudyTask$get_ar()

Extract abnormal returns for a single event.

Usage

EventStudyTask$get_ar(event_id = NULL)

Arguments

Returns

A tibble with abnormal returns for the event window.

EventStudyTask$get_car()

Extract cumulative abnormal returns for a single event.

Usage

EventStudyTask$get_car(event_id = NULL)

Arguments

Returns

A tibble with cumulative abnormal returns for the event window.

EventStudyTask$get_aar()

Extract average abnormal returns across events.

Usage

EventStudyTask$get_aar(group = NULL, stat_name = "CSectT")

Arguments

Returns

A tibble with AAR/CAAR results.

EventStudyTask$get_model_stats()

Extract model statistics for a single event.

Usage

EventStudyTask$get_model_stats(event_id = NULL)

Arguments

Returns

A list with model statistics.

EventStudyTask$clone()

The objects of this class are cloneable with this method.

Usage

EventStudyTask$clone(deep = FALSE)

Arguments

See Also

Other eventstudy-pipeline: ParameterSet, calculate_statistics(), fit_model(), prepare_event_study(), run_event_study()

Description

Export event study results to CSV, Excel, or LaTeX formats.

Usage

export_results(
  task,
  file,
  format = NULL,
  which = c("ar", "car", "aar", "model"),
  stat_name = "CSectT",
  ...
)

Arguments

Value

The file path (invisibly).

See Also

run_event_study, tidy.EventStudyTask

Other eventstudy-export: es_report(), generate_report(), tidy.EventStudyTask()

Description

Implements the Fama and French (1993) three-factor model:

$R_i - R_f = \alpha + \beta_m (R_m - R_f) + \beta_s SMB + \beta_h HML + \epsilon$

The data must contain columns: excess_return (firm return minus risk-free), market_excess (market return minus risk-free), smb, and hml. These can be joined via a factor table in EventStudyTask.

Super classes

ModelBase -> LinearFactorModel -> FamaFrench3FactorModel

Public fields

Methods

Public methods

• FamaFrench3FactorModel$new()

• FamaFrench3FactorModel$abnormal_returns()

• FamaFrench3FactorModel$clone()

FamaFrench3FactorModel$new()

Create a new FamaFrench3FactorModel.

Usage

FamaFrench3FactorModel$new(use_hac = FALSE, hac_lag = NULL)

Arguments

FamaFrench3FactorModel$abnormal_returns()

Calculate abnormal returns using the three-factor model.

Usage

FamaFrench3FactorModel$abnormal_returns(data_tbl)

Arguments

FamaFrench3FactorModel$clone()

The objects of this class are cloneable with this method.

Usage

FamaFrench3FactorModel$clone(deep = FALSE)

Arguments

See Also

Other eventstudy-models: BHARModel, Carhart4FactorModel, ComparisonPeriodMeanAdjustedModel, DCCGARCHModel, FamaFrench5FactorModel, GARCHModel, LinearFactorModel, LogReturn, MarketAdjustedModel, MarketModel, ModelBase, ReturnCalculation, RollingWindowModel, SimpleReturn, VolatilityModel, VolumeModel

Description

Implements the Fama and French (2015) five-factor model:

$R_i - R_f = \alpha + \beta_m (R_m - R_f) + \beta_s SMB + \beta_h HML + \beta_r RMW + \beta_c CMA + \epsilon$

Requires columns: excess_return, market_excess, smb, hml, rmw, cma.

Super classes

ModelBase -> LinearFactorModel -> FamaFrench5FactorModel

Public fields

Methods

Public methods

• FamaFrench5FactorModel$new()

• FamaFrench5FactorModel$abnormal_returns()

• FamaFrench5FactorModel$clone()

FamaFrench5FactorModel$new()

Create a new FamaFrench5FactorModel.

Usage

FamaFrench5FactorModel$new(use_hac = FALSE, hac_lag = NULL)

Arguments

FamaFrench5FactorModel$abnormal_returns()

Calculate abnormal returns using the five-factor model.

Usage

FamaFrench5FactorModel$abnormal_returns(data_tbl)

Arguments

FamaFrench5FactorModel$clone()

The objects of this class are cloneable with this method.

Usage

FamaFrench5FactorModel$clone(deep = FALSE)

Arguments

See Also

Other eventstudy-models: BHARModel, Carhart4FactorModel, ComparisonPeriodMeanAdjustedModel, DCCGARCHModel, FamaFrench3FactorModel, GARCHModel, LinearFactorModel, LogReturn, MarketAdjustedModel, MarketModel, ModelBase, ReturnCalculation, RollingWindowModel, SimpleReturn, VolatilityModel, VolumeModel

Description

Train the defined model on each event and calculate the abnormal return.

Usage

fit_model(task, parameter_set)

Arguments

Value

task

See Also

run_event_study, prepare_event_study, calculate_statistics

Other eventstudy-pipeline: EventStudyTask, ParameterSet, calculate_statistics(), prepare_event_study(), run_event_study()

Description

Evaluates the KB decision table (category "robustness" rules) against the diagnostic signals extracted from a fitted EventStudyTask or a precomputed es_diagnostics object, and returns a severity-ranked es_advice S3 object.

Usage

flag_robustness(x, provider = NULL, ...)

## Default S3 method:
flag_robustness(x, provider = NULL, ...)

## S3 method for class 'EventStudyTask'
flag_robustness(x, provider = NULL, ...)

## S3 method for class 'es_diagnostics'
flag_robustness(x, provider = NULL, ...)

Arguments

Details

No LLM provider, network connection, or API key is required. The returned es_advice object has the same shape as the Phase 7 Advice contract, flagged is_deterministic = TRUE and source = "offline_kb".

Value

An S3 object of class "es_advice" – see recommend_stat for field descriptions. Rules are filtered to category == "robustness".

See Also

recommend_stat, es_diagnostics, es_kb

Other eventstudy-advisor: AnthropicProvider, CustomProvider, OpenAICompatProvider, ProviderBase, es_advise(), es_diagnostics(), es_kb(), provider(), recommend_stat()

Examples

data(dieselgate)
task <- EventStudyTask$new(dieselgate$firm, dieselgate$index, dieselgate$request)
task <- run_event_study(task, ParameterSet$new())
advice <- flag_robustness(task)
print(advice)

Description

Builds the character vector rendered by print.Advice (one element per output line). The opt-in Advisor Pro footer is captured here (a no-op unless options(eventstudy.advisor_pro_footer = TRUE)), so print.Advice must not re-emit it.

Usage

## S3 method for class 'Advice'
format(x, ...)

Arguments

Value

A character vector, one element per printed line.

Description

Builds the character vector rendered by print.es_advice (one element per output line). The opt-in Advisor Pro footer is captured here (a no-op unless options(eventstudy.advisor_pro_footer = TRUE)), so print.es_advice must not re-emit it.

Usage

## S3 method for class 'es_advice'
format(x, ...)

Arguments

Value

A character vector, one element per printed line.

Description

Builds the character vector rendered by print.es_cross_sectional (one element per output line). The coefficient table is rendered via base::print.data.frame and spliced in at the same position.

Usage

## S3 method for class 'es_cross_sectional'
format(x, ...)

Arguments

Value

A character vector, one element per printed line.

Description

Builds the character vector rendered by print.es_diagnostics (one element per output line). See print.es_diagnostics.

Usage

## S3 method for class 'es_diagnostics'
format(x, ...)

Arguments

Value

A character vector, one element per printed line.

Description

Builds the character vector rendered by print.es_simulation (one element per output line).

Usage

## S3 method for class 'es_simulation'
format(x, ...)

Arguments

Value

A character vector, one element per printed line.

Description

Builds the character vector rendered by print.EventStudySummary (one element per output line). See print.EventStudySummary.

Usage

## S3 method for class 'EventStudySummary'
format(x, ...)

Arguments

Value

A character vector, one element per printed line.

Description

Event study model using GARCH(1,1) for time-varying volatility estimation. Uses the rugarch package to fit a GARCH(1,1) model with a market return regressor in the mean equation during the estimation window. Abnormal returns are computed as the difference between observed returns and the GARCH conditional mean. The time-varying sigma from GARCH can be used for standardized test statistics.

Super class

ModelBase -> GARCHModel

Public fields

Methods

Public methods

• GARCHModel$fit()

• GARCHModel$abnormal_returns()

• GARCHModel$clone()

GARCHModel$fit()

Fit the GARCH model on the estimation window.

Usage

GARCHModel$fit(data_tbl)

Arguments

GARCHModel$abnormal_returns()

Calculate abnormal returns from the GARCH model.

Usage

GARCHModel$abnormal_returns(data_tbl)

Arguments

GARCHModel$clone()

The objects of this class are cloneable with this method.

Usage

GARCHModel$clone(deep = FALSE)

Arguments

See Also

Other eventstudy-models: BHARModel, Carhart4FactorModel, ComparisonPeriodMeanAdjustedModel, DCCGARCHModel, FamaFrench3FactorModel, FamaFrench5FactorModel, LinearFactorModel, LogReturn, MarketAdjustedModel, MarketModel, ModelBase, ReturnCalculation, RollingWindowModel, SimpleReturn, VolatilityModel, VolumeModel

Description

Adjusts the sign test for the expected proportion of positive abnormal returns estimated from the estimation window, rather than assuming 0.5. This accounts for asymmetry in the return distribution.

Super class

TestStatisticBase -> GeneralizedSignTest

Public fields

Methods

Public methods

• GeneralizedSignTest$compute()

• GeneralizedSignTest$clone()

GeneralizedSignTest$compute()

Computes the generalized sign test for multiple events.

Usage

GeneralizedSignTest$compute(data_tbl, model)

Arguments

GeneralizedSignTest$clone()

The objects of this class are cloneable with this method.

Usage

GeneralizedSignTest$clone(deep = FALSE)

Arguments

See Also

Other eventstudy-statistics: ARTTest, BHARTTest, BMPTest, CARTTest, CSectTTest, CalendarTimePortfolioTest, KolariPynnonenTest, MultiEventStatisticsSet, PatellZTest, RankTest, SignTest, SingleEventStatisticsSet, StatisticsSetBase, TestStatisticBase, adjust_p_values(), bootstrap_test(), car_by_group(), car_quantiles(), cross_sectional_regression(), model_diagnostics(), pretrend_test(), simulate_event_study(), validate_task()

Description

Renders an automated report from a completed event study task in one or more output formats. Uses a bundled RMarkdown template with configurable sections. The narrative is assembled ONCE before the format loop – es_advise is never called per format (NARR-01).

Usage

generate_report(
  task,
  output_file = "event_study_report.html",
  format = "html",
  title = "Event Study Report",
  author = NULL,
  sections = c("exec_summary", "data_methods", "results", "diagnostics", "robustness",
    "references"),
  cross_sectional = NULL,
  confidence_level = 0.95,
  interactive = TRUE,
  advice = NULL,
  narrative = NULL,
  provider = NULL,
  verbose = getOption("eventstudy.verbose", TRUE),
  ...
)

Arguments

Value

A named character vector of output file paths, invisibly, keyed by format name (e.g. c(html = "/tmp/report.html", pdf = "/tmp/report.pdf")). A single-format call returns a length-1 named vector: result[["html"]] and result[[1L]] both resolve (backward-compatible with prior single-path callers).

See Also

Other eventstudy-export: es_report(), export_results(), tidy.EventStudyTask()

Examples

data(dieselgate)
task <- EventStudyTask$new(dieselgate$firm, dieselgate$index, dieselgate$request)
task <- run_event_study(task, ParameterSet$new())

# Single HTML format written to a temporary directory
out  <- file.path(tempdir(), "event_study_report.html")
path <- generate_report(task, output_file = out, format = "html")
path[["html"]]

Description

Extension of EventStudyTask for intraday (high-frequency) event studies. Supports POSIXct timestamps and time-based windows specified in minutes or hours.

Differences from EventStudyTask

• Date column contains POSIXct timestamps instead of date strings

• Event windows specified as time offsets (e.g., "-30min", "+60min")

• Handles trading session boundaries

Super class

EventStudyTask -> IntradayEventStudyTask

Public fields

Methods

Public methods

• IntradayEventStudyTask$new()

• IntradayEventStudyTask$print()

• IntradayEventStudyTask$clone()

IntradayEventStudyTask$new()

Create a new IntradayEventStudyTask.

Usage

IntradayEventStudyTask$new(
  firm_stock_data_tbl,
  reference_tbl,
  request_tbl,
  factor_tbl = NULL
)

Arguments

IntradayEventStudyTask$print()

Print summary.

Usage

IntradayEventStudyTask$print(...)

IntradayEventStudyTask$clone()

The objects of this class are cloneable with this method.

Usage

IntradayEventStudyTask$clone(deep = FALSE)

Arguments

See Also

Other eventstudy-tasks: PanelEventStudyTask, SyntheticControlTask, estimate_panel_event_study(), estimate_synthetic_control(), nonparametric_intraday_test(), plot_panel_event_study(), plot_synthetic_control(), prepare_intraday_event_study(), sc_placebo_test()

Description

Adjusts the BMP (Boehmer, Musumeci, Poulsen 1991) test for cross-sectional correlation of abnormal returns using the Kolari and Pynnoenen (2010) correction. Abnormal returns are standardized by each event's MODEL sigma (model$statistics$sigma, same as BMPTest) – not the forecast-error-corrected sigma. The adjustment scales the BMP statistic by a factor that accounts for the average pairwise correlation of standardized abnormal residuals in the estimation window, computed only over "usable" events (at least 2 finite estimation-window SARs, finite model sigma, and non-constant/non-degenerate SAR variance). The adjustment is never silently substituted with 1: an event that cannot contribute a usable estimation-window series is excluded from the correlation estimate and reported once; if fewer than 2 usable events remain, kp_t and ckp_t are NA.

Super class

TestStatisticBase -> KolariPynnonenTest

Public fields

Methods

Public methods

• KolariPynnonenTest$compute()

• KolariPynnonenTest$clone()

KolariPynnonenTest$compute()

Computes the Kolari-Pynnoenen adjusted BMP test.

Usage

KolariPynnonenTest$compute(data_tbl, model)

Arguments

KolariPynnonenTest$clone()

The objects of this class are cloneable with this method.

Usage

KolariPynnonenTest$clone(deep = FALSE)

Arguments

References

Kolari, J. W. and Pynnoenen, S. (2010). Event Study Testing with Cross-sectional Correlation of Abnormal Returns. The Review of Financial Studies, 23(11), 3996–4025.

See Also

Other eventstudy-statistics: ARTTest, BHARTTest, BMPTest, CARTTest, CSectTTest, CalendarTimePortfolioTest, GeneralizedSignTest, MultiEventStatisticsSet, PatellZTest, RankTest, SignTest, SingleEventStatisticsSet, StatisticsSetBase, TestStatisticBase, adjust_p_values(), bootstrap_test(), car_by_group(), car_quantiles(), cross_sectional_regression(), model_diagnostics(), pretrend_test(), simulate_event_study(), validate_task()

Description

Base class for multi-factor OLS models used in event studies. All factor models (Market Model, Fama-French, Carhart) share the same estimation approach: OLS regression of excess returns on factor returns during the estimation window.

Super class

ModelBase -> LinearFactorModel

Public fields

Methods

Public methods

• LinearFactorModel$new()

• LinearFactorModel$fit()

• LinearFactorModel$abnormal_returns()

• LinearFactorModel$clone()

LinearFactorModel$new()

Create a new LinearFactorModel.

Usage

LinearFactorModel$new(use_hac = FALSE, hac_lag = NULL)

Arguments

LinearFactorModel$fit()

Fit the linear factor model via OLS on the estimation window.

Usage

LinearFactorModel$fit(data_tbl)

Arguments

LinearFactorModel$abnormal_returns()

Calculate abnormal returns as observed minus predicted.

Usage

LinearFactorModel$abnormal_returns(data_tbl)

Arguments

LinearFactorModel$clone()

The objects of this class are cloneable with this method.

Usage

LinearFactorModel$clone(deep = FALSE)

Arguments

See Also

Other eventstudy-models: BHARModel, Carhart4FactorModel, ComparisonPeriodMeanAdjustedModel, DCCGARCHModel, FamaFrench3FactorModel, FamaFrench5FactorModel, GARCHModel, LogReturn, MarketAdjustedModel, MarketModel, ModelBase, ReturnCalculation, RollingWindowModel, SimpleReturn, VolatilityModel, VolumeModel

Description

R6 class for log return calculation

Super class

ReturnCalculation -> LogReturn

Public fields

Methods

Public methods

• LogReturn$calculate_return()

• LogReturn$clone()

LogReturn$calculate_return()

Calculates the return for a single stock.

Usage

LogReturn$calculate_return(
  tbl,
  in_column = "adjusted",
  out_column = "adjusted_return"
)

Arguments

LogReturn$clone()

The objects of this class are cloneable with this method.

Usage

LogReturn$clone(deep = FALSE)

Arguments

See Also

Other eventstudy-models: BHARModel, Carhart4FactorModel, ComparisonPeriodMeanAdjustedModel, DCCGARCHModel, FamaFrench3FactorModel, FamaFrench5FactorModel, GARCHModel, LinearFactorModel, MarketAdjustedModel, MarketModel, ModelBase, ReturnCalculation, RollingWindowModel, SimpleReturn, VolatilityModel, VolumeModel

Description

The Market Adjusted Model is another simple approach used in event studies to estimate the expected returns of a stock and calculate its abnormal returns during an event window. This model is less complex than the Market Model, as it assumes that a stock's expected return is equal to the market return, without considering any stock-specific factors. The Market Adjusted Model is particularly useful in situations where the estimation of individual stock parameters (such as alpha and beta) is not feasible or desired, and a basic benchmark for comparison is needed.

Super class

ModelBase -> MarketAdjustedModel

Public fields

Methods

Public methods

• MarketAdjustedModel$fit()

• MarketAdjustedModel$abnormal_returns()

• MarketAdjustedModel$clone()

MarketAdjustedModel$fit()

fit Fit the model with given data.

Usage

MarketAdjustedModel$fit(data_tbl)

Arguments

MarketAdjustedModel$abnormal_returns()

abnormal_returns Calculate the abnormal returns with given data.

Usage

MarketAdjustedModel$abnormal_returns(data_tbl)

Arguments

MarketAdjustedModel$clone()

The objects of this class are cloneable with this method.

Usage

MarketAdjustedModel$clone(deep = FALSE)

Arguments

See Also

Other eventstudy-models: BHARModel, Carhart4FactorModel, ComparisonPeriodMeanAdjustedModel, DCCGARCHModel, FamaFrench3FactorModel, FamaFrench5FactorModel, GARCHModel, LinearFactorModel, LogReturn, MarketModel, ModelBase, ReturnCalculation, RollingWindowModel, SimpleReturn, VolatilityModel, VolumeModel

Description

The Market Model is a widely used method in event studies to estimate the expected returns of a stock and calculate its abnormal returns during an event window. The model is based on a simple linear regression framework and captures the relationship between a stock's return and the return of a market index, such as the S&P 500 or the Dow Jones Industrial Average. The underlying assumption of the Market Model is that a stock's return is primarily influenced by market movements, along with a stock-specific idiosyncratic component.

Super class

ModelBase -> MarketModel

Public fields

Methods

Public methods

• MarketModel$new()

• MarketModel$set_formula()

• MarketModel$fit()

• MarketModel$abnormal_returns()

• MarketModel$clone()

MarketModel$new()

Create a new MarketModel.

Usage

MarketModel$new(use_hac = FALSE, hac_lag = NULL)

Arguments

MarketModel$set_formula()

Set the formula

Usage

MarketModel$set_formula(formula)

Arguments

MarketModel$fit()

Fit the model with given data.

Usage

MarketModel$fit(data_tbl)

Arguments

MarketModel$abnormal_returns()

Calculate the abnormal returns with given data.

Usage

MarketModel$abnormal_returns(data_tbl)

Arguments

MarketModel$clone()

The objects of this class are cloneable with this method.

Usage

MarketModel$clone(deep = FALSE)

Arguments

See Also

Other eventstudy-models: BHARModel, Carhart4FactorModel, ComparisonPeriodMeanAdjustedModel, DCCGARCHModel, FamaFrench3FactorModel, FamaFrench5FactorModel, GARCHModel, LinearFactorModel, LogReturn, MarketAdjustedModel, ModelBase, ReturnCalculation, RollingWindowModel, SimpleReturn, VolatilityModel, VolumeModel

Description

Run diagnostic tests on fitted event study models. Tests include normality of residuals, autocorrelation, and basic model fit quality.

Usage

model_diagnostics(task, event_id = NULL)

Arguments

Value

A tibble with diagnostic test results for each event.

See Also

Other eventstudy-statistics: ARTTest, BHARTTest, BMPTest, CARTTest, CSectTTest, CalendarTimePortfolioTest, GeneralizedSignTest, KolariPynnonenTest, MultiEventStatisticsSet, PatellZTest, RankTest, SignTest, SingleEventStatisticsSet, StatisticsSetBase, TestStatisticBase, adjust_p_values(), bootstrap_test(), car_by_group(), car_quantiles(), cross_sectional_regression(), pretrend_test(), simulate_event_study(), validate_task()

Description

Base (abstract) class for return models used inside an EventStudyTask. Each single event gets its own model instance, fitted on that event's estimation-window data alone. Subclass this to plug a custom return model into run_event_study() / fit_model().

A subclass must implement two methods:

• fit(data_tbl) – fit the model on data_tbl (a single event's rows, estimation and event window together) and populate private$.statistics plus set private$.is_fitted.

• abnormal_returns(data_tbl) – return data_tbl with an abnormal_returns column added for the event window.

The statistics active binding exposes a named list consumed by the test statistics layer. At minimum a subclass should populate: sigma, degree_of_freedom, residuals, forecast_error_corrected_sigma and forecast_error_corrected_sigma_car. Since 2026-09-24, a model may also set statistics$n_params (the number of parameters estimated from the estimation window); PatellZTest reads this field for its Q_i adjustment and falls back to 2 when a subclass does not report it.

Degenerate-input handling: subclasses that implement the shared contract (see R/contract.R) read self$degenerate_mode, self$event_id and self$firm_symbol, which are threaded onto the cloned model instance by fit_model() before fit() is called.

Public fields

Active bindings

Methods

Public methods

• ModelBase$fit()

• ModelBase$abnormal_returns()

• ModelBase$clone()

ModelBase$fit()

Fits the model with given data.

Usage

ModelBase$fit(data_tbl)

Arguments

ModelBase$abnormal_returns()

Calculate the abnormal returns with given data and fitted model.

Usage

ModelBase$abnormal_returns(data_tbl)

Arguments

ModelBase$clone()

The objects of this class are cloneable with this method.

Usage

ModelBase$clone(deep = FALSE)

Arguments

See Also

Other eventstudy-models: BHARModel, Carhart4FactorModel, ComparisonPeriodMeanAdjustedModel, DCCGARCHModel, FamaFrench3FactorModel, FamaFrench5FactorModel, GARCHModel, LinearFactorModel, LogReturn, MarketAdjustedModel, MarketModel, ReturnCalculation, RollingWindowModel, SimpleReturn, VolatilityModel, VolumeModel

Description

Contains a set of multi event test statistics as, e.g., AAR and CAAR cross-sectional t test. These are the default test statistics.

Super class

StatisticsSetBase -> MultiEventStatisticsSet

Public fields

Methods

Public methods

• MultiEventStatisticsSet$clone()

MultiEventStatisticsSet$clone()

The objects of this class are cloneable with this method.

Usage

MultiEventStatisticsSet$clone(deep = FALSE)

Arguments

See Also

Other eventstudy-statistics: ARTTest, BHARTTest, BMPTest, CARTTest, CSectTTest, CalendarTimePortfolioTest, GeneralizedSignTest, KolariPynnonenTest, PatellZTest, RankTest, SignTest, SingleEventStatisticsSet, StatisticsSetBase, TestStatisticBase, adjust_p_values(), bootstrap_test(), car_by_group(), car_quantiles(), cross_sectional_regression(), model_diagnostics(), pretrend_test(), simulate_event_study(), validate_task()

Description

Implements the non-parametric intraday event study methodology of Rinaudo & Saha (2014). For each event time, cumulative abnormal returns (CARs) on the event day are compared to the empirical distribution of CARs from estimation-period days. Significance is assessed without distributional assumptions.

Usage

nonparametric_intraday_test(
  estimation_window,
  event_window,
  event_times,
  p = 0.05,
  init_window = 5L,
  upper = FALSE
)

Arguments

Value

A named list of tibbles, one per event time. Each tibble contains:

id

Observation index within the significant window.

CAR

Cumulative abnormal return on the event day.

CI

Empirical confidence interval boundary from estimation days.

fitCI

Polynomial-smoothed CI (degree-4 polynomial fit).

When an event time is not significant, returns a single-row tibble with all values equal to zero.

References

Rinaudo, J.B. & Saha, A. (2014). Non-parametric intraday event studies.

See Also

Other eventstudy-tasks: IntradayEventStudyTask, PanelEventStudyTask, SyntheticControlTask, estimate_panel_event_study(), estimate_synthetic_control(), plot_panel_event_study(), plot_synthetic_control(), prepare_intraday_event_study(), sc_placebo_test()

Examples

# Build a small intraday grid: estimation window (multiple days) and a
# single event-day window sharing the same intraday time stamps.
set.seed(1)
times <- sprintf("%02d:%02d", 10L + seq_len(30L) %/% 60L, seq_len(30L) %% 60L)
est_data <- data.frame(
  day            = rep(seq_len(10L), each = 30L),
  time           = rep(times, 10L),
  abnormalReturn = rnorm(300L, 0, 0.001)
)
event_data <- data.frame(
  time           = times,
  abnormalReturn = rnorm(30L, 0, 0.001)
)

results <- nonparametric_intraday_test(
  estimation_window = est_data,
  event_window      = event_data,
  event_times       = times[c(5L, 20L)],
  p                 = 0.05,
  init_window       = 5
)

Description

A provider that issues POST {base_url}/chat/completions with an OpenAI-shaped request body. Because the endpoint is selected purely by base_url + model, this single class covers OpenAI itself AND every OpenAI-compatible backend – Ollama, LM Studio, or any gateway – via a base_url override, with no code change.

The API key is resolved at CALL time from OPENAI_API_KEY (never at construction, never stored on the object) and attached with req_auth_bearer_token(), which redacts the Authorization header in every print/error path. A missing key, transport/timeout failure, non-2xx status, malformed body, or missing completion text each degrades to exactly one warning() plus an 'es_provider_response' with text = NA_character_ – it never crashes the session and never returns a fabricated completion.

httr2 is required only for this provider and is guarded by requireNamespace() at the top of complete(), so the package installs and R CMD checks cleanly with httr2 absent.

Super class

ProviderBase -> OpenAICompatProvider

Methods

Public methods

• OpenAICompatProvider$new()

• OpenAICompatProvider$complete()

• OpenAICompatProvider$clone()

OpenAICompatProvider$new()

Construct an OpenAICompatProvider. Stores non-secret config only; the API key is resolved at call time inside complete().

Usage

OpenAICompatProvider$new(model, base_url = "https://api.openai.com/v1", ...)

Arguments

OpenAICompatProvider$complete()

Complete a prompt via POST {base_url}/chat/completions. Resolves the key at call time; on a missing key or any HTTP/parse failure returns one warning + NA. Structured output is OPTIONAL: when schema is supplied a response_format json_schema is added to the body, but omitting it uses the plain-text path (which local models that lack response_format support still handle).

Usage

OpenAICompatProvider$complete(prompt, schema = NULL, ...)

Arguments

Returns

An 'es_provider_response' (see ProviderBase$complete).

OpenAICompatProvider$clone()

The objects of this class are cloneable with this method.

Usage

OpenAICompatProvider$clone(deep = FALSE)

Arguments

See Also

Other eventstudy-advisor: AnthropicProvider, CustomProvider, ProviderBase, es_advise(), es_diagnostics(), es_kb(), flag_robustness(), provider(), recommend_stat()

Examples

## Not run: 
# OpenAI (reads OPENAI_API_KEY from the environment at call time):
p <- OpenAICompatProvider$new(model = "gpt-4o")
p$complete("Summarise these event-study diagnostics")

# Any OpenAI-compatible endpoint works via a base_url override -- e.g. a local
# Ollama server (no cloud key needed by the server, but OPENAI_API_KEY is still
# read as the bearer token; set it to any non-empty value for local servers):
p_local <- OpenAICompatProvider$new(
  model = "llama3",
  base_url = "http://localhost:11434/v1"   # Ollama; LM Studio: :1234/v1
)
p_local$complete("Summarise these diagnostics")

## End(Not run)

Description

Task container for panel (difference-in-differences style) event studies. This is designed for settings where units receive treatment at potentially different times, and we observe outcomes over multiple periods.

Methods

new(panel_data, unit_id, time_id, outcome, treatment, treatment_time)

Create a new panel event study task.

print()

Print summary.

Public fields

Methods

Public methods

• PanelEventStudyTask$new()

• PanelEventStudyTask$print()

• PanelEventStudyTask$clone()

PanelEventStudyTask$new()

Create a new PanelEventStudyTask.

Usage

PanelEventStudyTask$new(
  panel_data,
  unit_id = "unit_id",
  time_id = "time_id",
  outcome = "outcome",
  treatment = "treated",
  treatment_time = "treatment_time"
)

Arguments

PanelEventStudyTask$print()

Print summary.

Usage

PanelEventStudyTask$print(...)

PanelEventStudyTask$clone()

The objects of this class are cloneable with this method.

Usage

PanelEventStudyTask$clone(deep = FALSE)

Arguments

See Also

Other eventstudy-tasks: IntradayEventStudyTask, SyntheticControlTask, estimate_panel_event_study(), estimate_synthetic_control(), nonparametric_intraday_test(), plot_panel_event_study(), plot_synthetic_control(), prepare_intraday_event_study(), sc_placebo_test()

Description

The parameter set defines the Event Study, e.g, the return calculation, the event study model, the AR, CAR, AAR, and CAAR test statistics that should be applied.

Public fields

Methods

Public methods

• ParameterSet$new()

• ParameterSet$print()

• ParameterSet$clone()

ParameterSet$new()

Initialize the parameters that defines the Event Study that should be applied.

Usage

ParameterSet$new(
  return_calculation = SimpleReturn$new(),
  return_model = MarketModel$new(),
  single_event_statistics = SingleEventStatisticsSet$new(),
  multi_event_statistics = MultiEventStatisticsSet$new(),
  degenerate_handling = NULL
)

Arguments

ParameterSet$print()

Print a summary of the parameter set.

Usage

ParameterSet$print(...)

ParameterSet$clone()

The objects of this class are cloneable with this method.

Usage

ParameterSet$clone(deep = FALSE)

Arguments

See Also

Other eventstudy-pipeline: EventStudyTask, calculate_statistics(), fit_model(), prepare_event_study(), run_event_study()

Description

The Patell or Standardized Residual Test is a statistical tool employed in event studies to evaluate the null hypothesis that the average abnormal return at the event date is zero. The test statistics is approximately distributed as N(0, 1).

See also https://eventstudy.de/statistics/aar_caar_statistics.html

Super class

TestStatisticBase -> PatellZTest

Public fields

Methods

Public methods

• PatellZTest$compute()

• PatellZTest$clone()

PatellZTest$compute()

Computes the Patell Z test statistics for multiple events.

Usage

PatellZTest$compute(data_tbl, model)

Arguments

PatellZTest$clone()

The objects of this class are cloneable with this method.

Usage

PatellZTest$clone(deep = FALSE)

Arguments

See Also

Other eventstudy-statistics: ARTTest, BHARTTest, BMPTest, CARTTest, CSectTTest, CalendarTimePortfolioTest, GeneralizedSignTest, KolariPynnonenTest, MultiEventStatisticsSet, RankTest, SignTest, SingleEventStatisticsSet, StatisticsSetBase, TestStatisticBase, adjust_p_values(), bootstrap_test(), car_by_group(), car_quantiles(), cross_sectional_regression(), model_diagnostics(), pretrend_test(), simulate_event_study(), validate_task()

Description

Create a histogram of CARs across events, optionally colored by group.

Usage

plot_car_distribution(
  task,
  car_window = NULL,
  bins = 30,
  by_group = FALSE,
  title = NULL
)

Arguments

Value

A ggplot2 object.

See Also

Other eventstudy-plots: es_colours, plot_diagnostics(), plot_event_study(), plot_stocks(), theme_eventstudy()

Description

Create diagnostic plots for fitted event study models, including residual plots and Q-Q plots.

Usage

plot_diagnostics(task, event_id = NULL)

Arguments

Value

A ggplot2 plot arranged in a gridExtra 2x2 grid layout.

See Also

Other eventstudy-plots: es_colours, plot_car_distribution(), plot_event_study(), plot_stocks(), theme_eventstudy()

Description

Create an event study plot showing abnormal returns (AR), cumulative abnormal returns (CAR), average abnormal returns (AAR), or cumulative average abnormal returns (CAAR) with confidence bands.

Usage

plot_event_study(
  task,
  type = "car",
  event_id = NULL,
  group = NULL,
  stat_name = "CSectT",
  confidence_level = 0.95,
  title = NULL
)

Arguments

Value

A ggplot2 plot object.

See Also

Other eventstudy-plots: es_colours, plot_car_distribution(), plot_diagnostics(), plot_stocks(), theme_eventstudy()

Description

Create an event study plot from panel estimation results. Can also be called via plot_event_study() when given a PanelEventStudyTask.

Usage

plot_panel_event_study(task, confidence_level = 0.95, title = NULL)

Arguments

Value

A ggplot2 object.

See Also

Other eventstudy-tasks: IntradayEventStudyTask, PanelEventStudyTask, SyntheticControlTask, estimate_panel_event_study(), estimate_synthetic_control(), nonparametric_intraday_test(), plot_synthetic_control(), prepare_intraday_event_study(), sc_placebo_test()

Description

Visualize the adjusted close prices or abnormal returns of selected stocks around a specified event date.

Usage

plot_stocks(
  task,
  target_variable = "firm_adjusted",
  add_event_date = FALSE,
  max_symbols = 6,
  sample_symbols = TRUE,
  do_sample = NULL
)

Arguments

Value

A plotly plot object.

See Also

Other eventstudy-plots: es_colours, plot_car_distribution(), plot_diagnostics(), plot_event_study(), theme_eventstudy()

Description

Create plots for synthetic control analysis: trajectory comparison, treatment effect gap, or placebo test results.

Usage

plot_synthetic_control(task, type = c("trajectory", "gap", "placebo"))

Arguments

Value

A ggplot2 object.

See Also

Other eventstudy-tasks: IntradayEventStudyTask, PanelEventStudyTask, SyntheticControlTask, estimate_panel_event_study(), estimate_synthetic_control(), nonparametric_intraday_test(), plot_panel_event_study(), prepare_intraday_event_study(), sc_placebo_test()

Description

Perform return calculation for each stock and the corresponding reference market defined in the task and the parameter set.

Usage