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(),
  datatype = c("interval", "individual", "population")
)

Arguments

Details

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.

Value

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

See Also

Other Interval specifications: check.interval.deps(), check.interval.specification(), choose.auc.intervals(), get.interval.cols(), get.parameter.deps()

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

Description

Determine if there are any sparse or dense calculations requested within an interval

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. 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.sparse_auc(), sparse_auc_weight_linear(), sparse_mean()

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"),
  filter_requested = FALSE,
  filter_excluded = FALSE,
  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

A data.frame with columns named "conc" and "time" or an informative error

Description

Assert that a value is a dosing interval

Usage

assert_dosetau(tau)

Arguments

Value

tau or an informative error

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())). 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 an object is a PKNCAdata object

Usage

assert_PKNCAdata(object)

Arguments

Value

The PKNCAdata object (confirmed to be usable)

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

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

Take in a single row of an interval specification and return that row updated with any additional calculations that must be done to fulfill all dependencies.

Usage

check.interval.deps(x)

Arguments

Value

The interval specification with additional calculations added where requested outputs require them.

See Also

Other Interval specifications: add.interval.col(), check.interval.specification(), choose.auc.intervals(), get.interval.cols(), get.parameter.deps()

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)

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.

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(), check.interval.deps(), choose.auc.intervals(), get.interval.cols(), get.parameter.deps()

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.

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 for AUC are selected by the following metrics:

1. If only one dose is administered, use the PKNCA.options("single.dose.aucs")

2. If more than one dose is administered, estimate the AUC between any two doses that have PK taken at both of the dosing times and at least one time between the doses.

3. For the final dose of multiple doses, try to determine the dosing interval ($\tau$) and estimate the AUC in that interval if multiple samples are taken in the interval.

4. If there are samples $> \tau$ after the last dose, calculate the half life after the last dose.

Usage

choose.auc.intervals(
  time.conc,
  time.dosing,
  options = list(),
  single.dose.aucs = NULL
)

Arguments

Value

A data frame with columns for start, end, auc.type, and half.life. See check.interval.specification() for column definitions. The data frame may have zero rows if no intervals could be found.

See Also

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

Other Interval specifications: add.interval.col(), check.interval.deps(), check.interval.specification(), get.interval.cols(), get.parameter.deps()

Other Interval determination: find.tau()

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

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

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_min.hl.r.squared(min.hl.r.squared)

Arguments

Functions

• exclude_nca_span.ratio(): Exclude based on span.ratio

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

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

See Also

Other Result exclusions: exclude()

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

dplyr filtering for PKNCA

Usage

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

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

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

Arguments

See Also

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

Description

This is intended to find the interval over which x repeats by the rule unique(mod(x, interval)) is minimized.

Usage

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

Arguments

Value

A scalar indicating the repeating interval with the most repetition.

1. If all values are NA then NA is returned.

2. If all values are the same, then 0 is returned.

3. If all values are equally spaced, then that spacing is returned.

4. If one of the choices can minimize the number of unique values, then that is returned.

5. If none of the choices can minimize the number of unique values, then -1 is returned.

See Also

Other Interval determination: choose.auc.intervals()

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, conc_units)

Arguments

Value

A data.frame with one row and columns named "r.squared", "adj.r.squared", "PROB", "lambda.z", "clast.pred", "lambda.z.n.points", "half.life", "span.ratio"

See Also

pk.calc.half.life()

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

Get the impute function from either the intervals column or from the method

Usage

get_impute_method(intervals, impute)

Arguments

Value

The imputation function vector

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 first model from a list of models

Usage

get.first.model(object)

Arguments

Value

The first item in the object that is not a list or NA. If NA is passed in or the list (of lists) is all NA, then NA is returned.

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.deps(), check.interval.specification(), choose.auc.intervals(), get.parameter.deps()

Examples

get.interval.cols()

Description

Get all columns that depend on a parameter

Usage

get.parameter.deps(x)

Arguments

Value

A character vector of parameter names that depend on the parameter x. If none depend on x, then the result will be an empty vector.

See Also

Other Interval specifications: add.interval.col(), check.interval.deps(), check.interval.specification(), choose.auc.intervals(), get.interval.cols()

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(object$data$conc),
  level,
  data = object$result,
  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 'PKNCAdose'
group_vars(x)

Arguments

Value

A character vector (possibly empty) of the grouping variables

Functions

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

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

See Also

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

Description

Interpolate or extrapolate concentrations using the provided method

Usage

interpolate_conc_linear(conc_1, conc_2, time_1, time_2, time_out)

interpolate_conc_log(conc_1, conc_2, time_1, time_2, time_out)

extrapolate_conc_lambdaz(clast, lambda.z, tlast, time_out)

Arguments

Value

The interpolated or extrapolated value using the correct method

Description

