All functions

PKNCA-package PKNCA

Compute noncompartmental pharmacokinetics

PKNCA.choose.option()

Choose either the value from an option list or the current set value for an option.

PKNCA.options()

Set default options for PKNCA functions

PKNCA.options.describe()

Describe a PKNCA.options option by name.

PKNCA.set.summary()

Define how NCA parameters are summarized.

PKNCA_impute_fun_list()

Separate out a vector of PKNCA imputation methods into a list of functions

PKNCA_impute_method_start_conc0() PKNCA_impute_method_start_cmin() PKNCA_impute_method_start_predose()

Methods for imputation of data with PKNCA

PKNCAconc()

Create a PKNCAconc object

PKNCAdata()

Create a PKNCAdata object.

PKNCAdose()

Create a PKNCAdose object

PKNCAresults()

Generate a PKNCAresults object

add.interval.col()

Add columns for calculations within PKNCA intervals

addProvenance()

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

adj.r.squared()

Calculate the adjusted r-squared value

any_sparse_dense_in_interval()

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

as.data.frame(<PKNCAresults>)

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

as_PKNCAconc() as_PKNCAdose() as_PKNCAdata() as_PKNCAresults()

Convert an object into a PKNCAconc object

as_sparse_pk()

Generate a sparse_pk object

assert_PKNCAdata()

Assert that an object is a PKNCAdata object

assert_aucmethod()

Assert that a value is a valid AUC method

assert_conc() assert_time() assert_conc_time()

Verify that concentration measurements are valid

assert_dosetau()

Assert that a value is a dosing interval

assert_intervaltime_single()

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

assert_lambdaz()

Assert that a lambda.z value is valid

assert_number_between()

Confirm that a value is greater than another value

assert_numeric_between()

Confirm that a value is greater than another value

auc_integrate()

Support function for AUC integration

business.mean() business.sd() business.cv() business.geomean() business.geocv() business.min() business.max() business.median() business.range()

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

check.conversion()

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

check.interval.deps()

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.

check.interval.specification()

Check the formatting of a calculation interval specification data frame.

checkProvenance()

Check the hash of an object to confirm its provenance.

choose.auc.intervals()

Choose intervals to compute AUCs from time and dosing information

choose_interval_method()

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

clean.conc.blq()

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

clean.conc.na()

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

cov_holder()

Calculate the covariance for two time points with sparse sampling

check.conc.time()

The following functions are defunct

exclude()

Exclude data points or results from calculations or summarization.

exclude_nca_span.ratio() exclude_nca_max.aucinf.pext() exclude_nca_min.hl.r.squared()

Exclude NCA parameters based on examining the parameter set.

filter(<PKNCAresults>) filter(<PKNCAconc>) filter(<PKNCAdose>)

dplyr filtering for PKNCA

find.tau()

Find the repeating interval within a vector of doses

findOperator()

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

fit_half_life()

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.

formula(<PKNCAconc>) formula(<PKNCAdose>)

Extract the formula from a PKNCAconc object.

geomean() geosd() geocv()

Compute the geometric mean, sd, and CV

get.best.model()

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

get.first.model()

Get the first model from a list of models

get.interval.cols()

Get the columns that can be used in an interval specification

get.parameter.deps()

Get all columns that depend on a parameter

getAttributeColumn()

Retrieve the value of an attribute column.

getColumnValueOrNot()

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.

getDataName()

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

getDepVar()

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

getGroups(<PKNCAconc>) getGroups(<PKNCAdose>) getGroups(<PKNCAresults>)

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

getIndepVar()

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

get_impute_method()

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

group_by(<PKNCAresults>) group_by(<PKNCAconc>) group_by(<PKNCAdose>) ungroup(<PKNCAresults>) ungroup(<PKNCAconc>) ungroup(<PKNCAdose>)

dplyr grouping for PKNCA

group_vars(<PKNCAconc>) group_vars(<PKNCAdose>)

Get grouping variables for a PKNCA object

inner_join(<PKNCAresults>) left_join(<PKNCAresults>) right_join(<PKNCAresults>) full_join(<PKNCAresults>) inner_join(<PKNCAconc>) left_join(<PKNCAconc>) right_join(<PKNCAconc>) full_join(<PKNCAconc>) inner_join(<PKNCAdose>) left_join(<PKNCAdose>) right_join(<PKNCAdose>) full_join(<PKNCAdose>)

dplyr joins for PKNCA

interp.extrap.conc() interpolate.conc() extrapolate.conc() interp.extrap.conc.dose()

Interpolate concentrations between measurements or extrapolate concentrations after the last measurement.

interpolate_conc_linear() interpolate_conc_log() extrapolate_conc_lambdaz()

Interpolate or extrapolate concentrations using the provided method

is_sparse_pk()

Is a PKNCA object used for sparse PK?

model.frame(<PKNCAconc>) model.frame(<PKNCAdose>)

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

mutate(<PKNCAresults>) mutate(<PKNCAconc>) mutate(<PKNCAdose>)

dplyr mutate-based modification for PKNCA

normalize_exclude()

Normalize the exclude column by setting blanks to NA

parse_formula_to_cols()

Convert a formula representation to the columns for input data

pk.business()

Run any function with a maximum missing fraction of X and 0s possibly counting as missing. The maximum fraction missing comes from PKNCA.options("max.missing").

pk.calc.ae()

Calculate amount excreted (typically in urine or feces)

pk.calc.aucabove()

Calculate the AUC above a given concentration

pk.calc.aucint() pk.calc.aucint.last() pk.calc.aucint.all() pk.calc.aucint.inf.obs() pk.calc.aucint.inf.pred()

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

