aggregate_values_by_key {ISAnalytics} | R Documentation

## Aggregates matrices values based on specified key.

### Description

Performs aggregation on values contained in the integration matrices based on the key and the specified lambda. For more details on how to use this function: `vignette("Working with aggregate functions", package = "ISAnalytics")`

### Usage

    aggregate_values_by_key(
      x,
      association_file,
      value_cols = "Value",
      key = c("SubjectID", "CellMarker", "Tissue", "TimePoint"),
      lambda = list(sum = ~sum(.x, na.rm = TRUE)),
      group = c(mandatory_IS_vars(), annotation_IS_vars()),
      join_af_by = "CompleteAmplificationID"
    )

### Arguments

`x` | A single integration matrix (tibble) or a list of imported integration matrices (tibble)
`association_file` | The imported association file
`value_cols` | A character vector containing the names of the columns to apply the given lambdas. Must be numeric or integer columns.
`key` | A string or a character vector with column names of the association file to take as key
`lambda` | A named list of functions or purrr-style lambdas. See details section.
`group` | Other variables to include in the grouping besides `key`, can be set to NULL
`join_af_by` | A character vector representing the joining key between the matrix and the metadata. Useful to re-aggregate already aggregated matrices.

### Details

#### Setting the lambda parameter

The lambda parameter should always contain a named list of either functions or purrr-style lambdas. It is also possible to specify the namespace of the function in both ways, for example:

    lambda = list(sum = sum, desc = psych::describe)

Using purrr-style lambdas allows to specify arguments for the functions, keeping in mind that the first parameter should always be `.x`:

    lambda = list(sum = ~sum(.x, na.rm = TRUE))

It is also possible to use custom user-defined functions, keeping in mind that the symbol will be evaluated in the calling environment, for example if the function is called in the global environment and lambda contains "foo" as a function, "foo" will be evaluated in the global environment.

    foo <- function(x) {
      sum(x)
    }

    lambda = list(sum = ~sum(.x, na.rm = TRUE), foo = foo)

    # Or with lambda notation
    lambda = list(sum = ~sum(.x, na.rm = TRUE), foo = ~foo(.x))

#### Constraints on aggregation functions

Functions passed in the lambda parameters must respect a few constraints to properly work and it's the user responsibility to ensure this.

- Functions have to accept as input a numeric or integer vector

- Function should return a single value or a list/data frame: if a list or a data frame is returned as a result, all the columns will be added to the final data frame.

### Value

A list of tibbles or a single tibble aggregated according to the specified arguments

### See Also

Other Aggregate functions: `aggregate_metadata()`, `default_meta_agg()`

### Examples

    op <- options("ISAnalytics.widgets" = FALSE, "ISAnalytics.verbose" = FALSE)
    path_AF <- system.file("extdata", "ex_association_file.tsv",
        package = "ISAnalytics"
    )
    root_correct <- system.file("extdata", "fs.zip", package = "ISAnalytics")
    root_correct <- unzip_file_system(root_correct, "fs")
    association_file <- import_association_file(path_AF, root_correct,
        dates_format = "dmy"
    )
    matrices <- import_parallel_Vispa2Matrices_auto(
        association_file = association_file, root = NULL,
        quantification_type = c("fragmentEstimate", "seqCount"),
        matrix_type = "annotated", workers = 2, matching_opt = "ANY"
    )
    agg <- aggregate_values_by_key(
        x = matrices,
        association_file = association_file,
        value_cols = c("fragmentEstimate", "seqCount")
    )
    options(op)

[Package ISAnalytics version 1.2.1 Index]