interpolate.conc() and extrapolate.conc() returns an interpolated (or extrapolated) concentration. interp.extrap.conc() will choose whether interpolation or extrapolation is required and will also operate on many concentrations. These will typically be used to estimate the concentration between two measured concentrations or after the last measured concentration. Of note, these functions will not extrapolate prior to the first point.

Usage

interp.extrap.conc(
  conc,
  time,
  time.out,
  lambda.z = NA,
  clast = pk.calc.clast.obs(conc, time),
  options = list(),
  method = NULL,
  auc.type = "AUCinf",
  interp.method,
  extrap.method,
  ...,
  conc.blq = NULL,
  conc.na = NULL,
  check = TRUE
)

interpolate.conc(
  conc,
  time,
  time.out,
  options = list(),
  method = NULL,
  interp.method,
  conc.blq = NULL,
  conc.na = NULL,
  conc.origin = 0,
  ...,
  check = TRUE
)

extrapolate.conc(
  conc,
  time,
  time.out,
  lambda.z = NA,
  clast = pk.calc.clast.obs(conc, time),
  auc.type = "AUCinf",
  extrap.method,
  options = list(),
  conc.na = NULL,
  conc.blq = NULL,
  ...,
  check = TRUE
)

interp.extrap.conc.dose(
  conc,
  time,
  time.dose,
  route.dose = "extravascular",
  duration.dose = NA,
  time.out,
  out.after = FALSE,
  options = list(),
  conc.blq = NULL,
  conc.na = NULL,
  ...,
  check = TRUE
)

Arguments

Details

An NA value for the lambda.z parameter will prevent extrapolation.

extrap.method

'AUCinf'

Use lambda.z to extrapolate beyond the last point with the half-life.

'AUCall'

If the last point is above the limit of quantification or missing, this is identical to 'AUCinf'. If the last point is below the limit of quantification, then linear interpolation between the Clast and the next BLQ is used for that interval and all additional points are extrapolated as 0.

'AUClast'

Extrapolates all points after the last above the limit of quantification as 0.

duration.dose and direction.out are ignored if route.dose == "extravascular". direction.out is ignored if duration.dose > 0.

route.dose and duration.dose affect how interpolation/extrapolation of the concentration occurs at the time of dosing. If route.dose == "intravascular" and duration.dose == 0 then extrapolation occurs for an IV bolus using pk.calc.c0() with the data after dosing. Otherwise (either route.dose == "extravascular" or duration.dose > 0), extrapolation occurs using the concentrations before dosing and estimating the half-life (or more precisely, estimating lambda.z). Finally, direction.out can change the direction of interpolation in cases with route.dose == "intravascular" and duration.dose == 0. When direction.out == "before" interpolation occurs only with data before the dose (as is the case for route.dose == "extravascular"), but if direction.out == "after" interpolation occurs from the data after dosing.

Value

The interpolated or extrapolated concentration value as a scalar double (or vector for interp.extrap.conc()).

Functions

• interpolate.conc(): Interpolate concentrations through Tlast (inclusive)

• extrapolate.conc(): Extrapolate concentrations after Tlast

• interp.extrap.conc.dose(): Interpolate and extrapolate concentrations without interpolating or extrapolating beyond doses.

See Also

pk.calc.clast.obs(), pk.calc.half.life(), pk.calc.c0()

Description

Is a PKNCA object used for sparse PK?

Usage

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

## S3 method for class 'PKNCAdata'
is_sparse_pk(object)

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

is_sparse_pk(object)

Arguments

Value

TRUE if sparse and FALSE if dense (not sparse)

Description

Extract the columns used in the formula (in order) from a PKNCAconc or PKNCAdose object.

Usage

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

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

Arguments

Value

A data frame with the columns from the object in formula order.

Description

dplyr mutate-based modification for PKNCA

Usage

## S3 method for class 'PKNCAresults'
mutate(.data, ...)

## S3 method for class 'PKNCAconc'
mutate(.data, ...)

## S3 method for class 'PKNCAdose'
mutate(.data, ...)

Arguments

See Also

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

Description

Normalize the exclude column by setting blanks to NA

Usage

normalize_exclude(object)

Arguments

Value

The exclude vector where NA indicates not to exclude and anything else indicates to exclude.

Description

Convert a formula representation to the columns for input data

Usage

parse_formula_to_cols(form)

Arguments

Value

A list of column names for various formula parts

See Also

Other Formula parsing: findOperator()

Description

Convert the grouping info and list of results for each group into a results data.frame

Usage

pk_nca_result_to_df(group_info, result)

Arguments

Value

A data.frame with group_info and result combined, warnings filtered out, and results unnested.

Description

Note that all missing values are removed prior to calling the function.

Usage

pk.business(FUN, zero.missing = FALSE, max.missing)

Arguments

Value

A version of FUN that can be called with parameters that are checked for missingness (and zeros) with missing (and zeros) removed before the call. If max.missing is exceeded, then NA is returned.

Examples

