comorbid: Find comorbidities from ICD-9 codes.

In icd: Comorbidity Calculations and Tools for ICD-9 and ICD-10 Codes

Description

This is the main function which extracts comorbidities from a set of ICD-9 codes. Some comorbidity schemes have rules, for example, what to do when both 'hypertension' and 'hypertension with complications' are present. These rules are applied by default; if the exact fields from the original mappings are needed, use hierarchy = FALSE. For comorbidity counting, Charlson or Van Walraven scores the default should be used to apply the rules. For more about computing Hierarchical Condition Codes (HCC), see comorbid_hcc For more about comorbidities following the Clinical Classification Software (CCS) rules from AHRQ, see comorbid_ccs.

Usage

comorbid(
  x,
  map,
  visit_name = NULL,
  icd_name = NULL,
  short_code = guess_short(x, icd_name = icd_name),
  short_map = guess_short(map),
  return_df = FALSE,
  return_binary = FALSE,
  categorize_fun = categorize_simple,
  ...
)

icd10_comorbid(
  x,
  map,
  visit_name = NULL,
  icd_name = NULL,
  short_code = NULL,
  short_map = guess_short(map),
  return_df = FALSE,
  return_binary = FALSE,
  icd10_comorbid_fun = icd10_comorbid_reduce,
  ...
)

icd9_comorbid(
  x,
  map,
  visit_name = NULL,
  icd_name = NULL,
  short_code = guess_short(x, icd_name = icd_name),
  short_map = guess_short(map),
  return_df = FALSE,
  return_binary = FALSE,
  preclean = FALSE,
  categorize_fun = categorize_simple,
  comorbid_fun = comorbid_mat_mul_wide,
  ...
)

icd9_comorbid_ahrq(x, ..., abbrev_names = TRUE, hierarchy = TRUE)

icd10_comorbid_ahrq(x, ..., abbrev_names = TRUE, hierarchy = TRUE)

icd9_comorbid_elix(x, ..., abbrev_names = TRUE, hierarchy = TRUE)

icd10_comorbid_elix(x, ..., abbrev_names = TRUE, hierarchy = TRUE)

icd9_comorbid_quan_elix(x, ..., abbrev_names = TRUE, hierarchy = TRUE)

icd10_comorbid_quan_elix(x, ..., abbrev_names = TRUE, hierarchy = TRUE)

icd9_comorbid_quan_deyo(x, ..., abbrev_names = TRUE, hierarchy = TRUE)

icd10_comorbid_quan_deyo(x, ..., abbrev_names = TRUE, hierarchy = TRUE)

icd9_comorbid_charlson(...)

icd10_comorbid_charlson(...)

comorbid_ccs(x, icd_name = get_icd_name(x), ...)

icd9_comorbid_ccs(
  x,
  ...,
  single = TRUE,
  lvl = NULL,
  map = icd::icd9_map_single_ccs,
  short_map = TRUE
)

icd10_comorbid_ccs(x, ..., single = TRUE, lvl = NULL)

comorbid_ahrq(x, ...)

comorbid_elix(x, ...)

comorbid_quan_elix(x, ...)

comorbid_quan_deyo(x, ...)

comorbid_charlson(...)

comorbid_pccc_dx(
  x,
  visit_name = get_visit_name(x),
  icd_name = get_icd_name(x),
  short_code = guess_short(x, icd_name = icd_name),
  return_df = FALSE,
  return_binary = FALSE,
  ...
)

comorbid_pccc_pcs(
  x,
  visit_name = get_visit_name(x),
  icd_name,
  return_df = FALSE,
  return_binary = FALSE,
  ...
)

icd9_comorbid_pccc_dx(
  x,
  visit_name = NULL,
  icd_name = NULL,
  short_code = guess_short(x, icd_name = icd_name),
  return_df = FALSE,
  return_binary = FALSE,
  ...,
  abbrev_names = TRUE
)

