Quantile Regression Combined-Likelihood Compound Estimator for KK Designs (Continuous)

Fits the combined stacked quantile regression (matched-pair differences + reservoir) using the treatment indicator and all recorded covariates for continuous responses. Minimises the joint check-function loss over both data sources simultaneously. Inference is based on the stacked combined-likelihood quantile-regression fit.

Model. Analogous to InferenceContinKKOLSOneLik's single stacked design (matched-pair difference rows plus reservoir rows fit jointly), but the objective is the quantreg check-function loss \(\rho_\tau(u) = u(\tau - \mathbf{1}_{u<0})\) rather than squared error, so the estimand \(\beta_T\) is the treatment effect on the \(\tau\)-th quantile of the response, not the mean. tau = 0.5 (default) targets the median treatment effect, which is more robust to outliers and heavy-tailed responses than the OLS mean-based estimator; any value strictly between 0 and 1 is accepted. likelihood_tier = "none": no likelihood-based (score/gradient/lik_ratio) testing types, only Wald.

Assumptions. Continuous response; independent matched pairs and/or independent reservoir subjects; no censoring; a KK matching-on-the-fly design. Requires the quantreg package (listed in Suggests, not installed automatically).

References

Kapelner, A. and Krieger, A. M. (2014). Matching on-the-fly: Sequential allocation with higher power and efficiency. Biometrics, 70(2), 378-388. doi:10.1111/biom.12148 . (KK14 in REFERENCES.md.) Koenker, R. (2005). Quantile Regression. Cambridge University Press.

See also

InferenceContinKKQuantileRegrIVWC for the inverse-variance-weighted-combination alternative to this one-likelihood combined-fit approach. Quantile regression (orientation).

Super class

Inference -> InferenceContinKKQuantileRegrOneLik

Methods

Public methods

• InferenceContinKKQuantileRegrOneLik$new()

• InferenceContinKKQuantileRegrOneLik$clone()

+ inherited public methods from Inference

• Inference$capabilities()
• Inference$compute_asymp_confidence_interval()
• Inference$compute_asymp_two_sided_pval()
• Inference$compute_estimate()
• Inference$compute_exact_confidence_interval()
• Inference$compute_exact_two_sided_pval_for_treatment_effect()
• Inference$duplicate()
• Inference$get_analysis_data()
• Inference$get_covariates()
• Inference$get_design_object()
• Inference$get_model_formula()
• Inference$get_nonestimable_reason()
• Inference$get_nonestimable_stage()
• Inference$get_optimization_alg()
• Inference$get_response()
• Inference$get_response_type()
• Inference$get_treatment()
• Inference$is_nonestimable()
• Inference$set_optimization_alg()
• Inference$set_seed()
• Inference$supports()

---

InferenceContinKKQuantileRegrOneLik$new()

Initialize continuous-response KK combined-likelihood quantile-regression inference. The shared stacked matched-pair/reservoir quantile-regression fit and its tau semantics are documented on InferenceContinKKQuantileRegrOneLik and on the shared compute_estimate() method it inherits from the KKQuantileRegrOneLik component.

Usage

InferenceContinKKQuantileRegrOneLik$new(
  des_obj,
  model_formula = NULL,
  tau = 0.5,
  verbose = FALSE
)

Arguments

des_obj

A DesignSeqOneByOne object whose entire n subjects are assigned and response y is recorded within.

model_formula

Optional formula for covariate adjustment. If NULL (default), the formula from the design object is used and its pre-computed design matrix is reused. If a formula is provided, a new design matrix is constructed from the design's imputed covariates.

tau

The quantile level for regression, strictly between 0 and 1. Default is 0.5.

verbose

Whether to print progress messages.

Examples