my_mean <- pk.business(FUN=mean)
mean(c(1:3, NA))
# Less than half missing results in the summary statistic of the available
# values.
my_mean(c(1:3, NA))
# More than half missing results in a missing value
my_mean(c(1:3, rep(NA, 4)))

Description

Calculate amount excreted (typically in urine or feces)

Usage

pk.calc.ae(conc, volume, check = TRUE)

Arguments

Details

ae is sum(conc*volume).

The units for the concentration and volume should match such that sum(conc*volume) has units of mass or moles.

Value

The amount excreted during the interval

See Also

pk.calc.clr(), pk.calc.fe()

Description

Concentrations below the given concentration (conc_above) will be set to zero.

Usage

pk.calc.aucabove(conc, time, conc_above = NA_real_, ..., options = list())

Arguments

Value

The AUC of the concentration above the limit

Description

Calculate the AUC over an interval with interpolation and/or extrapolation of concentrations for the beginning and end of the interval.

Usage

pk.calc.aucint(
  conc,
  time,
  interval = NULL,
  start = NULL,
  end = NULL,
  clast = pk.calc.clast.obs(conc, time),
  lambda.z = NA,
  time.dose = NULL,
  route = "extravascular",
  duration.dose = 0,
  method = NULL,
  auc.type = "AUClast",
  conc.blq = NULL,
  conc.na = NULL,
  check = TRUE,
  ...,
  options = list()
)

pk.calc.aucint.last(
  conc,
  time,
  start = NULL,
  end = NULL,
  time.dose,
  ...,
  options = list()
)

pk.calc.aucint.all(
  conc,
  time,
  start = NULL,
  end = NULL,
  time.dose,
  ...,
  options = list()
)

pk.calc.aucint.inf.obs(
  conc,
  time,
  start = NULL,
  end = NULL,
  time.dose,
  lambda.z,
  clast.obs,
  ...,
  options = list()
)

pk.calc.aucint.inf.pred(
  conc,
  time,
  start = NULL,
  end = NULL,
  time.dose,
  lambda.z,
  clast.pred,
  ...,
  options = list()
)

Arguments

Details

When pk.calc.aucint() needs to extrapolate using lambda.z (in other words, using the half-life), it will always extrapolate using the logarithmic trapezoidal rule to align with using a half-life calculation for the extrapolation.

Value

The AUC for an interval of time as a number

Functions

• pk.calc.aucint.last(): Interpolate or extrapolate concentrations for AUClast

• pk.calc.aucint.all(): Interpolate or extrapolate concentrations for AUCall

• pk.calc.aucint.inf.obs(): Interpolate or extrapolate concentrations for AUCinf.obs

• pk.calc.aucint.inf.pred(): Interpolate or extrapolate concentrations for AUCinf.pred

See Also

PKNCA.options(), interp.extrap.conc.dose()

Other AUC calculations: pk.calc.auxc()

Description

Calculate AUC for intravenous dosing

Usage

pk.calc.auciv(conc, time, c0, auc, ..., check = TRUE)

pk.calc.auciv_pbext(auc, auciv)

Arguments

Details

The AUC for intravenous (IV) dosing extrapolates the AUC back from the first measurement to time 0 using c0 and the AUC calculated by another method (for example the auclast).

The calculation method takes the following steps:

• time = 0 must be present in the data with a measured concentration.

• The AUC between time = 0 and the next time point is calculated (auc_first).

• The AUC between time = 0 with c0 and the next time point is calculated (auc_second).

• The final AUC is the initial AUC plus the difference between the two AUCs (auc_final <- auc + auc_second - auc_first).

The calculation for back-extrapolation is 100*(1 - auc/auciv).

Value

pk.calc.auciv: The AUC calculated using c0

pk.calc.auciv_pctbackextrap: The AUC percent back-extrapolated

Functions

• pk.calc.auciv_pbext(): Calculate the percent back-extrapolated AUC for IV administration

Description

Calculate the AUC percent extrapolated

Usage

pk.calc.aucpext(auclast, aucinf)

Arguments

Details

aucpext is 100*(1-auclast/aucinf).

Value

The numeric value of the AUC percent extrapolated or NA_real_ if any of the following are true is.na(aucinf), is.na(auclast), aucinf <= 0, or auclast <= 0.

Description

Compute the area under the curve (AUC) and the area under the moment curve (AUMC) for pharmacokinetic (PK) data. AUC and AUMC are used for many purposes when analyzing PK in drug development.

Usage

pk.calc.auxc(
  conc,
  time,
  interval = c(0, Inf),
  clast = pk.calc.clast.obs(conc, time, check = FALSE),
  lambda.z = NA,
  auc.type = c("AUClast", "AUCinf", "AUCall"),
  options = list(),
  method = NULL,
  conc.blq = NULL,
  conc.na = NULL,
  check = TRUE,
  fun_linear,
  fun_log,
  fun_inf
)

pk.calc.auc(conc, time, ..., options = list())

pk.calc.auc.last(conc, time, ..., options = list())