icd10_comorbid_pccc_dx(
  x,
  visit_name = NULL,
  icd_name = NULL,
  short_code = guess_short(x, icd_name = icd_name),
  return_df = FALSE,
  return_binary = FALSE,
  ...,
  abbrev_names = TRUE
)

icd9_comorbid_pccc_pcs(
  x,
  visit_name = get_visit_name(x),
  icd_name = get_icd_pc_name(x),
  return_df = FALSE,
  return_binary = FALSE,
  ...,
  abbrev_names = TRUE
)

icd10_comorbid_pccc_pcs(
  x,
  visit_name = get_visit_name(x),
  icd_name,
  return_df = FALSE,
  return_binary = FALSE,
  ...,
  abbrev_names = TRUE
)

Arguments

x	data.frame containing a column of patient-visit identifiers and a column of ICD codes. The data.frame may be in ‘long’ or ‘wide’ format, like the example vermont_dx and uranium_pathology data.
map	A named list of the comorbidities with each list item containing a vector of decimal ICD-9 codes. icd includes a number of these, e.g., icd9_map_elix. Alternatively, this can be omitted if the convenience functions, such as icd10_comorbid_charlson are used directly. map should be in the form of a list, with the names of the items corresponding to the comorbidities (e.g. ‘HTN’, or ‘diabetes’) and the contents of each list item being a character vector of short-form (no decimal place, zero left-padded) ICD codes. There is no default: the user should use the family of functions, e.g. comorbid_ahrq, since these also name the fields correctly, and these functions also apply any hierarchical rules (see hierarchy below)
visit_name	The name of the column in the data frame which contains the patient or visit identifier. Typically this is the visit identifier, since patients come leave and enter hospital with different ICD-9 codes. It is a character vector of length one. If left empty, or NULL, then an attempt is made to guess which field has the ID for the patient encounter (not a patient ID, although this can of course be specified directly). The guesses proceed until a single match is made. Data frames may be wide with many matching fields, so to avoid false positives, anything but a single match is rejected. If there are no successful guesses, and visit_id was not specified, then the first column of the data frame is used.
icd_name	The name of the column in the data.frame which contains the ICD codes. This is a character vector of length one. If it is NULL, icd9 will attempt to guess the column name, looking for progressively less likely possibilities until it matches a single column. Failing this, it will take the first column in the data frame. Specifying the column using this argument avoids the guesswork.
short_code	single logical value which determines whether the ICD-9 code provided is in short (TRUE) or decimal (FALSE) form. Where reasonable, this is guessed from the input data.
short_map	Same as short, but applied to map instead of the data frame of ICD codes, x. All the codes in a mapping should be of the same type, i.e. short or decimal.
return_df	single logical value, if TRUE, return 'tidy' data, i.e., the result is a data frame with the first column being the visit_id, and the second being the count. If visit_id was a factor or named differently in the input, this is preserved.
return_binary	Single logical value, if TRUE, the returned matrix or data.frame will be composed of 1 and 0, instead of TRUE and FALSE, respectively. This conversion can also be done by the internal functions icd:::logical_to_binary and icd:::binary_to_logical, or using other tools, e.g. apply(x, 2, as.integer)
categorize_fun	Internal. Function used for the categorization problem.
...	Arguments passed through to comorbid, and ultimately categorize_simple, e.g. restore_id_order.
icd10_comorbid_fun	Internal function Default will be fast and accurate. A function which calculates comorbidities for ICD-10 codes, in which the comorbidity map only specifies parent codes, not every possible child.
preclean	single logical value, which, if TRUE causes ICD-9 'short' code input to be padded to correct three (or four for E code) length before applying the comorbidity map. For very large data sets, e.g. ten million rows, this is much slower than the comorbidity calculation. If you know that the source ICD-9 codes are already well formed (or have already run icd9_add_leading_zeroes), then preclean can be set to FALSE to save time.
comorbid_fun	Internal. Function used inside categorization.
abbrev_names	single logical value that defaults to TRUE, in which case the shorter human-readable names stored in e.g. ahrqComorbidNamesAbbrev are applied to the data frame column names.
hierarchy	single logical value that defaults to TRUE, in which case the hierarchy defined for the mapping is applied. E.g. in Elixhauser, you can't have uncomplicated and complicated diabetes both flagged.
single	a logical value, if TRUE then use single level CCS, otherwise use multi level
lvl	If multiple level CCS, then level must be selected as a number between one and four.

