Package 'PKNCA'

Description

Add columns for calculations within PKNCA intervals

Usage

add.interval.col(
  name,
  FUN,
  values = c(FALSE, TRUE),
  unit_type,
  pretty_name,
  depends = NULL,
  desc = "",
  sparse = FALSE,
  formalsmap = list(),
  FUN_sparse = NA_character_,
  formalsmap_sparse = list(),
  datatype = c("interval", "individual", "population"),
  pptestcd_cdisc = NULL,
  pptest_cdisc = NULL,
  formula = NULL,
  formula_note = NULL,
  tier = "uncommon",
  selection = NULL
)

Arguments

Details

FUN_sparse gives a parameter a second calculation function for sparse PK. With sparse data, a parameter that has one is calculated with it – from the pooled individual samples, and with formalsmap_sparse in place of formalsmap – and its result is reported as a sparse result. A parameter with no FUN_sparse falls back to FUN applied to the arithmetic-mean profile, which is what sparse data have always done. A sparse estimator names its concentration inputs conc/time the way a dense one does; those draw from the pooled samples rather than the mean profile. The estimators PKNCA ships are linear-trapezoidal only, so auc.method does not apply to them.

The formalsmap argument enables mapping some alternate formal argument names to parameters. It is used to generalize functions that may use multiple similar arguments (such as the variants of mean residence time). The names of the list should correspond to function formal parameter names and the values should be one of the following:

• For the current interval:

  character strings of NCA parameter name

  The value of the parameter calculated for the current interval.

  "conc"

  Concentration measurements for the current interval.

  "time"

  Times associated with concentration measurements for the current interval (values start at 0 at the beginning of the current interval).

  "volume"

  Volume associated with concentration measurements for the current interval (typically applies for excretion parameters like urine).

  "duration.conc"

  Durations associated with concentration measurements for the current interval.

  "dose"

  Dose amounts assocuated with the current interval.

  "time.dose"

  Time of dose start associated with the current interval (values start at 0 at the beginning of the current interval).

  "duration.dose"

  Duration of dose (typically infusion duration) for doses in the current interval.

  "route"

  Route of dosing for the current interval.

  "start"

  Time of interval start.

  "end"

  Time of interval end.

  "options"

  PKNCA.options governing calculations.

• For the current group:

  "conc.group"

  Concentration measurements for the current group.

  "time.group"

  Times associated with concentration measurements for the current group (values start at 0 at the beginning of the current interval).

  "volume.group"

  Volume associated with concentration measurements for the current interval (typically applies for excretion parameters like urine).

  "duration.conc.group"

  Durations assocuated with concentration measurements for the current group.

  "dose.group"

  Dose amounts assocuated with the current group.

  "time.dose.group"

  Time of dose start associated with the current group (values start at 0 at the beginning of the current interval).

  "duration.dose.group"

  Duration of dose (typically infusion duration) for doses in the current group.

  "route.group"

  Route of dosing for the current group.

• For sparse PK (NULL with dense PK, so a parameter naming one of these is only calculable with a sparse PKNCAconc):

  "conc.sparse"

  The pooled individual concentration measurements for the current interval ("conc" is the arithmetic-mean profile built from them).

  "time.sparse"

  Times associated with the pooled individual concentration measurements for the current interval (values start at 0 at the beginning of the current interval).

  "conc.sparse.group"

  The pooled individual concentration measurements for the current group.

  "time.sparse.group"

  Times associated with the pooled individual concentration measurements for the current group.

  "subject"

  Subject identifiers for the pooled individual concentration measurements for the current interval.

• Constants:

  a value wrapped in base::I()

  The value itself, passed to the function unchanged. Use this for an argument that selects a variant of a shared calculation function (for example, auc.type = I("AUCall")) rather than naming a data source or another parameter.

• For the reference interval:

  a parameter name wrapped in pknca_ref()

  The value of that NCA parameter calculated in the reference interval, which is the interval named by the ⁠<name>_ref⁠ column of the interval specification. A parameter with any such argument is a secondary parameter; see the vignette "Secondary parameters".

Value

NULL (Calling this function has a side effect of changing the available intervals for calculations)

See Also

Other Interval specifications: check.interval.specification(), choose.auc.intervals(), get.interval.cols(), get.parameter.deps(), interval_add_impute(), interval_add_param(), interval_add_secondary(), pknca_cdisc_codes(), pknca_check_parameter_classification(), pknca_concepts(), pknca_interval_table(), pknca_match_route(), pknca_parameter_table(), pknca_presets(), pknca_ref()

Examples

## Not run: 
add.interval.col("cmax",
                 FUN="pk.calc.cmax",
                 values=c(FALSE, TRUE),
                 unit_type="conc",
                 pretty_name="Cmax",
                 desc="Maximum observed concentration")
add.interval.col("cmax.dn",
                 FUN="pk.calc.dn",
                 values=c(FALSE, TRUE),
                 unit_type="conc_dosenorm",
                 pretty_name="Cmax (dose-normalized)",
                 desc="Maximum observed concentration, dose normalized",
                 formalsmap=list(parameter="cmax"),
                 depends="cmax")

## End(Not run)

Description

Add a hash and associated information to enable checking object provenance.

Usage

addProvenance(object, replace = FALSE)

Arguments

Value

The object with provenance as an added item

See Also

checkProvenance()

Description

Calculate the adjusted r-squared value

Usage

adj.r.squared(r.sq, n)

Arguments

Value

The numeric adjusted r-squared value

See Also

Other Half-life and elimination: pk.calc.aucpext(), pk.calc.half.life(), pk.calc.thalf.eff()

Description

A calculation is sparse when only sparse data can produce it, which is a property of the registration rather than a flag; see add.interval.col().

Usage

any_sparse_dense_in_interval(interval, sparse)

Arguments

Value

A logical value indicating if the interval requests any sparse (if sparse=TRUE) or dense (if sparse=FALSE) calculations.

Description

Convert an object into a PKNCAconc object

Usage

as_PKNCAconc(x, ...)

as_PKNCAdose(x, ...)

as_PKNCAdata(x, ...)

as_PKNCAresults(x, ...)

Arguments

Value

A converted object

Functions

• as_PKNCAdose(): Convert an object into a PKNCAdose object

• as_PKNCAdata(): Convert an object into a PKNCAdata object

• as_PKNCAresults(): Convert an object into a PKNCAresults object

Description

Generate a sparse_pk object

Usage

as_sparse_pk(conc, time, subject)

Arguments

Value

A sparse_pk object which is a list of lists. The inner lists have elements named: "time", The time of measurement; "conc", The concentration measured; "subject", The subject identifiers; "imputed", Whether the concentration at that time is imputed (known). The object will usually be modified by future functions to add more named elements to the inner list.

See Also

Other Sparse Methods: pk.calc.aucinf.obs_sparse(), pk.calc.aucivlast_sparse(), pk.calc.auclast_sparse(), pk.calc.sparse_auc(), pk.calc.sparse_aumc(), sparse_auc_weight_linear(), sparse_bootstrap(), sparse_mean(), summary.PKNCAresults_sparse_bootstrap()

Description

Extract the parameter results from a PKNCAresults and return them as a data.frame.

Usage

## S3 method for class 'PKNCAresults'
as.data.frame(
  x,
  ...,
  out_format = c("long", "wide", "cdisc"),
  filter_requested = FALSE,
  filter_excluded = FALSE,
  grpid_cols = NULL,
  grpid_numeric = NULL,
  out.format = deprecated()
)

Arguments

Value

A data.frame (or usually a tibble) of results

Description

Assert that a value is a valid AUC method

Usage

assert_aucmethod(method = c("lin up/log down", "linear", "lin-log"))

Arguments

Value

method or an informative error

Description

If the concentrations or times are invalid, will provide an error. Reasons for being invalid are

• time is not a number

• conc is not a number

• Any time value is NA

• time is not monotonically increasing

• conc and time are not the same length

Usage

assert_conc(conc, any_missing_conc = TRUE)

assert_time(time, sorted_time = TRUE)

assert_conc_time(conc, time, any_missing_conc = TRUE, sorted_time = TRUE)

Arguments

Details

Some cases may generate warnings but allow the data to proceed.

• A negative concentration is often but not always an error; it will generate a warning.

Value

conc or give an informative error

time or give an informative error

NULL, invisibly, when the data are valid; otherwise an informative error

Examples

assert_conc_time(conc = c(0, 2, 1), time = 0:2)
# Unsorted times are allowed when `sorted_time = FALSE`
assert_conc_time(conc = c(0, 2, 1), time = c(2, 0, 1), sorted_time = FALSE)

Description

Assert that a value is a dosing interval

Usage

assert_dosetau(tau)

Arguments

Value

tau or an informative error

Description

The specification is resolved the way PKNCAdata() and pk.nca() resolve it: the name of a column in intervals, NA to use the "impute" column of intervals when there is one, or otherwise a string of imputation methods. Every method named must exist.

Usage

assert_impute_method(impute, intervals = data.frame())

Arguments

Value

The resolved imputation strings (one per interval when read from a column), invisibly, or an error

See Also

PKNCA_impute_fun_list(), PKNCA_impute_method

Other Imputation: PKNCA_impute_fun_list(), PKNCA_impute_method, get_impute_column(), get_impute_method(), pknca_impute_methods()

Examples

assert_impute_method("start_predose,start_conc0")
assert_impute_method(
  "method",
  intervals = data.frame(start = 0, end = 24, method = "start_conc0")
)
try(assert_impute_method("start_misspelled"))

Description

Verifies that an interval definition is valid for a PKNCAdata object. Valid means that intervals are a data.frame (or data.frame-like object), that the column names are either the groupings of the PKNCAconc part of the PKNCAdata object or that they are one of the NCA parameters allowed (i.e. names(get.interval.cols())). The column that the impute setting of the PKNCAdata object names (see get_impute_method()) is also allowed, and it must be a character column, or a pknca_error_interval_impute_not_character error is raised. An interval_id identifies one interval: rows that share it may differ only in the parameters they request (and impute), not in start, end, or the groups, or a pknca_error_secondary_id_conflict error is raised. It will return the intervals argument unchanged, or it will raise an error.