pk.calc.auc.inf(conc, time, ..., options = list(), lambda.z)

pk.calc.auc.inf.obs(conc, time, clast.obs, ..., options = list(), lambda.z)

pk.calc.auc.inf.pred(conc, time, clast.pred, ..., options = list(), lambda.z)

pk.calc.auc.all(conc, time, ..., options = list())

pk.calc.aumc(conc, time, ..., options = list())

pk.calc.aumc.last(conc, time, ..., options = list())

pk.calc.aumc.inf(conc, time, ..., options = list(), lambda.z)

pk.calc.aumc.inf.obs(conc, time, clast.obs, ..., options = list(), lambda.z)

pk.calc.aumc.inf.pred(conc, time, clast.pred, ..., options = list(), lambda.z)

pk.calc.aumc.all(conc, time, ..., options = list())

Arguments

Details

pk.calc.auc.last is simply a shortcut setting the interval parameter to c(0, "last").

Extrapolation beyond Clast occurs using the half-life and Clast,obs; Clast,pred is not yet supported.

If all conc input are zero, then the AU(M)C is zero.

You probably do not want to call pk.calc.auxc(). Usually, you will call one of the other functions for calculating AUC like pk.calc.auc.last(), pk.calc.auc.inf.obs(), etc.

Value

A numeric value for the AU(M)C.

Functions

• pk.calc.auc(): Compute the area under the curve

• pk.calc.auc.last(): Compute the AUClast.

• pk.calc.auc.inf(): Compute the AUCinf

• pk.calc.auc.inf.obs(): Compute the AUCinf with the observed Clast.

• pk.calc.auc.inf.pred(): Compute the AUCinf with the predicted Clast.

• pk.calc.auc.all(): Compute the AUCall.

• pk.calc.aumc(): Compute the area under the moment curve

• pk.calc.aumc.last(): Compute the AUMClast.

• pk.calc.aumc.inf(): Compute the AUMCinf

• pk.calc.aumc.inf.obs(): Compute the AUMCinf with the observed Clast.

• pk.calc.aumc.inf.pred(): Compute the AUMCinf with the predicted Clast.

• pk.calc.aumc.all(): Compute the AUMCall.

References

Gabrielsson J, Weiner D. "Section 2.8.1 Computation methods - Linear trapezoidal rule." Pharmacokinetic & Pharmacodynamic Data Analysis: Concepts and Applications, 4th Edition. Stockholm, Sweden: Swedish Pharmaceutical Press, 2000. 162-4.

Gabrielsson J, Weiner D. "Section 2.8.3 Computation methods - Log-linear trapezoidal rule." Pharmacokinetic & Pharmacodynamic Data Analysis: Concepts and Applications, 4th Edition. Stockholm, Sweden: Swedish Pharmaceutical Press, 2000. 164-7.

See Also

clean.conc.blq()

Other AUC calculations: pk.calc.aucint()

Examples

myconc <- c(0, 1, 2, 1, 0.5, 0.25, 0)
mytime <- c(0, 1, 2, 3, 4,   5,    6)
pk.calc.auc(myconc, mytime, interval=c(0, 6))
pk.calc.auc(myconc, mytime, interval=c(0, Inf))

Description

Estimate the concentration at dosing time for an IV bolus dose.

Usage

pk.calc.c0(
  conc,
  time,
  time.dose = 0,
  method = c("c0", "logslope", "c1", "cmin", "set0"),
  check = TRUE
)

pk.calc.c0.method.logslope(conc, time, time.dose = 0, check = TRUE)

pk.calc.c0.method.c0(conc, time, time.dose = 0, check = TRUE)

pk.calc.c0.method.c1(conc, time, time.dose = 0, check = TRUE)

pk.calc.c0.method.set0(conc, time, time.dose = 0, check = TRUE)

pk.calc.c0.method.cmin(conc, time, time.dose = 0, check = TRUE)

Arguments

Details

Methods available for interpolation are below, and each has its own specific function.

c0

If the observed conc at time.dose is nonzero, return that. This method should usually be used first for single-dose IV bolus data in case nominal time zero is measured.

logslope

Compute the semilog line between the first two measured times, and use that line to extrapolate backward to time.dose

c1

Use the first point after time.dose

cmin

Set c0 to cmin during the interval. This method should usually be used for multiple-dose oral data and IV infusion data.

set0

Set c0 to zero (regardless of any other data). This method should usually be used first for single-dose oral data.

Value

The estimated concentration at time 0.

Functions

• pk.calc.c0.method.logslope(): Semilog regress the first and second points after time.dose. This method will return NA if the second conc after time.dose is 0 or greater than the first.

• pk.calc.c0.method.c0(): Use C0 = conc[time %in% time.dose] if it is nonzero.

• pk.calc.c0.method.c1(): Use C0 = C1.

• pk.calc.c0.method.set0(): Use C0 = 0 (typically used for single dose oral and IV infusion)