Details

The order of visits may change depending on the original sequence, and the underlying algorithm used. Usually this would be the order of the first occurrence of each visit/patient identifier, but this is not guaranteed unless restore_id_order is set to TRUE.

data.frames of patient data may have columns within them which are of class icd9, icd10 etc., but do not themselves have a class: therefore, the S3 mechanism for dispatch is not suitable. I may add a wrapper function which looks inside a data.frame of comorbidities, and dispatches to the appropriate function, but right now the user must call the icd9_ or icd10_ prefixed function directly.

Functions

• icd10_comorbid: ICD-10 comorbidities

• icd9_comorbid: Get comorbidities from data.frame of ICD-9 codes

• icd9_comorbid_ahrq: AHRQ comorbidities for ICD-9 codes

• icd10_comorbid_ahrq: AHRQ comorbidities for ICD-10 codes

• icd9_comorbid_elix: Elixhauser comorbidities for ICD-9 codes

• icd10_comorbid_elix: Elixhauser comorbidities for ICD-10 codes

• icd9_comorbid_quan_elix: Quan's Elixhauser comorbidities for ICD-9 codes

• icd10_comorbid_quan_elix: Quan's Elixhauser comorbidities for ICD-10 codes

• icd9_comorbid_quan_deyo: Quan's Deyo (Charlson) comorbidities for ICD-9 codes

• icd10_comorbid_quan_deyo: Quan's Deyo (Charlson) comorbidities for ICD-10 codes

• icd9_comorbid_charlson: Currently synonym for icd9_comorbid_quan_deyo

• icd10_comorbid_charlson: Currently synonym for icd10_comorbid_quan_deyo

• comorbid_ccs: Use AHRQ CCS for comorbidity classification

• icd9_comorbid_ccs: Compute AHRQ Clinical Classifications Software (CCS) scores from ICD-9 codes

• icd10_comorbid_ccs: Compute AHRQ Clinical Classifications Software (CCS) scores from ICD-10 codes

• comorbid_ahrq: AHRQ comorbidities, infers whether to use ICD-9 or ICD-10 codes

• comorbid_elix: Elixhauser comorbidities, infers whether to use ICD-9 or ICD-10 codes

• comorbid_quan_elix: Quan's Elixhauser comorbidities, infers whether to use ICD-9 or ICD-10 codes

• comorbid_quan_deyo: Quan's Deyo (Charlson) comorbidities, infers whether to use ICD-9 or ICD-10 codes

• comorbid_charlson: Calculate comorbidities using Charlson categories according to Quan/Deyo ICD categories. Synonymous with link{comorbid_quan_deyo} in this release.

• comorbid_pccc_dx: Calculate pediatric complex chronic conditions (PCCC) comorbidities

  Unlike with ICD-9 and ICD-10 diagnostic codes, 'icd' doesn't currently have a method for guessing which fields are procedure codes, so icd_name must be specified for the _pcs functions.

• comorbid_pccc_pcs: Calculate the PCCC comorbidities based on procedure codes,

• icd9_comorbid_pccc_dx: Calculate PCCC comorbidities from ICD-9 diagnosis codes

• icd10_comorbid_pccc_dx: Calculate PCCC comorbidities from ICD-10 diagnosis codes

• icd9_comorbid_pccc_pcs: Calculate PCCC comorbidities from ICD-9 procedure codes

• icd10_comorbid_pccc_pcs: Calculate PCCC comorbidities from ICD-10 procedure codes

See Also

icd9_map_single_ccs

Consider using comorbid_ahrq instead of comorbid_elix for more recently updated mappings based on the Elixhauser scheme.