Usage

assert_intervals(intervals, data)

Arguments

Value

The intervals argument unchanged, or it will raise an error.

Description

Assert that an interval is accurately defined as an interval, and return the interval

Usage

assert_intervaltime_single(interval = NULL, start = NULL, end = NULL)

Arguments

Value

interval (or c(start, end))

Description

Assert that a lambda.z value is valid

Usage

assert_lambdaz(
  lambda.z,
  any.missing = TRUE,
  .var.name = checkmate::vname(lambda.z)
)

Arguments

Value

lambda.z or an informative error

Description

Confirm that a value is greater than another value

Usage

assert_number_between(
  x,
  ...,
  na.ok = FALSE,
  len = 1,
  .var.name = checkmate::vname(x)
)

Arguments

Value

x or an informative error

Description

Confirm that a value is greater than another value

Usage

assert_numeric_between(
  x,
  any.missing = FALSE,
  null.ok = FALSE,
  lower_eq = -Inf,
  lower = -Inf,
  upper = Inf,
  upper_eq = Inf,
  ...,
  .var.name = checkmate::vname(x)
)

Arguments

Value

x

Description

Assert that a character vector only contains PKNCA parameter names

Usage

assert_param_name(param)

Arguments

Value

param or give an informative error

Description

Assert that an object is a PKNCAdata object

Usage

assert_PKNCAdata(object)

assert_PKNCAresults(object)

assert_PKNCAconc(object)

assert_PKNCAdose(object)

Arguments

Value

The object

Functions

• assert_PKNCAresults(): Assert that an object is a PKNCAresults object

• assert_PKNCAconc(): Assert that an object is a PKNCAconc object

• assert_PKNCAdose(): Assert that an object is a PKNCAdose object

Description

Assert that a value may either be a column name in the data (first) or a single unit value (second)

Usage

assert_unit_col(unit, data)

assert_unit_value(unit)

assert_unit(unit, data)

Arguments

Value

unit with an attribute of "unit_type" that is either "column" or "value", or NULL if is.null(unit)

Functions

• assert_unit_col(): Assert that a column name contains a character string (that could be a unit specification)

• assert_unit_value(): Assert that a value may be a single unit

  The function does not verify that it is a real unit like "ng/mL" only that it is a single character string.

Description

Support function for AUC integration

Usage

auc_integrate(
  conc,
  time,
  clast,
  tlast,
  lambda.z,
  interval_method,
  fun_linear,
  fun_log,
  fun_inf
)

Arguments

Description

be_assess() performs a complete bioequivalence (BE) assessment of one or more noncompartmental endpoints against a regulatory framework, including reference scaling and the pass/fail decision. It accepts the results of pk.nca() directly (a PKNCAresults object) or a tidy long data.frame, so the same workflow that produces NCA parameters flows into the regulatory decision. It is a thin wrapper over be_fit_models() that adds the be_assess class and its print/summary methods.

Usage

be_assess(object, ...)

## Default S3 method:
be_assess(
  object,
  reference_col,
  reference_value,
  endpoints = c("cmax", "aucinf.obs", "aucinf.pred", "auclast"),
  regulator = "ABE",
  model_type = NULL,
  alpha = 0.1,
  subject = NULL,
  sequence = NULL,
  period = NULL,
  design = NULL,
  covariates = NULL,
  heteroscedastic = FALSE,
  ...
)

## S3 method for class 'PKNCAresults_sparse_bootstrap'
be_assess(
  object,
  reference_col,
  reference_value,
  endpoints = c("cmax", "aucinf.obs", "aucinf.pred", "auclast"),
  regulator = "ABE",
  model_type = NULL,
  alpha = 0.1,
  subject = NULL,
  sequence = NULL,
  period = NULL,
  design = NULL,
  covariates = NULL,
  heteroscedastic = FALSE,
  ...
)

Arguments

Details

The model type is selected automatically from the design and the regulator. By design, a parallel study (one measurement per subject) uses a fixed-effects ANOVA ("anova"), while a crossover or replicate study (repeated measures per subject) uses the mixed model ("lmer") for the geometric mean ratio and its confidence interval. The FDA reference-scaled frameworks (FDA RSABE, NTID, HVNTID) always use intra-subject contrasts ("isc"), as the guidances specify, regardless of design. Pass model_type to override ("lmer", "anova", "isc", "nlme", or "gls"). Within-subject variability uses the regulatory ANOVA estimator for the "lmer"/"anova"/"isc" paths and the treatment-specific mixed-model estimator for "nlme".

With heteroscedastic = TRUE the residual variance is estimated separately for each treatment: a crossover or replicate study uses nlme::lme() with varIdent(~ 1 | treatment) ("nlme"), and a parallel study uses nlme::gls() with the same variance structure ("gls"). lme4::lmer() cannot estimate treatment-specific residual variances (its weights are fixed prior weights), so heteroscedastic = TRUE with model_type = "lmer" is an error. Without reference scaling, "nlme" accepts non-replicated designs and several test formulations; with reference scaling it needs a fully replicated design and one test formulation, because the per-formulation variances are then used as the within-subject variances.

regulator = "descriptive" estimates the geometric means, their ratio, and its confidence interval exactly as for "ABE" but applies no acceptance limits and reports no pass/fail, for comparisons such as food effect and drug-drug interaction studies.

For the results of a sparse bootstrap (Shen and Machado 2017; see sparse_bootstrap()), there is one estimate per treatment, from the sparse data, rather than one per subject. The ratio of the test and reference estimates is the point estimate, and its confidence interval is the percentile interval of the ratios of the bootstrap replicates (model_type = "bootstrap"). The ⁠gm_*⁠ columns hold the estimates of each treatment with their percentile intervals. A parallel design resamples the treatments independently; for a crossover, give the treatment column as paired to sparse_bootstrap(). There is no within-subject variance, so only the "ABE" and "descriptive" frameworks apply, and the results may have no groups other than reference_col (filter them first).

Value