• pk.calc.c0.method.cmin(): Use C0 = Cmin (typically used for multiple dose oral and IV infusion but not IV bolus)

Description

Calculate the average concentration during an interval.

Usage

pk.calc.cav(auc, start, end)

Arguments

Details

cav is auc/(end-start).

Value

The Cav (average concentration during the interval)

Description

Determine the concentration at the end of infusion

Usage

pk.calc.ceoi(conc, time, duration.dose = NA, check = TRUE)

Arguments

Value

The concentration at the end of the infusion, NA if duration.dose is NA, or NA if all time != duration.dose

Description

Calculate the (observed oral) clearance

Usage

pk.calc.cl(dose, auc)

Arguments

Details

cl is dose/auc.

If dose is the same length as the other inputs, then the output will be the same length as all of the inputs; the function assumes that you are calculating for multiple intervals simultaneously. If the inputs other than dose are scalars and dose is a vector, then the function assumes multiple doses were given in a single interval, and the sum of the doses will be used for the calculation.

Value

the numeric value of the total (CL) or observed oral clearance (CL/F)

References

Gabrielsson J, Weiner D. "Section 2.5.1 Derivation of clearance." Pharmacokinetic & Pharmacodynamic Data Analysis: Concepts and Applications, 4th Edition. Stockholm, Sweden: Swedish Pharmaceutical Press, 2000. 86-7.

Description

If all concentrations are missing, NA_real_ is returned. If all concentrations are zero (below the limit of quantification) or missing, zero is returned. If Tlast is NA (due to no non-missing above LOQ measurements), this will return NA_real_.

Usage

pk.calc.clast.obs(conc, time, check = TRUE)

Arguments

Value

The last observed concentration above the LOQ

See Also

Other NCA parameters for concentrations during the intervals: pk.calc.cmax(), pk.calc.count_conc(), pk.calc.cstart(), pk.calc.ctrough()

Description

Calculate renal clearance

Usage

pk.calc.clr(ae, auc)

Arguments

Details

clr is sum(ae)/auc.

The units for the ae and auc should match such that ae/auc has units of volume/time.

Value

The renal clearance as a number

See Also

pk.calc.ae(), pk.calc.fe()

Description

Determine maximum observed PK concentration

Usage

pk.calc.cmax(conc, check = TRUE)

pk.calc.cmin(conc, check = TRUE)

Arguments

Value

a number for the maximum concentration or NA if all concentrations are missing

Functions

• pk.calc.cmin(): Determine the minimum observed PK concentration

See Also

Other NCA parameters for concentrations during the intervals: pk.calc.clast.obs(), pk.calc.count_conc(), pk.calc.cstart(), pk.calc.ctrough()

Other NCA parameters for concentrations during the intervals: pk.calc.clast.obs(), pk.calc.count_conc(), pk.calc.cstart(), pk.calc.ctrough()

Description

count_conc is typically used for quality control on the data to ensure that there are a sufficient number of non-missing samples for a calculation and to ensure that data are consistent between individuals.

Usage

pk.calc.count_conc(conc, check = TRUE)

Arguments

Value

a count of the non-missing concentrations (0 if all concentrations are missing)

See Also

Other NCA parameters for concentrations during the intervals: pk.calc.clast.obs(), pk.calc.cmax(), pk.calc.cstart(), pk.calc.ctrough()

Description

Determine the concentration at the beginning of the interval

Usage

pk.calc.cstart(conc, time, start)

Arguments

Value

The concentration when time == end. If none match, then NA

See Also

Other NCA parameters for concentrations during the intervals: pk.calc.clast.obs(), pk.calc.cmax(), pk.calc.count_conc(), pk.calc.ctrough()

Description

Determine the trough (end of interval) concentration

Usage

pk.calc.ctrough(conc, time, end)

Arguments

Value

The concentration when time == end. If none match, then NA

See Also

Other NCA parameters for concentrations during the intervals: pk.calc.clast.obs(), pk.calc.cmax(), pk.calc.count_conc(), pk.calc.cstart()

Description

Determine the degree of fluctuation

Usage

pk.calc.deg.fluc(cmax, cmin, cav)

Arguments

Details

deg.fluc is 100*(cmax - cmin)/cav.

Value

The degree of fluctuation around the average concentration.

Description

Determine dose normalized NCA parameter

Usage

pk.calc.dn(parameter, dose)

Arguments

Value

a number for dose normalized AUC

Examples

pk.calc.dn(90, 10)

Description

Calculate the absolute (or relative) bioavailability

Usage

pk.calc.f(dose1, auc1, dose2, auc2)

Arguments

Details

f is (auc2/dose2)/(auc1/dose1).

Description

Calculate fraction excreted (typically in urine or feces)

Usage

pk.calc.fe(ae, dose)

Arguments

Details

fe is sum(ae)/dose

The units for ae and dose should be the same so that ae/dose is a unitless fraction.

Value

The fraction of dose excreted