set.seed(1)
x_dat <- data.frame(
  x1 = c(-1.2, -0.7, -0.2, 0.3, 0.8, 1.3, 1.8, 2.3),
  x2 = c(0, 1, 0, 1, 0, 1, 0, 1)
)
seq_des <- DesignSeqOneByOneKK14$new(n = nrow(x_dat), response_type = "continuous", verbose =
FALSE)
for (i in seq_len(nrow(x_dat))) {
  seq_des$add_one_subject_to_experiment_and_assign(x_dat[i, , drop = FALSE])
}
seq_des$add_all_subject_responses(c(1.2, 0.9, 1.5, 1.8, 2.1, 1.7, 2.6, 2.2))
infer <- InferenceContinKKQuantileRegrOneLik$new(seq_des, verbose
= FALSE)
infer

---

InferenceContinKKQuantileRegrOneLik$clone()

The objects of this class are cloneable with this method.

Usage

InferenceContinKKQuantileRegrOneLik$clone(deep = FALSE)

Arguments

deep

Whether to make a deep clone.

Examples

# \donttest{
seq_des = DesignSeqOneByOneKK14$new(n = 10, response_type = 'continuous')
for (i in 1:10) {
  seq_des$add_one_subject_to_experiment_and_assign(data.frame(x1 = rnorm(1), x2 = rnorm(1)))
}
seq_des$add_all_subject_responses(rnorm(10))
inf = InferenceContinKKQuantileRegrOneLik$new(seq_des)
inf$compute_estimate()
#> [1] 0.3050045
# }

## ------------------------------------------------
## Method `InferenceContinKKQuantileRegrOneLik$new()`
## ------------------------------------------------

