7: template<typename T> class Matrix {

12:   Matrix(std::size_t reserved_count) {

2: #define MATRIX_H

1: #ifndef MATRIX_H

66:         matrix <- matrix(c(in.x, in.y, not.x, not.y), nrow = 2)

67:         fisher <- stats::fisher.test(matrix, workspace = 2e6)

97:             matrix <- apply(quantiles, 2, function(x){

101:             matrix.x <- matrix[1:512,]

102:             matrix.y <- matrix[513:(2*512),]

223:                 density.matrix <- returnDensityMatrix()

224:                 x.matrix <- density.matrix[[1]]

225:                 y.matrix <- density.matrix[[2]]

87: 	returnDensityMatrix <- reactive({

107: 	returnDensityMatrixNorm <- reactive({

103:             return(list(matrix.x = matrix.x, matrix.y = matrix.y))

121:             matrix <- apply(quantiles, 2, function(x){

125:             matrix.x <- matrix[1:512,]

126:             matrix.y <- matrix[513:(2*512),]

127:             return(list(matrix.x = matrix.x, matrix.y = matrix.y))	

226:                 x.matrix <- ((x.matrix - mouse.x)/range.x)^2

227:                 y.matrix <- ((y.matrix - mouse.y)/range.y)^2

228:                 clickedIndex <- arrayInd(which.min(x.matrix+y.matrix),

229:                                          c(512,ncol(x.matrix)))[2]

266:                 density.matrix <- returnDensityMatrixNorm()

267:                 x.matrix <- density.matrix[[1]]

268:                 y.matrix <- density.matrix[[2]]

269:                 x.matrix <- ((x.matrix - mouse.x)/range.x)^2

270:                 y.matrix <- ((y.matrix - mouse.y)/range.y)^2

271:                 clickedIndex <- arrayInd(which.min(x.matrix+y.matrix),

272:                                          c(512,ncol(x.matrix)))[2]

359:             densitiesPlot(matrix.x = returnDensityMatrix()[[1]],

360:                           matrix.y = returnDensityMatrix()[[2]],

372:                                 matrix.x = returnDensityMatrix()[[1]],

373:                                 matrix.y = returnDensityMatrix()[[2]],

426: 		densitiesPlot(matrix.x = returnDensityMatrixNorm()[[1]],

427:                               matrix.y = returnDensityMatrixNorm()[[2]],

439:                                     matrix.x = returnDensityMatrixNorm()[[1]],

440:                                     matrix.y = returnDensityMatrixNorm()[[2]],

616:             matrix <- apply(betaQuantiles[[index]], 2, function(x){

620:             matrix.x <- matrix[1:512,]

621:             matrix.y <- matrix[513:(2*512),]

629:             densitiesPlot(matrix.x = matrix.x,

630:                           matrix.y = matrix.y,

6: } Matrix;

2: typedef struct MatrixStructure {

20:     Matrix kA;

21:     Matrix kB;

24:     Matrix lambdaA;

26:     Matrix lambdaB;

44: double columnMean ( Matrix &A, int column )

95: void mult ( Vector &a, Matrix &X, Vector &b )

2168:     Matrix <- Brick_get_matrix(Brick = Brick, chr1 = chr1, chr2 = chr2,

2255:     Matrix <- Brick_get_vector_values(Brick = Brick, chr1=chr1, chr2=chr2,

554:     Matrix_info <- return_configuration_matrix_info(Brick)

776:     Matrix.list.df <- do.call(rbind,chr1.list)

1322: Brick_load_matrix = function(Brick = NA, chr1 = NA, chr2 = NA, resolution = NA,

1613:     Matrix.list <- Brick_list_matrices(Brick = Brick, chr1 = chr1, 

1657:     Matrix.list <- Brick_list_matrices(Brick = Brick, chr1 = chr1, chr2 = chr2,

1713:     Matrix.list <- Brick_list_matrices(Brick = Brick, chr1 = chr1, chr2 = chr2,

1803:     Matrix.list <- Brick_list_matrices(Brick = Brick, chr1 = chr1, chr2 = chr2,

1898:     Matrix.list <- Brick_list_matrices(Brick = Brick, chr1 = chr1, chr2 = chr2,

2228: Brick_get_matrix = function(Brick, chr1, chr2, x_coords,

2574: Brick_get_entire_matrix = function(Brick, chr1, chr2, resolution){

2592:     entire_matrix <- dataset_handle[]

2848:     a_matrix <- .remove_nas(Brick_get_entire_matrix(Brick = Brick, 

2850:     normalised_matrix <- .normalize_by_distance_values(a_matrix)

2851:     correlation_matrix <- cor(normalised_matrix)

206:     Configuration_matrix_list <- list()

1419: Brick_load_cis_matrix_till_distance = function(Brick = NA, chr = NA, 

1607: Brick_matrix_isdone = function(Brick, chr1, chr2, resolution = NA){

1651: Brick_matrix_issparse = function(Brick, chr1, chr2, resolution = NA){

1703: Brick_matrix_maxdist = function(Brick, chr1, chr2, resolution = NA){

1758: Brick_matrix_exists = function(Brick, chr1, chr2, resolution = NA){

1797: Brick_matrix_minmax = function(Brick, chr1, chr2, resolution = NA){

1843: Brick_matrix_dimensions = function(Brick, chr1, chr2, resolution = NA){

1892: Brick_matrix_filename = function(Brick, chr1, chr2, resolution = NA){

2124: Brick_get_matrix_within_coords = function(Brick, x_coords,

2647: Brick_get_matrix_mcols = function(Brick, chr1, chr2, resolution, 

2706: Brick_list_matrix_mcols = function(){

8: #' table associated to the Hi-C experiment, creates a 2D matrix

21: #' contains 250 entries in the binning table, the _cis_ Hi-C data matrix for

24: #' matrices for chr1,chr2 will be a matrix with dimension 250 rows and

60: #' set to matrix dimensions/100.

95: #'                \item Min - min value of Hi-C matrix

96: #'                \item Max - max value of Hi-C matrix

97: #'                \item sparsity - specifies if this is a sparse matrix

99: #'                \item Done - specifies if a matrix has been loaded

101: #'            \item matrix - \strong{dataset} - contains the matrix

235:         Configuration_matrix_list <- return_configuration_matrix_info(

267:             Configuration_matrix_list[[paste(chrom1, chrom2, 

281:         Configuration_matrix_list, 

527: #' for that chromosome in a Hi-C matrix.

555:     current_resolution <- vapply(Matrix_info, function(a_list){

561:     chrom1_binned_length <- vapply(Matrix_info[current_resolution], 

565:     chrom1s <- vapply(Matrix_info[current_resolution], 

569:     chrom1_max_sizes <- vapply(Matrix_info[current_resolution], 

720: #' List the matrix pairs present in the Brick store.

727: #' @inheritParams Brick_load_matrix

733: #' minimum and maximum values in the matrix, done is a logical value

734: #' specifying if a matrix has been loaded and sparsity specifies if a matrix

735: #' is defined as a sparse matrix.

777:     rownames(Matrix.list.df) <- NULL

778:     return(Matrix.list.df)

1263: #' Load a NxM dimensional matrix into the Brick store.

1269: #' the rows of the matrix

1273: #' the columns of the matrix

1275: #' @param matrix_file \strong{Required}.

1277: #' matrix into the Brick store.

1280: #' The delimiter of the matrix file.

1283: #' If a matrix was loaded before, it will not be replaced. Use remove_prior to

1284: #' override and replace the existing matrix.

1290: #' If true, designates the matrix as being a sparse matrix, and computes the

1306: #' out_dir <- file.path(tempdir(), "matrix_load_test")

1314: #' Matrix_file <- system.file(file.path("extdata", 

1318: #' Brick_load_matrix(Brick = My_BrickContainer, chr1 = "chr2L", 

1319: #' chr2 = "chr2L", matrix_file = Matrix_file, delim = " ", 

1323:     matrix_file = NA, delim = " ", remove_prior = FALSE, num_rows = 2000, 

1328:         resolution = resolution, matrix_file = matrix_file, 

1348:     if(!Brick_matrix_exists(Brick = Brick, chr1 = chr1, chr2 = chr2,

1352:     if(Brick_matrix_isdone(Brick = Brick, chr1 = chr1,

1354:         stop("A matrix was preloaded before. ",

1367:         Matrix.file = matrix_file, delim = delim, Group.path = Group.path, 

1375: #' Load a NxN dimensional sub-distance \emph{cis} matrix into

1380: #' @inheritParams Brick_load_matrix

1384: #' the rows and cols of the matrix

1388: #' it does not make sense to load the entire matrix into the data structure, as

1389: #' after a certain distance, the matrix will become extremely sparse. This

1403: #' out_dir <- file.path(tempdir(), "matrix_load_dist_test")

1411: #' Matrix_file <- system.file(file.path("extdata", 

1415: #' Brick_load_cis_matrix_till_distance(Brick = My_BrickContainer, 

1416: #' chr = "chr2L", resolution = 100000, matrix_file = Matrix_file, 

1420:     resolution = NA, matrix_file, delim = " ", distance, remove_prior = FALSE,

1425:         matrix_file = matrix_file, delim = delim, distance = distance, 

1443:     if(!Brick_matrix_exists(Brick = Brick, chr1 = chr,

1447:     if(Brick_matrix_isdone(Brick = Brick, chr1 = chr,

1449:         stop("A matrix was preloaded before. Use remove_prior = TRUE to ",

1461:     RetVar <- ._Process_matrix_by_distance(Brick = Brick_filepath,

1462:         Matrix.file = matrix_file, delim = delim, Group.path = Group.path,

1470: #' Load a NxN dimensional matrix into the Brick store from an mcool file.

1472: #' Read an mcool contact matrix coming out of 4D nucleome projects into a

1477: #' @inheritParams Brick_load_matrix

1489: #' @param matrix_chunk \strong{Optional}. Default 2000.

1490: #' The nxn matrix square to fill per iteration in a mcool file.

1493: #' cooler_read_limit sets the upper limit for the number of records per matrix

1495: #' matrix_chunk value will be re-evaluated dynamically.

1521: #' resolution = 50000, matrix_chunk = 2000, remove_prior = TRUE,

1527: #' @seealso \code{\link{Create_many_Bricks_from_mcool}} to create matrix from 

1533:     matrix_chunk = 2000, cooler_read_limit = 10000000, remove_prior = FALSE,

1569:         resolution = resolution, matrix_chunk = matrix_chunk, 

1575: #' Check if a matrix has been loaded for a chromosome pair.

1579: #' @inheritParams Brick_load_matrix

1581: #' @return Returns a logical vector of length 1, specifying if a matrix has

1588: #' out_dir <- file.path(tempdir(), "matrix_isdone_test")

1596: #' Matrix_file <- system.file(file.path("extdata", 

1600: #' Brick_load_matrix(Brick = My_BrickContainer, chr1 = "chr2L", 

1601: #' chr2 = "chr2L", matrix_file = Matrix_file, delim = " ", 

1604: #' Brick_matrix_isdone(Brick = My_BrickContainer, chr1 = "chr2L", 

1609:     if(!Brick_matrix_exists(Brick = Brick, chr1 = chr1, chr2 = chr2,

1615:     return(Matrix.list[Matrix.list$chr1 == chr1 &

1616:         Matrix.list$chr2 == chr2, "done"])

1619: #' Check if a matrix for a chromosome pair is sparse.

1623: #' @inheritParams Brick_load_matrix

1625: #' @return Returns a logical vector of length 1, specifying if a matrix was

1626: #' loaded as a sparse matrix.

1632: #' out_dir <- file.path(tempdir(), "matrix_issparse_test")

1640: #' Matrix_file <- system.file(file.path("extdata", 

1644: #' Brick_load_matrix(Brick = My_BrickContainer, chr1 = "chr2L", 

1645: #' chr2 = "chr2L", matrix_file = Matrix_file, delim = " ", 

1648: #' Brick_matrix_issparse(Brick = My_BrickContainer, chr1 = "chr2L", 

1653:     if(!Brick_matrix_exists(Brick = Brick, chr1 = chr1, chr2 = chr2,

1659:     return(Matrix.list[Matrix.list$chr1 == chr1 &

1660:         Matrix.list$chr2 == chr2, "sparsity"])

1664: #' Get the maximum loaded distance from the diagonal of any matrix.

1666: #' If values beyond a certain distance were not loaded in the matrix, this

1670: #' `Brick_matrix_maxdist` will return this parameter.

1674: #' @inheritParams Brick_load_matrix

1677: #' distance loaded for that matrix

1684: #' out_dir <- file.path(tempdir(), "matrix_maxdist_test")

1692: #' Matrix_file <- system.file(file.path("extdata", 

1696: #' Brick_load_matrix(Brick = My_BrickContainer, chr1 = "chr2L", 

1697: #' chr2 = "chr2L", matrix_file = Matrix_file, delim = " ", 

1700: #' Brick_matrix_maxdist(Brick = My_BrickContainer, chr1 = "chr2L", 

1705:     if(!Brick_matrix_exists(Brick = Brick, chr1 = chr1, chr2 = chr2,

1709:     if(!Brick_matrix_isdone(Brick = Brick, chr1 = chr1, chr2 = chr2, 

1715:     return((Matrix.list[Matrix.list$chr1 == chr1 &

1716:         Matrix.list$chr2 == chr2, "distance"]))

1722: #' are provided. If a user is in doubt regarding whether a matrix is present or

1729: #' @inheritParams Brick_load_matrix

1731: #' @return Returns a logical vector of length 1, specifying if the matrix

1739: #' out_dir <- file.path(tempdir(), "matrix_exists_test")

1747: #' Matrix_file <- system.file(file.path("extdata", 

1751: #' Brick_load_matrix(Brick = My_BrickContainer, chr1 = "chr2L", 

1752: #' chr2 = "chr2L", matrix_file = Matrix_file, delim = " ", 

1755: #' Brick_matrix_exists(Brick = My_BrickContainer, chr1 = "chr2L", 

1765: #' Return the value range of the matrix

1769: #' @inheritParams Brick_load_matrix

1772: #' maximum finite real values in the matrix.

1778: #' out_dir <- file.path(tempdir(), "matrix_minmax_test")

1786: #' Matrix_file <- system.file(file.path("extdata", 

1790: #' Brick_load_matrix(Brick = My_BrickContainer, chr1 = "chr2L", 

1791: #' chr2 = "chr2L", matrix_file = Matrix_file, delim = " ", 

1794: #' Brick_matrix_minmax(Brick = My_BrickContainer, chr1 = "chr2L", 

1799:     if(!Brick_matrix_exists(Brick = Brick, chr1 = chr1, chr2 = chr2, 

1805:     Filter <- Matrix.list$chr1 == chr1 & Matrix.list$chr2 == chr2

1806:     Extent <- c(Matrix.list[Filter, "min"],Matrix.list[Filter, "max"])

1810: #' Return the dimensions of a matrix

1814: #' @inheritParams Brick_load_matrix

1816: #' @return Returns the dimensions of a Hi-C matrix for any given

1824: #' out_dir <- file.path(tempdir(), "matrix_dimension_test")

1832: #' Matrix_file <- system.file(file.path("extdata", 

1836: #' Brick_load_matrix(Brick = My_BrickContainer, chr1 = "chr2L", 

1837: #' chr2 = "chr2L", matrix_file = Matrix_file, delim = " ", 

1840: #' Brick_matrix_dimensions(Brick = My_BrickContainer, chr1 = "chr2L", 

1844:     if(!Brick_matrix_exists(Brick = Brick, chr1 = chr1, chr2 = chr2, 

1853:         dataset.path = Reference.object$hdf.matrix.name,

1859: #' Return the filename of the loaded matrix

1863: #' @inheritParams Brick_load_matrix

1866: #' the currently loaded matrix.

1873: #' out_dir <- file.path(tempdir(), "matrix_filename_test")

1881: #' Matrix_file <- system.file(file.path("extdata", 

1885: #' Brick_load_matrix(Brick = My_BrickContainer, chr1 = "chr2L", 

1886: #' chr2 = "chr2L", matrix_file = Matrix_file, delim = " ", 

1889: #' Brick_matrix_filename(Brick = My_BrickContainer, chr1 = "chr2L", 

1894:     if(!Brick_matrix_exists(Brick = Brick, chr1 = chr1, chr2 = chr2, 

1900:     Filter <- Matrix.list$chr1 == chr1 & Matrix.list$chr2 == chr2

1901:     Extent <- Matrix.list[Filter, "filename"]

1914: #' A string specifying the chromosome for the cis Hi-C matrix from which values

1947: #' Matrix_file <- system.file(file.path("extdata", 

1951: #' Brick_load_matrix(Brick = My_BrickContainer, chr1 = "chr2L", 

1952: #' chr2 = "chr2L", matrix_file = Matrix_file, delim = " ", 

1966: #' @seealso \code{\link{Brick_get_matrix_within_coords}} to get matrix by

1967: #' using matrix coordinates, \code{\link{Brick_fetch_row_vector}} to get values

1969: #' to get values using matrix coordinates, \code{\link{Brick_get_matrix}} to

1970: #' get matrix by using matrix coordinates.

1979:     if(!Brick_matrix_exists(Brick = Brick, chr1 = chr, 

1981:         !Brick_matrix_isdone(Brick = Brick, chr1 = chr, 

1993:     Max.dist <- Brick_matrix_maxdist(Brick = Brick, chr1 = chr, chr2 = chr,

1997:             "this matrix was at a distance of "

2041:             Name = Reference.object$hdf.matrix.name,

2055: #' Return a matrix subset between two regions.

2057: #' `Brick_get_matrix_within_coords` will fetch a matrix subset after

2060: #' This function calls \code{\link{Brick_get_matrix}}.

2075: #' If true, will force the retrieval operation when matrix contains loaded

2080: #' the matrix is returned.

2082: #' @return Returns a matrix of dimension x_coords binned length by y_coords

2090: #' out_dir <- file.path(tempdir(), "get_matrix_coords_test")

2098: #' Matrix_file <- system.file(file.path("extdata", 

2102: #' Brick_load_matrix(Brick = My_BrickContainer, chr1 = "chr2L", 

2103: #' chr2 = "chr2L", matrix_file = Matrix_file, delim = " ", 

2106: #' Brick_get_matrix_within_coords(Brick = My_BrickContainer,

2111: #' Brick_get_matrix_within_coords(Brick = My_BrickContainer,

2118: #' @seealso \code{\link{Brick_get_matrix}} to get matrix by using matrix

2122: #' \code{\link{Brick_get_vector_values}} to get values using matrix

2152:     if(!Brick_matrix_isdone(Brick = Brick, chr1 = chr1, chr2 = chr2,

2154:         stop(chr1," ",chr2," matrix is yet to be loaded into the class.")

2171:     return(Matrix)

2174: #' Return a matrix subset.

2176: #' `Brick_get_matrix` will fetch a matrix subset between row values

2182: #' @inheritParams Brick_load_matrix

2191: #' If provided a data transformation with FUN will be applied before the matrix

2194: #' @inheritParams Brick_get_matrix_within_coords

2196: #' @return Returns a matrix of dimension x_coords length by y_coords length.

2203: #' out_dir <- file.path(tempdir(), "get_matrix_test")

2211: #' Matrix_file <- system.file(file.path("extdata", 

2215: #' Brick_load_matrix(Brick = My_BrickContainer, chr1 = "chr2L", 

2216: #' chr2 = "chr2L", matrix_file = Matrix_file, delim = " ", 

2219: #' Brick_get_matrix(Brick = My_BrickContainer, chr1 = "chr2L", chr2 = "chr2L",

2222: #' @seealso \code{\link{Brick_get_matrix_within_coords}} to get matrix by using

2223: #' matrix genomic coordinates, \code{\link{Brick_get_values_by_distance}} to

2227: #' matrix coordinates.

2243:     if(!Brick_matrix_isdone(Brick = Brick, chr1 = chr1, chr2 = chr2, 

2245:         stop(chr1,chr2," matrix is yet to be loaded into the class.\n")

2258:         return(Matrix)             

2260:         return(FUN(Matrix))

2266: #' `Brick_fetch_row_vector` will fetch any given rows from a matrix. If

2273: #' @inheritParams Brick_load_matrix

2293: #' @inheritParams Brick_get_matrix_within_coords

2300: #' If provided a data transformation with FUN will be applied before the matrix

2320: #' Matrix_file <- system.file(file.path("extdata", 

2324: #' Brick_load_matrix(Brick = My_BrickContainer, chr1 = "chr2L", 

2325: #' chr2 = "chr2L", matrix_file = Matrix_file, delim = " ", 

2334: #' @seealso \code{\link{Brick_get_matrix_within_coords}} to get matrix by

2335: #' using matrix genomic coordinates, \code{\link{Brick_get_values_by_distance}}

2338: #' subset them, \code{\link{Brick_get_matrix}} to get matrix by using

2339: #' matrix coordinates.

2354:     max.dist <- Brick_matrix_maxdist(Brick = Brick, chr1 = chr1, chr2 = chr2, 

2359:     if(!Brick_matrix_isdone(Brick = Brick, chr1 = chr1, chr2 = chr2,

2361:         stop(chr1,chr2," matrix is yet to be loaded.")

2437: #' other matrix retrieval functions.

2441: #' @inheritParams Brick_load_matrix

2457: #' @inheritParams Brick_get_matrix_within_coords

2460: #' returns a matrix of dimension xaxis length by yaxis length.

2477: #' Matrix_file <- system.file(file.path("extdata", 

2481: #' Brick_load_matrix(Brick = My_BrickContainer, chr1 = "chr2L", 

2482: #' chr2 = "chr2L", matrix_file = Matrix_file, delim = " ", 

2503:     if(!Brick_matrix_isdone(Brick = Brick, chr1 = chr1, chr2 = chr2,

2505:         stop(chr1,chr2," matrix is yet to be loaded.")

2513:     Max.dist <- Brick_matrix_maxdist(Brick = Brick, chr1 = chr1, chr2 = chr2, 

2518:             "this matrix was at a distance of ",

2527:         Brick = Brick_filepath, Name = Reference.object$hdf.matrix.name, 

2536: #' Return an entire matrix for provided chromosome pair for a resolution.

2538: #' `Brick_get_entire_matrix` will return the entire matrix for the entire 

2544: #' @inheritParams Brick_load_matrix

2546: #' @return Returns an object of class matrix with dimensions corresponding to

2563: #' Matrix_file <- system.file(file.path("extdata", 

2567: #' Brick_load_matrix(Brick = My_BrickContainer, chr1 = "chr2L", 

2568: #' chr2 = "chr2L", matrix_file = Matrix_file, delim = " ", 

2571: #' Entire_matrix <- Brick_get_entire_matrix(Brick = My_BrickContainer, 

2581:     if(!Brick_matrix_isdone(Brick = Brick, chr1 = chr1, chr2 = chr2,

2583:         stop(chr1,chr2," matrix is yet to be loaded.")

2590:         Brick = Brick_filepath, Name = Reference_object$hdf.matrix.name, 

2594:     return(entire_matrix)

2597: #' Get the matrix metadata columns in the Brick store.

2599: #' `Brick_get_matrix_mcols` will get the specified matrix metadata column for

2600: #' a chr1 vs chr2 Hi-C data matrix. Here, chr1 represents the rows and chr2

2601: #' represents the columns of the matrix. For cis Hi-C matrices, where 

2615: #' @inheritParams Brick_load_matrix

2618: #' A character vector of length 1 specifying the matrix metric to retrieve

2620: #' @return Returns a 1xN dimensional vector containing the specified matrix

2628: #' out_dir <- file.path(tempdir(), "get_matrix_mcols_test")

2636: #' Matrix_file <- system.file(file.path("extdata", 

2640: #' Brick_load_matrix(Brick = My_BrickContainer, chr1 = "chr2L", 

2641: #' chr2 = "chr2L", matrix_file = Matrix_file, delim = " ", 

2644: #' Brick_get_matrix_mcols(Brick = My_BrickContainer, chr1 = "chr2L", 

2652:     Meta.cols <- Reference.object$hdf.matrix.meta.cols()

2657:     if(!Brick_matrix_exists(Brick = Brick, chr1 = chr1, chr2 = chr2, 

2659:         stop("Matrix for this chromsome pair does not exist.\n")  

2661:     if(!Brick_matrix_isdone(Brick = Brick, chr1 = chr1, chr2 = chr2,

2663:         stop("Matrix for this chromsome pair is yet to be loaded.\n")  

2668:     if(!Brick_matrix_issparse(Brick = Brick, chr1 = chr1, chr2 = chr2,

2670:         stop("This matrix is not a sparse matrix.",

2685: #' List the matrix metadata columns in the Brick store.

2687: #' `Brick_get_matrix_mcols` will list the names of all matrix metadata 

2690: #' @return Returns a vector containing the names of all matrix metadata columns

2697: #' out_dir <- file.path(tempdir(), "list_matrix_mcols_test")

2705: #' Brick_list_matrix_mcols()

2708:     Meta.cols <- Reference.object$hdf.matrix.meta.cols()

2714: #' upper triangle sparse matrix

2719: #' objects as a upper triangle sparse matrix (col > row) containing 

2746: #' Matrix_file <- system.file(file.path("extdata", 

2750: #' Brick_load_matrix(Brick = My_BrickContainer, chr1 = "chr2L", 

2751: #' chr2 = "chr2L", matrix_file = Matrix_file, delim = " ", 

2833: #' Matrix_file <- system.file(file.path("extdata", 

2837: #' Brick_load_matrix(Brick = My_BrickContainer, chr1 = "chr2L", 

2838: #' chr2 = "chr2L", matrix_file = Matrix_file, delim = " ", 

2852:     correlation_matrix <- .remove_nas(correlation_matrix)

2856:     pca_list <- prcomp(correlation_matrix)

2868: #' @inheritParams Brick_load_matrix

2873: #' sparse matrix

2875: #' @param matrix_chunk \strong{Optional}. Default 2000.

2876: #' The nxn matrix square to fill per iteration.

2900: #' Matrix_file <- system.file(file.path("extdata", 

2904: #' Brick_load_matrix(Brick = My_BrickContainer, chr1 = "chr2L", 

2905: #' chr2 = "chr2L", matrix_file = Matrix_file, delim = " ", 

2918:     resolution = NULL, batch_size = 1000000, matrix_chunk = 2000,

2930:         delim = delim, resolution = resolution, matrix_chunk = matrix_chunk, 

173:     Reference.object <- GenomicMatrix$new()

330:     Reference.object <- GenomicMatrix$new()

426:     Reference.object <- GenomicMatrix$new()

468:     Reference.object <- GenomicMatrix$new()

549:     Reference.object <- GenomicMatrix$new()

617:     Reference.object <- GenomicMatrix$new()

691:     Reference.object <- GenomicMatrix$new()

756:     Reference.object <- GenomicMatrix$new()

810:     Reference.object <- GenomicMatrix$new()

892:     Reference.object <- GenomicMatrix$new()

953:     Reference.object <- GenomicMatrix$new()

1086:     Reference.object <- GenomicMatrix$new()

1325:     Reference.object <- GenomicMatrix$new()

1366:     RetVar <- ._ProcessMatrix_(Brick = Brick_filepath, 

1423:     Reference.object <- GenomicMatrix$new()

1535:     Reference.object <- GenomicMatrix$new()

1608:     Reference.object <- GenomicMatrix$new()

1652:     Reference.object <- GenomicMatrix$new()

1704:     Reference.object <- GenomicMatrix$new()

1798:     Reference.object <- GenomicMatrix$new()

1848:     Reference.object <- GenomicMatrix$new()

1893:     Reference.object <- GenomicMatrix$new()

1977:     Reference.object <- GenomicMatrix$new()

2494:     Reference.object <- GenomicMatrix$new()

2575:     Reference_object <- GenomicMatrix$new()

2651:     Reference.object <- GenomicMatrix$new()

2707:     Reference.object <- GenomicMatrix$new()

2760:     Reference.object <- GenomicMatrix$new()

2920:     Reference.object <- GenomicMatrix$new()

898:     matrix <- t(sapply(data, unlist)) #list to matrix

325:                     plot.lodclust(as.matrix(track[,c("Start", "End")]),

396:     intervals <- as.matrix(intervals)

445:     intmat  <- matrix(intmat, ncol=2)

517:     if(is.data.frame(x) | is.matrix(x)) {

899:     aux    <-matrix[, c(2:5)]

183: 		int matrix[MAX_AA][MAX_AA];

173: typedef Vector<VectorInt> MatrixInt;

176: typedef Vector<VectorInt64> MatrixInt64;

179: class ScoreMatrix { //Matrix

197: typedef Vector<VectorIntX> MatrixIntX;

189: 		void set_matrix(int *mat1);

186: 		ScoreMatrix();

193: }; // END class ScoreMatrix

476: 	MatrixInt64  score_mat;

477: 	MatrixInt    back_mat;

531: extern ScoreMatrix  mat;

606: int local_band_align( char query[], char ref[], int qlen, int rlen, ScoreMatrix &mat,

6188:     chord.matrix = function(x) {

223:   d3.transpose = function(matrix) {

224:     if (!(n = matrix.length)) return [];

225:     for (var i = -1, m = d3.min(matrix, d3_transposeLength), transpose = new Array(m); ++i < m; ) {

227:         row[j] = matrix[j][i];

5952:       return new d3_transform(t ? t.matrix : d3_transformIdentity);

6116:     var chord = {}, chords, groups, matrix, n, padding = 0, sortGroups, sortSubgroups, sortChords;

6125:           x += matrix[i][j];

6139:             return sortSubgroups(matrix[i][a], matrix[i][b]);

6148:           var di = groupIndex[i], dj = subgroupIndex[di][j], v = matrix[di][dj], a0 = x, a1 = x += v * k;

6189:       if (!arguments.length) return matrix;

6190:       n = (matrix = x) && matrix.length;

1187:       point = point.matrixTransform(container.getScreenCTM().inverse());

2377:     matrix = matrix(0, nrow = length(keys) + 3, ncol = 1)

407:     pheat.matrix = data.lifting(x,data)

1223: draw_matrix <- function(matrix,

98:     ##  This function sorts a matrix to enhance mutual exclusivity

198:             stop('"group.samples" should be matrix with sample names and group assignment.')

364:     data.lifting <- function(obj, matrix) {

375:                                        function(obj, matrix) {

377:                                            ## Are you sure (obj %in% # matrix)

380:                                            if (obj %in% matrix) {

385:                                        rownames(matrix)))]

386:                 sub.data = matrix[keys.subset, , drop = FALSE]

394:                 matrix[keys.subset, ] = sub.data 

404:         return(list(data=matrix, colors=map.gradient))

408:     map.gradient = pheat.matrix$colors

409:     data = pheat.matrix$data

785:     data = matrix(0, nrow = ngenes(x), ncol = ntypes(x))

882:         tmp = as.matrix(subdata[which(refcol == i), ]);

1060:         t = c(as.vector(as.matrix(annotation_col)), colnames(annotation_col)) 

1083:             c(as.vector(as.matrix(annotation_row)),

1161:         stop("Gaps do not match with matrix size")

1182:     dist = matrix(0, nrow = 2 * n - 1, ncol = 2, dimnames = list(NULL, c("x", "y"))) 

1230:         n = nrow(matrix)

1231:         m = ncol(matrix)

1248:                      gp = gpar(fill = matrix, col = border_color))

1383:     return(as.matrix(new))

1550: heatmap_motor <- function(matrix,

1585:            nrow = nrow(matrix),

1586:            ncol = ncol(matrix),

1634:         ## gt = heatmap_motor(matrix, cellwidth = cellwidth,

1650:             heatmap_motor(matrix,

1711:     ## Draw matrix.

1713:     elem = draw_matrix(matrix, border_color, gaps_row, gaps_col, fmat, fontsize_number, number_color)

1714:     res = gtable_add_grob(res, elem, t = 4, l = 3, clip = "off", name = "matrix")

1810:         mat = as.matrix(mat)

1811:         return(matrix(scale_vec_colours(as.vector(mat),

1972: #' @param mat numeric matrix of the values to be plotted.

1994: #' of the above it is assumed that a distance matrix is provided.

2032: #' the cells. If this is a matrix (with same dimensions as original matrix), the contents

2033: #' of the matrix are shown instead of original values.

2067: #' # Create test matrix

2068: #' test = matrix(rnorm(200), 20, 10)

2144:     ## Preprocess matrix.

2146:     mat = as.matrix(mat)

2172:     if (is.matrix(display_numbers) | is.data.frame(display_numbers)) {

2174:             stop("If display_numbers provided as matrix, its dimensions have to match with mat")

2177:         display_numbers = as.matrix(display_numbers)

2178:         fmat = matrix(as.character(display_numbers), nrow = nrow(display_numbers), ncol = ncol(display_numbers))

2182:             fmat = matrix(sprintf(number_format, mat), nrow = nrow(mat), ncol = ncol(mat))

2185:             fmat = matrix(NA, nrow = nrow(mat), ncol = ncol(mat))

2259:     ## Select only the ones present in the matrix.

2378:     rownames(matrix) = c(keys, 'soft', 'co-occurrence', 'other')

2379:     ## colnames(matrix) = paste(to, collapse = ':')

2380:     colnames(matrix) = to[1]

2420:     matrix['co-occurrence', ] = length(co.occurrences)

2421:     cat('Co-occurrence in #samples: ', matrix['co-occurrence', ], '\n')

2426:         matrix[keys[i], ] = length(intersect(to.samples, hard.pattern.samples[[keys[i]]])) 

2427:     cat('Hard exclusivity in #samples:', matrix[keys, ], '\n')  

2433:     matrix['other', ] = length(intersect(to.samples, union))

2434:     cat('Other observations in #samples:', matrix['other', ], '\n') 

2438:     matrix['soft', ] = length(to.samples) - colSums(matrix)

2439:     cat('Soft exclusivity in #samples:', matrix['soft', ], '\n')  

2443:     sector.color = rep('gray', nrow(matrix) + 1) 

2444:     link.color = rep('gray', nrow(matrix)) 

2446:     names(sector.color) = c(rownames(matrix), colnames(matrix))

2447:     names(link.color) = rownames(matrix)

2465:     idx.max = which(matrix == max(matrix))

2466:     link.style = matrix(0, nrow=nrow(matrix), ncol=ncol(matrix))

2467:     rownames(link.style) = rownames(matrix)

2468:     colnames(link.style) = colnames(matrix)

2482:     sector.color[colnames(matrix)] = as.colors(x)[as.events(x, genes = to[1], types=to[2])[, 'type' ]]

2489:         ## rownames(matrix)[i] = paste(paste(rep(' ', i), collapse = ''), events.names[i, 'event' ])

2491:             rownames(matrix)[i] = paste(paste(rep(' ', i), collapse = ''), events.names[i, 'event' ])

2492:         else rownames(matrix)[i] = events.names[i, 'event' ]

2494:         names(sector.color)[i] = rownames(matrix)[i]    

2499:         cat('Circlize matrix.\n')

2500:         print(matrix)

2508:         chordDiagram(matrix, 

2536:         layout(matrix(c(1,2,3,3), ncol = 2, byrow = TRUE), heights = c(4, 1))

2551:         print(matrix)

2553:         ## barplot(matrix[, 1], widths, space = 0)

2555:         rownames(matrix)[length(keys) + 1] = '2 or more\n(soft-exclusivity)'

2556:         rownames(matrix)[length(keys) + 2] = 'all together\n(co-occurrence)'

2558:         rownames(matrix)[nrow(matrix)] = 'none of the\nevents'

2560:         summary = matrix[ (length(keys) + 1):nrow(matrix), 1, drop = FALSE]

2561:         summary = rbind( sum(matrix[1:length(keys),]), summary)

2586:         exclus = matrix[1:length(keys), 1, drop = FALSE]

2617:                    c(paste(sum(matrix[1:length(keys) ,]), 'with 1 event (hard exclusivity)'),

2618:                      paste(matrix[length(keys) + 1, ],  'with 2 or more events'),

2619:                      paste(matrix[length(keys) + 2, ], 'with all events (co-occurrence)'),

2620:                      paste(matrix[length(keys) + 3, ], 'with no events')

180:         h <- WGCNA::labeledHeatmap(Matrix = moduleTraitCor,

51:     group.matrix <- compare.matrix[, group.samples]

53:     value.matrix <- group.matrix[DEH.loci, ]

58:     hit.matrix <- as.matrix(o)

60:         input.matrix = value.matrix

68:             mean.matrix <- foreach(i = geneid, .combine = cbind) %do%

173:         textMatrix <- paste(signif(moduleTraitCor, 2),

11: #' @param compare.matrix The comparison matrix generated from

17: #' for the samples in the comparison matrix. The row names should

35: #' heterogeneity matrix for patients

38: #' if node type is gene,it contains the epigenetic heterogeneity matrix for

41: epiNetwork <- function(node.type = "locus", DEH, compare.matrix,

49:     compare.matrix <- compare.matrix[which(compare.matrix$type == value), ]

50:     rownames(compare.matrix) <- compare.matrix$location

54:     value.matrix <- t(value.matrix)

61:         nSamples = nrow(value.matrix)

71:                   queryhit.id <- hit.matrix[which(hit.matrix[, 2] == i), 1]

73:                   epivalue <- value.matrix[, queryhit.loci$loci]

82:             mean.matrix <- mean.matrix[, colSums(mean.matrix) != 0]

83:             nSamples <- dim(mean.matrix)[1]

84:             input.matrix <- mean.matrix

90:     sft <- WGCNA::pickSoftThreshold(input.matrix, powerVector = powers,

131:     net <- WGCNA::blockwiseModules(input.matrix, power = softpowers,

157:         module <- data.frame(gene = colnames(input.matrix),

161:     MEs0 <- WGCNA::moduleEigengenes(input.matrix, moduleColors)$eigengenes

194:         geneset <- data.frame(DEHloci = mcols(userset[hit.matrix[,1]])$loci,

195:             gene = mcols(annotation.obj[hit.matrix[,2]])$name,

262:         result <- list(epimatrix = input.matrix, module = module,

265:         result <- list(epimatrix = input.matrix, module = module)

12: #' the compMatrix() function.

175:         dim(textMatrix) <- dim(moduleTraitCor)

183:             colors = WGCNA::blueWhiteRed(50), textMatrix = textMatrix,

6015:             matrix <- gcl$vmap[rev(gcl$row.order), results$hvc$order, drop = FALSE]

6083:                        matrix <- results$rcm[rev(results$tvc$order), results$hvc$order]

6324:                        matrix <- results$rcm[rev(results$tvc$order), results$hvc$order]

1079: winsorize.matrix <- function(mat, trim) {

3405: calculate.joint.posterior.matrix <- function(lmatl, n.samples = 100, bootstrap = TRUE, n.cores = 15) {

3422: calculate.batch.joint.posterior.matrix <- function(lmatll, composition, n.samples = 100, n.cores = 15) {

3810: get.exp.posterior.matrix <- function(m1, counts, marginals, grid.weight = rep(1, nrow(marginals)), rescale = TRUE, n.cores =...(17 bytes skipped)...

3826: get.exp.logposterior.matrix <- function(m1, counts, marginals, grid.weight = rep(1, nrow(marginals)), rescale = TRUE, n.cores =...(6 bytes skipped)...

109: ##' Filter counts matrix

111: ##' Filter counts matrix based on gene and cell requirements

113: ##' @param counts read count matrix. The rows correspond to genes, columns correspond to individual cells

118: ##' @return a filtered read count matrix

145: ##' @param counts read count matrix. The rows correspond to genes (should be named), columns correspond to individual cells. The matrix should contain integer counts

163: ##' @return a model matrix, with rows corresponding to different cells, and columns representing different parameters of the d...(16 bytes skipped)...

184: ...(114 bytes skipped)...thod is designed to work on read counts - do not pass normalized read counts (e.g. FPKM values). If matrix contains read counts, but they are stored as numeric values, use counts<-apply(counts,2,function(x)...(49 bytes skipped)...

208: ##' @param counts count matrix

228:     fpkm <- log10(exp(as.matrix(fpkm))+1)

229:     wts <- as.numeric(as.matrix(1-fail[, colnames(fpkm)]))

262: ##' @param counts read count matrix

264: ...(41 bytes skipped)...e two groups of cells being compared. The factor entries should correspond to the rows of the model matrix. The factor should have two levels. NAs are allowed (cells will be omitted from comparison).

265: ##' @param batch a factor (corresponding to rows of the model matrix) specifying batch assignment of each cell, to perform batch correction

284: ##' \code{difference.posterior} returns a matrix of estimated expression difference posteriors (rows - genes, columns correspond to different magnit...(64 bytes skipped)...

305:         stop("ERROR: provided count data does not cover all of the cells specified in the model matrix")

309:     counts <- as.matrix(counts[, ci])

416: ##' @param models model matrix

417: ##' @param counts count matrix

513: ##' @param counts read count matrix

516: ##' @param batch a factor describing which batch group each cell (i.e. each row of \code{models} matrix) belongs to

523: ##' @return \subsection{default}{ a posterior probability matrix, with rows corresponding to genes, and columns to expression levels (as defined by \code{prior$x})

525: ...(24 bytes skipped)...ndividual.posterior.modes}{ a list is returned, with the \code{$jp} slot giving the joint posterior matrix, as described above. The \code{$modes} slot gives a matrix of individual expression posterior mode values on log scale (rows - genes, columns -cells)}

526: ...(85 bytes skipped)...st} slot giving a list of individual posterior matrices, in a form analogous to the joint posterior matrix, but reported on log scale }

538: ...(43 bytes skipped)...counts))) { stop("ERROR: provided count data does not cover all of the cells specified in the model matrix") }

545:     counts <- as.matrix(counts[, ci, drop = FALSE])

571:     # prepare matrix models

574:     mm <- matrix(NA, nrow(models), length(mn))

575:     mm[, which(!is.na(mc))] <- as.matrix(models[, mc[!is.na(mc)], drop = FALSE])

645: # models - entire model matrix, or a subset of cells (i.e. select rows) of the model matrix for which the estimates should be obtained

647: # return - a matrix of log(FPM) estimates with genes as rows and cells  as columns (in the model matrix order).

653: ##' @param counts count matrix

655: ##' @return a matrix of expression magnitudes on a log scale (rows - genes, columns - cells)

666: ...(43 bytes skipped)...counts))) { stop("ERROR: provided count data does not cover all of the cells specified in the model matrix") }

672: # magnitudes can either be a per-cell matrix or a single vector of values which will be evaluated for each cell

676: ##' Returns estimated drop-out probability for each cell (row of \code{models} matrix), given either an expression magnitude

678: ##' @param magnitudes a vector (\code{length(counts) == nrows(models)}) or a matrix (columns correspond to cells) of expression magnitudes, given on a log scale

679: ##' @param counts a vector (\code{length(counts) == nrows(models)}) or a matrix (columns correspond to cells) of read counts from which the expression magnitude should be estimate...(1 bytes skipped)...

681: ##' @return a vector or a matrix of drop-out probabilities

704:     if(is.matrix(magnitudes)) { # a different vector for every cell

705: ...(55 bytes skipped)...es))) { stop("ERROR: provided magnitude data does not cover all of the cells specified in the model matrix") }

730: ##' @param counts read count matrix (must contain the row corresponding to the specified gene)

732: ##' @param groups a two-level factor specifying between which cells (rows of the models matrix) the comparison should be made

733: ##' @param batch optional multi-level factor assigning the cells (rows of the model matrix) to different batches that should be controlled for (e.g. two or more biological replicates). The e...(224 bytes skipped)...

759:     counts <- as.matrix(counts[gene, ci, drop = FALSE])

819:         layout(matrix(c(1:3), 3, 1, byrow = TRUE), heights = c(2, 1, 2), widths = c(1), FALSE)

926: ##' @param counts count matrix

927: ...(8 bytes skipped)...am reference a vector of expression magnitudes (read counts) corresponding to the rows of the count matrix

936: ##' @return matrix of scde models

988:         #l <- layout(matrix(seq(1, 4*length(ids)), nrow = length(ids), byrow = TRUE), rep(c(1, 1, 1, 0.5), length(ids)), rep(1,...(23 bytes skipped)...

989:         l <- layout(matrix(seq(1, 4), nrow = 1, byrow = TRUE), rep(c(1, 1, 1, 0.5), 1), rep(1, 4), FALSE)

1000:         # make a joint model matrix

1011: ##' Determine principal components of a matrix using per-observation/per-variable weights

1015: ##' @param mat matrix of variables (columns) and observations (rows)

1026: ##' @return a list containing eigenvector matrix ($rotation), projections ($scores), variance (weighted) explained by each component ($var), total (...(45 bytes skipped)...

1030: ##' mat <- matrix( c(rnorm(5*10,mean=0,sd=1), rnorm(5*10,mean=5,sd=1)), 10, 10)  # random matrix

1032: ##' matw <- matrix( c(rnorm(5*10,mean=0,sd=1), rnorm(5*10,mean=5,sd=1)), 10, 10)  # random weight matrix

1040:       stop("bwpca: weight matrix contains NaN values")

1043:       stop("bwpca: value matrix contains NaN values")

1046:         matw <- matrix(1, nrow(mat), ncol(mat))

1061: ##' Winsorize matrix

1065: ##' @param mat matrix

1068: ##' @return Winsorized matrix

1072: ##' mat <- matrix( c(rnorm(5*10,mean=0,sd=1), rnorm(5*10,mean=5,sd=1)), 10, 10)  # random matrix

1075: ##' win.mat <- winsorize.matrix(mat, 0.1)

1100: ##' @param counts count matrix (integer matrix, rows- genes, columns- cells)

1133: ...(114 bytes skipped)...thod is designed to work on read counts - do not pass normalized read counts (e.g. FPKM values). If matrix contains read counts, but they are stored as numeric values, use counts<-apply(counts,2,function(x)...(49 bytes skipped)...

1162:         #celld <- WGCNA::cor(log10(matrix(as.numeric(as.matrix(ca)), nrow = nrow(ca), ncol = ncol(ca))+1), method = cor.method, use = "p", nThreads = n.cores)

1164:             celld <- WGCNA::cor(sqrt(matrix(as.numeric(as.matrix(ca[, ids])), nrow = nrow(ca), ncol = length(ids))), method = cor.method, use = "p", nThreads = n.co...(4 bytes skipped)...

1166:             celld <- stats::cor(sqrt(matrix(as.numeric(as.matrix(ca[, ids])), nrow = nrow(ca), ncol = length(ids))), method = cor.method, use = "p")

1174:         # TODO: correct for batch effect in cell-cell similarity matrix

1176:             # number batches 10^(seq(0, n)) compute matrix of id sums, NA the diagonal,

1178:             bm <- matrix(bid, byrow = TRUE, nrow = length(bid), ncol = length(bid))+bid

1181:             # use tapply to calculate means shifts per combination reconstruct shift vector, matrix, subtract

1239:                     l <- layout(matrix(seq(1, 4), nrow = 1, byrow = TRUE), rep(c(1, 1, 1, ifelse(local.theta.fit, 1, 0.5)), 1), rep(1, 4),...(7 bytes skipped)...

1263:     # make a joint model matrix

1278: ##' @param models model matrix (select a subset of rows to normalize variance within a subset of cells)

1279: ##' @param counts read count matrix

1288: ##' @param weight.k k value to use in the final weight matrix

1294: ##' @param gene.length optional vector of gene lengths (corresponding to the rows of counts matrix)

1307: ##' \item{matw} { weight matrix corresponding to the expression matrix}

1334:         stop(paste("supplied count matrix (cd) is missing data for the following cells:[", paste(rownames(models)[!rownames(models) %in% coln...(44 bytes skipped)...

1343:         if(verbose) { cat("Winsorizing count matrix ... ") }

1345:         #tfpm <- log(winsorize.matrix(exp(fpm), trim = trim))

1346:         tfpm <- winsorize.matrix(fpm, trim)

1430:     if(verbose) { cat("calculating weight matrix ... ") }

1450:     # calculate batch-specific version of the weight matrix if needed

1695:     # use milder weight matrix

1787: ##' (weighted) projection of the expression matrix onto a specified aspect (some pattern

1794: ##' @param center whether the matrix should be re-centered following pattern subtraction

1796: ##' @return a modified varinfo object with adjusted expression matrix (varinfo$mat)

1850: ##' @param center whether the expression matrix should be recentered

1989: ##' Determine de-novo gene clusters, their weighted PCA lambda1 values, and random matrix expectation.

1995: ##' @param n.samples number of randomly generated matrix samples to test the background distribution of lambda1 on

2004: ...(10 bytes skipped)... secondary.correlation whether clustering should be performed on the correlation of the correlation matrix instead

2014: ##' \item{varm} {standardized lambda1 values for each randomly generated matrix cluster}

2036:         mat <- winsorize.matrix(mat, trim = trim)

2060:                 gd <- as.dist(1-WGCNA::cor(as.matrix(gd), method = "p", nThreads = n.cores))

2062:                 gd <- as.dist(1-cor(as.matrix(gd), method = "p"))

2103:                 # generate random normal matrix

2105:                 m <- matrix(rnorm(nrow(mat)*n.cells), nrow = nrow(mat), ncol = n.cells)

2113:                     m <- winsorize.matrix(m, trim = trim)

2124:                         gd <- as.dist(1-WGCNA::cor(as.matrix(gd), method = "p", nThreads = 1))

2126:                         gd <- as.dist(1-cor(as.matrix(gd), method = "p"))

2230: ##' \item{xv} {a matrix of normalized aspect patterns (rows- significant aspects, columns- cells}

2231: ##' \item{xvw} { corresponding weight matrix }

2505: ##' @param distance distance matrix

2569:     if(trim > 0) { xvl$d <- winsorize.matrix(xvl$d, trim) } # trim prior to determining the top sets

2593: ...(35 bytes skipped)...f whether to return just the hclust result or a list containing the hclust result plus the distance matrix and gene values

2690: ##' @param mat Numeric matrix

2694: ##' @param row.cols  Matrix of row colors.

2695: ##' @param col.cols  Matrix of column colors. Useful for visualizing cell annotations such as batch labels.

2730: ##' @param col.cols  Matrix of column colors. Useful for visualizing cell annotations such as batch labels. Default NULL.

2840:         layout(matrix(c(1:3), 3, 1, byrow = TRUE), heights = c(2, 1, 2), widths = c(1), FALSE)

2953:                 m1@concomitant@x <- matrix()

2955:                     mod@x <- matrix()

2956:                     mod@y <- matrix()

3083: # vil - optional binary matrix (corresponding to counts) with 0s marking likely drop-out observations

3118:     f <- calcNormFactors(as.matrix(counts[gis, !is.na(groups)]), ...)

3127:     fpkm <- log10(exp(as.matrix(fpkm))+1)

3128:     wts <- as.numeric(as.matrix(1-fail[, colnames(fpkm)]))

3218:         # pair cell name matrix

3267:             m1@concomitant@x <- matrix()

3269:                 mod@x <- matrix()

3270:                 mod@y <- matrix()

3327:             #l <- layout(matrix(seq(1, 4*length(ids)), nrow = length(ids), byrow = TRUE), rep(c(1, 1, 1, 0.5), length(ids)), rep(1,...(23 bytes skipped)...

3328:             l <- layout(matrix(seq(1, 4), nrow = 1, byrow = TRUE), rep(c(1, 1, 1, ifelse(linear.fit, 1, 0.5)), 1), rep(1, 4), FALS...(2 bytes skipped)...

3344:         # make a joint model matrix

3386:             df <- get.exp.logposterior.matrix(group.ifm[[nam]], dat[, nam], marginals, n.cores = inner.cores, grid.weight = prior$grid.weight)

3403: # calculate joint posterior matrix for a given group of experiments

3420: # lmatll - list of posterior matrix lists (as obtained from calculate.posterior.matrices)

3467: # calculate a joint posterior matrix with bootstrap

3589:     #matrix(cbind(ifelse(rdf$count<= zero.count.threshold, 0.95, 0.05), ifelse(rdf$count > zero.count.threshold...(15 bytes skipped)...

3604:         l <- layout(matrix(c(1:4), 1, 4, byrow = TRUE), c(1, 1, 1, 0.5), rep(1, 4), FALSE)

3654:     fdf <- data.frame(y = rowMeans(matrix(log10(rdf$fpm[1:(n.zero.windows*bw)]+1), ncol = bw, byrow = TRUE)), zf = rowMeans(matrix(as.integer(rdf$cluster[1:(n.zero.windows*bw)] == 1), ncol = bw, byrow = TRUE)))

3663:         cm0 <- exp(model.matrix(mt, data = mf) %*% m1@concomitant@coef)

3716: # df: count matrix

3717: # xr: expression level for each row in the matrix

3740: # counts - observed count matrix corresponding to the models

3780:     cm0 <- exp(model.matrix(mt, data = mf) %*% m1@concomitant@coef)

3797:     cm0 <- model.matrix(mt, data = mf) %*% m1@concomitant@coef

3805: # returns a matrix of posterior values, with rows corresponding to genes, and

3812:     #message(paste("get.exp.posterior.matrix() :", round((1-length(uc)/length(counts))*100, 3), "% savings"))

3828:     #message(paste("get.exp.logposterior.matrix() :", round((1-length(uc)/length(counts))*100, 3), "% savings"))

3841: # similar to get.exp.posterior.matrix(), but returns inverse ecdf list

3848: # similar to get.exp.posterior.matrix(), but returns inverse ecdf list

3871:     cm0 <- exp(model.matrix(mt, data = mf) %*% m1@concomitant@coef)

4138:         m <- matrix(sapply(components, function(x) x@logLik(model@x, model@y)), nrow = nrow(model@y))

4141:         m <- matrix(do.call(cbind, lapply(seq_along(components), function(i) {

4175:         m <- matrix(sapply(components, function(x) x@logLik(model@x, model@y)), nrow = nrow(model@y))

4178:         m <- matrix(do.call(cbind, lapply(seq_along(components), function(i) {

4223:         m <- matrix(sapply(components, function(x) x@logLik(model@x, model@y)), nrow = nrow(model@y))

4226:         m <- matrix(do.call(cbind, lapply(seq_along(components), function(i) {

4488:     x <- as.matrix(x)

4490:     ynames <- if (is.matrix(y))

4611:                 stop(gettextf("X matrix has rank %d, but only %d observations",

4711:         fit$qr <- as.matrix(fit$qr)

4718:         Rmat <- as.matrix(Rmat)

4856:     if (!is.matrix(x)) {

5008: # weight matrix should have the same dimensions as the data matrix

5154:         stop("'x' must be a numeric matrix")

5259:         if(is.matrix(ColSideColors)) {

5261:                 stop("'ColSideColors' matrix must have the same number of columns as length ncol(x)")

5306:         if(is.matrix(ColSideColors)) {

5307:             image(t(matrix(1:length(ColSideColors), byrow = TRUE, nrow = nrow(ColSideColors), ncol = ncol(ColSideColors))), co...(70 bytes skipped)...

5572:         mat <- winsorize.matrix(mat, trim = trim)

5583:     dd <- as.dist(1-abs(cor(t(as.matrix(d)))))

5599:         vd <- as.dist(1-cor(as.matrix(d)))

5669: ##' @param colcols optional column color matrix

5678: ##' @param box whether to draw a box around the plotted matrix

5680: ##' @param return.details whether the function should return the matrix as well as full PCA info instead of just PC1 vector

5726:         mat <- winsorize.matrix(mat, trim = trim)

5766:             mat <- winsorize.matrix(mat, trim = trim)

5791:     dd <- as.dist(1-abs(cor(t(as.matrix(d)))))

5807:         vd <- as.dist(1-cor(as.matrix(d)))

5973: ##' @field mat Matrix of posterior mode count estimates

5974: ##' @field matw Matrix of weights associated with each estimate in \code{mat}

6016:             matrix <- list(data = as.numeric(t(matrix)),

6017:                            dim = dim(matrix),

6018:                            rows = rownames(matrix),

6019:                            cols = colnames(matrix),

6024:             ol <- list(matrix = matrix)

6026:                 rcmvar <- matrix(gcl$rotation[rev(gcl$row.order), , drop = FALSE], ncol = 1)

6033:                 colcols <- matrix(gcl$oc[results$hvc$order], nrow = 1)

6084:                        matrix <- list(data = as.numeric(t(matrix)),

6085:                                       dim = dim(matrix),

6086:                                       rows = rownames(matrix),

6087:                                       cols = colnames(matrix),

6090:                                       range = range(matrix)

6095:                        rcmvar <- matrix(apply(results$rcm[rev(results$tvc$order), , drop = FALSE], 1, var), ncol = 1)

6105:                        ol <- list(matrix = matrix, rowcols = rowcols, colcols = colcols, coldend = treeg, trim = trim)

6159:                        patc <- .Call("matCorr", as.matrix(t(mat)), as.matrix(pat, ncol = 1) , PACKAGE = "scde")

6325:                        body <- paste(capture.output(write.table(round(matrix, 1), sep = "\t")), collapse = "\n")

1081:     wm <- .Call("winsorizeMatrix", mat, trim, PACKAGE = "scde")

1755:         ##   # construct mat multiplier submatrix

3723:         x <- FLXgetModelmatrix(m1@model[[1]], edf, m1@model[[1]]@formula)

3724:         #cx <- FLXgetModelmatrix(m1@concomitant, edf, m1@concomitant@formula)

428:     hm <- WGCNA::labeledHeatmap(Matrix = modtraitcor,

991:                 matrix <- list_mat[[x]]

131:     cor_matrix <- calculate_cor_adj(cor_method, norm.exp, SFTpower, net_type)$cor

132:     adj_matrix <- calculate_cor_adj(cor_method, norm.exp, SFTpower, net_type)$adj

957:     cor_matrix <- net$correlation_matrix

407:     textMatrix <- paste(signif(modtraitcor, 2), modtraitsymbol, sep = "")

94: #'   \item Adjacency matrix

99: #'   \item Correlation matrix

130:     if(verbose) { message("Calculating adjacency matrix...") }

134:     #Convert to matrix

135:     gene_ids <- rownames(adj_matrix)

136:     adj_matrix <- matrix(adj_matrix, nrow=nrow(adj_matrix))

137:     rownames(adj_matrix) <- gene_ids

138:     colnames(adj_matrix) <- gene_ids

140:     #Calculate TOM from adjacency matrix

141:     if(verbose) { message("Calculating topological overlap matrix (TOM)...") }

143:     TOM <- WGCNA::TOMsimilarity(adj_matrix, TOMType = tomtype)

207:     kwithin <- WGCNA::intramodularConnectivity(adj_matrix, new.module_colors)

209:     result.list <- list(adjacency_matrix = adj_matrix,

214:                         correlation_matrix = cor_matrix,

295:     expr <- as.matrix(t(norm.exp))

312:     # Define a matrix of labels for the original and all resampling runs

313:     labels <- matrix(0, nGenes, nRuns + 1)

359: #' @param cex.text Font size for numbers inside matrix. Default: 0.6.

395:     modtraitcor <- cor(as.matrix(MEs), trait, use = "p", method=cor_method)

463: #'   \item{filtered_corandp}{Filtered matrix of correlation and p-values}

464: #'   \item{raw_GS}{Raw matrix of gene significances}

493:     GS <- cor(as.matrix(t(final_exp)), trait, use = "p")

514:     p <- ComplexHeatmap::pheatmap(as.matrix(GS), border_color = NA,

610:         fmat <- matrix(c(GinSet, RinSet, GninSet, RninSet), nrow = 2,

865:     edges <- net$correlation_matrix

888: #' Get edge list from an adjacency matrix for a group of genes

910: #' the correlation matrix was calculated. Only required

919: #' edge lists by filtering the original correlation matrix by the thresholds

956:     # Define objects containing correlation matrix and data frame of genes and modules

963:         cor_matrix <- cor_matrix[keep, keep]

968:         cor_matrix <- cor_matrix[genes, genes]

971:     # Should we filter the matrix?

973:         # Create edge list from correlation matrix

974:         edges <- cormat_to_edgelist(cor_matrix)

987:             list_mat <- replicate(length(cutoff), cor_matrix, simplify = FALSE)

992:                 matrix[matrix < cutoff[x] ] <- NA

993:                 diag(matrix) <- 0

996:                 degree <- rowSums(matrix, na.rm=TRUE)

999:                 matrix[lower.tri(matrix, diag=TRUE)] <- NA

1001:                 # Convert symmetrical matrix to edge list (Gene1, Gene2, Weight)

1002:                 matrix <- na.omit(data.frame(as.table(matrix), stringsAsFactors=FALSE))

1003:                 result <- list(matrix=matrix, degree=degree)

1027:                 stop("Please, specify the number of samples used to calculate the correlation matrix")

1048:         # Create edge list from correlation matrix without filtering

1049:         edgelist <- cormat_to_edgelist(cor_matrix)

408:     dim(textMatrix) <- dim(modtraitcor)

412:         textMatrix <- t(textMatrix)

433:                                 textMatrix = textMatrix, setStdMargins = FALSE,

231:       matrix = matrices [[m]]

73:   matrix.start.lines = grep ('A\\s*[:\\|]', text)

79:   pwm.matrix = parsePWMfromText (lines)

148:     matrix.start.lines = grep ('A:', text)

153:     pwm.matrix = parsePWMfromText (lines.of.text)

157:     matrix.name <- paste(name.tokens[(token.count-1):token.count], collapse="/")

195:     matrix.name = names (matrices) [m]

33: createMatrixNameUniqifier = function (matrix)

36:   write (as.character (matrix), file=temporary.file)

52:   result = matrix (nrow=4, ncol=column.count, byrow=TRUE, dimnames=list (c ('A', 'C', 'G', 'T'), 1:column.count))

74:   stopifnot (length (matrix.start.lines) == 1)

75:   #printf ('%50s: %s', filename, list.to.string (matrix.start.lines))

76:   start.line = matrix.start.lines [1]

80:   return (pwm.matrix)

149:     stopifnot (length (matrix.start.lines) == 1)

150:     start.line = matrix.start.lines [1]

158:     matrices [[matrix.name]] = pwm.matrix

184: # and update matrix names

196:     #printf ('%d: %s', m, matrix.name)

197:     native.name.raw = gsub ('All_PWMs/', '', matrix.name)

225:       # the organism-dataSource-geneIdentifier matrix name.

232:       uniqifier = createMatrixNameUniqifier (matrix)

42: } # createMatrixNameUniqifier

1590:         matrix <- .import_single_matrix(x)

1481: .import_single_matrix <- function(path, to_exclude = NULL, separator = "\t") {

3869:     matrix_desc <- df %>%

4083:             sub_matrix <- matrix_desc[, seq(from = t1, to = t2, by = 1)]

4129:             sub_matrix <- matrix_desc[, seq(from = t1, to = t2, by = 1)]

1981: .join_matrix_af <- function(df, association_file, date_col) {

86: # Finds experimental columns in an integration matrix.

89: # standard integration matrix columns, if there are returns their names.

108: # Checks if the integration matrix is annotated or not.

123: #### ---- Internals for matrix import ----####

125: #---- USED IN : import_single_Vispa2Matrix ----

149: # Reads an integration matrix using data.table::fread

187: # Reads an integration matrix using readr::read_delim

695:     matrix_type,

697:     multi_quant_matrix) {

705:     stopifnot(is.character(matrix_type) & matrix_type %in% c(

709:     stopifnot(is.logical(multi_quant_matrix) & length(multi_quant_matrix) == 1)

1196: # @param matrix_type The matrix_type to lookup (one between "annotated" or

1208:     matrix_type) {

1219:     ms <- if (matrix_type == "annotated") {

1220:         .matrix_annotated_suffixes()

1222:         .matrix_not_annotated_suffixes()

1231:             "_matrix",

1466: # A single threaded and simplified version of import_single_Vispa2Matrix

1471: # and to reshape the entire matrix directly

1820:     matrix_type,

1826:         matrix_type

1942: # Checks if association file contains more information than the matrix.

1945: # the examined matrix there are additional CompleteAmplificationIDs contained

1946: # in the association file that weren't included in the integration matrix (for

1971: # Produces a joined tibble between the sequence count matrix and the

1995: # @param joined_df The joined tibble obtained via `.join_matrix_af`

2139: # for multi quantification matrix)

2182: # for multi quantification matrix)

2251: # for multi quantification matrix)

2292: # for multi quantification matrix)

2376: # (obtained via `.join_matrix_af`)

2377: # @param after The final matrix obtained after collision processing

2427: # Internal for obtaining summary info about the input sequence count matrix

2454:     ## Joined is the matrix already joined with metadata

2583: # @param x The list of matrices to aggregate. If a single matrix has to be

2584: # supplied it must be enclosed in a list. For example `x = list(matrix)`.

2658: # meaning a subset of an integration matrix in which all rows

2661: # @param x An integration matrix subset (see description)

2675: # @return A named list with recalibrated matrix and recalibration map.

2721:             return(list(recalibrated_matrix = x, map = map_recalibr))

2840:     list(recalibrated_matrix = x, map = map_recalibr)

3868:     # --- OBTAIN MATRIX (ALL TPs)

3883:         as.matrix()

3884:     # --- OBTAIN MATRIX (STABLE TPs)

3903:             as.matrix()

3908:     timecaptures <- length(colnames(matrix_desc))

3915:         matrix_desc = matrix_desc,

3924:             matrix_desc = patient_slice_stable,

3935:         matrix_desc = matrix_desc,

3943:             matrix_desc = patient_slice_stable,

3953:     estimate_consecutive_m0 <- if (ncol(matrix_desc) > 1) {

3955:             matrix_desc = matrix_desc,

3963:     estimate_consecutive_mth <- if (stable_tps & ncol(matrix_desc) > 2) {

3964:         # - Note: pass the whole matrix, not only stable slice

3966:             matrix_desc = matrix_desc,

3987: .closed_m0_est <- function(matrix_desc, timecaptures, cols_estimate_mcm,

3990:     models0 <- Rcapture::closedp.0(matrix_desc,

3998:         colnames(matrix_desc)[1],

4002:         colnames(matrix_desc)[ncol(matrix_desc)],

4032: .closed_mthchaobc_est <- function(matrix_desc, timecaptures, cols_estimate_mcm,

4034:     mthchaobc <- Rcapture::closedp.bc(matrix_desc,

4042:         colnames(matrix_desc)[1],

4046:         colnames(matrix_desc)[ncol(matrix_desc)],

4076: .consecutive_m0bc_est <- function(matrix_desc, cols_estimate_mcm, subject) {

4078:     indexes <- seq(from = 1, to = ncol(matrix_desc) - 1, by = 1)

4085:                 colnames(sub_matrix)[1],

4089:                 colnames(sub_matrix)[ncol(sub_matrix)],

4092:             patient_trend_M0 <- Rcapture::closedp.bc(sub_matrix,

4123: .consecutive_mth_est <- function(matrix_desc, cols_estimate_mcm, subject) {

4124:     indexes_s <- seq(from = 1, to = ncol(matrix_desc) - 2, by = 1)

4131:                 colnames(sub_matrix)[1],

4135:                 colnames(sub_matrix)[ncol(sub_matrix)],

4138:             patient_trend_Mth <- Rcapture::closedp.bc(sub_matrix,

1509:         rlang::abort(.malformed_ISmatrix_error(),

5000:     var chord = {}, chords, groups, matrix, n, padding = 0, sortGroups, sortSubgroups, sortChords;

5001:     chord.matrix = function(x) {

2751:   d3.transpose = function(matrix) {

2752:     return d3.zip.apply(d3, matrix);

3138:       return new d3_transform(t ? t.matrix : d3_transformIdentity);

4937:           x += matrix[i][j];

4951:             return sortSubgroups(matrix[i][a], matrix[i][b]);

4960:           var di = groupIndex[i], dj = subgroupIndex[di][j], v = matrix[di][dj], a0 = x, a1 = x += v * k;

5002:       if (!arguments.length) return matrix;

5003:       n = (matrix = x) && matrix.length;

651:       point = point.matrixTransform(container.getScreenCTM().inverse());

84:                 matrix <- pathCor_pathprint_v1.2.3_dframe

89:                 matrix <- pathCor_pathprint_v1.2.3_unadjusted_dframe 

98:                 matrix <- pathCor_Hv5.1_dframe

102:                 matrix <- pathCor_Hv5.1_unadjusted_dframe 

111:                 matrix <- pathCor_CPv5.1_dframe

115:                 matrix <- pathCor_CPv5.1_unadjusted_dframe 

123:                 matrix <- pathCor_GOBPv5.1_dframe

127:                 matrix <- pathCor_GOBPv5.1_unadjusted_dframe 

173:         step1_matrix <-

174:             subset(matrix, abs(PathCor) >= min_abs_corr & p.value <= max_pval)

178:             temp_cor <- subset(step1_matrix,(Pathway.A == unused_genesets[i]

199:         # create matrix with geneset groups

210:         step2_matrix <-

211:             subset(step1_matrix, Pathway.A %in% interesting_genesets &

217:                         top, " top correlated genesets, ", dim(step2_matrix)[1],

224:                         top, " top correlated genesets, ", dim(step2_matrix)[1],

227:         po = new("pcxn",type = "pcxn_analyze", data = as.matrix(step2_matrix),

900:     matrix = NULL

1013:     as.adj.matrix(x,

1289:     as.adj.matrix(x,

646: as.adj.matrix <- function(x,

916:     matrix.to.df <- function(m) {    

1035:     matrix.to.df <- function(z) {   

1213:     matrix.to.df <- function(z) {   

1217:         prederr.matrix = x$kfold[[z]]$prederr

1297:     matrix.to.df <- function(z) {  

1303:         posterr.matrix = get(z, x$kfold)$posterr

1967:     adj.matrix = get(model, as.adj.matrix(x, models = model))

21: #' @return A TRONCO genotypes matrix.

87: #' @return A matrix with 2 columns (event type, gene name) for the events found.

121: #' @return A matrix with 1 column annotating stages and rownames as sample IDs.

143: #' @return A matrix with 1 column annotating stages and rownames as sample IDs.

180: #' @return A matrix, subset of \code{as.genotypes(x)} with colnames substituted  with events' types.

627: #' Extract the adjacency matrix of a TRONCO model. The matrix is indexed with colnames/rownames which 

629: #' specify a subset of events to build the matrix, a subset of models if multiple reconstruction have

630: #' been performed. Also, either the prima facie matrix or the post-regularization matrix can be extracted.

634: #' as.adj.matrix(test_model)

635: #' as.adj.matrix(test_model, events=as.events(test_model)[5:15,])

636: #' as.adj.matrix(test_model, events=as.events(test_model)[5:15,], type='pf')

638: #' @title as.adj.matrix

642: #' @param type Either the prima facie ('pf') or the post-regularization ('fit') matrix, 'fit' by default.

643: #' @return The adjacency matrix of a TRONCO model. 

644: #' @export as.adj.matrix

667:             mat = m[[i]]$adj.matrix$adj.matrix.fit

669:             mat = m[[i]]$adj.matrix$adj.matrix.pf

683: #' Extract the marginal probabilities from a TRONCO model. The return matrix is indexed with rownames which 

685: #' specify a subset of events to build the matrix, a subset of models if multiple reconstruction have

709:         stop('Events should have colnames to access the adjacency matrix - use \'as.events\' function?')

734: #' Extract the joint probabilities from a TRONCO model. The return matrix is indexed with rownames/colnames which 

736: #' specify a subset of events to build the matrix, a subset of models if multiple reconstruction have

761:         stop('Events should have colnames to access the adjacency matrix - use \'as.events\' function?')

787: #' Extract the conditional probabilities from a TRONCO model. The return matrix is indexed with rownames which 

789: #' specify a subset of events to build the matrix, a subset of models if multiple reconstruction have

814:         stop('Events should have colnames to access the adjacency matrix - use \'as.events\' function?')

903:         matrix$pf = x$adj.matrix.prima.facie   

905:         matrix =

906:             as.adj.matrix(x,

911:     matrix = lapply(matrix, keysToNames, x = x)

981:     return(lapply(matrix, matrix.to.df))

1012:     matrix = 

1019:     matrix = lapply(matrix, keysToNames, x = x)

1036:         m = matrix[[z]]

1117:     res = lapply(seq_along(matrix), matrix.to.df)

1118:     names(res) = names(matrix)

1219:             names(prederr.matrix) = lapply(names(prederr.matrix), function(k) { nameToKey(x, k) })

1220:             return(prederr.matrix)

1225:         df$prederr = t(as.data.frame(prederr.matrix)) # values

1248:     res = lapply(seq_along(models), matrix.to.df)

1288:     matrix = 

1295:     matrix = lapply(matrix, keysToNames, x = x)

1302:         m = matrix[[z]]

1306:             rownames(posterr.matrix) = lapply(rownames(posterr.matrix), function(k) { nameToKey(x, k) })

1307:             colnames(posterr.matrix) = lapply(colnames(posterr.matrix), function(k) { nameToKey(x, k) })

1308:             return(posterr.matrix)

1312:         posterr.matrix = keysToNames(posterr.matrix, x = x)

1333:                     val = posterr.matrix[[select,selected]]

1369:     res = lapply(models, matrix.to.df)

1370:     names(res) = names(matrix)

1802: #' Convert colnames/rownames of a matrix into intelligible event names, e.g., change a key G23 in 'Mutation KRAS'.

1807: #' adj_matrix = as.adj.matrix(test_model, events=as.events(test_model)[5:15,])$capri_bic

1808: #' keysToNames(test_model, adj_matrix)

1813: #' @param matrix A matrix with colnames/rownames which represent genotypes keys. 

1814: #' @return The matrix with intelligible colnames/rownames. 

1817: keysToNames <- function(x, matrix) {

1819:     if (!is.matrix(matrix)

1820:         || any(is.null(colnames(matrix)))

1821:         || any(is.null(rownames(matrix))))

1822:         stop('"matrix" should be a matrix with rownames/colnames.')

1830:     colnames(matrix) = sapply(colnames(matrix), resolve)

1831:     rownames(matrix) = sapply(rownames(matrix), resolve)

1832:     return(matrix)

1840: #' adj_matrix = as.adj.matrix(test_model, events=as.events(test_model)[5:15,])$bic

1961:     genotypes = as.matrix(genotypes)

1968:     adj.matrix = keysToNames(x, adj.matrix)

1975:     for (from in rownames(adj.matrix)) {

1976:         for (to in colnames(adj.matrix)) {

1977:             if (adj.matrix[from, to] == 1) {

82:         matrix <- matrix(new_value)

80:     aggregate_matrix <- t(vapply(meta_data, function(x) {

86:     metadata_matrix <- cbind(m_names,aggregate_matrix)

92:     cond_matrix <- NULL

85:     m_names <- matrix(names)

95:         cond_matrix <- rbind(cond_matrix, def)

99:         cond_matrix <- rbind(cond_matrix, exact)

103:         cond_matrix <- rbind(cond_matrix, full)

104:     cond_matrix

106:     matrix <- matrices[[matrix.id]]

75:   matrix.names <- sapply(pwm.list, function (element) element$title)

101:   matrix.ids <- names(matrices)

103:   for (matrix.id in matrix.ids) {

302:   rawMatrixList <- readRawMatrices("./", dataDir)

44:   for (i in 1:max){ # loop through all motifs in the matrix file, one motif at a time

63:    mtx <- pwm.1$matrix

71: # rather than a sublist of title and matrix, each element is simply a matrix, with the element named

74:   matrices <- sapply(pwm.list, function (element) element$matrix)

76:   matrix.names <- sub("^> ", "", matrix.names)

77:   names(matrices) <- matrix.names

104:     tokens <- strsplit(matrix.id, ".", fixed=TRUE)[[1]]

107:     geneSymbol <- sub("_HUMAN.*$", "", matrix.id)

108:     tbl.sub <- subset(tbl.raw, Model==matrix.id)

116:     new.row <- list (providerName=matrix.id,

117:                      providerId=matrix.id, #"HOCOMOCO v8 and ChiPMunk 3.1"

125:                      sequenceCount=max(colSums(matrix)),

131:     #printf("matrix.id: %s", matrix.id);

134:     full.name <- sprintf ('%s-%s-%s', organism, dataSource, matrix.id)

136:     } # for matrix.id

151:      # make sure the reliability score (A-D) is searchably found in the matrix rowname

162: # we now have metadata rownames, one per matrix, each of which has all (or at least at lot) of information

163: # used in querying.  For instance, the hocomoco give name for the first matrix is

209:      # after normalization, each matrix column should total to 1.0

210:      # so sum(matrix) should be equals to the number of columns

232:   result <- matrix (nrow=4, ncol=cols,

247:   #return (list (title=title, consensus.sequence=consensus.sequence, matrix=result))

248:   return (list (title=title, matrix=result))

303:   length(rawMatrixList)

304:   matrices <- extractMatrices (rawMatrixList)

903:   matrix <- Matrix::Matrix(0, nrow = nrow(motifs), ncol = ncol(motifs) - 21 ,sparse = TRUE)

363: makeSummarizedExperimentFromGeneMatrix <- function(exp, genome = genome){

476: splitmatrix <- function(x,by="row") {

900: getMatrix <- function(filename) {

5: #' @param met A Summaerized Experiment, a matrix or path of rda file only containing the data.

6: #' @param exp A Summaerized Experiment, a matrix or path of rda file only containing the data. Rownames should be 

11: #'  of the gene expression and DNA methylation matrix. This should be used if your matrix

14: ...(14 bytes skipped)...A methylation" and "Gene expression"), primary (sample ID) and colname (names of the columns of the matrix).

89: #'    #1) Get gene expression matrix

246:         stop("Please the gene expression matrix should receive ENSEMBLE IDs")

307:         stop("Error DNA methylation matrix and gene expression matrix are not in the same order")

322: ...(63 bytes skipped)...ary (sample ID) and colname(DNA methylation and gene expression sample [same as the colnames of the matrix])")

341:         stop("Error DNA methylation matrix and gene expression matrix are not in the same order")

387:     stop("Please the gene expression matrix should receive ENSEMBLE IDs (ENSG)")

409:   assay <- data.matrix(met)

442: #' This function will receive the DNA methylation and gene expression matrix and will create

444: #' @param met DNA methylation matrix or Summarized Experiment

445: #' @param exp Gene expression matrix or Summarized Experiment

473: # @param x A matrix 

475: # @return A list each of which is the value of each row/column in the matrix.

693: #' @param data A MultiAssayExperiment with a DNA methylation martrix or a DNA methylation matrix

896: # This will read this homer file and create a sparce matrix

904:   colnames(matrix) <- gsub(" Distance From Peak\\(sequence,strand,conservation\\)","",colnames(motifs)[-c(1:21)])

905:   rownames(matrix) <- motifs$PeakID

906:   matrix[!is.na(motifs[,-c(1:21)])] <- 1

907:   matrix <- as(matrix, "nsparseMatrix")

908:   return(matrix)

917: #' foreground <- Matrix::Matrix(sample(0:1,size = 100,replace = TRUE), 

921: #' background <- Matrix::Matrix(sample(0:1,size = 100,replace = TRUE), 

935:   a <- Matrix::colSums(foreground)

936:   b <- nrow(foreground) - Matrix::colSums(foreground)

937:   c <- Matrix::colSums(background)

938:   d <- nrow(background) - Matrix::colSums(background)

940:     x <- fisher.test(matrix(c(a[i],b[i],c[i],d[i]),nrow = 2,ncol = 2))