See Also

pk.calc.ae(), pk.calc.clr()

Description

The terminal elimination half-life is estimated from the final points in the concentration-time curve using semi-log regression (log(conc)~time) with automated selection of the points for calculation (unless manually.selected.points is TRUE).

Usage

pk.calc.half.life(
  conc,
  time,
  tmax,
  tlast,
  manually.selected.points = FALSE,
  options = list(),
  min.hl.points = NULL,
  adj.r.squared.factor = NULL,
  conc.blq = NULL,
  conc.na = NULL,
  first.tmax = NULL,
  allow.tmax.in.half.life = NULL,
  check = TRUE
)

Arguments

Details

See the "Half-Life Calculation" vignette for more details on the calculation methods used.

If manually.selected.points is FALSE (default), the half-life is calculated by computing the best fit line for all points at or after tmax (based on the value of allow.tmax.in.half.life). The best half-life is chosen by the following rules in order:

• At least min.hl.points points included

• A lambda.z > 0 and at the same time the best adjusted r-squared (within adj.r.squared.factor)

• The one with the most points included

If manually.selected.points is TRUE, the conc and time data are used as-is without any form of selection for the best-fit half-life.

Value

A data frame with one row and columns for

tmax

Time of maximum observed concentration (only included if not given as an input)

tlast

Time of last observed concentration above the LOQ (only included if not given as an input)

r.squared

coefficient of determination

adj.r.squared

adjusted coefficient of determination

lambda.z

elimination rate

lambda.z.time.first

first time for half-life calculation

lambda.z.n.points

number of points in half-life calculation

clast.pred

Concentration at tlast as predicted by the half-life line

half.life

half-life

span.ratio