set.seed(1)
x_dat <- data.frame(
  x1 = c(-1.2, -0.7, -0.2, 0.3, 0.8, 1.3, 1.8, 2.3),
  x2 = c(0, 1, 0, 1, 0, 1, 0, 1)
)
seq_des <- DesignSeqOneByOneKK14$new(n = nrow(x_dat), response_type = "continuous", verbose =
FALSE)
for (i in seq_len(nrow(x_dat))) {
  seq_des$add_one_subject_to_experiment_and_assign(x_dat[i, , drop = FALSE])
}
seq_des$add_all_subject_responses(c(1.2, 0.9, 1.5, 1.8, 2.1, 1.7, 2.6, 2.2))
infer <- InferenceContinKKQuantileRegrOneLik$new(seq_des, verbose
= FALSE)
infer
#> <InferenceContinKKQuantileRegrOneLik>
#>   Inherits from: <Inference>
#>   Public:
#>     approximate_bayesian_bootstrap_distribution_beta_hat_T: function (...) 
#>     approximate_bootstrap_distribution_beta_hat_T: function (B = 501, show_progress = TRUE, debug = FALSE, bootstrap_type = NULL) 
#>     approximate_jackknife_distribution_beta_hat_T: function (unit = "auto") 
#>     approximate_m_out_of_n_bootstrap_distribution_beta_hat_T: function (...) 
#>     approximate_rand_bootstrap_distribution_beta_hat_T: function (...) 
#>     approximate_randomization_distribution_beta_hat_T: function (r = 501, delta = 0, transform_responses = "none", show_progress = TRUE, 
#>     approximate_subsampling_distribution_beta_hat_T: function (...) 
#>     capabilities: function () 
#>     clone: function (deep = FALSE) 
#>     compute_asymp_confidence_interval: function (alpha = 0.05) 
#>     compute_asymp_two_sided_pval: function (delta = 0) 
#>     compute_bayesian_bootstrap_confidence_interval: function (...) 
#>     compute_bayesian_bootstrap_two_sided_pval: function (...) 
#>     compute_bootstrap_confidence_interval: function (...) 
#>     compute_bootstrap_two_sided_pval: function (...) 
#>     compute_estimate: function (estimate_only = FALSE) 
#>     compute_estimate_with_bootstrap_weights: function (subject_or_block_weights, estimate_only = FALSE) 
#>     compute_exact_confidence_interval: function (...) 
#>     compute_exact_two_sided_pval_for_treatment_effect: function (...) 
#>     compute_jackknife_bias_estimate: function (unit = "auto") 
#>     compute_jackknife_estimate: function (unit = "auto") 
#>     compute_jackknife_std_error: function (unit = "auto") 
#>     compute_jackknife_wald_confidence_interval: function (alpha = 0.05, unit = "auto") 
#>     compute_jackknife_wald_two_sided_pval: function (delta = 0, unit = "auto") 
#>     compute_m_out_of_n_bootstrap_confidence_interval: function (...) 
#>     compute_m_out_of_n_bootstrap_two_sided_pval: function (...) 
#>     compute_rand_bootstrap_confidence_interval: function (...) 
#>     compute_rand_bootstrap_two_sided_pval: function (...) 
#>     compute_rand_confidence_interval: function (alpha = 0.05, r = 501, pval_epsilon = 0.005, show_progress = TRUE, 
#>     compute_rand_two_sided_pval: function (r = 501, delta = 0, transform_responses = "none", na.rm = TRUE, 
#>     compute_subsampling_confidence_interval: function (...) 
#>     compute_subsampling_sensitivity: function (...) 
#>     compute_subsampling_two_sided_pval: function (...) 
#>     compute_wald_confidence_interval: function (alpha = 0.05) 
#>     compute_wald_two_sided_pval: function (delta = 0) 
#>     duplicate: function (verbose = FALSE, make_fork_cluster = FALSE) 
#>     get_analysis_data: function () 
#>     get_covariates: function () 
#>     get_design_object: function () 
#>     get_mod: function () 
#>     get_model_formula: function () 
#>     get_nonestimable_reason: function () 
#>     get_nonestimable_stage: function () 
#>     get_optimization_alg: function () 
#>     get_response: function () 
#>     get_response_type: function () 
#>     get_summary: function () 
#>     get_supported_bayesian_bootstrap_ci_types: function (...) 
#>     get_supported_bayesian_bootstrap_pval_types: function (...) 
#>     get_supported_bootstrap_ci_types: function (...) 
#>     get_supported_bootstrap_pval_types: function (...) 
#>     get_supported_rand_bootstrap_ci_types: function (...) 
#>     get_supported_rand_bootstrap_pval_types: function (...) 
#>     get_supported_testing_types: function () 
#>     get_treatment: function () 
#>     initialize: function (des_obj, model_formula = NULL, tau = 0.5, verbose = FALSE) 
#>     is_nonestimable: function (type = c("any", "estimate", "se")) 
#>     num_cores: active binding
#>     select_optimal_b_subsampling: function (...) 
#>     select_optimal_m_out_of_n_bootstrap: function (...) 
#>     set_custom_randomization_statistic_cpp: function (fn) 
#>     set_custom_randomization_statistic_function: function (custom_randomization_statistic_function) 
#>     set_optimization_alg: function (optimization_alg = NULL, allow_irls = private$optimization_alg_allow_irls, 
#>     set_seed: function (seed) 
#>     set_testing_type: function (testing_type = "wald") 
#>     supports: function (capability) 
#>     supports_rand_pval_for_incidence: function () 
#>   Private:
#>     .__loaded_lazy_components: KKQuantileRegrOneLik
#>     X: -1.2 -0.7 -0.2 0.3 0.8 1.3 1.8 2.3 0 1 0 1 0 1 0 1
#>     active_resampling_operation: NULL
#>     allocate_resampling_sizes_by_stratum: function (...) 
#>     analyze_custom_randomization_statistic: function () 
#>     any_censoring: FALSE
#>     approximate_bayesian_bootstrap_statistics_beta_hat_T: function (...) 
#>     approximate_bayesian_jackknife_distribution_beta_hat_T: function (...) 
#>     approximate_bootstrap_statistics_beta_hat_T: function (...) 
#>     approximate_jackknife_distribution_beta_hat_T_private: function (...) 
#>     approximate_m_out_of_n_bootstrap_distribution_beta_hat_T_impl: function (...) 
#>     approximate_subsampling_distribution_beta_hat_T_impl: function (...) 
#>     assert_design_supports_randomization_draw: function (method_family) 
#>     assert_design_supports_resampling: function (method_family) 
#>     assert_design_supports_resampling_replay: function (method_family) 
#>     assert_exact_inference_params: function (type, args_for_type) 
#>     assert_finite_se: function () 
#>     assert_jackknife_supported: function (unit = "auto") 
#>     assert_no_incidence_only_randomization_args: function (resp_type, type, args_for_type) 
#>     assert_valid_bootstrap_type: function (...) 
#>     bayesian_bootstrap_cache_key: function (...) 
#>     bayesian_bootstrap_ci_types: NULL
#>     bayesian_bootstrap_pval_types: NULL
#>     bayesian_bootstrap_sample_weights: function (...) 
#>     bca_ci_core: function (...) 
#>     bca_pval_core: function (...) 
#>     begin_rand_worker_reuse_session: function () 
#>     boot_distr_cache: NULL
#>     bootstrap_ci_types: NULL
#>     bootstrap_confidence_interval_extreme: function (...) 
#>     bootstrap_estimates_extreme: function (...) 
#>     bootstrap_extreme_ci_width_threshold: NULL
#>     bootstrap_extreme_estimate_threshold: NULL
#>     bootstrap_pval_types: NULL
#>     bootstrap_replication_stats: function (...) 
#>     bootstrap_sample_indices: function (...) 
#>     bootstrap_subset_inference: function (...) 
#>     brt_mc_control: NULL
#>     build_bayesian_bootstrap_context: function (...) 
#>     build_fast_randomization_worker_cache: function (prev_cache = NULL, preserve_cache_keys = character()) 
#>     build_jackknife_deletion_draws: function (...) 
#>     build_randomization_ci_search_bounds: function (inf_obj, r, alpha, transform_arg, permutations, ci_search_control, 
#>     build_randomization_distribution_cache_key: function (r, delta, transform_responses, permutations) 
#>     build_resampling_draw_from_units: function (...) 
#>     cache_nonestimable_estimate: function (reason = "not_estimable") 
#>     cache_nonestimable_se: function (reason = "standard_error_unavailable") 
#>     cached_X_full_for_reduced: NULL
#>     cached_design_matrix: NULL
#>     cached_harden_for_design_matrix: NULL
#>     cached_hardened_X_cov: NULL
#>     cached_j_treat_for_reduced: NULL
#>     cached_keep_for_reduced: NULL
#>     cached_reduced_X: NULL
#>     cached_values: list
#>     cached_vc_params: NULL
#>     cached_w_for_design_matrix: NULL
#>     check_bootstrap_replicate_deadline: function (...) 
#>     check_rand_bootstrap_ci_deadline: function (...) 
#>     check_randomization_ci_deadline: function (ci_search_control = NULL, label = "Randomization CI bisection") 
#>     ci_bayesian_bca: function (...) 
#>     ci_bca: function (...) 
#>     ci_calibrated_bootstrap: function (...) 
#>     ci_exact_zhang_combined: function (alpha, pval_epsilon, combination_method = "Fisher") 
#>     ci_from_boot_distribution: function (...) 
#>     ci_smoothed_bootstrap: function (...) 
#>     ci_studentized: function (...) 
#>     ci_symmetric_studentized: function (...) 
#>     clear_fit_warm_start: function () 
#>     clear_kk_bootstrap_worker_design_caches: function (worker_priv) 
#>     clear_likelihood_null_warm_cache: function () 
#>     clear_likelihood_test_eval_cache: function () 
#>     clear_nonestimable_state: function () 
#>     closed_form_ci_from_affine_null_draws: function (...) 
#>     compute_basic_kk_match_data_impl: function () 
#>     compute_basic_match_data: function () 
#>     compute_bayesian_bootstrap_distribution_with_reused_workers: function (...) 
#>     compute_bayesian_bootstrap_worker_estimate: function (...) 
#>     compute_bootstrap_distribution_with_reused_workers: function (...) 
#>     compute_bootstrap_worker_estimate: function (worker_state) 
#>     compute_bootstrap_worker_estimate_via_compute_treatment_estimate: function (...) 
#>     compute_brt_null_statistics_with_reused_workers: function (...) 
#>     compute_brt_null_statistics_with_se: function (...) 
#>     compute_ci_by_inverting_the_randomization_test_iteratively: function (r, l, u, pval_th, tol, transform_responses, lower, 
#>     compute_estimate_from_matched_and_reservoir: function (run_matched, run_reservoir) 
#>     compute_exact_confidence_interval_rand: function (type, alpha, args_for_type) 
#>     compute_exact_two_sided_pval_rand: function (type, delta, args_for_type) 
#>     compute_fast_randomization_distr: function (y, permutations, delta, transform_responses, zero_one_logit_clamp = .Machine$double.eps) 
#>     compute_fast_randomization_distr_via_reused_worker: function (y, permutations, delta, transform_responses, preserve_cache_keys = character(), 
#>     compute_jackknife_distribution_with_reused_workers: function (...) 
#>     compute_jackknife_summary: function (unit = "auto") 
#>     compute_kk_bootstrap_debug_with_reused_worker: function (kk_boot_draws, kk_boot_context) 
#>     compute_kk_bootstrap_distribution_with_reused_workers: function (kk_boot_draws, kk_boot_context, actual_cores, show_progress) 
#>     compute_kk_bootstrap_worker_estimate: function (worker_state) 
#>     compute_m_out_of_n_bootstrap_confidence_interval_impl: function (...) 
#>     compute_m_out_of_n_bootstrap_two_sided_pval_impl: function (...) 
#>     compute_rand_bootstrap_ci_pval_cached: function (...) 
#>     compute_rand_bootstrap_distribution_with_reused_workers: function (...) 
#>     compute_randomization_ci_pval_cached: function (inf_obj, r, delta, transform_responses, permutations, 
#>     compute_randomization_distr_via_reused_worker_states: function (permutations, delta, transform_responses, actual_rand_cores, 
#>     compute_randomization_worker_estimate: function (worker_state) 
#>     compute_resampling_draw_distribution: function (...) 
#>     compute_reservoir_and_match_statistics: function () 
#>     compute_reusable_bootstrap_worker_distribution: function (...) 
#>     compute_subsampling_confidence_interval_impl: function (...) 
#>     compute_subsampling_sensitivity_impl: function (...) 
#>     compute_subsampling_two_sided_pval_impl: function (...) 
#>     compute_subsampling_worker_estimate: function (...) 
#>     compute_treatment_estimate_during_randomization_inference: function (estimate_only = TRUE) 
#>     compute_two_sided_brt_pval_studentized: function (...) 
#>     compute_two_sided_brt_pval_with_sequential_mc: function (...) 
#>     compute_two_sided_pval_with_sequential_mc: function (t, r, delta, transform_responses, show_progress, permutations, 
#>     compute_two_sided_randomization_pval_band: function (t0s, t, conf_level) 
#>     compute_two_sided_randomization_pval_from_t0s: function (t0s, t) 
#>     compute_wald_confidence_interval_impl: function (alpha) 
#>     compute_wald_two_sided_pval_impl: function (delta) 
#>     compute_weighted_combined_estimate: function (row_weights, estimate_only = TRUE) 
#>     compute_z_or_t_ci_from_s_and_df: function (alpha) 
#>     compute_z_or_t_two_sided_pval_from_s_and_df: function (delta) 
#>     create_bootstrap_worker_state: function () 
#>     create_design_backed_bootstrap_worker_state: function (...) 
#>     create_design_matrix: function () 
#>     create_kk_bootstrap_context: function (y, dead, w, X, m, n_reservoir) 
#>     create_kk_bootstrap_worker_state: function (kk_boot_context) 
#>     create_reusable_bootstrap_worker: function (...) 
#>     current_bayesian_bootstrap_context: NULL
#>     current_bayesian_bootstrap_subject_or_block_weights: NULL
#>     dead: 1 1 1 1 1 1 1 1
#>     des_obj: DesignSeqOneByOneKK14, DesignSeqOneByOne, Design, R6
#>     des_obj_priv_int: environment
#>     effective_parallel_cores: function (operation, requested_cores = self$num_cores) 
#>     end_rand_worker_reuse_session: function () 
#>     ensure_mirai_daemons: function (n) 
#>     ensure_resampling_distribution_cache: function (operation) 
#>     estimate_bootstrap_worker: function (...) 
#>     evaluate_lightweight_custom_randomization_statistic: function (lightweight_custom_context, y, w, dead, cpp_fn_override = NULL) 
#>     evaluate_m_out_of_n_bootstrap_size: function (...) 
#>     evaluate_subsampling_size: function (...) 
#>     expand_bound: function (inf_obj, bound, est, r, transform_arg, permutations, 
#>     expand_rand_bootstrap_bound: function (...) 
#>     expand_subject_or_block_weights_to_row_weights: function (...) 
#>     extract_dollar_paths: function (expr) 
#>     extract_se_from_rq: function (fit, coef_name) 
#>     finalize: function () 
#>     fit_warm_start: NULL
#>     fit_warm_start_enabled: TRUE
#>     fit_warm_start_fisher: NULL
#>     fit_warm_start_type: NULL
#>     fit_warm_start_weights: NULL
#>     fit_with_hardened_qr_column_dropping: function (X_full, fit_fun, fit_ok, required_cols = 1L) 
#>     fixed_covariate_keep_cache: NULL
#>     fork_cluster: NULL
#>     generate_exchangeable_resampling_draws: function (...) 
#>     generate_permutations: function (r) 
#>     generate_rand_bootstrap_draws: function (...) 
#>     get_X: function () 
#>     get_bootstrap_type: function (...) 
#>     get_brt_distribution_prefix: function (...) 
#>     get_cached_centered_resampling_pivot: function (...) 
#>     get_cached_resampling_distribution: function (operation, cache_key) 
#>     get_cluster_jackknife_ids: function (...) 
#>     get_compiled_cpp_stat: function () 
#>     get_complexity_tier: function () 
#>     get_degrees_of_freedom: function () 
#>     get_estimand_type: function () 
#>     get_exchangeable_units: function (...) 
#>     get_fit_warm_start: function (type = c("beta", "params")) 
#>     get_fit_warm_start_fisher: function (expected_dim = NULL) 
#>     get_fit_warm_start_for_length: function (type = c("beta", "params"), expected_length = NULL) 
#>     get_fit_warm_start_weights: function (expected_n = NULL) 
#>     get_likelihood_null_warm_state: function (key) 
#>     get_likelihood_test_eval_cache: function () 
#>     get_likelihood_test_eval_entry: function (testing_type, delta) 
#>     get_optimal_warm_start_config: function (expected_length, expected_fisher_dim = expected_length) 
#>     get_or_create_fork_cluster: function () 
#>     get_randomization_ci_seed_candidates: function (inf_obj, alpha) 
#>     get_randomization_distribution_prefix: function (r, delta, transform_responses, show_progress, permutations, 
#>     get_resampling_block_ids: function (...) 
#>     get_resampling_cluster_ids: function (...) 
#>     get_resampling_draw_contract: function (operation) 
#>     get_resampling_strata_ids: function (...) 
#>     get_standard_error: function () 
#>     get_supported_information_preferences_impl: function () 
#>     get_supported_testing_types_impl: function () 
#>     get_w_signed: function (w) 
#>     harden: TRUE
#>     has_general_censoring: FALSE
#>     has_match_structure: TRUE
#>     has_private_method: function (method_name) 
#>     high_precision_confirm_and_refine_ci_bound: function (l, u, lower, r, transform_responses, permutations, 
#>     infer_original_se: function (...) 
#>     init_kk_passthrough: function (des_obj) 
#>     invert_ci_to_find_two_sided_pval_for_treatment_effect: function (delta = 0) 
#>     invert_rand_bootstrap_test_bisection: function (...) 
#>     is_KK: TRUE
#>     is_a_asymp: function () 
#>     is_a_kk_compound_estimator: function () 
#>     is_a_kk_passthrough_design: function () 
#>     is_a_rand_ci: function () 
#>     is_bernoulli_design: function () 
#>     is_resampling_control_condition: function (...) 
#>     jack_distr_cache: NULL
#>     jackknife_always_nonestimable: function () 
#>     jackknife_block_size_gt_one_unsupported: function (unit = "auto") 
#>     jackknife_cache_key: function (unit = "auto") 
#>     kk_passthrough: TRUE
#>     kk_passthrough_compound: TRUE
#>     likelihood_null_warm_cache: NULL
#>     likelihood_test_delta_key: function (testing_type, delta) 
#>     lin_xm_m_vec: NULL
#>     lin_xm_structural: NULL
#>     load_bayesian_bootstrap_draw_into_worker: function (...) 
#>     load_bayesian_bootstrap_weights_into_worker: function (...) 
#>     load_bootstrap_draw_into_worker: function (...) 
#>     load_bootstrap_sample_into_design_backed_worker: function (...) 
#>     load_bootstrap_sample_into_worker: function (worker_state, indices) 
#>     load_kk_bootstrap_sample_into_worker: function (worker_state, sample_info) 
#>     load_m_out_of_n_bootstrap_draw_into_worker: function (...) 
#>     load_non_param_bootstrap_draw_into_worker: function (...) 
#>     load_rand_bootstrap_assignment_into_worker: function (...) 
#>     load_rand_bootstrap_draw_into_worker: function (...) 
#>     load_randomization_draw_into_worker: function (worker_state, draw, delta, transform_responses, setup, 
#>     load_randomization_perm_into_worker: function (worker_state, perm_w, delta, transform_responses, y_delta, 
#>     load_resampling_draw_into_worker: function (operation, worker_state, draw, ...) 
#>     load_subsampling_draw_into_worker: function (...) 
#>     m: 0 0 0 0 0 0 0 0
#>     m_out_of_n_bootstrap_cache_key: function (...) 
#>     m_out_of_n_bootstrap_centered_pivot: function (...) 
#>     m_out_of_n_bootstrap_sample_indices: function (...) 
#>     mark_jackknife_nonestimable_if_block_unsupported: function (unit = "auto") 
#>     missing_bootstrap_ci: function (...) 
#>     model_formula: formula
#>     n: 8
#>     n_cpp_threads: function (n_work_items) 
#>     normalize_delta_for_cache: function (delta, resolution = NULL) 
#>     normalize_exact_inference_args: function (type, args_for_type = NULL, pval_epsilon = NULL) 
#>     normalize_jackknife_unit: function (unit = "auto") 
#>     normalize_likelihood_test_delta: function (delta) 
#>     normalize_randomization_ci_search_control: function (ci_search_control, r, pval_epsilon) 
#>     nsim_rand: 499
#>     null_fit_warm_start_enabled: TRUE
#>     num_cores_override: NULL
#>     object_has_private_method: function (obj, method_name) 
#>     only_matches: function () 
#>     only_reservoir: function () 
#>     optimization_alg: lbfgs
#>     optimization_alg_allow_irls: FALSE
#>     optimization_alg_default: lbfgs
#>     p: NULL
#>     par_lapply: function (X, FUN, n_cores = self$num_cores, budget = 1L, show_progress = FALSE, 
#>     parallel_dispatch_policy: function (operation) 
#>     prob_T: 0.5
#>     pval_bayesian_bca: function (...) 
#>     pval_bca: function (...) 
#>     quantile_rand_ci: TRUE
#>     rand_boot_draws_counter: NULL
#>     rand_bootstrap_ci_conservative_count: NULL
#>     rand_bootstrap_ci_timeout_deadline: function (...) 
#>     rand_bootstrap_ci_types: NULL
#>     rand_bootstrap_draw_matrices: function (...) 
#>     rand_bootstrap_pval_types: NULL
#>     rand_bootstrap_transform_code: function (...) 
#>     reduce_design_matrix_once: function (X, j_treat, cache_key) 
#>     reduce_design_matrix_preserving_treatment: function (X_full) 
#>     reduce_design_matrix_preserving_treatment_fixed_covariates: function (X_full) 
#>     reduce_design_matrix_preserving_treatment_matrix: function (X_full) 
#>     reduce_treatment_only_design_fast: function (X_full) 
#>     reduced_design_keep_cache: NULL
#>     renumber_match_ids: function (...) 
#>     requires_blocking_design: function () 
#>     resampling_centered_pval: function (...) 
#>     resampling_ci_from_centered_distribution: function (...) 
#>     resampling_effective_p: function (...) 
#>     resampling_error_to_na: function (...) 
#>     resampling_scaling_factor: function (...) 
#>     resampling_scaling_key: function (...) 
#>     resolve_dollar_path: function (expr) 
#>     resolve_jackknife_unit: function (unit = "auto") 
#>     resolve_resampling_size: function (...) 
#>     resolve_resampling_unit: function (...) 
#>     reusable_bootstrap_worker_enabled: TRUE
#>     run_rand_bootstrap_iteration: function (...) 
#>     run_rand_bootstrap_iteration_with_se: function (...) 
#>     run_randomization_iteration: function (thread_des_obj, thread_inf_obj, perm_idx, permutations, 
#>     sample_exchangeable_unit_ids: function (...) 
#>     seed: NULL
#>     select_optimal_b_subsampling_impl: function (...) 
#>     select_optimal_m_out_of_n_bootstrap_impl: function (...) 
#>     select_optimal_resample_size: function (...) 
#>     sequential_mc_band_excludes_threshold: function (t0s, t, threshold, conf_level) 
#>     sequential_mc_control_enabled: function (mc_ctrl) 
#>     set_cached_centered_resampling_pivot: function (...) 
#>     set_cached_resampling_distribution: function (operation, cache_key, value) 
#>     set_fit_warm_start: function (start, type = c("beta", "params"), fisher = NULL, weights = NULL, 
#>     set_likelihood_null_warm_state: function (key, delta, start) 
#>     set_likelihood_test_eval_entry: function (testing_type, delta, entry) 
#>     setup_randomization_template_and_shifts: function (delta, transform_responses, zero_one_logit_clamp = .Machine$double.eps) 
#>     shared_combined_likelihood: function (estimate_only = FALSE) 
#>     shift_randomization_responses: function (y, w, delta, transform_responses, response_type, inverse = FALSE, 
#>     should_use_design_randomization_for_incidence: function () 
#>     should_use_zhang_incidence_randomization: function () 
#>     smart_cold_start_default: TRUE
#>     stable_signature: function (obj) 
#>     studentized_bootstrap_pivots: function (...) 
#>     studentized_interval_scale_unstable: function (...) 
#>     subsampling_cache_key: function (...) 
#>     subsampling_centered_pivot: function (...) 
#>     subsampling_sample_indices: function (...) 
#>     subset_permutations: function (permutations, indices) 
#>     supports_bayesian_bootstrap: function (...) 
#>     supports_design_randomization_draw: TRUE
#>     supports_design_resampling: TRUE
#>     supports_design_resampling_replay: TRUE
#>     supports_information_preference: function () 
#>     supports_interval_or_left_censored_data: function () 
#>     supports_likelihood_tests: function () 
#>     supports_observed_information: function () 
#>     supports_reusable_bootstrap_worker: function () 
#>     sync_randomization_worker_state: function (thread_des_obj, thread_inf_obj) 
#>     tau: 0.5
#>     transform_y_fn_list: list
#>     try_cached_reduced_design_keep: function (X_full, keep = private$reduced_design_keep_cache) 
#>     use_reusable_bootstrap_worker: function () 
#>     use_reusable_kk_bootstrap_worker: function () 
#>     validate_bootstrap_worker_state: function (...) 
#>     verbose: FALSE
#>     w: 0 0 1 1 0 1 1 1
#>     warned_no_parallel: FALSE
#>     xm_m_vec: NULL
#>     xm_structural: NULL
#>     y: 1.2 0.9 1.5 1.8 2.1 1.7 2.6 2.2
#>     y_L: NA NA NA NA NA NA NA NA
#>     y_R: NA NA NA NA NA NA NA NA
#>     y_temp: 1.2 0.9 1.5 1.8 2.1 1.7 2.6 2.2