#############################
# AGGREGATES #
############################
AGGREGATES <- function(value)
{
op_list <- list(value = value)
## Set the name for the class
class(op_list) <- "AGGREGATES"
return(op_list)
}
check.META_AGGREGATES <- function(value)
{
if(is.character(value) && length(value)>1)
stop("value: no multiple string")
if(!is.character(value))
stop("value: is not a string")
}
META_AGGREGATES <- function(value)
{
op_list <- list(value = value)
## Set the name for the class
class(op_list) <- "META_AGGREGATES"
return(op_list)
}
print.META_AGGREGATES <- function(obj) {
res <- as.character(obj)
cat(res)
}
as.character.META_AGGREGATES <- function(obj) {
class <- class(obj)[1]
val <- obj$value
c(class,val)
}
take_value.META_AGGREGATES <- function(obj){
class <- class(obj)[1]
val <- obj$value
text <- switch(class,
"SUM" = paste0("sum_",val),
"MIN" = paste0("min_",val),
"MAX" = paste0("max_",val),
"COUNT" = paste0("count"),
"BAG" = paste0("bag_",val),
"BAGD" = paste0("bagd_",val),
"AVG" = paste0("avg_",val),
"STD" = paste0("std_"),
"MEDIAN" = paste0("median_",val),
"Q1" = paste0("q1_",val),
"Q2" = paste0("q2_"),
"Q3" = paste0("q3_",val)
)
text
}
#' AGGREGATES object class constructor
#'
#'
#' This class constructor is used to create instances of AGGREGATES object,
#' to be used in GMQL functions that require aggregate on value.
#'
#' \itemize{
#' \item{SUM: It prepares input parameter to be passed to the library
#' function sum, performing all the type conversions needed }
#' \item{COUNT: It prepares input parameter to be passed to the library
#' function count, performing all the type conversions needed }
#' \item{COUNTSAMP: It prepares input parameter to be passed to the library
#' function countsamp, performing all the type conversions needed.
#' It is used only with group_by functions}
#' \item{MIN: It prepares input parameter to be passed to the library
#' function minimum, performing all the type conversions needed }
#' \item{MAX: It prepares input parameter to be passed to the library
#' function maximum, performing all the type conversions needed }
#' \item{AVG: It prepares input parameter to be passed to the library
#' function mean, performing all the type conversions needed }
#' \item{MEDIAN: It prepares input parameter to be passed to the library
#' function median, performing all the type conversions needed }
#' \item{STD: It prepares input parameter to be passed to the library
#' function standard deviation, performing all the type conversions needed}
#' \item{BAG: It prepares input parameter to be passed to the library
#' function bag; this function creates comma-separated strings of
#' attribute values, performing all the type conversions needed}
#' \item{BAGD: It prepares input parameter to be passed to the library
#' function bagd; this function creates comma-separated strings of distinct
#' attribute values, performing all the type conversions needed}
#' \item{Q1: It prepares input parameter to be passed to the library
#' function fist quartile, performing all the type conversions needed}
#' \item{Q2: It prepares input parameter to be passed to the library
#' function second quartile, performing all the type conversions needed }
#' \item{Q3: It prepares input parameter to be passed to the library
#' function third quartile, performing all the type conversions needed }
#' }
#'
#' @param value string identifying name of metadata or region attribute
#'
#' @return Aggregate object
#'
#' @examples
#'
#' ## This statement initializes and runs the GMQL server for local execution
#' ## and creation of results on disk. Then, with system.file() it defines
#' ## the path to the folder "DATASET" in the subdirectory "example"
#' ## of the package "RGMQL" and opens such folder as a GMQL dataset
#' ## named "exp" using CustomParser
#'
#' init_gmql()
#' test_path <- system.file("example", "DATASET", package = "RGMQL")
#' exp = read_gmql(test_path)
#'
#' ## This statement copies all samples of exp dataset into res dataset, and
#' ## then calculates new metadata attribute sum_score for each of them:
#' ## sum_score is the sum of score values of the sample regions.
#'
#' res = extend(exp, sum_score = SUM("score"))
#'
#' ## This statement copies all samples of exp dataset into res dataset,
#' ## and then calculates new metadata attribute min_pvalue for each of them:
#' ## min_pvalue is the minimum pvalue of the sample regions.
#'
#' res = extend(exp, min_pvalue = MIN("pvalue"))
#'
#' ## This statement copies all samples of exp dataset into res dataset,
#' ## and then calculates new metadata attribute max_score for each of them:
#' ## max_score is the maximum score of the sample regions.
#'
#' res = extend(exp, max_score = MAX("score"))
#'
#' ## The following cover operation produces output regions where at least 2
#' ## and at most 3 regions of exp dataset overlap, having as resulting region
#' ## attribute the average signal of the overlapping regions;
#' ## the result has one sample for each input cell value.
#'
#' res = cover(exp, 2, 3, groupBy = conds("cell"), avg_signal = AVG("signal"))
#'
#' ## This statement copies all samples of 'exp' dataset into 'out' dataset,
#' ## and then for each of them it adds another metadata attribute, allScore,
#' ## which is the aggregation comma-separated list of all the values
#' ## that the region attribute score takes in the sample.
#'
#' out = extend(exp, allScore = BAG("score"))
#'
#' ## This statement counts the regions in each sample and stores their number
#' ## as value of the new metadata RegionCount attribute of the sample.
#'
#' out = extend(exp, RegionCount = COUNT())
#'
#' ## This statement copies all samples of exp dataset into res dataset,
#' ## and then calculates new metadata attribute std_score for each of them:
#' ## std_score is the standard deviation of the score values of the sample
#' ## regions.
#'
#' res = extend(exp, std_score = STD("score"))
#'
#' ## This statement copies all samples of exp dataset into res dataset,
#' ## and then calculates new metadata attribute m_score for each of them:
#' ## m_score is the median score of the sample regions.
#'
#' res = extend(exp, m_score = MEDIAN("score"))
#'
#'
#' @name AGGREGATES-Object
#' @aliases SUM
#' @rdname aggr-class
#' @export
#'
SUM <- function(value)
{
check.META_AGGREGATES(value)
list <- list(value = value)
## Set the name for the class
class(list) <- c("SUM","AGGREGATES","META_AGGREGATES")
return(list)
}
#' @name AGGREGATES-Object
#' @aliases COUNT
#' @rdname aggr-class
#' @export
#'
COUNT <- function()
{
list <- list()
## Set the name for the class
class(list) <- c("COUNT","AGGREGATES","META_AGGREGATES")
return(list)
}
as.character.COUNT <- function(obj) {
class <- class(obj)[1]
c(class,"")
}
check.COUNT <- function(obj){}
#' @name AGGREGATES-Object
#' @aliases COUNTSAMP
#' @rdname aggr-class
#' @export
#'
COUNTSAMP <- function()
{
list <- list()
## Set the name for the class
class(list) <- c("COUNTSAMP","AGGREGATES","META_AGGREGATES")
return(list)
}
as.character.COUNTSAMP <- function(obj) {
class <- class(obj)[1]
c(class,"")
}
check.COUNTSAMP <- function(obj){}
#' @name AGGREGATES-Object
#' @aliases MIN
#' @rdname aggr-class
#' @export
#'
MIN <- function(value)
{
check.META_AGGREGATES(value)
list <- list(value = value)
## Set the name for the class
class(list) <- c("MIN","AGGREGATES","META_AGGREGATES")
return(list)
}
#' @name AGGREGATES-Object
#' @aliases MAX
#' @rdname aggr-class
#' @export
#'
MAX <- function(value)
{
check.META_AGGREGATES(value)
list <- list(value = value)
## Set the name for the class
class(list) <- c("MAX","AGGREGATES","META_AGGREGATES")
return(list)
}
#' @name AGGREGATES-Object
#' @aliases AVG
#' @rdname aggr-class
#' @export
#'
AVG <- function(value)
{
check.META_AGGREGATES(value)
list <- list(value = value)
## Set the name for the class
class(list) <- c("AVG","AGGREGATES","META_AGGREGATES")
return(list)
}
#' @name AGGREGATES-Object
#' @aliases MEDIAN
#' @rdname aggr-class
#' @export
#'
MEDIAN <- function(value)
{
check.META_AGGREGATES(value)
list <- list(value = value)
## Set the name for the class
class(list) <- c("MEDIAN","AGGREGATES","META_AGGREGATES")
return(list)
}
#' @name AGGREGATES-Object
#' @aliases STD
#' @rdname aggr-class
#' @export
#'
STD <- function(value)
{
check.META_AGGREGATES(value)
list <- list(value = value)
## Set the name for the class
class(list) <- c("STD","META_AGGREGATES")
return(list)
}
#' @name AGGREGATES-Object
#' @aliases BAG
#' @rdname aggr-class
#' @export
#'
BAG <- function(value)
{
check.META_AGGREGATES(value)
list <- list(value = value)
## Set the name for the class
class(list) <- c("BAG","AGGREGATES","META_AGGREGATES")
return(list)
}
#' @name AGGREGATES-Object
#' @aliases BAGD
#' @rdname aggr-class
#' @export
#'
BAGD <- function(value)
{
check.META_AGGREGATES(value)
list <- list(value = value)
## Set the name for the class
class(list) <- c("BAGD","AGGREGATES","META_AGGREGATES")
return(list)
}
#' @name AGGREGATES-Object
#' @aliases Q1
#' @rdname aggr-class
#' @export
#'
Q1 <- function(value)
{
check.META_AGGREGATES(value)
list <- list(value = value)
## Set the name for the class
class(list) <- c("Q1","META_AGGREGATES")
return(list)
}
#' @name AGGREGATES-Object
#' @aliases Q2
#' @rdname aggr-class
#' @export
#'
Q2 <- function(value)
{
check.META_AGGREGATES(value)
list <- list(value = value)
## Set the name for the class
class(list) <- c("Q2","META_AGGREGATES")
return(list)
}
#' @name AGGREGATES-Object
#' @aliases Q3
#' @rdname aggr-class
#' @export
#'
Q3 <- function(value)
{
check.META_AGGREGATES(value)
list <- list(value = value)
## Set the name for the class
class(list) <- c("Q3","META_AGGREGATES")
return(list)
}