span ratio [ratio of half-life to time used for half-life calculation

References

Gabrielsson J, Weiner D. "Section 2.8.4 Strategies for estimation of lambda-z." Pharmacokinetic & Pharmacodynamic Data Analysis: Concepts and Applications, 4th Edition. Stockholm, Sweden: Swedish Pharmaceutical Press, 2000. 167-9.

Description

Calculate the elimination rate (Kel)

Usage

pk.calc.kel(mrt)

Arguments

Value

the numeric value of the elimination rate

Description

Calculate the mean residence time (MRT) for single-dose data or linear multiple-dose data.

Usage

pk.calc.mrt(auc, aumc)

pk.calc.mrt.iv(auc, aumc, duration.dose)

Arguments

Details

mrt is aumc/auc - duration.dose/2 where duration.dose = 0 for oral administration.

Value

the numeric value of the mean residence time

Functions

• pk.calc.mrt.iv(): MRT for an IV infusion

See Also

pk.calc.mrt.md()

Description

Calculate the mean residence time (MRT) for multiple-dose data with nonlinear kinetics.

Usage

pk.calc.mrt.md(auctau, aumctau, aucinf, tau)

Arguments

Details

mrt.md is aumctau/auctau + tau*(aucinf-auctau)/auctau and should only be used for multiple dosing with equal intervals between doses.

Note that if aucinf == auctau (as would be the assumption with linear kinetics), the equation becomes the same as the single-dose MRT.

See Also

pk.calc.mrt()

Description

Determine the peak-to-trough ratio

Usage

pk.calc.ptr(cmax, ctrough)

Arguments

Details

ptr is cmax/ctrough.

Value

The ratio of cmax to ctrough (if ctrough == 0, NA)

Description

The AUC is calculated as:

Usage

pk.calc.sparse_auc(
  conc,
  time,
  subject,
  method = NULL,
  auc.type = "AUClast",
  ...,
  options = list()
)

pk.calc.sparse_auclast(conc, time, subject, ..., options = list())

Arguments

Details

$AUC=\sum\limits_{i} w_i \bar{C}_i$

Where:

$AUC$

is the estimated area under the concentration-time curve

$w_i$

is the weight applied to the concentration at time i (related to the time which it affects, see sparse_auc_weight_linear())

$\bar{C}_i$

is the average concentration at time i

Functions

• pk.calc.sparse_auclast(): Compute the AUClast for sparse PK

See Also

Other Sparse Methods: as_sparse_pk(), sparse_auc_weight_linear(), sparse_mean()

Description

Determine the PK swing

Usage

pk.calc.swing(cmax, cmin)

Arguments

Details

swing is 100*(cmax - cmin)/cmin.

Value

The swing above the minimum concentration. If cmin is zero, then the result is infinity.

Description

Calculate the effective half-life

Usage

pk.calc.thalf.eff(mrt)

Arguments

Details

thalf.eff is log(2)*mrt.

Value

the numeric value of the effective half-life

Description

Interpolation is performed aligning with PKNCA.options("auc.method"). Extrapolation outside of the measured times is not yet implemented. The method may be changed by giving a named method argument, as well.

Usage

pk.calc.time_above(conc, time, conc_above, ..., options = list(), check = TRUE)

Arguments

Details

For 'lin up/log down', if clast is above conc_above and there are concentrations BLQ after that, linear down is used to extrapolate to the BLQ concentration (equivalent to AUCall).

Value

the time above the given concentration

Description

Determine the observed lag time (time before the first concentration above the limit of quantification or above the first concentration in the interval)

Usage

pk.calc.tlag(conc, time)

Arguments

Value

The time associated with the first increasing concentration

Description

NA will be returned if all conc are NA or 0.

Usage

pk.calc.tlast(conc, time, check = TRUE)

pk.calc.tfirst(conc, time, check = TRUE)

Arguments

Value

The time of the last observed concentration measurement

Functions

• pk.calc.tfirst(): Determine the first concentration above the limit of quantification.

Description

Input restrictions are:

1. the conc and time must be the same length,

2. the time may have no NAs,

NA will be returned if:

1. the length of conc and time is 0

2. all conc is 0 or NA

Usage

pk.calc.tmax(conc, time, options = list(), first.tmax = NULL, check = TRUE)

Arguments

Value

The time of the maximum concentration

Description

Extract the dose used for calculations

Usage

pk.calc.totdose(dose)

Arguments

Value

The total dose for an interval

Description

Calculate the steady-state volume of distribution (Vss)

Usage

pk.calc.vss(cl, mrt)

Arguments

Details

vss is cl*mrt.

Value

the volume of distribution at steady-state

Description

Calculate the terminal volume of distribution (Vz)

Usage

pk.calc.vz(cl, lambda.z)

Arguments

Details

vz is cl/lambda.z.

Description

The pk.nca function computes the NCA parameters from a PKNCAdata object. All options for the calculation and input data are set in prior functions (PKNCAconc, PKNCAdose, and PKNCAdata). Options for calculations are set either in PKNCAdata or with the current default options in PKNCA.options.

Usage

pk.nca(data, verbose = FALSE)

Arguments

Details

When performing calculations, all time results are relative to the start of the interval. For example, if an interval starts at 168 hours, ends at 192 hours, and and the maximum concentration is at 169 hours, tmax=169-168=1.

Value

A PKNCAresults object.

See Also

PKNCAdata(), PKNCA.options(), summary.PKNCAresults(), as.data.frame.PKNCAresults(), exclude()

Description

For one subject/time range, compute all available PK parameters. All the internal options should be set by PKNCA.options() prior to running. The only part that changes with a call to this function is the concentration and time.

Usage

pk.nca.interval(
  conc,
  time,
  volume,
  duration.conc,
  dose,
  time.dose,
  duration.dose,
  route,
  conc.group = NULL,
  time.group = NULL,
  volume.group = NULL,
  duration.conc.group = NULL,
  dose.group = NULL,
  time.dose.group = NULL,
  duration.dose.group = NULL,
  route.group = NULL,
  impute_method = NA_character_,
  include_half.life = NULL,
  exclude_half.life = NULL,
  subject,
  sparse,
  interval,
  options = list()
)

Arguments

Value

A data frame with the start and end time along with all PK parameters for the interval

See Also

check.interval.specification()

Description

Compute NCA for multiple intervals

Usage

pk.nca.intervals(
  data_conc,
  data_dose,
  data_intervals,
  sparse,
  options,
  impute,
  verbose = FALSE
)

Arguments

Value

A data.frame with all NCA results

Description

Compute the time to steady-state (tss)

Usage

pk.tss(..., type = c("monoexponential", "stepwise.linear"), check = TRUE)

Arguments

Value

A data frame with columns as defined from pk.tss.monoexponential and/or pk.tss.stepwise.linear.

See Also

Other Time to steady-state calculations: pk.tss.monoexponential(), pk.tss.stepwise.linear()

Description

Clean up the time to steady-state parameters and return a data frame for use by the tss calculators.

Usage

pk.tss.data.prep(
  conc,
  time,
  subject,
  treatment,
  subject.dosing,
  time.dosing,
  options = list(),
  conc.blq = NULL,
  conc.na = NULL,
  check = TRUE,
  ...
)

Arguments

Value

a data frame with columns for concentration, time, subject, and treatment.

Description

Trough concentrations are selected as concentrations at the time of dosing. An exponential curve is then fit through the data with a different magnitude by treatment (as a factor) and a random steady-state concentration and time to stead-state by subject (see random.effects argument).

Usage

pk.tss.monoexponential(
  ...,
  tss.fraction = 0.9,
  output = c("population", "popind", "individual", "single"),
  check = TRUE,
  verbose = FALSE
)

Arguments

Value

A scalar float for the first time when steady-state is achieved or NA if it is not observed.

References

Maganti, L., Panebianco, D.L. & Maes, A.L. Evaluation of Methods for Estimating Time to Steady State with Examples from Phase 1 Studies. AAPS J 10, 141–147 (2008). https://doi.org/10.1208/s12248-008-9014-y

See Also

Other Time to steady-state calculations: pk.tss(), pk.tss.stepwise.linear()

Description

This function is not intended to be called directly. Please use pk.tss.monoexponential.

Usage

pk.tss.monoexponential.individual(
  data,
  output = c("individual", "single"),
  verbose = FALSE
)

Arguments

Details

If no model converges, then the tss.monoexponential.single and/or tss.monoexponential.individual column will be set to NA.

Value

A data frame with either one row (if population output is provided) or one row per subject (if popind is provided). The columns will be named tss.monoexponential.population and/or tss.monoexponential.popind.

Description

This function is not intended to be called directly. Please use pk.tss.monoexponential.

Usage

pk.tss.monoexponential.population(
  data,
  output = c("population", "popind"),
  verbose = FALSE
)

Arguments

Details

If no model converges, then the tss.monoexponential.population column will be set to NA. If the best model does not include a random effect for subject on Tss then the tss.monoexponential.popind column of the output will be set to NA.

Value

A data frame with either one row (if population output is provided) or one row per subject (if popind is provided). The columns will be named tss.monoexponential.population and/or tss.monoexponential.popind.

Description

A linear slope is fit through the data to find when it becomes non-significant. Note that this is less preferred than the pk.tss.monoexponential due to the fact that with more time or more subjects the performance of the test changes (see reference).

Usage

pk.tss.stepwise.linear(
  ...,
  min.points = 3,
  level = 0.95,
  verbose = FALSE,
  check = TRUE
)

Arguments

Details

The model is fit with a different magnitude by treatment (as a factor, if given) and a random slope by subject (if given). A minimum of min.points is required to fit the model.

Value

A scalar float for the first time when steady-state is achieved or NA if it is not observed.

References

Maganti L, Panebianco DL, Maes AL. Evaluation of Methods for Estimating Time to Steady State with Examples from Phase 1 Studies. AAPS Journal 10(1):141-7. doi:10.1208/s12248-008-9014-y

See Also

Other Time to steady-state calculations: pk.tss(), pk.tss.monoexponential()

Description

Compute pharmacokinetic (PK) noncompartmental analysis (NCA) parameters.

Details

PKNCA has been cross-validated with both Phoenix WinNonlin(R) and Pumas (click here for the cross-validation article)

A common workflow would load data from a file or database into a data.frame then run the following code.

Author(s)

Maintainer: Bill Denney [email protected] (ORCID)

Authors:

• Clare Buckeridge [email protected]

Other contributors:

• Sridhar Duvvuri [contributor]

See Also

Useful links:

• https://billdenney.github.io/pknca/

• https://github.com/billdenney/pknca

• http://billdenney.github.io/pknca/

• Report bugs at https://github.com/billdenney/pknca/issues

Examples

## Not run: 
# Load concentration-time data into a data.frame called d.conc
# with columns named "conc", "time", and "subject".
my.conc <- PKNCAconc(d.conc, conc~time|subject)
# Load dose-time data into a data.frame called d.dose
# with columns named "dose", "time", and "subject".
my.dose <- PKNCAdose(d.dose, dose~time|subject)
# Combine the concentration-time and dose-time data into an object
# ready for calculations.
my.data <- PKNCAdata(my.conc, my.dose)
# Perform the calculations
my.results <- pk.nca(my.data)
# Look at summary results
summary(my.results)
# Look at a listing of results
as.data.frame(my.results)

## End(Not run)

Description

Find NCA parameters with a given unit type

Usage

pknca_find_units_param(unit_type)

Arguments

Value

A character vector of parameters with a given unit type

Description

An error will be raised if the functions are not found.

Usage

PKNCA_impute_fun_list(x)

Arguments

Details

This function is not for use by users of PKNCA.

Value

A list of character vectors of functions to run.

Description

Methods for imputation of data with PKNCA

Usage

PKNCA_impute_method_start_conc0(conc, time, start = 0, ..., options = list())

PKNCA_impute_method_start_cmin(conc, time, start, end, ..., options = list())

PKNCA_impute_method_start_predose(
  conc,
  time,
  start,
  end,
  conc.group,
  time.group,
  ...,
  max_shift = NA_real_,
  options = list()
)

Arguments

Value

A data.frame with one column named conc with imputed concentrations and one column named time with the times.

Functions

• PKNCA_impute_method_start_conc0(): Add a new concentration of 0 at the start time, even if a nonzero concentration exists at that time (usually used with single-dose data)

• PKNCA_impute_method_start_cmin(): Add a new concentration of the minimum during the interval at the start time (usually used with multiple-dose data)

• PKNCA_impute_method_start_predose(): Shift a predose concentration to become the time zero concentration (only if a time zero concentration does not exist)

Description

Perform unit conversion (if possible) on PKNCA results

Usage

pknca_unit_conversion(result, units)

Arguments

Value

The result table with units converted

Description

Add parentheses to a unit value, if needed

Usage

pknca_units_add_paren(unit)

Arguments