pk.calc.auciv() pk.calc.auciv_pbext()

Calculate AUC for intravenous dosing

pk.calc.aucpext()

Calculate the AUC percent extrapolated

pk.calc.auxc() pk.calc.auc() pk.calc.auc.last() pk.calc.auc.inf() pk.calc.auc.inf.obs() pk.calc.auc.inf.pred() pk.calc.auc.all() pk.calc.aumc() pk.calc.aumc.last() pk.calc.aumc.inf() pk.calc.aumc.inf.obs() pk.calc.aumc.inf.pred() pk.calc.aumc.all()

A compute the Area Under the (Moment) Curve

pk.calc.c0() pk.calc.c0.method.logslope() pk.calc.c0.method.c0() pk.calc.c0.method.c1() pk.calc.c0.method.set0() pk.calc.c0.method.cmin()

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

pk.calc.cav()

Calculate the average concentration during an interval.

pk.calc.ceoi()

Determine the concentration at the end of infusion

pk.calc.cl()

Calculate the (observed oral) clearance

pk.calc.clast.obs()

Determine the last observed concentration above the limit of quantification (LOQ).

pk.calc.clr()

Calculate renal clearance

pk.calc.cmax() pk.calc.cmin()

Determine maximum observed PK concentration

pk.calc.count_conc()

Count the number of concentration measurements in an interval

pk.calc.cstart()

Determine the concentration at the beginning of the interval

pk.calc.ctrough()

Determine the trough (end of interval) concentration

pk.calc.deg.fluc()

Determine the degree of fluctuation

pk.calc.dn()

Determine dose normalized NCA parameter

pk.calc.f()

Calculate the absolute (or relative) bioavailability

pk.calc.fe()

Calculate fraction excreted (typically in urine or feces)

pk.calc.half.life()

Compute the half-life and associated parameters

pk.calc.kel()

Calculate the elimination rate (Kel)

pk.calc.mrt() pk.calc.mrt.iv()

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

pk.calc.mrt.md()

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

pk.calc.ptr()

Determine the peak-to-trough ratio

pk.calc.sparse_auc() pk.calc.sparse_auclast()

Calculate AUC and related parameters using sparse NCA methods

pk.calc.swing()

Determine the PK swing

pk.calc.thalf.eff()

Calculate the effective half-life

pk.calc.time_above()

Determine time at or above a set value

pk.calc.tlag()

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

pk.calc.tlast() pk.calc.tfirst()

Determine time of last observed concentration above the limit of quantification.

pk.calc.tmax()

Determine time of maximum observed PK concentration

pk.calc.totdose()

Extract the dose used for calculations

pk.calc.vss()

Calculate the steady-state volume of distribution (Vss)

pk.calc.vz()

Calculate the terminal volume of distribution (Vz)

pk.nca()

Compute NCA parameters for each interval for each subject.

pk.nca.interval()

Compute all PK parameters for a single concentration-time data set

pk.nca.intervals()

Compute NCA for multiple intervals

pk.tss()

Compute the time to steady-state (tss)

pk.tss.data.prep()

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

pk.tss.monoexponential()

Compute the time to steady state using nonlinear, mixed-effects modeling of trough concentrations.

pk.tss.monoexponential.individual()

A helper function to estimate individual and single outputs for monoexponential time to steady-state.

pk.tss.monoexponential.population()

A helper function to estimate population and popind outputs for monoexponential time to steady-state.

pk.tss.stepwise.linear()

Compute the time to steady state using stepwise test of linear trend

pk_nca_result_to_df()

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

pknca_find_units_param()

Find NCA parameters with a given unit type

pknca_unit_conversion()

Perform unit conversion (if possible) on PKNCA results

pknca_units_add_paren()

Add parentheses to a unit value, if needed

pknca_units_table()

Create a unit assignment and conversion table

print(<PKNCAconc>) summary(<PKNCAconc>) print(<PKNCAdose>) summary(<PKNCAdose>)

Print and/or summarize a PKNCAconc or PKNCAdose object.

print(<PKNCAdata>)

Print a PKNCAdata object

print(<provenance>)

Print the summary of a provenance object

print(<summary_PKNCAresults>)

Print the results summary

roundString()

Round a value to a defined number of digits printing out trailing zeros, if applicable.

roundingSummarize()

During the summarization of PKNCAresults, do the rounding of values based on the instructions given.

setAttributeColumn()

Add an attribute to an object where the attribute is added as a name to the names of the object.

setDuration()

Set the duration of dosing or measurement

setExcludeColumn()

Set the exclude parameter on an object

setRoute()

Set the dosing route

signifString()

Round a value to a defined number of significant digits printing out trailing zeros, if applicable.

sort(<interval.cols>)

Sort the interval columns by dependencies.

sparse_auc_weight_linear()

Calculate the weight for sparse AUC calculation with the linear-trapezoidal rule

sparse_mean()

Calculate the mean concentration at all time points for use in sparse NCA calculations

sparse_pk_attribute()

Set or get a sparse_pk object attribute

sparse_to_dense_pk()

Extract the mean concentration-time profile as a data.frame

summary(<PKNCAdata>)

Summarize a PKNCAdata object showing important details about the concentration, dosing, and interval information.

summary(<PKNCAresults>)

Summarize PKNCA results

superposition()

Compute noncompartmental superposition for repeated dosing

time_calc()

Times relative to an event (typically dosing)

tss.monoexponential.generate.formula()

A helper function to generate the formula and starting values for the parameters in monoexponential models.

var_sparse_auc()

Calculate the variance for the AUC of sparsely sampled PK