Found 30860 results in 8400 files, showing top 50 files (show more).
XVector:R/RdsCollection-class.R: [ ] |
---|
45: .validate_dirpath <- function(dirpath, what="the 'dirpath' slot")
|
119: abspath <- file_path_as_absolute(x@dirpath)
|
81: filepaths <- file.path(dirpath, filenames)
|
13: dirpath="character", # Absolute path to an existing directory.
|
48: return(paste0(what, " must be a single string specifying the path ",
|
51: return(paste0(what, " must contain the path to an existing directory"))
|
122: "path (", abspath, ") to directory ", x@dirpath))
|
144: RdsCollection <- function(path=".", filenames=NULL)
|
147: msg <- .validate_dirpath(path, what="'path'")
|
155: filenames <- dir(path, pattern=pattern, all.files=TRUE)
|
158: msg <- .validate_filenames(filenames, path, what="'filenames'")
|
176: new2("RdsCollection", dirpath=file_path_as_absolute(path),
|
186: setMethod("path", "RdsCollection", function(object) object@dirpath)
|
208: readRDS(file.path(path(x), x@filenames[[i]]))
|
47: if (!isSingleString(dirpath))
|
50: if (!dir.exists(dirpath))
|
64: .validate_filenames <- function(filenames, dirpath, what="the 'filenames' slot")
|
84: be_what <- paste0("present in directory \"", dirpath, "\"")
|
91: function(filepath) {
|
92: inherits(try(infoRDS(filepath), silent=TRUE), "try-error")
|
115: ## Validate the 'dirpath' slot.
|
116: msg <- .validate_dirpath(x@dirpath)
|
120: if (abspath != x@dirpath)
|
121: return(paste0("the 'dirpath' slot must contain the absolute ",
|
125: msg <- .validate_filenames(x@filenames, x@dirpath)
|
82: missing_idx <- which(!file.exists(filepaths))
|
90: not_ok <- vapply(filepaths,
|
XVector:R/RdaCollection-class.R: [ ] |
---|
45: .get_rdapath <- function(dirpath, objname)
|
55: filepath <- .get_rdapath(dirpath, objname)
|
99: x_dirpath <- x@dirpath
|
110: filepaths <- .get_rdapath(x_dirpath, x_objnames)
|
50: file.path(dirpath, filename)
|
18: dirpath="character", # a single string
|
53: .load_serialized_object <- function(dirpath, objname)
|
57: loaded_names <- load(filepath, envir=tempenv)
|
59: stop("file '", filepath, "' contains 0 or more ",
|
62: stop("serialized object in file '", filepath, "' ",
|
77: setGeneric("rdaPath", signature="x",
|
78: function(x, objname) standardGeneric("rdaPath")
|
82: setMethod("rdaPath", "RdaCollection",
|
88: .get_rdapath(x@dirpath, objname)
|
137: RdaCollection <- function(dirpath, objnames)
|
139: new("RdaCollection", dirpath=dirpath, objnames=objnames)
|
161: .load_serialized_object(x@dirpath, i)
|
111: missing_idx <- which(!file.exists(filepaths))
|
121: filepaths_in_1string <-
|
122: paste(paste0("'", filepaths[missing_idx], "'"), collapse=", ")
|
124: msg <- c(what, filepaths_in_1string, is_or_are, "missing")
|
StarBioTrek:man/path.Rd: [ ] |
---|
4: \name{path}
|
5: \alias{path}
|
6: \title{pathway data list}
|
9: pathway data list
|
MineICA:man/relativePath.Rd: [ ] |
---|
3: \title{Relative path}
|
5: relativePath(path1, path2)
|
8: \item{path1}{The first path}
|
10: \item{path2}{The second path}
|
13: The relative path between path1 and path2
|
16: Computes the relative path between two imbricated paths
|
19: \code{path1} and \code{path2} must be imbricated.
|
22: path1 <- "home/lulu/res/gene2comp/"
|
23: path2 <- "home/lulu/res/comp2annot/invasive/"
|
24: relativePath(path1,path2)
|
1: \name{relativePath}
|
2: \alias{relativePath}
|
ISAnalytics:man/default_report_path.Rd: [ ] |
---|
3: \name{default_report_path}
|
4: \alias{default_report_path}
|
8: default_report_path()
|
11: A path
|
18: default_report_path()
|
CONFESS:man/pathUpdater.Rd: [ ] |
---|
7: pathUpdater(data, path)
|
10: \item{data}{Data matrix. A matrix of centroids with their path progression indices.}
|
12: \item{path}{Numeric vector. The path progression indices.}
|
15: The sorted cluster indices (path)
|
18: A helper that updates the path sorted clusters after re-estimation by change-point analysis.
|
3: \name{pathUpdater}
|
4: \alias{pathUpdater}
|
5: \title{pathUpdater}
|
multiGSEA:man/archivePath.Rd: [ ] |
---|
5: \title{Retrieve path to a cached file.}
|
13: String containing the path to the file.
|
16: The function retrieves the path to a file that is cached in the archive
|
3: \name{archivePath}
|
4: \alias{archivePath}
|
7: archivePath(filename)
|
CONFESS:man/fixPath.Rd: [ ] |
---|
18: It tests whether the path has been appropariately defined and produces an error if not.
|
3: \name{fixPath}
|
4: \alias{fixPath}
|
5: \title{FixPath}
|
7: fixPath(data, groups)
|
rawrr:man/rawrrAssemblyPath.Rd: [ ] |
---|
5: \title{Derives the path where all .NET assemblies are stored.}
|
10: path
|
13: Derives the path where all .NET assemblies are stored.
|
3: \name{rawrrAssemblyPath}
|
4: \alias{rawrrAssemblyPath}
|
7: rawrrAssemblyPath()
|
16: rawrrAssemblyPath()
|
ORFik:man/getGtfPathFromTxdb.Rd: [ ] |
---|
5: \title{Get path of GTF that created txdb}
|
16: a character file path, returns NULL if not valid
|
3: \name{getGtfPathFromTxdb}
|
4: \alias{getGtfPathFromTxdb}
|
7: getGtfPathFromTxdb(txdb, stop.error = TRUE)
|
TrajectoryGeometry:man/crooked_path_center.Rd: [ ] |
---|
4: \name{crooked_path_center}
|
5: \alias{crooked_path_center}
|
6: \title{Crooked path center}
|
11: projection of crooked_path.
|
18: crooked_path_center
|
22: the projection of crooked_path
|
TrajectoryGeometry:man/straight_path.Rd: [ ] |
---|
4: \name{straight_path}
|
5: \alias{straight_path}
|
6: \title{Straight path}
|
10: The path is roughly in the (1,0,0) direction.
|
18: straight_path
|
21: A path of n points in dimension d is an n x d matrix. This
|
22: particular path is relatively straight.
|
CONFESS:man/path.initiator.Rd: [ ] |
---|
3: \name{path.initiator}
|
4: \alias{path.initiator}
|
5: \title{path.initiator}
|
7: path.initiator(data, where)
|
13: the starting point of the progression path.}
|
16: A starting point for the progression path
|
19: It finds the cluster that initiates the progression path.
|
splatter:man/getPathOrder.Rd: [ ] |
---|
5: \title{Get path order}
|
7: getPathOrder(path.from)
|
10: \item{path.from}{vector giving the path endpoints that each path originates
|
14: Vector giving the order to process paths in.
|
17: Identify the correct order to process paths so that preceding paths have
|
3: \name{getPathOrder}
|
4: \alias{getPathOrder}
|
StarBioTrek:man/path_KEGG.Rd: [ ] |
---|
4: \name{path_KEGG}
|
5: \alias{path_KEGG}
|
6: \title{All pathways data from KEGG}
|
7: \format{A list of pathways with the involved genes}
|
9: All pathways data from KEGG
|
ORFik:man/optimized_txdb_path.Rd: [ ] |
---|
3: \name{optimized_txdb_path}
|
4: \alias{optimized_txdb_path}
|
5: \title{Get path for optimization files for txdb}
|
7: optimized_txdb_path(txdb, create.dir = FALSE, stop.error = TRUE)
|
18: a character file path, returns NULL if not valid
|
22: Get path for optimization files for txdb
|
TrajectoryGeometry:man/straight_path_center.Rd: [ ] |
---|
4: \name{straight_path_center}
|
5: \alias{straight_path_center}
|
6: \title{Straight path center}
|
11: projection of straight_path.
|
19: straight_path_center
|
23: the projection so straight_path
|
TrajectoryGeometry:man/straight_path_projection.Rd: [ ] |
---|
4: \name{straight_path_projection}
|
5: \alias{straight_path_projection}
|
6: \title{Straight path projection}
|
10: The projection of straight_path[2:14,] onto the unit sphere as seen
|
11: from straight_path[1,] .
|
19: straight_path_projection
|
22: The projection of straight_path onto the unit sphere. This is a
|
ORFik:man/findFromPath.Rd: [ ] |
---|
10: \item{filepaths}{path to all files}
|
3: \name{findFromPath}
|
4: \alias{findFromPath}
|
7: findFromPath(filepaths, candidates, slot = "auto")
|
16: else must be a character vector of length 1 or equal length as filepaths.}
|
TrajectoryGeometry:man/crooked_path_radius.Rd: [ ] |
---|
4: \name{crooked_path_radius}
|
5: \alias{crooked_path_radius}
|
6: \title{Crooked path radius}
|
11: crooked_path to the point minimizing this mean distance.
|
19: crooked_path_radius
|
23: crooked_path to the point minimizing this mean distance.
|
cfDNAPro:man/examplePath.Rd: [ ] |
---|
5: \title{Get path to cfDNAPro example folder.}
|
11: If `NULL`, the path of extdata folder will be returned.}
|
14: A string. (i.e. the path.)
|
18: directory. This function helps get the path to the data.
|
2: % Please edit documentation in R/examplePath.R
|
3: \name{examplePath}
|
4: \alias{examplePath}
|
7: examplePath(data = NULL)
|
21: examplePath()
|
22: examplePath("groups_picard")
|
23: examplePath("step6")
|
TrajectoryGeometry:man/crooked_path.Rd: [ ] |
---|
4: \name{crooked_path}
|
5: \alias{crooked_path}
|
6: \title{Crooked path}
|
10: This path changes direction after the 5th point.
|
20: crooked_path
|
23: A path of n points in dimension d is an n x d matrix. This
|
24: particular path is relatively crooked.
|
TrajectoryGeometry:man/straight_path_radius.Rd: [ ] |
---|
4: \name{straight_path_radius}
|
5: \alias{straight_path_radius}
|
6: \title{Straight path radius}
|
11: straight_path to the point minimizing this mean distance.
|
19: straight_path_radius
|
23: straight_path to the point minimizing this mean distance.
|
hipathia:man/path_vals.Rd: [ ] |
---|
4: \name{path_vals}
|
5: \alias{path_vals}
|
10: data(path_vals)
|
22: \code{path_vals <- get_paths_matrix(results)}
|
6: \title{Pathways matrix of the BRCA gene expression dataset}
|
7: \format{Matrix with 40 columns and 1868 rows. Row names are Pathway IDs
|
13: Matrix with 40 columns and 1868 rows. Row names are Pathway IDs
|
17: Matrix of pathway activation values for the BRCA dataset. This matrix is
|
19: by means of the \code{get_paths_matrix} function.
|
18: extracted from the Results object returned by the \code{hipathia} function
|
methylKit:man/getDBPath-methods.Rd: [ ] |
---|
10: \title{Get path to database of the methylDB objects}
|
27: The function returns the path to the flat file database that stores the data
|
39: #The path to the database is returned
|
4: \name{getDBPath}
|
5: \alias{getDBPath}
|
6: \alias{getDBPath,methylRawListDB-method}
|
7: \alias{getDBPath,methylBaseDB-method}
|
8: \alias{getDBPath,methylRawDB-method}
|
9: \alias{getDBPath,methylDiffDB-method}
|
12: getDBPath(x)
|
14: \S4method{getDBPath}{methylRawListDB}(x)
|
16: \S4method{getDBPath}{methylBaseDB}(x)
|
18: \S4method{getDBPath}{methylRawDB}(x)
|
20: \S4method{getDBPath}{methylDiffDB}(x)
|
40: getDBPath(methylBaseDB.obj)
|
loci2path:man/getPathDescription-methods.Rd: [ ] |
---|
30: loci=eset.list, path=biocarta)
|
31: path.des <- getPathDescription(result, biocarta)
|
2: % Please edit documentation in R/allGenerics.R, R/loci2pathResult-methods.R
|
6: \alias{getPathDescription,loci2pathResult-method}
|
7: \title{Extract description for enriched pathways from query result and
|
12: \S4method{getPathDescription}{loci2pathResult}(res, geneset)
|
26: This function extracts the pathway description from geneSet object.
|
4: \name{getPathDescription}
|
5: \alias{getPathDescription}
|
10: getPathDescription(res, ...)
|
nethet:man/hugepath.Rd: [ ] |
---|
5: \title{Graphical Lasso path with huge package}
|
22: Graphical Lasso path with huge package
|
3: \name{hugepath}
|
4: \alias{hugepath}
|
7: hugepath(s, rholist, penalize.diagonal = NULL, trace = NULL)
|
BgeeCall:man/getWorkingPath.Rd: [ ] |
---|
8: \title{`working_path` Getter}
|
18: the value of the `working_path` slot of the object
|
21: Get value of the `working_path` slot
|
26: working_path <- getWorkingPath(user)
|
4: \name{getWorkingPath}
|
5: \alias{getWorkingPath}
|
6: \alias{getWorkingPath,UserMetadata-method}
|
7: \alias{getWorkingPath,userMetadata}
|
10: getWorkingPath(userObject)
|
12: \S4method{getWorkingPath}{UserMetadata}(userObject)
|
TrajectoryGeometry:man/crooked_path_projection.Rd: [ ] |
---|
4: \name{crooked_path_projection}
|
5: \alias{crooked_path_projection}
|
6: \title{Crooked path projection}
|
10: The projection of crooked_path[7:14,] onto the unit sphere as seen
|
11: from crooked_path[6,] .
|
19: crooked_path_projection
|
22: The projection of the last 8 points on crooked_path onto the unit
|
StarBioTrek:man/GetPathData.Rd: [ ] |
---|
7: GetPathData(path_ALL)
|
10: \item{path_ALL}{variable. The user can select the variable as obtained by GetData function}
|
19: pathway_ALL_GENE<-GetPathData(path_ALL=path[1:3])
|
5: \title{Get genes inside pathways.}
|
13: a list of pathways
|
16: GetPathData creates a list of genes inside the pathways.
|
3: \name{GetPathData}
|
4: \alias{GetPathData}
|
ramwas:man/isAbsolutePath.Rd: [ ] |
---|
4: Check if Path is Absolute.
|
7: Check whether a path is relative or absolute.
|
10: isAbsolutePath(path)
|
13: \item{path}{
|
14: Path to be tested.
|
21: \code{TRUE} if the path is absolute, \code{FALSE} otherwise.
|
29: For instance, "~hi" is not an absolute path.
|
1: \name{isAbsolutePath}
|
2: \alias{isAbsolutePath}
|
18: The function is designed to word with both Windows and Unix paths.
|
32: See also \code{\link{makefullpath}}.
|
35: isAbsolutePath( "C:/123" ) # TRUE
|
36: isAbsolutePath( "~123" ) # FALSE
|
37: isAbsolutePath( "~/123" ) # TRUE
|
38: isAbsolutePath( "/123" ) # TRUE
|
39: isAbsolutePath( "\\\\123" ) # TRUE
|
40: isAbsolutePath( "asd\\\\123" ) # FALSE
|
41: isAbsolutePath( "a\\\\123" ) # FALSE
|
StarBioTrek:man/GetPathNet.Rd: [ ] |
---|
7: GetPathNet(path_ALL)
|
10: \item{path_ALL}{variable. The user can select the variable as obtained by GetData function}
|
19: pathway_net<-GetPathNet(path_ALL=path[1:3])
|
5: \title{Get interacting genes inside pathways.}
|
13: a list of pathways
|
16: GetPathNet creates a list of genes inside the pathways.
|
3: \name{GetPathNet}
|
4: \alias{GetPathNet}
|
MACSQuantifyR:man/setPath.Rd: [ ] |
---|
5: \title{sets custom output path}
|
7: setPath(MACSQuant,path=NULL)
|
14: \item{path}{user defined path, default is tempd}
|
17: object of class MACSQuant with updated path
|
20: This function allows the user to set the output directory path
|
26: user_path="."
|
27: #MACSQuant = setPath(MACSQuant,path=user_path)
|
3: \name{setPath}
|
4: \alias{setPath}
|
23: filepath <- system.file("extdata", "SingleDrugs.xlsx",
|
25: #MACSQuant = load_MACSQuant(filepath)
|
ggtree:man/get.path.Rd: [ ] |
---|
3: \name{get.path}
|
4: \alias{get.path}
|
5: \title{get.path}
|
7: get.path(phylo, from, to)
|
20: path from start node to end node
|
xcms:man/phenoDataFromPaths.Rd: [ ] |
---|
11: path) of the experiment's files.}
|
5: \title{Derive experimental design from file paths}
|
7: phenoDataFromPaths(paths)
|
10: \item{paths}{\code{character} representing the file names (including the full
|
3: \name{phenoDataFromPaths}
|
4: \alias{phenoDataFromPaths}
|
14: The \code{phenoDataFromPaths} function builds a \code{data.frame}
|
ramwas:man/makefullpath.Rd: [ ] |
---|
4: Combine Path and Filename into Filename with Path
|
7: Combine a path with a filename into filename with path.
|
10: makefullpath(path, filename)
|
13: \item{path}{
|
14: Path, relative to which the filename is expected to be.
|
18: Can be just filename, include relative path, or
|
19: include absolute path.
|
23: Function returns \code{filename} if it includes absolute path or
|
24: if \code{path} is \code{NULL}.
|
27: Filename with the path included.
|
42: # Path is ignored if the filename already includes absolute path
|
1: \name{makefullpath}
|
2: \alias{makefullpath}
|
33: See also \code{\link{isAbsolutePath}}.
|
36: makefullpath("dir1/dir2", "file.txt")
|
39: makefullpath("dir1/dir2", "dir3/file.txt")
|
44: makefullpath("dir1/dir2", "/file.txt")
|
47: makefullpath("dir1/dir2", "C:/file.txt")
|
gespeR:man/path-methods.Rd: [ ] |
---|
4: \name{path<-}
|
5: \alias{path<-}
|
6: \alias{path<-,TargetRelations,character-method}
|
7: \title{path}
|
9: path(object) <- value
|
11: \S4method{path}{TargetRelations,character}(object) <- value
|
16: \item{value}{A string defining the path}
|
19: A \code{\linkS4class{TargetRelations}} object with set path
|
22: Set the path of a a \code{\linkS4class{TargetRelations}} object object
|
26: path(trels) <- "/dev/null"
|
hipathia:man/get_pathway_functions.Rd: [ ] |
---|
27: \item{unique}{Boolean, whether to return the first function for each path.}
|
3: \name{get_pathway_functions}
|
4: \alias{get_pathway_functions}
|
5: \title{Returns functions related to a pathway}
|
7: get_pathway_functions(
|
8: pathigraph,
|
16: \item{pathigraph}{Pathway object}
|
24: nodes of the pathways or not. If FALSE, functions will refer to all the nodes
|
25: of the pathway.}
|
30: List of annotations from pathways to functions
|
33: Returns functions related to a pathway
|
sitadela:man/getsetDbPath.Rd: [ ] |
---|
4: \title{Get and set sitadela default database path}
|
10: \item{db}{path to a valid SQLite database file.}
|
17: used to set and get the path to a sitadela annotation
|
19: \code{file.path(system.file(package="sitadela"),"annotation.sqlite")}.
|
21: environment pointing to the desired path.
|
1: \name{getsetDbPath}
|
2: \alias{setDbPath}
|
3: \alias{getDbPath}
|
6: setDbPath(db = NULL)
|
7: getDbPath()
|
16: The \code{setDbPath} and \code{getDbPath} functions are
|
24: myPath <- "/home/me/test.sqlite"
|
25: setDbPath(myPath)
|
26: getDbPath()
|
CONFESS:man/estimatePath.Rd: [ ] |
---|
13: It can be either "clockwise" or "anticlockwise" depending on how the path is expected
|
16: \item{start}{Integer. The cluster number that is assigned as the path starting point}
|
19: The sorted cluster indices (path)
|
22: The main function for automatic path estimation .
|
3: \name{estimatePath}
|
4: \alias{estimatePath}
|
5: \title{estimatePath}
|
7: estimatePath(data, type, start)
|
systemPipeR:man/tryPath.Rd: [ ] |
---|
7: Function to check if the full path (file or directory) exists.
|
10: tryPath(path)
|
13: \item{path}{
|
14: a character vector of full path name.
|
18: This function produces a character vector of the file or directory name defined on the \code{path} argument.
|
21: A character vector containing the name of the file or directory. If the path does not exist, it will return an error message.
|
28: tryPath(path=file)
|
1: \name{tryPath}
|
2: \alias{tryPath}
|
peakPantheR:man/spectraPaths_and_metadata_UI_helper.Rd: [ ] |
---|
16: \item{spectraMetadataPath}{NULL or path to a csv of spectra metadata, with
|
31: input_spectraPaths <- c('./path/file1', './path/file2', './path/file3')
|
5: \title{UI data import helper - prepare file paths and metadata}
|
9: spectraMetadataPath = NULL
|
13: \item{spectraPaths}{NULL or character vector of spectra file paths, to set
|
17: spectra as row and metadata as columns. (spectraPaths in column `filepath`)}
|
26: the `filepath` column
|
30: # spectraPath
|
36: dimnames=list(c(),c('filepath', 'testcol')),
|
40: spectraMetaPath <- tempfile(pattern="file", tmpdir=tempdir(), fileext='.csv')
|
43: file=spectraMetaPath,
|
48: spectraMetadataPath = spectraMetaPath)
|
3: \name{spectraPaths_and_metadata_UI_helper}
|
4: \alias{spectraPaths_and_metadata_UI_helper}
|
7: spectraPaths_and_metadata_UI_helper(
|
8: spectraPaths = NULL,
|
20: spectraPaths (str) and spectraMetadata (DataFrame or NULL) read from
|
24: Return spectraPaths and spectraMetadata from a .csv file (if available).
|
25: If reading from the spectraMetadata file, the spectraPaths are taken from
|
34: input_spectraMetadata <- data.frame(matrix(data=c(input_spectraPaths,
|
47: spectraPaths_and_metadata_UI_helper(spectraPaths = NULL,
|
NetPathMiner:man/NetPathMiner-package.Rd: [ ] |
---|
8: \title{General framework for network extraction, path mining.}
|
10: NetPathMiner implements a flexible module-based process flow for network path mining and visualization,
|
13: formats, enabling its utility to most common pathway databases.
|
15: thousands of output paths.
|
4: \name{NetPathMiner-package}
|
5: \alias{NetPathMiner-package}
|
6: \alias{NetPathMiner}
|
12: NetPathMiner supports construction of various types of genome scale networks from KGML, SBML and BioPAX
|
14: NetPathMiner also provides different visualization techniques to facilitate the analysis of even
|
netDx:man/getGMjar_path.Rd: [ ] |
---|
3: \name{getGMjar_path}
|
4: \alias{getGMjar_path}
|
7: getGMjar_path(verbose = FALSE)
|
13: (char) Path to local cached copy of GeneMANIA jar file..
|
20: getGMjar_path()
|
EventPointer:man/ArrayDatamultipath.Rd: [ ] |
---|
5: \title{Preprocessed arrays data with multi-path events}
|
23: Preprocessed arrays data with multi-path events
|
2: % Please edit documentation in R/ArrayDatamultipath.R
|
3: \name{ArrayDatamultipath}
|
4: \alias{ArrayDatamultipath}
|
12: data(ArrayDatamultipath)
|
15: ArrayDatamultipath object contains preprocessed junction
|
Category:man/probes2Path.Rd: [ ] |
---|
1: \name{probes2Path}
|
2: \alias{probes2Path}
|
9: probes2Path(pids, data = "hgu133plus2")
|
17: This is a simple look up in the appropriate chip \code{PATH} data
|
30: probes2Path(x, "hgu95av2.db")
|
3: \title{A function to map probe identifiers to pathways. }
|
6: up all KEGG pathways that the probe is documented to be involved in.
|
21: A list of pathway vectors. One element for each value of \code{pid}
|
22: that is mapped to at least one pathway.
|
ggmanh:man/default_gds_path.Rd: [ ] |
---|
3: \name{default_gds_path}
|
4: \alias{default_gds_path}
|
5: \title{Path to Default GDS File}
|
7: default_gds_path()
|
13: Find path to the default gds file.
|
16: default_gds_path()
|
fgsea:man/gmtPathways.Rd: [ ] |
---|
10: \item{gmt.file}{Path to a GMT file.}
|
2: % Please edit documentation in R/pathways.R
|
5: \title{Returns a list of pathways from a GMT file.}
|
16: Returns a list of pathways from a GMT file.
|
19: pathways <- gmtPathways(system.file(
|
3: \name{gmtPathways}
|
4: \alias{gmtPathways}
|
7: gmtPathways(gmt.file)
|
hipathia:man/normalize_paths.Rd: [ ] |
---|
7: normalize_paths(path_vals, metaginfo)
|
10: \item{path_vals}{SummarizedExperiment or matrix of the pathway values}
|
16: depending on the class of \code{path_vals}.
|
30: data(path_vals)
|
33: path_normalized <- normalize_paths(path_vals, pathways)
|
3: \name{normalize_paths}
|
4: \alias{normalize_paths}
|
5: \title{Normalize the pathway matrix by rows}
|
12: \item{metaginfo}{Pathways object}
|
15: SummarizedExperiment or matrix of normalized pathway values,
|
19: Due to the nature of the Hipathia method, the length of a pathway may
|
31: pathways <- load_pathways(species = "hsa", pathways_list = c("hsa03320",
|
21: subpathways, we strongly recommend to normalize the matrix with this
|
25: This function removes the bias caused by the length of the subpathways
|
VanillaICE:man/parsedPath.Rd: [ ] |
---|
6: \title{Complete path to directory for keeping parsed files}
|
16: A character string indicating the complete path for storing parsed
|
3: \name{parsedPath}
|
4: \alias{parsedPath}
|
5: \alias{parsedPath,ArrayViews-method}
|
8: parsedPath(object)
|
10: \S4method{parsedPath}{ArrayViews}(object)
|