Other comorbidity computations: comorbid_hcc()

Other comorbidities: comorbid_hcc(), icd10_map_ahrq_pcs, icd9_map_ahrq, icd9_map_elix, icd9_map_hcc, icd9_map_pccc, icd9_map_quan_deyo, icd9_map_quan_elix, icd9_map_single_ccs

Other comorbidity computations: comorbid_hcc()

Other comorbidities: comorbid_hcc(), icd10_map_ahrq_pcs, icd9_map_ahrq, icd9_map_elix, icd9_map_hcc, icd9_map_pccc, icd9_map_quan_deyo, icd9_map_quan_elix, icd9_map_single_ccs

Examples

library(icd)
vermont_dx[1:5, 1:10]
# get first few rows and columns of Charlson comorbidities using Quan/Deyo
# mapping of ICD-9 or ICD-10 codes Charlson categories
comorbid_quan_deyo(vermont_dx)[1:5, 1:14]

# Note that the comorbidity calculations automatically finds the ICD code
# columns, and uses 'wide' or 'long' format data.

stopifnot(
  identical(
    comorbid_quan_deyo(vermont_dx),
    comorbid_quan_deyo(wide_to_long(vermont_dx))
  )
)

# get summary AHRQ (based on Elixhauser) comorbidities for the Uranium data:
summary(comorbid_ahrq(uranium_pathology))

pts <- icd_long_data(
  visit_name = c("2", "1", "2", "3", "3"),
  icd9 = c("39891", "40110", "09322", "41514", "39891")
)
comorbid(pts, icd9_map_ahrq, short_code = TRUE) # visit_name is now sorted
pts <- icd_long_data(
  visit_name = c("1", "2", "3", "4", "4"),
  icd_name = c("20084", "1742", "30410", "41514", "95893"),
  date = as.Date(c(
    "2011-01-01", "2011-01-02", "2011-01-03",
    "2011-01-04", "2011-01-04"
  ))
)

pt_hccs <- comorbid_hcc(pts, date_name = "date")
head(pt_hccs)

pts10 <- icd_long_data(
  visit_name = c("a", "b", "c", "d", "e"),
  icd_name = c("I058", NA, "T82817A", "", "I69369"),
  date = as.Date(
    c("2011-01-01", "2011-01-02", "2011-01-03", "2011-01-03", "2011-01-03")
  )
)

icd10_comorbid(pts10, map = icd10_map_ahrq)
# or if library(icd) hasn't been called first:
icd::icd10_comorbid(pts10, map = icd::icd10_map_ahrq)
# or most simply:
icd::icd10_comorbid_ahrq(pts10)

# specify a simple custom comorbidity map:
my_map <- list(
  "malady" = c("100", "2000"),
  "ailment" = c("003", "040")
)
two_pts <- data.frame(
  visit_id = c("v01", "v01", "v02", "v02"),
  icd9 = as.icd9(c("040", "000", "100", "000")),
  stringsAsFactors = FALSE
)
comorbid(two_pts, map = my_map)
# not pediatric data, but let's look for this example
head(icd9_comorbid_pccc_dx(vermont_dx))
# Six random codes from each PCCC procedure code map. 'icd' will use
# an heuristic to guess whether ICD-9 or ICD-10:
pts <- data.frame(
  encounters = c(10, 11, 12),
  icd9_pcs = c("0152", "304", "0050"),
  icd10_pcs = c("0B110Z4", "02YA0Z2", "031209D")
)
comorbid_pccc_pcs(pts, icd_name = "icd9_pcs", return_binary = TRUE)
comorbid_pccc_pcs(pts, icd_name = "icd10_pcs", return_binary = TRUE)

# All ICD-9 procedure codes are numeric, some ICD-10 procedure codes
# are numeric, so best to call functions directly:
pts <- data.frame(encounters = c(100), icd10_pcs = c("0016070"))
icd10_comorbid_pccc_pcs(pts, icd_name = "icd10_pcs")

icd documentation built on July 2, 2020, 4:07 a.m.