An object of class be_assess (a data.frame), ordered by endpoint (in the order requested) then by test formulation (reference-first), with one row per endpoint and test formulation and the columns endpoint, test, n, design, units (the endpoint's measurement units; the column is omitted with a warning when units are not provided), the reference and test geometric means with their 90% confidence intervals on the measurement scale (gm_reference, gm_reference_lower, gm_reference_upper, gm_test, gm_test_lower, gm_test_upper), gmr_percent, ci_lower, ci_upper, cvwr_percent, cvwt_percent, swr, limit_lower, limit_upper, criterion, regulator, model_type, and pass. ⁠limit_*⁠ are NA for the RSABE criterion and criterion is NA for the limit-based frameworks. For regulator = "descriptive" the limit_lower, limit_upper, criterion, and pass columns are omitted. A caption attribute documents the model and the decision rule, or states that no regulatory decision was applied.

Methods (by class)

• be_assess(PKNCAresults_sparse_bootstrap): Bioequivalence from the percentile intervals of a sparse bootstrap (Shen and Machado 2017)

References

Shen M, Machado SG. Bioequivalence evaluation of sparse sampling pharmacokinetics data using bootstrap resampling method. Journal of Biopharmaceutical Statistics. 2017;27(2):257-264. doi:10.1080/10543406.2016.1265543

See Also

be_compare() to assess one dataset under several frameworks, be_within_var(), and be_regulator().

Other Bioequivalence: be_compare(), be_dataset(), be_design(), be_expand_limits(), be_extract_param(), be_fit_model_single(), be_fit_models(), be_regulator(), be_table(), be_within_var()

Examples

# A replicate-design crossover in long (PPTESTCD/PPORRES) format
set.seed(1)
nsub <- 24
seqs <- rep(c("TRTR", "RTRT"), length.out = nsub)
b <- stats::rnorm(nsub, sd = 0.4)
d <- do.call(rbind, lapply(seq_len(nsub), function(i) {
  trt <- strsplit(seqs[i], "")[[1]]
  data.frame(
    subject = i, sequence = seqs[i], period = seq_along(trt), treatment = trt,
    PPTESTCD = "auclast",
    PPORRES = exp(log(100) + ifelse(trt == "T", 0.04, 0) + b[i] +
                    stats::rnorm(length(trt), sd = 0.45))
  )
}))
be_assess(d, reference_col = "treatment", reference_value = "R",
          endpoints = "auclast", regulator = "EMA")

Description

be_compare() runs be_assess() under several regulatory frameworks and stacks the results, so the same study can be judged side by side under the different reference-scaling rules. Frameworks that the design does not support (for example NTID on a partial replicate) are skipped with a warning. Rows for the "descriptive" framework have NA in the decision columns.

Usage

be_compare(
  object,
  reference_col,
  reference_value,
  endpoints = c("cmax", "aucinf.obs", "aucinf.pred", "auclast"),
  regulators = c("ABE", "EMA", "HC", "GCC", "FDA"),
  model_type = NULL,
  alpha = 0.1,
  subject = NULL,
  sequence = NULL,
  period = NULL,
  design = NULL,
  covariates = NULL,
  heteroscedastic = FALSE
)

Arguments

Value

An object of class be_compare (a data.frame) with the be_assess() columns for every endpoint, test formulation, and regulator.

See Also

be_assess()

Other Bioequivalence: be_assess(), be_dataset(), be_design(), be_expand_limits(), be_extract_param(), be_fit_model_single(), be_fit_models(), be_regulator(), be_table(), be_within_var()

Examples

set.seed(1)
nsub <- 24
seqs <- rep(c("TRTR", "RTRT"), length.out = nsub)
b <- stats::rnorm(nsub, sd = 0.4)
d <- do.call(rbind, lapply(seq_len(nsub), function(i) {
  trt <- strsplit(seqs[i], "")[[1]]
  data.frame(
    subject = i, sequence = seqs[i], period = seq_along(trt), treatment = trt,
    PPTESTCD = "auclast",
    PPORRES = exp(log(100) + ifelse(trt == "T", 0.04, 0) + b[i] +
                    stats::rnorm(length(trt), sd = 0.45))
  )
}))
be_compare(d, reference_col = "treatment", reference_value = "R",
           endpoints = "auclast", regulators = c("EMA", "HC", "GCC", "FDA"))

Description

be_dataset() prepares a noncompartmental result for bioequivalence calculation: it accepts a PKNCAresults object or a tidy long data.frame, resolves the value column, drops excluded/invalid rows, detects the subject/sequence/period columns, validates the reference, and sets the reference formulation as the first factor level. It standardizes the modeling columns (.subject, .sequence, .period, .trt, .logval) used by the downstream fitters.

Usage

be_dataset(object, ...)

## Default S3 method:
be_dataset(
  object,
  reference_col,
  reference_value,
  endpoints = c("cmax", "aucinf.obs", "aucinf.pred", "auclast"),
  subject = NULL,
  sequence = NULL,
  period = NULL,
  covariates = NULL,
  ...
)

## S3 method for class 'PKNCAresults_sparse_bootstrap'
be_dataset(
  object,
  reference_col,
  reference_value,
  endpoints = c("cmax", "aucinf.obs", "aucinf.pred", "auclast"),
  subject = NULL,
  sequence = NULL,
  period = NULL,
  covariates = NULL,
  ...
)

Arguments

Details

The endpoint value is taken from the PPSTRES column when present, otherwise PPORRES. The measurement units are read from the matching units column – PPSTRESU for PPSTRES, or PPORRESU for PPORRES – which a PKNCAresults object provides automatically; a plain data.frame supplies units the same way by including the corresponding PPSTRESU/PPORRESU column. When no units column is present, units are unavailable and the units column is omitted from the assessment table.

Each covariate is copied to a standardized column named ⁠.cov_<name>⁠ (character columns become factors). A covariate may not be one of the subject, sequence, period, treatment, or value columns, and it may not be missing in any row that is analyzed.

Value

An object of class be_dataset: a list with data (the standardized long frame, including a .units column and one ⁠.cov_<name>⁠ column per covariate), columns (the resolved column names, including units and covariates), reference_value, test_levels, and endpoints (those present). For the results of a sparse bootstrap (see sparse_bootstrap()), data has one row per bootstrap replicate, group, and endpoint instead of one per subject and period.

Methods (by class)

• be_dataset(PKNCAresults_sparse_bootstrap): The replicates of a sparse bootstrap, one row per replicate, treatment, and endpoint

See Also

Other Bioequivalence: be_assess(), be_compare(), be_design(), be_expand_limits(), be_extract_param(), be_fit_model_single(), be_fit_models(), be_regulator(), be_table(), be_within_var()

Description

be_design() inspects the treatment-by-period pattern of a crossover study and reports the design type, the replication of the reference and test formulations, and which regulatory frameworks are feasible. Reference scaling (EMA/HC/GCC/FDA) requires the reference to be replicated; the narrow therapeutic index frameworks additionally require the test to be replicated.

Usage

be_design(data, subject, sequence, period, treatment, reference_value)

Arguments

Value

An object of class be_design: a list with elements design (one of "parallel", "2x2x2", "full_replicate", "partial_replicate", "other"), n_sequences, n_periods, n_treatments, n_subjects, sequences, treatments, reference, replicate_reference, replicate_test, reps_reference, reps_test, balanced, and feasible (a named logical vector for abe, abel, rsabe, ntid, hvntid). reps_reference is the median, over subjects, of the number of times a subject received the reference. reps_test is the same median computed separately for each test formulation; with several test formulations it is the smallest of those medians, so replicate_test is TRUE only when every test formulation is replicated.

See Also

be_assess()

Other Bioequivalence: be_assess(), be_compare(), be_dataset(), be_expand_limits(), be_extract_param(), be_fit_model_single(), be_fit_models(), be_regulator(), be_table(), be_within_var()

Examples

d <- data.frame(
  subject = rep(1:4, each = 4),
  period = rep(1:4, times = 4),
  sequence = rep(c("TRTR", "RTRT"), each = 8),
  treatment = c("T", "R", "T", "R", "R", "T", "R", "T",
                "T", "R", "T", "R", "R", "T", "R", "T")
)
be_design(d, "subject", "sequence", "period", "treatment", reference_value = "R")

Description

be_expand_limits() computes the (possibly widened) bioequivalence acceptance limits for a scaled-ABE framework given the within-reference standard deviation. For EMA and Health Canada the limits widen geometrically with swR and are capped; for the GCC they jump to a fixed wider band; below the switching variability they remain the conventional 80.00-125.00%.

Usage

be_expand_limits(swR, regulator)

Arguments

Value

A named numeric vector c(lower, upper) of acceptance limits as percentages.

See Also

be_regulator(), be_assess()

Other Bioequivalence: be_assess(), be_compare(), be_dataset(), be_design(), be_extract_param(), be_fit_model_single(), be_fit_models(), be_regulator(), be_table(), be_within_var()

Examples

be_expand_limits(0.485, "EMA") # capped expansion
be_expand_limits(0.20, "EMA")  # below the switch: 80-125%
be_expand_limits(0.40, "GCC")  # fixed GCC band

Description

be_extract_param() turns a be_fit_model_single() fit into the parameters the regulatory decision needs. It always computes the intra-subject-contrast (ISC) point estimate, then dispatches on the model type to extract the model-based geometric means, the geometric mean ratio and its confidence interval, and the within-formulation standard deviations.

Usage

be_extract_param(fit, ds_ep, alpha = 0.1)

Arguments

Value

A data.frame with one row per test formulation, carrying the model and ISC point estimates/intervals, geometric means, and within-formulation variances.

See Also

Other Bioequivalence: be_assess(), be_compare(), be_dataset(), be_design(), be_expand_limits(), be_fit_model_single(), be_fit_models(), be_regulator(), be_table(), be_within_var()

Description

be_fit_model_single() fits the average-BE model for a single endpoint and dispatches on model_type to be_fit_model_lmer(), be_fit_model_nlme(), be_fit_model_gls(), or be_fit_model_anova(). This is the only place model fitting happens. For the "lmer", "anova", and "isc" types the within-formulation ANOVA variances are also fit here; for "nlme" they come from the single mixed model. Covariate columns carried by be_dataset() (⁠.cov_<name>⁠) enter every model as additive fixed effects.

Usage

be_fit_model_single(
  ds_ep,
  model_type = c("lmer", "nlme", "anova", "isc", "gls"),
  scaling = TRUE
)

Arguments

Value

An object of class be_fit: a list with model_type, the fitted model, and (for lmer/anova/isc) ref_var/test_var within-formulation ANOVA variances. The endpoint's measurement units are attached as a units attribute (NULL when not provided).

See Also

Other Bioequivalence: be_assess(), be_compare(), be_dataset(), be_design(), be_expand_limits(), be_extract_param(), be_fit_models(), be_regulator(), be_table(), be_within_var()

Description

be_fit_models() runs the single bioequivalence calculation path and returns the regulatory pass/fail table. It coordinates the stages in order: be_dataset() to prepare the data, be_design() to classify the design and choose the model, be_fit_model_single() to fit, be_extract_param() to extract the parameters, and be_table() to apply the regulatory decision. be_assess() and be_compare() are thin verbs over it.

Usage

be_fit_models(
  object,
  reference_col,
  reference_value,
  endpoints = c("cmax", "aucinf.obs", "aucinf.pred", "auclast"),
  regulator = "ABE",
  model_type = NULL,
  alpha = 0.1,
  subject = NULL,
  sequence = NULL,
  period = NULL,
  design = NULL,
  covariates = NULL,
  heteroscedastic = FALSE
)

Arguments

Value

A data.frame with one row per endpoint and test formulation (the columns described in be_assess()).

See Also

Other Bioequivalence: be_assess(), be_compare(), be_dataset(), be_design(), be_expand_limits(), be_extract_param(), be_fit_model_single(), be_regulator(), be_table(), be_within_var()

Description

be_regulator() returns the scaling type, switching and capping rules, and regulatory constants that define a bioequivalence (BE) assessment framework. It is the single source of truth for these values: be_assess() and the internal decision functions pull every constant from here rather than hard-coding it.

Usage

be_regulator(
  name = c("ABE", "EMA", "HC", "GCC", "FDA", "NTID", "HVNTID", "descriptive")
)

Arguments

Details

The supported frameworks and their constants are:

• ABE – average bioequivalence; the universal unscaled criterion that the 90% confidence interval fall within 80.00-125.00%. No reference scaling.

• EMA – average bioequivalence with expanding limits (ABEL). Scaling begins when the within-reference coefficient of variation (CVwR) exceeds 30% (cvswitch = 0.30); the limits widen as ⁠exp(+/- k * swR)⁠ with the regulatory constant k = 0.76 and the expansion is capped at ⁠CVwR = 50%⁠ (limits 69.84-143.19%). The constant 0.76 is log(1.25) / sqrt(log(1 + 0.30^2)) rounded to two decimals, as fixed by the EMA bioequivalence guideline.

• HC – Health Canada; ABEL with the same k = 0.76 but the expansion is capped at ⁠CVwR = 57.382%⁠ (upper limit 150%).

• GCC – Gulf Cooperation Council; fixed widened limits of 75.00-133.33% whenever ⁠CVwR > 30%⁠ (not CV-dependent).

• FDA – reference-scaled average bioequivalence (RSABE). The linearized (Howe/Hyslop) criterion uses r_const = log(1.25) / 0.25 = 0.8926 (theta = r_const^2) and switches from unscaled ABE when swR >= 0.294 (CVwR of about 30%).

• NTID – FDA narrow therapeutic index drugs; uses r_const = -log(0.9) / 0.1 = 1.0536 and always applies the scaled criterion (a fully replicated design is required).

• HVNTID – FDA highly variable narrow therapeutic index drugs; the RSABE-style scaled criterion with the NTID constant and the within-subject standard deviation ratio constraint.

• descriptive – no regulatory decision. The geometric means, their ratio, and its confidence interval are estimated exactly as for ABE, but no acceptance limits are applied and no pass/fail is reported. Use it for comparisons that are estimated rather than judged, such as food effect and drug-drug interaction studies.

All decision frameworks additionally impose the point-estimate constraint that the geometric mean ratio fall within 80.00-125.00%.

Value

An object of class be_regulator: a list with elements name, scaling (one of "none", "abel", "rsabe", "ntid", "hvntid"), cvswitch, r_const, cvcap, switch_swr, pe_constr, est_method ("anova" or "isc"), decision (FALSE only for "descriptive"), and switch_basis.

See Also

be_expand_limits() for the ABEL acceptance limits and be_assess() for the full assessment.

Other Bioequivalence: be_assess(), be_compare(), be_dataset(), be_design(), be_expand_limits(), be_extract_param(), be_fit_model_single(), be_fit_models(), be_table(), be_within_var()

Examples

be_regulator("EMA")
be_regulator("FDA")
be_regulator("descriptive")

Description

be_table() takes the parameters from be_extract_param() and a regulatory framework and produces the final per-endpoint pass/fail table. It selects the regulator-appropriate statistic (the model contrast for the expanding-limits frameworks, intra-subject contrasts for the FDA family) and calls the per-framework decision functions; it is the only place regulator decisions are made.

Usage

be_table(
  params,
  regulator,
  alpha = 0.1,
  design = NA_character_,
  model_type = NA_character_
)

Arguments

Value

A data.frame with one row per endpoint and test formulation and the pass/fail decision columns. For the "descriptive" framework the decision columns (limit_lower, limit_upper, criterion, and pass) are omitted.

See Also

Other Bioequivalence: be_assess(), be_compare(), be_dataset(), be_design(), be_expand_limits(), be_extract_param(), be_fit_model_single(), be_fit_models(), be_regulator(), be_within_var()

Description

be_within_var() estimates the within-subject standard deviations of the log-transformed endpoint separately for the reference (swR) and test (swT) formulations, the quantities that reference-scaling frameworks need. The default model_type = "anova" is an analysis of variance (ANOVA) of the replicate observations within each formulation; this is the estimator used by both Method A and Method B of the EMA replicateBE reference implementation and by the FDA moment-based approach, and it works for full and partial replicate designs. model_type = "nlme" instead fits a single mixed model with treatment-specific residual variances and requires a fully replicated design; it is provided as the alternative described in the FDA progesterone guidance and can differ slightly from "anova".

Usage

be_within_var(
  data,
  value,
  subject,
  period,
  treatment,
  reference_value,
  model_type = c("anova", "nlme"),
  alpha = 0.1
)

Arguments

Value

An object of class be_within_var: a list with swR, swT, s2wR, s2wT, cvwr_percent, cvwt_percent, df_wR, df_wT, sw_ratio (= swT/swR), sw_ratio_ci_upper (the upper 1 - alpha confidence bound of the ratio), model_type, and alpha. swT and the ratio are NA when the test formulation is not replicated (for example a partial replicate design).

See Also

be_assess()

Other Bioequivalence: be_assess(), be_compare(), be_dataset(), be_design(), be_expand_limits(), be_extract_param(), be_fit_model_single(), be_fit_models(), be_regulator(), be_table()

Description

Generate functions to do the named function (e.g. mean) applying the business rules.

Usage

business.mean(x, ...)

business.sd(x, ...)

business.cv(x, ...)

business.geomean(x, ...)

business.geocv(x, ...)

business.min(x, ...)

business.max(x, ...)

business.median(x, ...)

business.range(x, ...)

Arguments

Value

The value of the various functions or NA if too many values are missing

Functions

• business.sd(): Compute the standard deviation with business rules.

• business.cv(): Compute the coefficient of variation with business rules.

• business.geomean(): Compute the geometric mean with business rules.

• business.geocv(): Compute the geometric coefficient of variation with business rules.

• business.min(): Compute the minimum with business rules.

• business.max(): Compute the maximum with business rules.

• business.median(): Compute the median with business rules.

• business.range(): Compute the range with business rules.

See Also

pk.business()

Description

Check that the conversion to a data type does not change the number of NA values

Usage

check.conversion(x, FUN, ...)

Arguments

Value

FUN(x, ...) or an error if the set of NAs change.

Description

Calculation interval specifications are data frames defining what calculations will be required and summarized from all time intervals. Note: parameters which are not requested may be calculated if it is required for (or computed at the same time as) a requested parameter.

Usage

check.interval.specification(x, impute = NA_character_)

Arguments

Details

start and end time must always be given as columns, and the start must be before the end. Other columns define the parameters to be calculated and the groupings to apply the intervals to.

Data are selected for calculation within an interval by the time of the measurement or dose: a row is included when its time is at or after start and at or before end (a dose exactly at end is not included in the interval). For duration data (for example, urine collections or intravenous infusions), the time is the start of the collection or administration, and the duration is not considered during selection: a collection that starts within the interval and ends after end is included and contributes its full amount to the interval. For the simplest interpretation of results, align collection start and end times with interval boundaries.

Value

x The potentially updated data frame with the interval calculation specification.

See Also

The vignette "Selection of Calculation Intervals"

Other Interval specifications: add.interval.col(), choose.auc.intervals(), get.interval.cols(), get.parameter.deps(), interval_add_impute(), interval_add_param(), interval_add_secondary(), pknca_cdisc_codes(), pknca_check_parameter_classification(), pknca_concepts(), pknca_interval_table(), pknca_match_route(), pknca_parameter_table(), pknca_presets(), pknca_ref()

Description

Check the hash of an object to confirm its provenance.

Usage

checkProvenance(object)

Arguments

Value

TRUE if the provenance is confirmed to be consistent, FALSE if the provenance is not consistent, or NA if provenance is not present. An object that was modified after it was created by a PKNCA function that marks provenance (for example dplyr::filter(), dplyr::mutate(), exclude(), or normalize() on a PKNCAresults object) has a hash such as "filtered from <hash>" instead of the original hash and always gives FALSE.

See Also

addProvenance()

Description

Choose how to interpolate, extrapolate, or integrate data in each concentration interval

Usage

choose_interval_method(conc, time, tlast, method, auc.type, options)

Arguments

Value

A character vector of methods for interpolation/extrapolation methods that is the same length as conc which indicates how to interpolate/integrate between each of the concentrations (all but the last value in the vector) and how to extrapolate after tlast (the last item in the vector). Possible values in the vector are: 'zero', 'linear', 'log', and 'extrap_log'

Description

Intervals are selected by the following metrics:

1. If there are no dose times, no intervals are generated and a "pknca_warning_no_dose_times_for_group" warning is given.

2. If only one dose is administered and any sample follows it, the interval runs from the dose to infinity with the parameters pknca_interval_table() gives for a single dose.

3. If more than one dose is administered, an interval is generated between any two consecutive doses that have samples at both dose times and at least one sample between them. It is a dosing interval when the samples run up to the next dose, and a single-dose profile bounded by the next dose when they stop partway and leave a washout.

4. For the final dose, the dosing interval ($\tau$) is found with find.tau(). An interval one $\tau$ long is generated when a sample was taken at its end, with the parameters for a dose at steady state. It starts at the first dose of the last complete cycle, which is the last dose itself unless the regimen gives more than one dose per $\tau$, so that the interval never contains a dose that was not recorded.

5. If samples continue beyond $\tau$ after the last dose, the half-life is calculated from the last dose onward. If the last dose has samples after it but gets neither of these, its profile is calculated to infinity as a single dose.

Usage

choose.auc.intervals(
  time.conc,
  time.dosing,
  options = list(),
  single.dose.aucs = NULL,
  route = "extravascular",
  sparse = FALSE,
  timeu = NULL,
  time.conc.nominal = NULL,
  time.dosing.nominal = NULL,
  dense.samples = 3,
  conc = NULL
)

Arguments

Details

When find.dose.regimen() finds a change of regimen in the dose times (more than one segment) and the design is not sparse, the intervals follow the segments instead:

• One steady-state interval for each segment, when a sample ends it. An earlier segment's interval is its last complete cycle, from the cycle's first dose to the recorded dose one period later (the dose that starts the next segment, unless a dose was missed before it), so it never contains a later dose. The last segment's interval is its last cycle, one period at the segment's own period. Like the interval after the last dose, a steady-state interval needs only a sample at its end, so it may have as few as two samples.

• The interval after the first dose, as above.

• The interval after any other dose only when the dose is sampled densely: at least dense.samples samples (3 by default) strictly within one period of its segment after the dose. A sample counts by its nominal time when it has one (time.conc.nominal), from the dose's nominal time when that is given (time.dosing.nominal), so that a sample drawn a little late counts where it was scheduled; a sample without a nominal time counts by its actual time. Samples at the same time count once, and samples without a concentration (conc is NA) do not count; samples below the limit of quantification do. Nominal times must share the actual times' origin (time since the first dose, for example). When they restart instead, as times since the latest dose do, the actual times are used with a "pknca_warning_intervals_nominal_restart" warning.

• The last dose gets the intervals above at the period of the last segment, even when an earlier segment has more doses.

A "pknca_warning_intervals_by_segment" warning names the segments and the intervals chosen. It is also a "pknca_warning_tau_regimen_change" warning, which it replaces.

$\tau$ is matched to the nominal dosing intervals of find.dose.regimen() in the time unit timeu, taken to be hours when it is not given: dose times recorded a little early or late give the nominal interval, and an interval that matches none of them, such as dosing every hour, gives a "pknca_warning_tau_not_nominal" warning. With timeu = NA (a unit PKNCA cannot use), $\tau$ is found from the dose times alone.

Times are matched within a tolerance rather than exactly, so a sample drawn a little before its nominal time still bounds the interval it belongs to. The window is the auto.interval.tolerance option as a fraction of the interval's length, and it only reaches backward: a sample drawn after a boundary belongs to what follows that boundary, so a concentration drawn after a dose cannot stand in for the predose sample.

Setting the auto.interval.method option to "legacy" calculates the parameter lists PKNCA used before pknca_interval_table() was available: the single.dose.aucs option for single-dose data, and AUClast, Cmax, and Tmax for each interval of multiple-dose data. The intervals themselves are found the same way either way.

Value

A data frame with columns for start, end, and the parameters to calculate. See check.interval.specification() for column definitions. The data frame may have zero rows if no intervals could be found.

See Also

pknca_interval_table(), pk.calc.auc(), pk.calc.half.life(), PKNCA.options()

Other Interval specifications: add.interval.col(), check.interval.specification(), get.interval.cols(), get.parameter.deps(), interval_add_impute(), interval_add_param(), interval_add_secondary(), pknca_cdisc_codes(), pknca_check_parameter_classification(), pknca_concepts(), pknca_interval_table(), pknca_match_route(), pknca_parameter_table(), pknca_presets(), pknca_ref()

Other Interval determination: find.dose.regimen(), find.tau(), resolve_dose_tau()

Examples

# A single dose gives one profile to infinity
choose.auc.intervals(c(0, 1, 2, 4, 8, 24), 0)[, c("start", "end")]

# Daily dosing with a dense profile on the first and last day
choose.auc.intervals(
  c(0, 1, 2, 4, 8, 12, 24, 48, 72, 96, 120, 144, 145, 146, 148, 152, 156, 168, 192),
  seq(0, 144, by = 24)
)[, c("start", "end")]

Description

Handle BLQ values in the concentration measurements as requested by the user.

Usage

clean.conc.blq(
  conc,
  time,
  ...,
  options = list(),
  conc.blq = NULL,
  conc.na = NULL,
  check = TRUE
)

Arguments

Details

NA concentrations (and their associated times) will be handled as described in clean.conc.na() before working with the BLQ values. The method for handling NA concentrations can affect the output of which points are considered BLQ and which are considered "middle". Values are considered BLQ if they are 0.

conc.blq can be set either a scalar indicating what should be done for all BLQ values or a list with elements either named "first", "middle" and "last" or "before.tmax" and "after.tmax" each set to a scalar.

The meaning of each of the list elements is:

first

Values up to the first non-BLQ value. Note that if all values are BLQ, this includes all values.

middle

Values that are BLQ between the first and last non-BLQ values.

last

Values that are BLQ after the last non-BLQ value

before.tmax

Values that are BLQ before the time at first maximum concentration

after.tmax

Values that are BLQ after the time at first maximum concentration

The valid settings for each are:

"drop"

Drop the BLQ values

"keep"

Keep the BLQ values

a number

Set the BLQ values to that number

Value

The concentration and time measurements (data frame) filtered and cleaned as requested relative to BLQ in the middle.

See Also

Other Data cleaners: clean.conc.na()

Description

NA concentrations (and their associated times) will be removed then the BLQ values in the middle

Usage

clean.conc.na(conc, time, ..., options = list(), conc.na = NULL, check = TRUE)

Arguments

Value

The concentration and time measurements (data frame) filtered and cleaned as requested relative to NA in the concentration.

See Also

Other Data cleaners: clean.conc.blq()

Description

The calculation follows equation A3 in Holder 2001 (see references below):

Usage

cov_holder(sparse_pk)

Arguments

Details

$\hat{\sigma}_{ij} = \sum\limits_{k=1}^{r_{ij}}{\frac{\left(x_{ik} - \bar{x}_i\right)\left(x_{jk} - \bar{x}_j\right)}{\left(r_{ij} - 1\right) + \left(1 - \frac{r_{ij}}{r_i}\right)\left(1 - \frac{r_{ij}}{r_j}\right)}}$

If $r_{ij} = 0$, then $\hat{\sigma}_{ij}$ is defined as zero (rather than dividing by zero).

Where:

$\hat{\sigma}_{ij}$

The covariance of times i and j

$r_i$ and $r_j$

The number of subjects (usually animals) at times i and j, respectively

$r_{ij}{r_ij}$

The number of subjects (usually animals) at both times i and j

$x_{ik}$ and $x_{jk}$

The concentration measured for animal k at times i and j, respectively

$\bar{x}_i$ and $\bar{x}_j$

The mean of the concentrations at times i and j, respectively

The Cauchy-Schwartz inequality is enforced for covariances to keep correlation coefficients between -1 and 1, inclusive, as described in equations 8 and 9 of Nedelman and Jia 1998.

Value

A matrix with one row and one column for each element of sparse_pk_attribute. The covariances are on the off diagonals, and for simplicity of use, it also calculates the variance on the diagonal elements.

References

Holder DJ. Comments on Nedelman and Jia’s Extension of Satterthwaite’s Approximation Applied to Pharmacokinetics. Journal of Biopharmaceutical Statistics. 2001;11(1-2):75-79. doi:10.1081/BIP-100104199

Nedelman JR, Jia X. An extension of Satterthwaite’s approximation applied to pharmacokinetics. Journal of Biopharmaceutical Statistics. 1998;8(2):317-328. doi:10.1080/10543409808835241

Description

The following functions are defunct

Usage

check.conc.time(...)

Arguments

Functions

• check.conc.time(): Defunct as of version 0.11

Description

Checks if specified unit columns exist in a PKNCA object (either PKNCAconc or PKNCAdose). If the columns do not exist, it creates them and assigns default values (NA or existing units).

Usage

ensure_column_unit_exists(pknca_obj, unit_name)

Arguments

Details

The function performs the following steps:

1. Checks if the specified unit columns exist in the PKNCA object.

2. If a column does not exist, it creates the column and assigns default values.

3. If not default values are provided, it assigns NA to the new column.

Value

The updated PKNCA object with ensured unit columns.

Description

Exclude data points or results from calculations or summarization.

Usage

exclude(object, reason, mask, FUN)

## Default S3 method:
exclude(object, reason, mask, FUN)

Arguments

Details

Only one of mask or FUN may be given. If FUN is given, it will be called with two arguments: a data.frame (or similar object) that consists of a single group of the data and the full object (e.g. the PKNCAconc object), FUN(current_group, object), and it must return a logical vector equivalent to mask or a character vector with the reason text given when data should be excluded or NA_character_ when the data should be included (for the current exclusion test).

Value

The object with updated information in the exclude column. The exclude column will contain the reason if mask or FUN indicate. If a previous reason for exclusion was given, then subsequent reasons for exclusion will be added to the first with a semicolon space ("; ") separator.

Methods (by class)

• exclude(default): The general case for data exclusion

See Also

Other Result exclusions: exclude_nca, pknca_exclude_rules(), pknca_missing_samples()

Examples

myconc <- PKNCAconc(data.frame(subject=1,
                               time=0:6,
                               conc=c(1, 2, 3, 2, 1, 0.5, 0.25)),
                    conc~time|subject)
exclude(myconc,
        reason="Carryover",
        mask=c(TRUE, rep(FALSE, 6)))

Description

Exclude NCA parameters based on examining the parameter set.

Usage

exclude_nca_span.ratio(min.span.ratio)

exclude_nca_max.aucinf.pext(max.aucinf.pext)

exclude_nca_count_conc_measured(
  min_count,
  exclude_param_pattern = c("^aucall", "^aucinf", "^aucint", "^auciv", "^auclast",
    "^aumc", "^sparse_auc")
)

exclude_nca_min.hl.r.squared(min.hl.r.squared)

exclude_nca_min.hl.adj.r.squared(min.hl.adj.r.squared = 0.9)

exclude_nca_tmax_early(tmax_early = 0)

exclude_nca_tmax_0()

exclude_nca_tmax_coverage(min_subjects = 4, k_warn = 1.5, k_exclude = 3)

Arguments

Value

A function to give to exclude() as FUN. Its pknca_affected_parameters attribute lists the parameters it can exclude, and its pknca_options attribute lists the PKNCA.options() entries its thresholds came from (see pknca_exclude_rules()).

Functions

• exclude_nca_span.ratio(): Exclude based on the half-life span ratio

• exclude_nca_max.aucinf.pext(): Exclude based on the percent of AUC extrapolated to infinity (both observed and predicted)

• exclude_nca_count_conc_measured(): Exclude based on the count of concentrations measured and not below the lower limit of quantification (affects AUC and AUMC parameters)

• exclude_nca_min.hl.r.squared(): Exclude based on half-life r-squared

• exclude_nca_min.hl.adj.r.squared(): Exclude based on half-life adjusted r-squared

• exclude_nca_tmax_early(): Exclude based on implausibly early Tmax (often used for extravascular dosing with a Tmax value of 0)

• exclude_nca_tmax_0(): Exclude based on implausibly early Tmax (special case for tmax_early = 0)

• exclude_nca_tmax_coverage(): Exclude based on whether a subject has a sample within Tukey's fences around the Tmax values of its group; the rule flags a subject with no sample within the inner fences, and excludes only a subject with no sample within the outer fences

Tmax coverage

exclude_nca_tmax_coverage() compares each subject's samples with the Tmax values of its group; it flags a subject whose samples miss the usual Tmax times, and excludes only beyond the outer fences. The group is the summary group of summary.PKNCAresults(): every grouping column except the subject, with the interval start and end (so each part, treatment, analyte, and interval is its own group). From the first and third quartiles of the Tmax values of every subject in the group (the subject being judged included), Tukey's inner fences are the quartiles extended by k_warn times the interquartile range, and the outer fences by k_exclude times it. The quartiles are those of stats::quantile(type = 7), the default type; with few subjects, the types differ (Tmax values of 1, 1, 2, 2, 1, and 8 give a third quartile of 2 with type 7, 3.5 with type 6, and 2.5 with type 8). Tmax values that are missing or already excluded are not used. The ranges never start before the interval start, where a reported range starts when its lower fence is below it. A sample at the interval start counts only when the subject's dose at or before the interval start is an intravascular bolus (route intravascular and no duration or a duration of zero in PKNCAdose()), so a predose sample does not count after an extravascular dose or when the results have no dose data.

The samples are the concentration rows with an actual time within the interval (the rows that pk.nca() used) that have a concentration and are not excluded. When the concentration data have a nominal time (time.nominal in PKNCAconc()), the samples are placed by their nominal time minus the interval start, so the nominal times must share the origin of the interval times (for example, the nominal time since the first dose); otherwise, they are placed by their actual time. The Tmax values are placed the same way: with nominal times, a subject's Tmax is the nominal time of the sample it was found at, so an offset between the actual and nominal times moves the fences and the samples together. A subject whose Tmax sample has no nominal time does not enter the fences, and a subject whose samples in the interval have no nominal time at all is not judged, with a pknca_message_tmax_coverage_no_nominal_subject message. Times are never converted between units, and the time unit is only used in the text.

• A subject with no sample within the outer fences is excluded: every parameter of that interval is excluded with a reason that gives the outer range and the subject's sample nearest to it.

• A subject with a sample within the outer fences but none within the inner fences is flagged as a possible data issue and not excluded: a pknca_warning_tmax_coverage_outlier warning has the fields group (a one-row data.frame with the group and subject), tmax_range (the inner range, relative to the interval start), and nearest_sample (the subject's sample nearest to it, relative to the interval start).

• With nominal times, a subject with a sample within the inner fences that is missing some of the group's nominal times within them (see pknca_missing_samples()) gets a pknca_message_tmax_coverage_partial message that Cmax and Tmax may be unreliable. Its fields are group, tmax_range, time_nominal_missing, and reason (as in pknca_missing_samples()). Without nominal times, there is no schedule to compare with, and no message is given.

• The warnings and messages can be caught with withCallingHandlers().

• A group with fewer than min_subjects subjects with a Tmax on the basis of the fences (one subject, for example) is not checked, and a pknca_message_tmax_coverage_few_subjects message says so once per group. Quartiles of fewer than four values describe the spread of the group poorly.

• When the nominal times disagree with the interval, the group is not checked, and a pknca_warning_tmax_coverage_no_nominal warning says so once per group. They disagree when no nominal time of the group is after the interval start, when most samples of the group with an actual time in the interval have a nominal time outside it, or when a subject's nominal times go back to the start of its schedule while its actual times increase within the interval, as when the nominal times restart at each dose.

• Sparse data have one Tmax per group, from the mean profile, so they are not checked, and a pknca_message_tmax_coverage_sparse message says so once per call to exclude().

See Also

Other Result exclusions: exclude(), pknca_exclude_rules(), pknca_missing_samples()

Examples

my_conc <- PKNCAconc(data.frame(conc=1.1^(3:0),
                                time=0:3,
                                subject=1),
                     conc~time|subject)
my_data <- PKNCAdata(my_conc,
                     intervals=data.frame(start=0, end=Inf,
                                          aucinf.obs=TRUE,
                                          aucpext.obs=TRUE))
my_result <- pk.nca(my_data)
my_result_excluded <- exclude(my_result,
                              FUN=exclude_nca_max.aucinf.pext())
as.data.frame(my_result_excluded)

Description

Exclude rows from NCA results based on specified thresholds for a given parameter. This function allows users to define minimum and/or maximum acceptable values for a parameter and excludes rows that fall outside these thresholds.

Usage

exclude_nca_by_param(
  parameter,
  min_thr = NULL,
  max_thr = NULL,
  affected_parameters = parameter
)

Arguments

Value

A function that can be used with PKNCA::exclude to mark through the 'exclude' column the rows in the PKNCA results based on the specified thresholds for a parameter. Its pknca_affected_parameters attribute lists the parameters it can mark (see pknca_exclude_rules()).

Examples

# Example dataset
my_data <- PKNCA::PKNCAdata(
  PKNCA::PKNCAconc(data.frame(conc = 5:1,
                              time = 0:4,
                              subject = 1),
                   conc ~ time | subject),
  PKNCA::PKNCAdose(data.frame(subject = 1, dose = 100, time = 0),
                   dose ~ time | subject)
)
my_result <- PKNCA::pk.nca(my_data)

# Exclude rows where span.ratio is less than 2
excluded_result <- PKNCA::exclude(
  my_result,
  FUN = exclude_nca_by_param("span.ratio", min_thr = 2)
)
as.data.frame(excluded_result)

Description

Rows are selected by their time falling within the interval: start <= time and time <= end (or time < end when include_end=FALSE). For duration data (for example, urine collections or intravenous infusions), time is the start of the collection or administration, and the duration column is not consulted during selection: a record whose duration starts within the interval and ends after the interval end is selected and contributes its full amount to calculations within the interval. For the simplest interpretation of results, align collection start and end times with interval boundaries.

Usage

filter_interval(data, start, end, include_na = FALSE, include_end = TRUE)

Arguments

Value

The rows of data selected for the interval

Description

Filtering a PKNCAconc or PKNCAdose object filters its data. Filtering a PKNCAresults object filters the result table and, when the filter only uses group columns (the columns after the | in the PKNCAconc formula), the concentration data, the dose data, and the intervals of x$data as well, so that the filtered results are consistent with their data. Only those three are filtered; group_ref and units of the PKNCAdata are not.

Usage

## S3 method for class 'PKNCAresults'
filter(.data, ..., .by = NULL, .preserve = FALSE)

## S3 method for class 'PKNCAconc'
filter(.data, ..., .by = NULL, .preserve = FALSE)

## S3 method for class 'PKNCAdose'
filter(.data, ..., .by = NULL, .preserve = FALSE)

Arguments

Details

The filter is evaluated once, on the result table. The groups that remain there are the groups kept: the rows of the concentration data, dose data, and intervals are kept when their values in the group columns that they share with the result table match a remaining group. A table that has none of those group columns (for example, intervals with no group columns) is left whole, and groups that have no rows in the result table are dropped from the data. Because the filter is evaluated only on the results, any filter that aggregates over rows (such as ID == max(ID)) keeps the same groups in every table.

A filter that uses any other column of the result table (such as PPTESTCD, PPORRES, or exclude), or that uses no column of the result table, filters the result table only. Columns are recognized when the expressions name them (part == "SAD", .data$part == "SAD", and the columns of .by). Variables of the calling environment are not treated as columns. Filters that choose columns without naming them (.data[[var]], across(), if_any(), if_all(), pick(), and tidyselect helpers such as all_of() or starts_with()) filter the result table only, with a message that the data were not filtered. The columns start and end belong to the result table, so a filter on them leaves the data unchanged.

mutate() and the joins change only the result table; assigning into the object directly is the caller's responsibility and is not tracked.

A PKNCAresults object that a PKNCA dplyr verb changes (filter(), mutate(), group_by(), ungroup(), and the joins) no longer matches the hash that checkProvenance() verifies: the hash is replaced by a marker such as "filtered from <hash>" and checkProvenance() returns FALSE. A call that leaves the object identical keeps its provenance.

See Also

Other dplyr verbs: group_by.PKNCAresults(), inner_join.PKNCAresults(), mutate.PKNCAresults()

Description

The dose times are sorted and times that repeat are dropped. The regimen is then described as one or more segments, each a stretch of dosing that repeats over a period, found in this order:

1. Equally spaced doses repeat over their spacing.

2. A cycle of 2 to 4 doses per period that every dose follows is looked for next. The period is the median span of that many spacings, refined by least squares, and each dose's time within the period falls into one of the positions of the cycle. The spacings between the positions must differ from one another by more than tol, every dose must be within snap.tol of the period of its position, and every position must hold at least two doses (two complete periods). The positions must also explain the scatter of the doses: the doses sit at most half as far from their positions as the spacings sit from their median, and the positions fit the doses better than evenly spaced positions by more than chance (an F test at the 0.999 level). Daily doses recorded a few hours early or late are therefore daily dosing, not a cycle. Twice-daily doses at 08:00 and 16:00 repeat every 24 hours with offsets 0 and 8. When the period is not one of the given tau.choices and a whole number of periods is, that multiple is used if the doses hold two complete repeats of it (so a 48 hour choice selects two days of twice-daily dosing only when there are at least nine doses); the built-in nominal set never selects a longer period.

3. Doses whose spacings are all within tol of their median are evenly spaced with scatter, and repeat over the median spacing.

4. Otherwise, each spacing is labeled with the candidate it is within tol of (on the log scale), and the rest are clustered on the log scale. Doses squeezed into one interval between two runs of the regimen are set aside as extra doses. Runs of at least min.run spacings with one label anchor segments, and the runs must hold most of the spacings. A spacing outside the runs is a missed dose when it is a whole number (up to max.missed) of the segment's interval and is irregular when it is not; a dose given early or late is the dose between two irregular spacings. Neighboring anchors with the same label are one segment, so a change of regimen gives several segments.

5. When that reading has missed or irregular doses or more than one segment, a cycle of 2 to 4 doses that at least 70% of the doses follow is used instead if it explains more spacings, or as many with no more missed, off-schedule, or extra doses and changes of regimen. This keeps three-times-daily dosing with a dose not given as three times daily, and daily dosing after twice-daily dosing as a change of regimen.

6. If none of that fits, there is no repeating interval.

Usage

find.dose.regimen(
  x,
  tau.choices = NULL,
  timeu = NULL,
  options = list(),
  tol = 0.2,
  snap.tol = 0.1,
  min.run = 2,
  max.missed = 4
)

Arguments

Details

The interval of a segment is snapped to the nearest candidate within snap.tol (source "nominal"), and is otherwise the value found in the data (source "auto"). The value found in the data is the median of the spacings (or spans) that set it, so scatter in the recorded times does not move it. The candidates are tau.choices when it is given. Otherwise they are the built-in nominal intervals, converted from hours to timeu: Q4H (4 hours), QID (6), TID (8), BID (12), QD (24), QOD (48), Q72H (72), QW (168), Q2W (336), Q3W (504), Q4W (672), Q6W (1008), Q8W (1344), and Q12W (2016).

Without a time unit, the times are taken to be hours, as PKNCA takes date-times to be, so dose times 24 and 26 hours apart are once-daily dosing. Times recorded in another unit without saying so are then compared with intervals in hours, and an interval that matches none of them gives a "pknca_warning_tau_not_nominal" warning; give timeu to avoid that. timeu = NA says that the unit is not one PKNCA can use, and the intervals then come from the data alone (every source is "auto"). Converting a unit other than "hr" needs the units package; without it, such a unit gives a "pknca_message_tau_units_fallback" message and the intervals come from the data alone, so results for data in other units can differ between installations with and without that package.

Value

A data frame with one row per segment and the columns:

segment

The segment number

start, end

The first and last dose time of the segment; a dose where the regimen changes ends one segment and starts the next

n_doses

The number of doses in the segment

interval

The period that the dose pattern repeats over, NA for a single dose or when nothing repeats

label

The name of the candidate for an evenly spaced regimen with the segment's number of doses per period (twice-daily doses at 0 and 10 hours are "BID"), or NA

source

"nominal" when interval is a candidate and "auto" when it was found in the data

n_intervals_used

The spacings that set the interval

n_missed

Doses read as missed

n_irregular

Doses off schedule or extra

note

A description of anything unusual

offsets

A list column of the dose times within one period, relative to the first dose of the period

With no dose times, the data frame has no rows.

Conditions

pknca_warning_tau_irregular_dosing

A segment has missed doses (the message names the dose times before them) or doses off schedule (the message names those doses).

pknca_warning_tau_not_nominal

There were candidates to match (any timeu other than NA) and a segment matched none of them. The message includes the regimen table.

pknca_warning_tau_regimen_change

More than one segment was found. The message includes the regimen table.

pknca_warning_dose_regimen

The parent class of the three warnings above, to handle them together.

pknca_message_tau_units_fallback

timeu is not "hr" and the units package is not installed to convert it, so the intervals come from the data alone.

pknca_error_regimen_time_unit

timeu cannot be converted to hours.

pknca_error_regimen_time_class

x is a date-time or difftime rather than a number.

See Also

find.tau(), which gives the interval of the segment with the most doses

Other Interval determination: choose.auc.intervals(), find.tau(), resolve_dose_tau()

Examples

# Daily dosing with the times as recorded
find.dose.regimen(c(0, 23.6, 48, 72.4, 96), timeu = "hr")
# Twice daily at breakfast and dinner repeats daily
find.dose.regimen(c(0, 10, 24, 34, 48, 58), timeu = "hr")
# Daily, then twice daily
suppressWarnings(
  find.dose.regimen(c(0, 24, 48, 72, 84, 96, 108, 120), timeu = "hr")
)

Description

The regimen is found with find.dose.regimen(), and the interval is the period of its segment with the most doses (the latest of those when segments tie). In brief, the dose times are sorted and times that repeat are dropped; equally spaced doses give their spacing; a pattern of more than one dose per interval that repeats over at least two complete intervals gives the interval it repeats over; doses scattered within a tolerance of one spacing give their median spacing; and otherwise runs of the same spacing form the regimen, with the gaps between them read as missed doses (a whole number of intervals) or doses off schedule. Times are compared on the log scale within tol and snap.tol of find.dose.regimen(), so a dose recorded at 23.6 hours is a daily dose.

Usage

find.tau(
  x,
  na.action = stats::na.omit,
  options = list(),
  tau.choices = NULL,
  timeu = NULL
)

Arguments

Details

Looking for a repeating pattern before reading anything as a missed dose is what keeps a regimen with a regular gap in it, such as dosing three times a day at 0, 6, and 12 hours, from being reported as a 6 hour interval with a dose missing overnight.

The intervals are matched to tau.choices when it is given. When it is NA (the default), they are matched to the built-in nominal intervals listed in find.dose.regimen(), in the unit timeu. Without a time unit, the times are taken to be hours, so find.tau(c(0, 24, 50)) is 24 (once daily) rather than the median spacing of 25; times in another unit should give timeu, or they are compared with intervals in hours and an interval that matches none of them gives a "pknca_warning_tau_not_nominal" warning. The warnings of find.dose.regimen() are given here as well, notably "pknca_warning_tau_irregular_dosing" for missed doses or doses off schedule.

Value

NA when there are no dose times or no interval repeats, 0 for a single dose time, and otherwise the repeating interval.

See Also

Other Interval determination: choose.auc.intervals(), find.dose.regimen(), resolve_dose_tau()

Examples

# Equally spaced doses give their spacing
find.tau(c(0, 24, 48, 72))
# Twice-daily dosing repeats daily although no two doses are a day apart
find.tau(c(0, 10, 24, 34, 48, 58), tau.choices = c(12, 24))
# Dose times as recorded, with the unit known
find.tau(c(0, 23.6, 48, 72.4, 96), timeu = "hr")

Description

Find the first occurrence of an operator in a formula and return the left, right, or both sides of the operator.

Usage

findOperator(x, op, side)

Arguments

Value

The side of the operator requested, NA if requesting the left side of a unary operator, and NULL if the operator is not found.

See Also

Other Formula parsing: parse_formula_to_cols()

Description

Perform the half-life fit given the data. The function simply fits the data without any validation. No selection of points or any other components are done.

Usage

fit_half_life(data, tlast)

Arguments

Value

A named list with one value each for "r.squared", "adj.r.squared", "lambda.z.corrxy", "lambda.z", "clast.pred", "lambda.z.time.first", "lambda.z.time.last", "lambda.z.n.points", "half.life", and "span.ratio". pk.calc.half.life() fits one candidate per span of terminal points and builds a data.frame from the candidate it selects.

See Also

pk.calc.half.life()

Description

Perform a Tobit half-life fit given the data. The function fits the data using maximum likelihood without any point selection or validation.

Usage

fit_half_life_tobit(data, tlast, optim_control = list())

Arguments

Value

A data.frame with one row and columns named "lambda.z", "clast.pred", "lambda.z.time.first", "lambda.z.time.last", "lambda.z.n.points", "lambda.z.n.points_blq", "half.life", "span.ratio", "tobit_residual", and "adj_tobit_residual". Returns NA for all columns if stats::optim() does not converge, and emits a warning.

See Also

pk.calc.half.life(), fit_half_life_tobit_LL()

Description

Helper function used by fit_half_life_tobit() via stats::optim(). For observations above the LLOQ, the normal density contributes to the likelihood. For censored (BLQ) observations, the normal CDF up to the LLOQ contributes.

Usage

fit_half_life_tobit_LL(par, log_conc, time, mask_blq, log_lloq)

Arguments

Value

The negative sum of the log-likelihood (a scalar)

See Also

fit_half_life_tobit()

Description

Extract the formula from a PKNCAconc object.

Usage

## S3 method for class 'PKNCAconc'
formula(x, ...)

## S3 method for class 'PKNCAdose'
formula(x, ...)

Arguments

Value

A formula object

Description

Compute the geometric mean, sd, and CV

Usage

geomean(x, na.rm = FALSE)

geosd(x, na.rm = FALSE)

geocv(x, na.rm = FALSE)

Arguments

Value

The scalar value of the geometric mean, geometric standard deviation, or geometric coefficient of variation.

Functions

• geosd(): Compute the geometric standard deviation, exp(sd(log(x))).

• geocv(): Compute the geometric coefficient of variation, sqrt(exp(sd(log(x))^2)-1)*100.

References

Kirkwood T. B.L. Geometric means and measures of dispersion. Biometrics 1979; 35: 908-909

Examples

geomean(1:3)
geosd(1:3)
geocv(1:3)

Description

Concentrations are given as concentrations, not log-concentrations. Take the natural log of conc if the log-concentration is wanted.

Usage

get_halflife_curve(
  object,
  tout = NULL,
  n = 50,
  extrapolate_earlier = FALSE,
  extrapolate_later = TRUE
)

Arguments

Details

Like stats::approx(), give either tout for specific times or n for equally-spaced times. With n, the times span the concentrations used for the fit (time_first to time_last from get_halflife_fit()), so tout is required to extrapolate.

Value

A data.frame with the grouping columns, the interval start and end times, and the columns:

• time: the time of the concentration, on the same scale as the times in the concentration data

• conc: the concentration on the half-life fit at that time

conc is NA where the half-life could not be calculated or was excluded, and where extrapolation was requested but not allowed. Groups without a fit give a single row with an NA time when tout is NULL, since no times can be generated for them.

See Also

get_halflife_fit() for the slope and intercept of the fit, and get_halflife_points() for the concentrations used for it

Examples

o_conc <- PKNCAconc(Theoph, conc~Time|Subject)
o_data <- PKNCAdata(o_conc, intervals = data.frame(start = 0, end = Inf, half.life = TRUE))
o_nca <- pk.nca(o_data)
# Equally-spaced times across the fit
head(get_halflife_curve(o_nca))
# Specific times, extrapolating past the last concentration used
get_halflife_curve(o_nca, tout = c(12, 24, 36))

Description

The half-life fit is the log-linear regression of concentration on time, log(conc) = intercept + slope*time. Concentrations along the line are exp(intercept + slope*time).

Usage

get_halflife_fit(object)

Arguments

Details

Times in a PKNCAresults object are relative to the start of the interval, but time_first, time_last, and the time scale of intercept are on the same scale as the times in the concentration data so that the line can be drawn with the observed concentrations.

Value

A data.frame with one row for each group and interval where half-life was calculated. Along with the grouping columns and the interval start and end times, it has the columns:

• intercept: the natural log of the concentration where the line crosses time 0

• slope: the slope of the line, -lambda.z

• time_first, time_last: the first and last times of the concentrations used for the fit

intercept and slope are NA when the half-life could not be calculated or was excluded.

See Also

get_halflife_points() to see which concentrations were used for the fit

Examples

o_conc <- PKNCAconc(Theoph, conc~Time|Subject)
o_data <- PKNCAdata(o_conc, intervals = data.frame(start = 0, end = Inf, half.life = TRUE))
o_nca <- pk.nca(o_data)
get_halflife_fit(o_nca)

Description

Determine which concentrations were used for half-life calculation

Usage

get_halflife_points(object)

Arguments

Value

A logical vector with TRUE if the point was used for half-life (including concentrations below the limit of quantification within the range of times for calculation), FALSE if it was not used for half-life but the half-life was calculated for the interval, and NA if half-life was not calculated for the interval. If a row is excluded from all calculations, it is set to NA as well.

Examples

o_conc <- PKNCAconc(Theoph, conc~Time|Subject)
o_data <- PKNCAdata(o_conc, intervals = data.frame(start = 0, end = Inf, half.life = TRUE))
o_nca <- pk.nca(o_data)
get_halflife_points(o_nca)

Description

get_impute_column() applies the first two of the three readings of impute described in get_impute_method() and says which column get_impute_method() reads the methods from. It does not read the column, so it does not check that the column is character.

Usage

get_impute_column(intervals, impute)

Arguments

Value

The name of the column of intervals that the methods come from (character scalar): impute when it names a column of intervals, or "impute" when impute is NA and intervals has a column named "impute". NULL when impute is itself the method string, or is NA and there is no "impute" column, so there is no column.

See Also

Other Imputation: PKNCA_impute_fun_list(), PKNCA_impute_method, assert_impute_method(), get_impute_method(), pknca_impute_methods()

Examples

intervals <- data.frame(start = 0, end = 24, impute = "start_conc0", my_impute = "start_cmin")
get_impute_column(intervals, impute = "my_impute")
get_impute_column(intervals, impute = NA)
# A method string is not a column
get_impute_column(intervals, impute = "start_predose")
# NA without an "impute" column is not a column either
get_impute_column(intervals[, c("start", "end")], impute = NA)

Description

get_impute_method() is the rule pk.nca() uses to find the imputation methods for each interval, from the impute argument of PKNCAdata() and the intervals. It reads impute one of three ways, in this order:

Usage

get_impute_method(intervals, impute)

Arguments

Details

1. If impute is the name of a column in intervals, the methods are that column's values, one per interval. The name may be any column name, not only "impute".

2. Otherwise, if impute is NA and intervals has a column named "impute", the methods are that column's values, one per interval.

3. Otherwise impute is itself the method (or comma- or space-separated methods) for every interval, and the result is impute as a single value. An NA that finds no "impute" column therefore gives a single NA_character_, meaning no imputation.

get_impute_method() only reads the specification. It does not check that the methods exist; assert_impute_method() does. get_impute_column() gives the name of the column the methods are read from, which tells a column from a method string even for an intervals table with one row.

Value

A character vector of imputation specifications: one per row of intervals when read from a column, and of length one otherwise (the method string, or NA_character_ for no imputation). A column that is not character is an error, except that a column of only NA (which is logical when made with NA) is read as no imputation.

See Also

Other Imputation: PKNCA_impute_fun_list(), PKNCA_impute_method, assert_impute_method(), get_impute_column(), pknca_impute_methods()

Examples

intervals <- data.frame(start = 0, end = 24, impute = "start_conc0")
# The column named by `impute`
get_impute_method(intervals, impute = "impute")
# NA finds the column named "impute"
get_impute_method(intervals, impute = NA)
# NA without an "impute" column means no imputation
get_impute_method(intervals[, c("start", "end")], impute = NA)
# Anything else is the method for every interval
get_impute_method(intervals, impute = "start_predose")

Description

Extract the best model from a list of models using the AIC.

Usage

get.best.model(object, ...)

Arguments

Value

The model which is assessed as best. If more than one are equal, the first is chosen.

Description

Get the columns that can be used in an interval specification

Usage

get.interval.cols()

Value

A list with named elements for each parameter. Each list element contains the parameter definition.

See Also

check.interval.specification() and the vignette "Selection of Calculation Intervals"

Other Interval specifications: add.interval.col(), check.interval.specification(), choose.auc.intervals(), get.parameter.deps(), interval_add_impute(), interval_add_param(), interval_add_secondary(), pknca_cdisc_codes(), pknca_check_parameter_classification(), pknca_concepts(), pknca_interval_table(), pknca_match_route(), pknca_parameter_table(), pknca_presets(), pknca_ref()

Examples

get.interval.cols()

Description

Get all columns that depend on a parameter

Usage

get.parameter.deps(x, recursive = FALSE)

Arguments

Details

The two directions answer different questions. The default answers "what becomes invalid if x changes?". recursive = TRUE answers "what does x need?", and its result mixes parameter names with the raw inputs the calculation ends at, such as "conc", "time", "dose", and "time.dose".

Value

With recursive = FALSE (default), a character vector of parameter names that depend on the parameter x; empty if none do. With recursive = TRUE, the unique set of everything x is calculated from, following each dependency to the end.

See Also

Other Interval specifications: add.interval.col(), check.interval.specification(), choose.auc.intervals(), get.interval.cols(), interval_add_impute(), interval_add_param(), interval_add_secondary(), pknca_cdisc_codes(), pknca_check_parameter_classification(), pknca_concepts(), pknca_interval_table(), pknca_match_route(), pknca_parameter_table(), pknca_presets(), pknca_ref()

Description

Retrieve the value of an attribute column.

Usage

getAttributeColumn(object, attr_name, warn_missing = c("attr", "column"))

Arguments

Value

The value of the attribute (or NULL if the attribute is not set or the column does not exist)

Description

Get the value from a column in a data frame if the value is a column there, otherwise, the value should be a scalar or the length of the data.

Usage

getColumnValueOrNot(data, value, prefix = "X")

Arguments

Value

A list with elements named "data", "name" giving the data with a column named "name" with the value in that column.

Description

Get the name of the element containing the data for the current object.

Usage

## S3 method for class 'PKNCAconc'
getDataName(object)

## S3 method for class 'PKNCAdose'
getDataName(object)

## S3 method for class 'PKNCAresults'
getDataName(object)

getDataName(object)

## Default S3 method:
getDataName(object)

Arguments

Value

A character scalar with the name of the data object (or NULL if the method does not apply).

Methods (by class)

• getDataName(default): If no data name exists, returns NULL.

See Also

Other PKNCA object extractors: getDepVar(), getIndepVar()

Description

Get the dependent variable (left hand side of the formula) from a PKNCA object.

Usage

getDepVar(x, ...)

Arguments

Value

The vector of the dependent variable from the object.

See Also

Other PKNCA object extractors: getDataName.PKNCAconc(), getIndepVar()

Description

Get the groups (right hand side after the | from a PKNCA object).

Get the groups (right hand side after the | from a PKNCA object).

Usage

## S3 method for class 'PKNCAconc'
getGroups(
  object,
  form = stats::formula(object),
  level,
  data = as.data.frame(object),
  sep
)

## S3 method for class 'PKNCAdata'
getGroups(object, ...)

## S3 method for class 'PKNCAdose'
getGroups(...)

## S3 method for class 'PKNCAresults'
getGroups(
  object,
  form = formula(as_PKNCAconc(object)),
  level,
  data = as.data.frame(object),
  sep
)

Arguments

Value

A data frame with the (selected) group columns.

A data frame with the (selected) group columns.

Description

Get the independent variable (right hand side of the formula) from a PKNCA object.

Usage

getIndepVar(x, ...)

Arguments

Value

The vector of the independent variable from the object.

See Also

Other PKNCA object extractors: getDataName.PKNCAconc(), getDepVar()

Description

dplyr grouping for PKNCA

Usage

## S3 method for class 'PKNCAresults'
group_by(.data, ..., .add = FALSE, .drop = dplyr::group_by_drop_default(.data))

## S3 method for class 'PKNCAconc'
group_by(.data, ..., .add = FALSE, .drop = dplyr::group_by_drop_default(.data))

## S3 method for class 'PKNCAdose'
group_by(.data, ..., .add = FALSE, .drop = dplyr::group_by_drop_default(.data))

## S3 method for class 'PKNCAresults'
ungroup(x, ...)

## S3 method for class 'PKNCAconc'
ungroup(x, ...)

## S3 method for class 'PKNCAdose'
ungroup(x, ...)

Arguments

See Also

Other dplyr verbs: filter.PKNCAresults(), inner_join.PKNCAresults(), mutate.PKNCAresults()

Description

Get grouping variables for a PKNCA object

Usage

## S3 method for class 'PKNCAconc'
group_vars(x)

## S3 method for class 'PKNCAdata'
group_vars(x)

## S3 method for class 'PKNCAdose'
group_vars(x)

## S3 method for class 'PKNCAresults'
group_vars(x)

Arguments

Value

A character vector (possibly empty) of the grouping variables

Functions

• group_vars(PKNCAdata): Get group_vars for a PKNCAdata object from the PKNCAconc object within

• group_vars(PKNCAdose): Get group_vars for a PKNCAdose object

• group_vars(PKNCAresults): Get group_vars for a PKNCAresults object from the PKNCAconc object within

Description

dplyr joins for PKNCA

Usage

## S3 method for class 'PKNCAresults'
inner_join(
  x,
  y,
  by = NULL,
  copy = FALSE,
  suffix = c(".x", ".y"),
  ...,
  keep = FALSE
)

## S3 method for class 'PKNCAresults'
left_join(
  x,
  y,
  by = NULL,
  copy = FALSE,
  suffix = c(".x", ".y"),
  ...,
  keep = FALSE
)

## S3 method for class 'PKNCAresults'
right_join(
  x,
  y,
  by = NULL,
  copy = FALSE,
  suffix = c(".x", ".y"),
  ...,
  keep = FALSE
)

## S3 method for class 'PKNCAresults'
full_join(
  x,
  y,
  by = NULL,
  copy = FALSE,
  suffix = c(".x", ".y"),
  ...,
  keep = FALSE
)

## S3 method for class 'PKNCAconc'
inner_join(
  x,
  y,
  by = NULL,
  copy = FALSE,
  suffix = c(".x", ".y"),
  ...,
  keep = FALSE
)

## S3 method for class 'PKNCAconc'
left_join(
  x,
  y,
  by = NULL,
  copy = FALSE,
  suffix = c(".x", ".y"),
  ...,
  keep = FALSE
)

## S3 method for class 'PKNCAconc'
right_join(
  x,
  y,
  by = NULL,
  copy = FALSE,
  suffix = c(".x", ".y"),
  ...,
  keep = FALSE
)

## S3 method for class 'PKNCAconc'
full_join(
  x,
  y,
  by = NULL,
  copy = FALSE,
  suffix = c(".x", ".y"),
  ...,
  keep = FALSE
)

## S3 method for class 'PKNCAdose'
inner_join(
  x,
  y,
  by = NULL,
  copy = FALSE,
  suffix = c(".x", ".y"),
  ...,
  keep = FALSE
)

## S3 method for class 'PKNCAdose'
left_join(
  x,
  y,
  by = NULL,
  copy = FALSE,
  suffix = c(".x", ".y"),
  ...,
  keep = FALSE
)

## S3 method for class 'PKNCAdose'
right_join(
  x,
  y,
  by = NULL,
  copy = FALSE,
  suffix = c(".x", ".y"),
  ...,
  keep = FALSE
)

## S3 method for class 'PKNCAdose'
full_join(
  x,
  y,
  by = NULL,
  copy = FALSE,
  suffix = c(".x", ".y"),
  ...,
  keep = FALSE
)

Arguments