Found 32647 results in 8630 files, showing top 450 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
gemma.R:man/gemmaPath.Rd: [ ]
5: \title{Get gemma path}
13: Get gemma path
3: \name{gemmaPath}
4: \alias{gemmaPath}
7: gemmaPath()
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()
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/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/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/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/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.
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.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}
12: data(path_vals)
24: \code{path_vals <- get_paths_matrix(results)}
6: \title{Pathways matrix of the BRCA gene expression dataset}
8: Matrix with 40 columns and 1868 rows. Row names are Pathway IDs
15: Matrix with 40 columns and 1868 rows. Row names are Pathway IDs
19: Matrix of pathway activation values for the BRCA dataset. This matrix is
21: by means of the \code{get_paths_matrix} function.
20: 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)
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")
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")
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
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"
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}
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
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()
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)
EventPointer:man/EventDetectionMultipath.Rd: [ ]
7: EventDetectionMultipath(Input, cores, Path, paths = 2)
14: \item{Path}{Directory where to write the EventsFound_RNASeq.txt file}
30:    AllEvents_RNASeq_MP<-EventDetectionMultipath(SG_RNASeq,cores=1,Path=TxtPath,paths=3)
2: % Please edit documentation in R/EventDetectionMultipath.R
3: \name{EventDetectionMultipath}
4: \alias{EventDetectionMultipath}
5: \title{Detect splicing multipath events using EventPointer methodology}
16: \item{paths}{Maximum number of paths of the events to find.}
23: Identification of all the multipath alternative splicing events in the splicing graphs
29:    TxtPath<-tempdir()
DIAlignR:man/plotAlignmentPath.Rd: [ ]
5: \title{Visualize alignment path through similarity matrix}
16: Plot aligned path through the similarity matrix. Reference run has indices on X-axis, eXp run has them on Y-axis.
3: \name{plotAlignmentPath}
4: \alias{plotAlignmentPath}
7: plotAlignmentPath(AlignObjOutput)
21: dataPath <- system.file("extdata", package = "DIAlignR")
24: AlignObjOutput <- getAlignObjs(analytes = 4618L, runs, dataPath = dataPath, objType = "medium")
25: plotAlignmentPath(AlignObjOutput)
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)
fedup:man/readPathways.Rd: [ ]
17: \item{pathwayFile}{(char) path to file with pathway annotations}
2: % Please edit documentation in R/pathways.R
5: \title{Returns a list of pathways from various file formats.}
8:     pathwayFile,
10:     pathCol = NULL,
19: \item{header}{(logical) whether \code{pathwayFile} has a header
22: \item{pathCol}{(char or int) column name or number with pathway identifiers
23: (for use with non-GMT input files (eg "Pathway.ID" or 2; default NULL))}
29: in a pathway (default 1)}
32: in a pathway (default Inf)}
35: A list of vectors with pathway annotations.
38: This function supports custom pathway annotations to use
39: for fedup pathway enrichment analysis. Current file formats supported are
43: # Generate pathway list from GMT annotation file
44: pathways <- readPathways(
50: # Generate pathway list from XLSX annotation file
51: pathways <- readPathways(
53:     header = TRUE, pathCol = "Enriched.GO.names", geneCol = "Gene.ID"
3: \name{readPathways}
4: \alias{readPathways}
7: readPathways(
DEsubs:man/subpathwayTypes.Rd: [ ]
27: via a path starting from a gene of interest.}
67: \item{'all.eccentricity'}{Shortest path distance from the farthest other 
34: connected to each other by paths.}
46: \item{'all.KEGG'}{Genes acting as a bridge among KEGG pathway maps. }
62: \item{'all.betweenness'}{Number of shortest paths from all vertices to  
3: \name{subpathwayTypes}
4: \alias{subpathwayTypes}
5: \title{All subpathway types}
7: subpathwayTypes(grouping)
11: subsets of availiable subpathway types can be extracted.}
14: A vector of all 124 basic subpathway types. See Details section for handly 
18: All subpathway types.
21: Apart from the 124 distinct subpathway types, several groupings are availiable:
23: \item{'all'}{ All subpathway options. }
74: An exhaustive list of all 124 subpathway types follows:
206: basic.types <- subpathwayTypes()
207: stream.types <- subpathwayTypes(grouping='all.stream')
genArise:man/set.path.project.Rd: [ ]
1: \name{set.path.project}
2: \alias{set.path.project}
3: \title{set.path.project}
8: set.path.project(path, results.file, graphics.file, envir)
11:   \item{path}{Project path value}
BgeeCall:man/setWorkingPath.Rd: [ ]
8: \title{`working_path` Setter}
17: \item{workingPath}{path to the directory wanted as `working_path`}
20: An object of the class UserMetadata with new `working_path`
24: Set value of the `working_path` slot
4: \name{setWorkingPath}
5: \alias{setWorkingPath}
6: \alias{setWorkingPath,UserMetadata,character-method}
7: \alias{setWorkingPath,userMetadata,character}
10: setWorkingPath(userObject, workingPath)
12: \S4method{setWorkingPath}{UserMetadata,character}(userObject, workingPath)
29: user <- setWorkingPath(user, getwd())
BgeeCall:man/setRNASeqLibPath.Rd: [ ]
8: \title{`rnaseq_lib_path` Setter}
17: \item{rnaSeqLibPath}{path to the directory wanted as `rnaseq_lib_path`}
20: An object of the class UserMetadata with new `rnaseq_lib_path`
24: Set value of the `rnaseq_lib_path` slot
4: \name{setRNASeqLibPath}
5: \alias{setRNASeqLibPath}
6: \alias{setRNASeqLibPath,UserMetadata,character-method}
7: \alias{setRNASeqLibPath,userMetadata,character}
10: setRNASeqLibPath(userObject, rnaSeqLibPath)
12: \S4method{setRNASeqLibPath}{UserMetadata,character}(userObject, rnaSeqLibPath)
29: user <- setRNASeqLibPath(user, getwd())
hipathia:man/get_pathways_annotations.Rd: [ ]
20: path in a single character string.}
3: \name{get_pathways_annotations}
4: \alias{get_pathways_annotations}
5: \title{Get Pathways functional annotations}
7: get_pathways_annotations(pathway_names, metaginfo, dbannot, collapse = FALSE)
10: \item{pathway_names}{Character vector of the names of the pathways}
12: \item{metaginfo}{Pathways object}
23: 2-columns matrix with the annotations of each pathway ID in the
27: Get functional annotation of the pathways, either for a particular
31: pathways <- load_pathways(species = "hsa", pathways_list = c("hsa03320",
33: pathway_names <- c("P-hsa03320-37", "P-hsa03320-61", "P-hsa03320-46",
35: \dontrun{get_pathways_annotations(pathway_names, pathways, "GO")}
36: get_pathways_annotations(pathway_names, pathways, "uniprot")
flowWorkspace:man/gh_pop_get_full_path.Rd: [ ]
3: \name{gh_pop_get_full_path}
4: \alias{gh_pop_get_full_path}
5: \title{convert the partial gating path to the full path}
7: gh_pop_get_full_path(gh, path)
12: \item{path}{the partial gating path}
15: the full gating path
18: convert the partial gating path to the full path
hipathia:man/get_path_names.Rd: [ ]
3: \name{get_path_names}
4: \alias{get_path_names}
5: \title{Tranlates path IDs to path names}
7: get_path_names(metaginfo, names, maxchar = NULL)
36: data(path_vals)
39: translated_names <- get_path_names(pathways, rownames(path_vals))
10: \item{metaginfo}{Pathways object}
25: as "pathway: effector_protein", where "pathway" is the pathway to
30: as "pathway: receptor_protein - effector_protein", where "pathway" is
31: the pathway to which the subpathway belongs, "receptor_protein" is the
37: pathways <- load_pathways(species = "hsa", pathways_list = c("hsa03320",
12: \item{names}{Character vector with the subpathway IDs to be translated}
19: subpathways IDs, in the same order as provided.
22: Translates the subpathway IDs to readable and comprensible names.
24: For effector subpathways, the names of the subpathways are encoded
26: which the subpathway belongs and "effector_protein" is the name of
27: the last node in the subpathway.
29: For decomposed subpathways, the names of the subpathways are encoded
32: name of the initial node of the subpathway and "effector_protein" is
33: the name of the last node in the subpathway.
clipper:man/prunePaths.Rd: [ ]
6:   best scoring path is choosen.}
11:   \item{clust}{filename where path-cluster is saved. NULL means no
3: \title{Summarize the paths obtained by clipper according to their similarity.}
5:   representant of those paths that have more than 1-thr similarity. The
7: \usage{prunePaths(pathSummary, thr=NULL, clust=NULL, sep=";")}
9:   \item{pathSummary}{a matrix resulting from clipper function.}
1: \name{prunePaths}
2: \alias{prunePaths}
27: prunePaths(toyEx, thr=0.1)
RBGL:man/extractPath.Rd: [ ]
3: \title{convert a dijkstra.sp predecessor structure into the path joining two nodes   }
6: determine a path between two nodes in a graph,
31: \value{numeric vector of indices of nodes along shortest path}
1: \name{extractPath}
2: \alias{extractPath}
11: extractPath(s, f, pens)
40: extractPath(1,9,dd$pen)
35: \seealso{  \code{\link[e1071:shortestPaths]{allShortestPaths}}}
idpr:man/meanScaledHydropathy.Rd: [ ]
13: the path to a .fasta or .fa file.}
2: % Please edit documentation in R/scaledHydropathy.R
3: \name{meanScaledHydropathy}
4: \alias{meanScaledHydropathy}
5: \title{Calculate the Mean Scaled Hydropathy}
7: meanScaledHydropathy(sequence, roundScore = NA)
19: A numeric value equal to the Mean Scaled Hydropathy.
22: This function utilizes the scaledHydropathyGlobal() function and
23:   easily returns the averaged hydropathy as a numeric value.
35: #Calculate the mean scaled hydropathy
36:  meanScaledHydropathy(aaString)
37:  meanScaledHydropathy(aaVector)
41:   displaying the hydropathic character of a protein.
47: Other scaled hydropathy functions: 
50: \code{\link{scaledHydropathyGlobal}()},
51: \code{\link{scaledHydropathyLocal}()}
53: \concept{scaled hydropathy functions}
ngsReports:man/path.Rd: [ ]
2: % Please edit documentation in R/path.R
3: \name{path}
4: \alias{path}
5: \alias{path,.FastqcFile-method}
6: \alias{path,FastqcData-method}
7: \alias{path,FastqcDataList-method}
10: \S4method{path}{.FastqcFile}(object)
12: \S4method{path}{FastqcData}(object)
14: \S4method{path}{FastqcDataList}(object)
26: Obtains the file.path for objects of multiple classes
36: path(fdl)
8: \title{Return the File Paths from an object}
20: A character vector of the file paths to the underlying FastQC reports
23: Return the File Paths from an object
PanomiR:man/path_gene_table.Rd: [ ]
4: \name{path_gene_table}
5: \alias{path_gene_table}
16: data(path_gene_table)
22: data(path_gene_table)
6: \title{A table of gene-pathway association. based on the pathways of MSigDB.}
10:   \item{Pathway}{An MSigDB annotated pathway}
11:   \item{ENTREZID}{The ENTREZID of a gene belonging to the pathway}
12:   \item{ENSEMBL}{The ENSEMBL of a gene belonging to the pathway}
19: A table of gene-pathway association. based on the pathways of MSigDB.
CellBench:man/set_cellbench_cache_path.Rd: [ ]
3: \name{set_cellbench_cache_path}
4: \alias{set_cellbench_cache_path}
5: \title{Set CellBench cache path}
7: set_cellbench_cache_path(path = "./.CellBenchCache")
10: \item{path}{the path to where method caches should be stored}
16: Set CellBench cache path
20: # hidden folder in local path
21: set_cellbench_cache_path(".CellBenchCache"))
24: set_cellbench_cache_path(file.path(tempdir(), ".CellBenchCache"))
TrajectoryUtils:man/defineMSTPaths.Rd: [ ]
34: Each vector contains the names of nodes in \code{g} and defines a path through the MST from a root to an endpoint node.
40: When \code{roots} is specified, a path is defined from the root to each endpoint node (i.e., with degree 1) in \code{g}.
43: When \code{times} is specified, a path is defined from each local minima in time to the nearest local maxima within each component of \cod...(5 bytes skipped)...
5: \title{Define paths through the MST}
37: Define paths through the MST, either from pre-specified root nodes or based on external timing information.
60: \code{\link{splitByBranches}}, for a root-free way of obtaining paths.
2: % Please edit documentation in R/defineMSTPaths.R
3: \name{defineMSTPaths}
4: \alias{defineMSTPaths}
7: defineMSTPaths(g, roots, times = NULL, clusters = NULL, use.median = FALSE)
49: defineMSTPaths(test.g, roots="A")
50: defineMSTPaths(test.g, roots="B")
52: defineMSTPaths(test.g, times=c(A=0, B=1, C=2, D=3))
53: defineMSTPaths(test.g, times=c(A=0, B=-1, C=2, D=3))
54: defineMSTPaths(test.g, times=c(A=0, B=5, C=2, D=3))
GraphPAC:man/Find.TSP.Path.Rd: [ ]
1: \name{Find.TSP.Path}
2: \alias{Find.TSP.Path}
5: Find.TSP.Path
11: Find.TSP.Path(PositionList, mutation.matrix, insertion.type = "cheapest_insertion",
26: 	The TSP package starts the path at a random amino acid. Such that the results are easily reproducible, the default starts the path on the first amino acid in the protein.
33: \item{candidate.path}{A numeric vector of the sequence found through the protein.}
34: \item{candidate.path.distance}{The distance traveled along the candidate path.}
36: \item{linear.path.distance}{The distance traveled if one were to visit the amino acids in the original sequence (1 ->...(18 bytes skipped)...
52: #Save all the results to path.results
53: path.results <- Find.TSP.Path(KRAS.Positions$Positions, KRAS.Mutations)
loci2path:man/loci2pathResult-class.Rd: [ ]
45:   loci=eset.list, path=biocarta)
4: \name{loci2pathResult-class}
5: \alias{loci2pathResult-class}
6: \alias{loci2pathResult}
9: \alias{resultTable,loci2pathResult-method}
10: \alias{coveredGene,loci2pathResult-method}
11: \title{loci2pathResult Class}
17: \S4method{resultTable}{loci2pathResult}(x)
19: \S4method{coveredGene}{loci2pathResult}(x)
25: Object of CLass loci2pathResult
28: loci2pathResult Class contains information for the query result from 
30: pathway table, and a vector of gene names that are associated with loci 
37: summary of eQTL and gene numbers, pathway names and gene names, etc.}
47: resultTable(result) # a data.frame for enriched pathways
mdp:man/pathway_summary.Rd: [ ]
8: pathway_summary(sample_results, path, file_name, control_samples,
14: \item{path}{directory to save images}
3: \name{pathway_summary}
4: \alias{pathway_summary}
5: \title{print pathways
6: generates a summary plot for pathways and sample score plot of best gene set}
24: for each pathway
27: print pathways
28: generates a summary plot for pathways and sample score plot of best gene set
TrajectoryGeometry:man/getDistanceDataForPaths.Rd: [ ]
20: for the appropriate center for each path.  Each path
27:     generateRandomPaths(path=straight_path,randomizationParam='bySteps',N=5)
5: \title{Produce distance statistics for random paths}
7: getDistanceDataForPaths(paths, statistic)
10: \item{paths}{- A list of paths.  Each of these is an n x d matrix.}
18: This function takes a list of paths and a choice of
22: will be the randomized paths.  It is therefore assumed
26: paths =
28: distance = getDistanceDataForPaths(paths=paths,statistic='max')
3: \name{getDistanceDataForPaths}
4: \alias{getDistanceDataForPaths}
netboost:man/netboostPackagePath.Rd: [ ]
5: \title{Returns the absolute path to "exec" folder in the package.}
10: Absolute path of installed package
13: Returns the absolute path to "exec" folder in the package.
3: \name{netboostPackagePath}
4: \alias{netboostPackagePath}
7: netboostPackagePath()
RCy3:man/getCurrentSandboxPath.Rd: [ ]
10: current sandbox path
13: Return the current sandbox path.
3: \name{getCurrentSandboxPath}
4: \alias{getCurrentSandboxPath}
5: \title{getCurrentSandboxPath}
7: getCurrentSandboxPath()
17: getCurrentSandboxPath()
gep2pep:man/gene2pathways.Rd: [ ]
30: repo_path <- file.path(tempdir(), "gep2pepTemp")
32: rp <- createRepository(repo_path, db)
39: unlink(repo_path, TRUE)
3: \name{gene2pathways}
4: \alias{gene2pathways}
5: \title{Finds pathways including a given gene.}
7: gene2pathways(rp, genes, and = TRUE)
20: A database of pathways suitable as input to
21:     \code{\link{PathSEA}}.
24: Given a gene, find the set of pathways that involve it in each
26: pathways for the \code{\link{PathSEA}}.
34: ## Finding all pathways containing "FAM126A":
35: subpw <- gene2pathways(rp, "FAM126A")
43: createRepository, PathSEA
rsemmed:man/plot_path.Rd: [ ]
3: \name{plot_path}
4: \alias{plot_path}
5: \title{Display path (plot form)}
7: plot_path(graph, path)
12: \item{path}{A vertex sequence (\code{igraph.vs}) (the path to display)}
18: Plot the graph form of a path
21: All connections among nodes along the supplied path are plotted with 
30: plot_path(g_mini, paths[[1]][[1]])
34: \code{\link{text_path}} for textual display of paths
29: paths <- find_paths(g_mini, from = node_cortisol, to = node_stress)
RCy3:man/getAbsSandboxPath.Rd: [ ]
16: Get absolute sandbox path.
3: \name{getAbsSandboxPath}
4: \alias{getAbsSandboxPath}
5: \title{getAbsSandboxPath}
7: getAbsSandboxPath(fileLocation)
20: getAbsSandboxPath()
CONFESS:man/updateCentroidsPaths.Rd: [ ]
7: updateCentroidsPaths(data, estimates, path.type)
15: \item{path.type}{Character vector. A user-defined vector that characterizes the cell progression dynamics.
16: The first element can be either "circular" or "A2Z" or "other". If "circular" the path progression is
17: assummed to exhibit a circle-like behavior. If "A2Z" the path is assumed to have a well-defined start
22: A list of adjusted fluorescence signals and the updated path after the change-point analysis
25: It updates the path sorted clusters after re-estimation by change-point analysis.
3: \name{updateCentroidsPaths}
4: \alias{updateCentroidsPaths}
5: \title{updateCentroidsPaths}
basilisk:man/obtainEnvironmentPath.Rd: [ ]
5: \title{Obtain the environment path}
11: Alternatively a string containing a path to an existing environment.}
14: String containing the path to an instantiated Conda environment.
20: Obtain a path to a Conda environment, lazily installing it if necessary.
25: tmploc <- file.path(tempdir(), "my_package_A")
2: % Please edit documentation in R/obtainEnvironmentPath.R
3: \name{obtainEnvironmentPath}
4: \alias{obtainEnvironmentPath}
7: obtainEnvironmentPath(env)
29: obtainEnvironmentPath(tmploc)
33: \dontrun{obtainEnvironmentPath(env)}
RCy3:man/getDefaultSandboxPath.Rd: [ ]
10: default sandbox path
13: Return the default path, which isn't one of the properties tracked in the default_sandbox.
3: \name{getDefaultSandboxPath}
4: \alias{getDefaultSandboxPath}
5: \title{getDefaultSandboxPath}
7: getDefaultSandboxPath()
17: getDefaultSandboxPath()
netboost:man/netboostMCUPGMAPath.Rd: [ ]
5: \title{Returns the absolute path to folder with mcupgma executables and scripts.}
10: Absolute path for "mcupgma" folder
13: Returns the absolute path to folder with mcupgma executables and scripts.
3: \name{netboostMCUPGMAPath}
4: \alias{netboostMCUPGMAPath}
7: netboostMCUPGMAPath()
surfaltr:man/tmhmm_fix_path.Rd: [ ]
2: % Please edit documentation in R/tmhmm_fix_path.R
3: \name{tmhmm_fix_path}
4: \alias{tmhmm_fix_path}
7: tmhmm_fix_path(fasta_filename, folder_name)
13: \item{folder_name}{Path to folder containing installed tmhmm software}
22: In order to set a standard path that allows tmhmm to run, the path
RCy3:man/setDefaultSandboxPath.Rd: [ ]
10: \item{newPath}{new path of default sandbox}
13: default sandbox path
16: Set and return the default path, which isn't one of the properties tracked in the default_sandbox.
3: \name{setDefaultSandboxPath}
4: \alias{setDefaultSandboxPath}
5: \title{setDefaultSandboxPath}
7: setDefaultSandboxPath(newPath)
20: setDefaultSandboxPath()
SBGNview:man/findPathways.Rd: [ ]
24: \item{SBGNview.data.folder}{A character string. Default: "./SBGNview.tmp.data". The path to a folder that will hold downloaded ID mapping files and pathway information data files.}
5: \title{Retrieve pathways by keywords}
10:   keyword.type = "pathway.name",
18: ...(122 bytes skipped)...equire 'all' or 'any' of the keywords to be present. It only makes difference when keyword.type is 'pathway.name'.}
20: \item{keyword.type}{A character string. Either 'pathway.name' (default) or one of the ID types in \code{data('mapped.ids')}}
27: A dataframe. Contains information of pathways found.
30: This function searches for pathways by input keywords.
33: If 'keyword.type' is 'pathway.name' (default), this function will search for the presence of any keyword in the pathway.name column of data(path...(66 bytes skipped)...one of the identifier types and 'keywords' are corresponding identifiers, this function will return pathways that include nodes mapped to input identifiers.
36: data(pathways.info)
37: input.pathways <- findPathways('Adrenaline and noradrenaline biosynthesis')
3: \name{findPathways}
4: \alias{findPathways}
7: findPathways(
hipathia:man/get_paths_data.Rd: [ ]
26: readable names, use \code{get_path_names}.
31: defines its own effector subpathway as the nodes and edges in a path leading
42: path_vals <- get_paths_data(results)
3: \name{get_paths_data}
4: \alias{get_paths_data}
7: get_paths_data(results, matrix = FALSE)
28: Effector subpathways are subgraphs of a pathway including all the paths
30: nodes in the graph. Each effector protein (final node) in a pathway
34: Decomposed subpathways are subgraphs of a pathway including all the paths
5: \title{Gets the object of subpathway activation values}
10: \item{results}{Results object as returned by \code{hipathia}.}
17: of activation of each decomposed subpathway for each sample.
21: subpathway for each sample. Rows represent the subpathways and columns
22: represent the samples. Each cell is the value of activation of a subpathway
25: Rownames are the IDs of the subpathways. In order to transform IDs into
37: as final nodes in the graph. Each effector subpathway can be decomposed
38: in as many decomposed subpathways as initial nodes it includes.
OmnipathR:man/omnipath_get_config_path.Rd: [ ]
3: \name{omnipath_get_config_path}
4: \alias{omnipath_get_config_path}
5: \title{Current config file path}
7: omnipath_get_config_path(user = FALSE)
14: Character: path to the config file.
17: Current config file path
20: omnipath_get_config_path()
OmnipathR:man/omnipath_logfile.Rd: [ ]
5: \title{Path to the current OmnipathR log file}
10: Character: path to the current logfile, or \code{NULL} if no
14: Path to the current OmnipathR log file
3: \name{omnipath_logfile}
4: \alias{omnipath_logfile}
7: omnipath_logfile()
17: omnipath_logfile()
22: \code{\link{omnipath_log}}
18: # [1] "/home/denes/omnipathr/omnipathr-log/omnipathr-20210309-1642.log"
hipathia:man/load_pathways.Rd: [ ]
24: * \code{path_norm} Vector of normalization values for decomposed
3: \name{load_pathways}
4: \alias{load_pathways}
5: \title{Loads the pathways object.}
7: load_pathways(species, pathways_list = NULL)
12: \item{pathways_list}{Vector of the IDs of the pathways to load. By default
13: all available pathways are load.}
16: An pathways object including
17: * \code{species} Species to which the pathways are related.
18: * \code{pathigraphs} List of Pathigraph objects. Each Pathigraph contains
19: the necessary information of a pathway for it to be analyzed
22: pathways stored in \code{pathigraphs}.
28: Loads the pathways object, which includes information about the pathways
32: The object of pathways includes information about the pathways and the
35: package. These functions will analyze all the pathways included in this
36: object. By default, all available pathways are load. In order to restrict
37: the analysis to a predefined set of pathways, specify the set of pathways
38: to load with the parameter \code{pathways_list}.
41: \dontrun{pathways <- load_pathways("hsa")   # Loads all pathways for human}
42: pathways <- load_pathways("mmu", c("mmu03320", "mmu04024", "mmu05200"))
43:    # Loads pathways 03320, 04024 and 05200 for mouse
20: with \code{Hipathia}.
23: * \code{eff_norm} Vector of normalization values for effector subpathways.
25: subpathways.
33: subpathways which will be analyzed. This object must be provided to some
34: of the functions (like \code{hipathia} or \code{quantify_terms}) in the
netboost:man/netboostTmpPath.Rd: [ ]
5: \title{Returns the absolute path to temporary folder of the package.
6: To change temporary path, use normal R variables (TEMPDIR etc).}
11: Absolute path for "exec" folder
14: Returns the absolute path to temporary folder of the package.
15: To change temporary path, use normal R variables (TEMPDIR etc).
3: \name{netboostTmpPath}
4: \alias{netboostTmpPath}
8: netboostTmpPath()
TrajectoryGeometry:man/projectPathToSphere.Rd: [ ]
5: \title{Project a path onto the unit sphere}
7: projectPathToSphere(path, from = 1, to = nrow(path), d = ncol(path))
10: \item{path}{- This is an mxn dimensional matrix. Each row is
13: \item{from}{- The starting place along the path which will be
16: \item{to}{- The end point of the path.  This defaults to
17: nrow(path).}
20: ncol(path)}
23: This returns a projection of the path onto the d-1 sphere
27: This function takes a path in d dimensional space and projects it onto
32: projection1 = projectPathToSphere(straight_path)
33: projection2 = projectPathToSphere(crooked_path,from=6)
3: \name{projectPathToSphere}
4: \alias{projectPathToSphere}
idpr:man/scaledHydropathyGlobal.Rd: [ ]
13: the path to a .fasta or .fa file.}
57: ##The path to the file as a character string
2: % Please edit documentation in R/scaledHydropathy.R
3: \name{scaledHydropathyGlobal}
4: \alias{scaledHydropathyGlobal}
5: \title{Protein Scaled Hydropathy Calculations}
7: scaledHydropathyGlobal(sequence, plotResults = FALSE, proteinName = NA, ...)
29:   Score for each residue shown in the column "Hydropathy".
32: This is used to calculate the scaled hydropathy of an amino acid
59: exampleDF <- scaledHydropathyGlobal(aaString,
63: exampleDF <- scaledHydropathyGlobal(aaVector,
68:   scaledHydropathyGlobal(aaString,
72:   gg <- scaledHydropathyGlobal(aaVector,
74:   gg <- gg + ggplot2::ylab("Local Hydropathy")
77:                                              y = Hydropathy + 0.1))
82:   displaying the hydropathic character of a protein.
88: Other scaled hydropathy functions: 
91: \code{\link{meanScaledHydropathy}()},
92: \code{\link{scaledHydropathyLocal}()}
94: \concept{scaled hydropathy functions}
MetaPhOR:man/CytoPath.Rd: [ ]
18: \item{DEGpath}{character, the path to a DEG file by DESeq2 or limma}
20: \item{figpath}{character, the path to which the figure will be saved}
37:         figpath = file.path(tempdir(), "example_map"),
2: % Please edit documentation in R/cytoPath.R
3: \name{cytoPath}
4: \alias{cytoPath}
5: \title{Map Differentially Expressed Genes to Dysregulated Pathways}
7: cytoPath(
8:     pathway,
9:     DEGpath,
10:     figpath,
16: \item{pathway}{character, the name of the pathway to be visualized}
28: cytoPath() Returns a Cytoscape figure of DEG data on rWikiPathways
35: cytoPath(pathway = "Tryptophan Metabolism",
36:         DEGpath = system.file("extdata/BRCA_DEGS.csv", package = "MetaPhOR"),
hipathia:man/paths_to_go_ancestor.Rd: [ ]
5: \title{Create path results table with highest significant GO ancestors}
31: the path is related (not necessarily unique), the Wilcoxon comparison
38: path from this GO term to the term "GO:0008150". The ancestors of a node
39: are defined as all the nodes from which a path can be defined from the
46: data(path_vals)
47: sample_group <- brca_design[colnames(path_vals),"group"]
3: \name{paths_to_go_ancestor}
4: \alias{paths_to_go_ancestor}
7: paths_to_go_ancestor(pathways, comp_paths, comp_go, pval = 0.05)
10: \item{pathways}{Pathways object}
12: \item{comp_paths}{Wilcoxon comparison of the matrix of pathways values
24: Create table of results with the comparison of the paths together with
29: The table returns in each row: the name of a pathway and its Wilcoxon
49: \dontrun{pathways <- load_pathways(species = "hsa", pathways_list =
51: table <- paths_to_go_ancestor(pathways, comp, comp_go)}
HiCBricks:man/BrickContainer_get_path_to_file.Rd: [ ]
3: \name{BrickContainer_get_path_to_file}
4: \alias{BrickContainer_get_path_to_file}
5: \title{Get the path to HDF files present in the Brick container.}
7: BrickContainer_get_path_to_file(
17: A string specifying the path to the Brick store created
40: \code{BrickContainer_get_path_to_file} fetches the list of HDF file paths
45: Bintable.path <- system.file("extdata",
48: out_dir <- file.path(tempdir(), "BrickContainer_list_filepath_test")
51: My_BrickContainer <- Create_many_Bricks(BinTable = Bintable.path, 
56: BrickContainer_get_path_to_file(Brick = My_BrickContainer, chr1 = "chr2L",
29: cis will list intra-choromosomal file paths and trans will list
30: inter-chromosomal file paths.}
37: A vector containing filepaths
GMRP:man/pathdiagram.Rd: [ ]
4: Path Diagram
14: ...(5 bytes skipped)...ect that is dataset consisting of correlation matrix of risk factors and a numeric vector of direct path coefficients.
20: a numeric parameter, is R-square obtained from path analysis.
27: The \emph{pathdata} contains correlation matrix of risk factors and a numeric vector of direct path coefficients obtained from path...(7 bytes skipped)...is of beta data of \code{SNP}s on risk factors and disease. Columns must have risk factor names and path.
30: NULL. pathdiagram will create one-level path diagram labeled with colors.
48: colnames(mypath)<-c("ldl","hdl","tg","path")
51: #        ldl       hdl        tg      path
60: \keyword{path }
1: \name{pathdiagram}
2: \alias{pathdiagram}
10: pathdiagram(pathdata, disease, R2, range)
13:   \item{pathdata}{
39:     \code{\link{pathdiagram2}}, \code{\link[diagram]{plotmat}}, \code{\link[diagram]{plotweb}}
44: mypath<-matrix(NA,3,4)
45: mypath[1,]<-c(1.000000,-0.066678, 0.420036,0.764638)
46: mypath[2,]<-c(-0.066678,1.000000,-0.559718,0.496831)
47: mypath[3,]<-c(0.420036,-0.559718,1.000000,0.414346)
50: #mypath
56: mypath<-as.data.frame(mypath)
57: pathdiagram(pathdata=mypath,disease="cad",R2=0.988243,range=c(1:3))
KEGGlincs:man/path_genes_by_cell_type.Rd: [ ]
2: % Please edit documentation in R/path_genes_by_cell_type.R
3: \name{path_genes_by_cell_type}
4: \alias{path_genes_by_cell_type}
7: path_genes_by_cell_type(KEGG_mappings, pert_time = 96, get_KOs = FALSE,
32: path_genes_by_cell_type(p53_KEGG_mappings)
5: \title{See how many pathway gene knock-outs are available from data}
21: A plot depicting percentage of pathway genes knocked-out by 
26:  corresponding to the pathway of interest
CytoML:man/matchPath.Rd: [ ]
5: \title{Given the leaf node, try to find out if a collection of nodes can be matched to a path in a graph(tree) by the bottom-up searching}
17: TRUE if path is found, FALSE if not path is matched.
20: Given the leaf node, try to find out if a collection of nodes can be matched to a path in a graph(tree) by the bottom-up searching
3: \name{matchPath}
4: \alias{matchPath}
7: matchPath(g, leaf, nodeSet)
famat:man/path_enrich.Rd: [ ]
1: \name{path_enrich}
2: \alias{path_enrich}
10:     path_enrich(source, metabo, genes)
63:     listr=path_enrich("REAC", meta, genes)
3: \title{Pathway enrichment analysis}
5:     Perform a pathway enrichment analysis using a list of genes and a list of
6:     metabolites. Pathways enrichment analysis is performed using MPINet for
15:         Pathways database used, either Kegg ("KEGG"), Reactome ("REAC") or
35:     \item{resmeta}{Results of metabolites pathway enrichment analysis}
36:     \item{resgene}{Results of genes pathway enrichment analysis}
43:     the network-based metabolite pathway identification of pathways.. R package
62:     ## perform pathway enrichment analysis on Reactome pathways
16:         Wikipathays ("WP")
TrajectoryGeometry:man/pathProgression.Rd: [ ]
5: \title{Measure a path's progression}
7: pathProgression(path, from = 1, to = nrow(path), d = ncol(path), direction)
10: \item{path}{- An n x d matrix}
12: \item{from}{- The point along the path to be taken as the starting
15: \item{to}{- The point along the path to be used as the end point.
16: This defaults to nrow(path).}
18: \item{d}{- The dimension to be used.  This defaults to ncol(path).}
25:     of the path along the line through its starting point in the
29: This function measures the progress of a path in a specified
36:     pathProgression(straight_path,direction=straight_path_center)
38:     pathProgression(crooked_path,from=6,direction=crooked_path_center)
3: \name{pathProgression}
4: \alias{pathProgression}
ShortRead:man/ExperimentPath-class.Rd: [ ]
38:   specified path to the corresponding directory (described above).
1: \name{ExperimentPath-class}
3: \alias{ExperimentPath-class}
5: \alias{ExperimentPath}
7: \alias{show,ExperimentPath-method}
8: \alias{detail,ExperimentPath-method}
10: \title{(Legacy) "ExperimentPath" class representing a file hierarchy of data
18:   \code{\linkS4class{SolexaPath}}) represent different technologies.
25:   \code{ExperimentPath(experimentPath)}
28:     \item{experimentPath}{\code{character(1)} object pointing to the
32:       \code{TRUE} results in warnings if paths do not exist.}
34:   All paths must be fully-specified.
37:   \code{ExperimentPath} has one slot, containing a fully
40:     \item{\code{basePath}}{See above.}
42:   The slot is accessed with \code{experimentPath}.
51:     \item{show}{\code{signature(object = "ExperimentPath")}: briefly
52:       summarize the file paths of \code{object}.}
54:     \item{detail}{\code{signature(x = "ExperimentPath")}: summarize
55:       file paths of \code{x}.}
61: showClass("ExperimentPath")
CausalR:man/DetermineInteractionTypeOfPath.Rd: [ ]
5: \title{determine interaction type of path}
12: \item{nodesInPath}{an ordered list of the nodes visited on the path - note that these contain numbers which use 
19: Determines the sign of a given path.
20: Given a path and through the network, this function will determine if the path results in activation or inhibition.
2: % Please edit documentation in R/DetermineInteractionTypeOfPath.r
3: \name{DetermineInteractionTypeOfPath}
4: \alias{DetermineInteractionTypeOfPath}
7: DetermineInteractionTypeOfPath(network, nodesInPath)
16: a signed integer representing the paths sign
AnnotationForge:inst/AnnDbPkg-templates/ARABIDOPSIS.DB/man/PATH.Rd: [ ]
1: \name{@ANNOBJPREFIX@PATH}
2: \alias{@ANNOBJPREFIX@PATH}
6:   for various organisms. @ANNOBJPREFIX@PATH maps TAIR identifiers to the
40: x <- @ANNOBJPREFIX@PATH
46:   # Get the PATH for the first five genes
3: \title{Mappings between TAIR identifiers and KEGG pathway identifiers}
5:   KEGG (Kyoto Encyclopedia of Genes and Genomes) maintains pathway data
7:   identifiers used by KEGG for pathways in which the genes represented
11:   Each KEGG pathway has a name and identifier. Pathway name for a given pathway
16:   Graphic presentations of pathways are searchable at
17:   url http://www.genome.ad.jp/kegg/pathway.html by using pathway identifiers as
20:   Mappings were based on data provided by: @PATHSOURCE@
41: # Get the TAIR identifiers that are mapped to a KEGG pathway ID
AnnotationForge:inst/AnnDbPkg-templates/ARABIDOPSISCHIP.DB/man/PATH.Rd: [ ]
1: \name{@ANNOBJPREFIX@PATH}
2: \alias{@ANNOBJPREFIX@PATH}
6:   for various organisms. @ANNOBJPREFIX@PATH maps probe identifiers to the
40: x <- @ANNOBJPREFIX@PATH
46:   # Get the PATH for the first five probes
3: \title{Mappings between probe identifiers and KEGG pathway identifiers}
5:   KEGG (Kyoto Encyclopedia of Genes and Genomes) maintains pathway data
7:   identifiers used by KEGG for pathways in which the genes represented
11:   Each KEGG pathway has a name and identifier. Pathway name for a given pathway
16:   Graphic presentations of pathways are searchable at
17:   url http://www.genome.ad.jp/kegg/pathway.html by using pathway identifiers as
20:   Mappings were based on data provided by: @PATHSOURCE@
41: # Get the probe identifiers that are mapped to a KEGG pathway ID
StarBioTrek:man/listpathnet.Rd: [ ]
2: % Please edit documentation in R/path_star.R
5: \title{Get human KEGG pathway data and the output of list_path_net  define the common genes.}
10: \item{lista_net}{output of path_net}
22: list_path<-listpathnet(lista_net=lista_network,pathway=pathway[1:5])
7: listpathnet(lista_net, pathway_exp)
12: \item{pathway_exp}{pathway data as provided by getKEGGdata}
15: a list of genes for each pathway (interacting genes belong to that pathway)
18: listpathnet creates a list of interacting genes for each human pathway.
21: lista_network<-pathnet(genes.by.pathway=pathway[1:5],data=netw)
3: \name{listpathnet}
4: \alias{listpathnet}
AnnotationForge:inst/AnnDbPkg-templates/YEASTCHIP.DB/man/PATH.Rd: [ ]
1: \name{@ANNOBJPREFIX@PATH}
2: \alias{@ANNOBJPREFIX@PATH}
6:   for various organisms. @ANNOBJPREFIX@PATH maps probe identifiers to the
41: x <- @ANNOBJPREFIX@PATH
47:   # Get the PATH for the first five probes
3: \title{Mappings between probe identifiers and KEGG pathway identifiers}
5:   KEGG (Kyoto Encyclopedia of Genes and Genomes) maintains pathway data
7:   identifiers used by KEGG for pathways in which the genes represented
11:   Each KEGG pathway has a name and identifier. Pathway name for a given pathway
16:   Graphic presentations of pathways are searchable at
17:   url http://www.genome.ad.jp/kegg/pathway.html by using pathway identifiers as
20:   Mappings were based on data provided by: @PATHSOURCE@
42: # Get the probe identifiers that are mapped to a KEGG pathway ID
AnnotationForge:inst/AnnDbPkg-templates/MALARIA.DB/man/PATH.Rd: [ ]
1: \name{@ANNOBJPREFIX@PATH}
2: \alias{@ANNOBJPREFIX@PATH}
3: \alias{@ANNOBJPREFIX@PATH2ORF}
7:   for various organisms. @ANNOBJPREFIX@PATH maps ORF identifiers to the
27:     x <- @ANNOBJPREFIX@PATH
33:       # Get the PATH for the first five genes
41:     xx <- as.list(@ANNOBJPREFIX@PATH2ORF)
4: \title{Mappings between ORF identifiers and KEGG pathway identifiers}
6:   KEGG (Kyoto Encyclopedia of Genes and Genomes) maintains pathway data
8:   identifiers used by KEGG for pathways
11:   Each KEGG pathway has a name and identifier. Pathway name for a given pathway
16:   Graphic presentations of pathways are searchable at
17:   url http://www.genome.ad.jp/kegg/pathway.html by using pathway identifiers as
20:   Mappings were based on data provided by: @PATHSOURCE@
28:     # Get the ORF identifiers that are mapped to a KEGG pathway ID
42:     # Remove pathway identifiers that do not map to any ORF id
ROntoTools:man/keggPathwayGraphs.Rd: [ ]
43: kpg[["path:hsa04110"]]
44: head(nodes(kpg[["path:hsa04110"]]))
45: head(edges(kpg[["path:hsa04110"]]))
5: \title{Download and parse KEGG pathway data}
16: \item{relPercThresh}{percentage of the number of relation types over all possible realtions in the pathway}
25: A list of \code{\link{graphNEL}} objects encoding the pathway information.
28: Download and parse KEGG pathway data
32: # The pathway cache provided as part of the pathway contains only the 
33: # pathways that passed the default filtering. We recommend, re-downloading
34: # the pathways using the updateCache parameter
37: # to update the pathway cache for human run:
3: \name{keggPathwayGraphs}
4: \alias{keggPathwayGraphs}
7: keggPathwayGraphs(organism = "hsa", targRelTypes = c("GErel", "PCrel",
35: kpg <- keggPathwayGraphs("hsa")
38: # kpg <- keggPathwayGraphs("hsa", updateCache = TRUE)
52: \code{\link{keggPathwayNames}}
NetPathMiner:man/extractPathNetwork.Rd: [ ]
5: \title{Creates a subnetwork from a ranked path list}
19: Creates a subnetwork from a ranked path list generated by \code{\link{pathRanker}}.
35:  ranked.p <- pathRanker(rgraph, method="prob.shortest.path",
46: Other Path ranking methods: \code{\link{getPathsAsEIDs}},
52: \concept{Path ranking methods}
2: % Please edit documentation in R/pathRank.R
7: extractPathNetwork(paths, graph)
10: \item{paths}{The paths extracted by \code{\link{pathRanker}}.}
15: A subnetwork from all paths provided. If paths are computed for several
34: 	## Get ranked paths using probabilistic shortest paths.
38: 	## Get the subnetwork of paths in reaction graph.
41: 	## Get the subnetwork of paths in the original metabolic graph.
47:   \code{\link{pathRanker}}, \code{\link{samplePaths}}
3: \name{extractPathNetwork}
4: \alias{extractPathNetwork}
36: 					K=20, minPathSize=6)
39: 	reaction.sub <- getPathsAsEIDs(ranked.p, rgraph)
42: 	metabolic.sub <- getPathsAsEIDs(ranked.p, ex_sbml)
EventPointer:man/CDFfromGTF_Multipath.Rd: [ ]
23: \item{PSR}{Path to the Exon probes txt file}
25: \item{Junc}{Path to the Junction probes txt file}
2: % Please edit documentation in R/CDFfromGTF_Multipath.R
3: \name{CDFfromGTF_Multipath}
4: \alias{CDFfromGTF_Multipath}
5: \title{CDF file creation for EventPointer (MultiPath)}
7: CDFfromGTF_Multipath(
12:   PathCDF,
14:   paths = 2
27: \item{PathCDF}{Directory where the output will be saved}
32: \item{paths}{Maximum number of paths of the events to find.}
48:    PathFiles<-system.file('extdata',package='EventPointer')
49:    DONSON_GTF<-paste(PathFiles,'/DONSON.gtf',sep='')
50:    PSRProbes<-paste(PathFiles,'/PSR_Probes.txt',sep='')
51:    JunctionProbes<-paste(PathFiles,'/Junction_Probes.txt',sep='')
57:    CDFfromGTF_Multipath(input='AffyGTF',inputFile=DONSON_GTF,PSR=PSRProbes,Junc=JunctionProbes,
58:                         PathCDF=Directory,microarray=microarray,paths=3)
PathoStat:man/runPathoStat.Rd: [ ]
14: \item{report_dir}{Output report directory path}
2: % Please edit documentation in R/pathoStat.R
5: \title{Statistical Microbiome Analysis on the pathostat input and generates a
12: \item{pstat}{phyloseq extension pathostat object}
25: Statistical Microbiome Analysis on the pathostat input and generates a
3: \name{runPathoStat}
4: \alias{runPathoStat}
8: runPathoStat(pstat = NULL, report_dir = ".",
29: runPathoStat(interactive = FALSE)
Path2PPI:man/Path2PPI.Rd: [ ]
1: \name{Path2PPI-class}
4: \alias{Path2PPI-class}
5: \alias{Path2PPI}
6: \alias{addReference,Path2PPI-method}
7: \alias{getHybridNetwork,Path2PPI-method}
8: \alias{getPPI,Path2PPI-method}
9: \alias{initialize,Path2PPI-method}
10: \alias{plot.Path2PPI,Path2PPI-method}
11: \alias{predictPPI,Path2PPI-method}
12: \alias{removeReference,Path2PPI-method}
13: \alias{show,Path2PPI-method}
14: \alias{showInteraction,Path2PPI-method}
15: \alias{showReferences,Path2PPI-method}
18: \title{Class \code{"Path2PPI"}}
20: An instance of the class \code{Path2PPI} is the major object in the Path2PPI 
25: Path2PPI(...)
51:     \item{\code{\link{addReference}}}{\code{signature(path2ppi = "Path2PPI")} }
53:     \code{signature(path2ppi = "Path2PPI")} }
54:     \item{\code{\link{getPPI}}}{\code{signature(path2ppi = "Path2PPI")} }
55:     \item{\code{\link{initialize}}}{\code{signature(.Object = "Path2PPI")} }
56:     \item{\code{\link{plot.Path2PPI}}}{\code{signature(x = "Path2PPI")} }
57:     \item{\code{\link{predictPPI}}}{\code{signature(path2ppi = "Path2PPI")} }
59:     \code{signature(path2ppi = "Path2PPI")} }
60:     \item{\code{\link{show}}}{\code{signature(object = "Path2PPI")} }
62:     \code{signature(path2ppi = "Path2PPI")} }
64:     \code{signature(path2ppi = "Path2PPI")} }
70: An instance of the class \code{Path2PPI}.
75: Arguments to \code{Path2PPI()} and the \code{\link{new}} method are obligatory 
92: ppi <- Path2PPI("Autophagy induction", "Podospora anserina", "5145")
35:     \item{\code{pathway}:}{Object of class \code{"character"} }
78:   \strong{pathway} \tab A character string with the name of the pathway which 
NetPathMiner:man/getPathsAsEIDs.Rd: [ ]
5: \title{Convert a ranked path list to edge ids of a graph}
18: Convert a ranked path list to Edge ids of a graph, where paths can come from
19: a different representation (for example matching path from a reaction network to
36:  ranked.p <- pathRanker(rgraph, method="prob.shortest.path",
40: 	path.eids <- getPathsAsEIDs(ranked.p, rgraph)
43: 	path.eids <- getPathsAsEIDs(ranked.p, ex_sbml)
47: Other Path ranking methods: \code{\link{extractPathNetwork}},
53: \concept{Path ranking methods}
2: % Please edit documentation in R/pathRank.R
7: getPathsAsEIDs(paths, graph)
10: \item{paths}{The paths extracted by \code{\link{pathRanker}}.}
35: 	## Get ranked paths using probabilistic shortest paths.
39: 	## Get the edge ids along paths in the reaction graph.
42: 	## Get the edge ids along paths in the original metabolic graph.
48:   \code{\link{pathRanker}}, \code{\link{samplePaths}}
3: \name{getPathsAsEIDs}
4: \alias{getPathsAsEIDs}
37: 					K=20, minPathSize=6)
StarBioTrek:man/pathnet.Rd: [ ]
2: % Please edit documentation in R/path_star.R
3: \name{pathnet}
4: \alias{pathnet}
5: \title{Get human KEGG pathway data and creates a network data.}
7: pathnet(genes.by.pathway, data)
10: \item{genes.by.pathway}{a list of pathway data as provided by ConvertedIDgenes}
15: a list of network data for each pathway (interacting genes belong to that pathway)
18: pathnet creates a list of network data for each human pathway. The network data will be generated when interacting genes belong to that pathway.
21: lista_net<-pathnet(genes.by.pathway=pathway[1:5],data=netw)
qpgraph:man/qpPathWeight.Rd: [ ]
7: Calculation of path weights
10: Calculates the path weight for a path of an undirected graph.
13: \S4method{qpPathWeight}{matrix}(X, path, Q=integer(0), M=integer(0),
18:   \item{path}{character vector of consecutive vertex names defining a path in an
24:   \item{normalized}{logical; TRUE (default) when the calculated path weight should be
31: Calculation of path weights. This implementation is still under development and will give only correct results with eit...(155 bytes skipped)...
35: The calculated path weight for the given path.
25:         normalized so that weights are comparable between paths with different endpoints,
1: \name{qpPathWeight}
2: \alias{qpPathWeight}
3: \alias{qpPathWeight,matrix-method}
4: \alias{qpPathWeight,dspMatrix-method}
67: npc <- sapply(1:nrow(edg), function(i) qpPathWeight(S, edg[i, ]))
NoRCE:man/pathwayEnrichment.Rd: [ ]
23: \item{gmtFile}{File path of the gmt file}
2: % Please edit documentation in R/pathway.R
3: \name{pathwayEnrichment}
4: \alias{pathwayEnrichment}
5: \title{For a given gmt file of a specific pathway database, pathway enrichment
8: pathwayEnrichment(
49: Pathway Enrichment
52: For a given gmt file of a specific pathway database, pathway enrichment
animalcules:man/read_pathoscope_data.Rd: [ ]
12:   input.files.path.vec = NULL,
24: \item{input.files.path.vec}{vector of pathoscope file paths}
2: % Please edit documentation in R/read_pathoscope_data.R
3: \name{read_pathoscope_data}
4: \alias{read_pathoscope_data}
5: \title{Reads the data from PathoScope reports and returns a list of
8: read_pathoscope_data(
10:   pathoreport_file_suffix = "-sam-report.tsv",
17: \item{input_dir}{Directory where the tsv files from PathoScope are located}
19: \item{pathoreport_file_suffix}{PathoScope report files suffix}
21: \item{use.input.files}{whether input dir to pathoscope files
22: or directly pathoscope files}
26: \item{input.files.name.vec}{vector of pathoscope file names}
32: Reads the data from PathoScope reports and returns a list of
TrajectoryGeometry:man/pathToSphericalData.Rd: [ ]
5: \title{Find the spherical data for a given path}
7: pathToSphericalData(path, from, to, d, statistic)
10: \item{path}{- This is an mxn dimensional matrix. Each row is
13: \item{from}{- The starting place along the path which will be
16: \item{to}{- The end point of the path.  This defaults to
17: nrow(path).}
20: ncol(path)}
26:     projections of the path to the sphere, the center for those
31: This function takes a path and returns a list containing
37: sphericalData = pathToSphericalData(straight_path,from=1,
38:                                     to=nrow(straight_path), d=3,
3: \name{pathToSphericalData}
4: \alias{pathToSphericalData}
rhdf5client:man/setPath.Rd: [ ]
7: \title{set path for hsds server resource}
14: \item{folderPath}{character string with path to user's folder on hsds server}
4: \name{setPath}
5: \alias{setPath}
6: \alias{setPath,H5S_source,character-method}
9: setPath(object, folderPath, ...)
19: an updated object with folderPath set
27: setPath(hsdsCon, "/home/stvjc/hdf5_mat.h5")-> hsds
GMRP:man/path.Rd: [ ]
1: \name{path}
2: \alias{path}
4: Path Analysis
7: \emph{path} is used to perform path analysis of multiple causal or risk variables on an outcome or disease of study.
10: path(betav,model,outcome)
25: \emph{path...(344 bytes skipped)...al) variables and disease or outcome. The beta values are equivalently quantitative values, so this path function can also be used to analyze direct and indirect contributions of quantitative traits to ec...(14 bytes skipped)...
28: ...(20 bytes skipped)...s: beta coefficients of regressions of risk variables on outcome or disease, correlation matrix and path matrix and also return director path coefficients and R-square.
39: Wright, S. 1934 The method of path coefficients. \emph{Annals of Mathematical Statistics} \bold{5} (3): 161-215.
46: betav may also be a matrix of SNP path coefficients onto risk variables and disease.
56: pathvalue<-path(betav=mybeta,model=mod,outcome="cad")
59: \keyword{path}
idpr:man/scaledHydropathyLocal.Rd: [ ]
19: the path to a .fasta or .fa file.}
64:   ##The path to the file as a character string.
2: % Please edit documentation in R/scaledHydropathy.R
3: \name{scaledHydropathyLocal}
4: \alias{scaledHydropathyLocal}
5: \title{Calculate the Average Scaled Hydropathy of an Amino Acid Sequence}
7: scaledHydropathyLocal(
32: optional setting to replace the name of the plot if hydropathy = TRUE.}
40: This is used to calculate the scaled hydropathy of an amino acid
66: exampleDF <- scaledHydropathyLocal(aaString,
70: exampleDF <- scaledHydropathyLocal(aaVector,
75: exampleDF_window3 <- scaledHydropathyLocal(aaString,
79: exampleDF_window15 <- scaledHydropathyLocal(aaString,
85:   scaledHydropathyLocal(aaString,
89:  gg <- scaledHydropathyLocal(aaVector,
92:  gg <- gg + ggplot2::ylab("Local Hydropathy")
95:                                             y = WindowHydropathy + 0.1))
100:   displaying the hydropathic character of a protein.
106: Other scaled hydropathy functions: 
109: \code{\link{meanScaledHydropathy}()},
110: \code{\link{scaledHydropathyGlobal}()}
112: \concept{scaled hydropathy functions}
DEGraph:man/getKEGGPathways.Rd: [ ]
19: \usage{getKEGGPathways(path=NULL, rootPath="networkData/ftp.genome.jp/pub/kegg/xml/kgml", organism="hsa", metaTag=c("non-metabolic", "metaboli...(34 bytes skipped)...
22:   \item{path}{A \code{\link[base]{character}} value, the local _full_ path of KGML data.}
23:   \item{rootPath}{A \code{\link[base]{character}} value, the local _root_ path of KGML data.}
37: \details{If 'path' is supplied, KGML files in this directory are loaded.
55: path <- system.file("extdata", package="KEGGgraph")
56: grList <- getKEGGPathways(path=path, verbose=TRUE)
13: \title{Builds a graph for each of the KEGG pathways}
16:  Builds a graph for each of the KEGG pathways.
25:      pathways should be considered. Defaults to "hsa" (Homo Sapiens).}
26:   \item{metaTag}{A \code{\link[base]{character}} value, specifying the type of pathways to
34:   A \code{\link[base]{list}} containing a \code{\link[=graph-class]{graph}} object for each KEGG pathway with at least one edge.
39:   <rootPath>/<metaTag>/"organisms"/<organism>, which mirrors the
63:   ## Download all human KGML pathways locally
64:   pathname <- system.file("downloadScripts", "downloadKeggXmlFiles.R", package="DEGraph")
65:   source(pathname)
4: %  ./getKEGGPathways.R
9: \name{getKEGGPathways}
10: \alias{getKEGGPathways}
47:   \code{\link{KEGGpathway2Graph}}
68:   grList <- getKEGGPathways(pattern="040", verbose=TRUE)
netDx:man/fetchPathwayDefinitions.Rd: [ ]
21: (char) Path to local cached copy of GMT file
5: \title{fetch pathway definitions from downloads.baderlab.org}
10: \item{month}{(numeric or char) month of pathway definition file. Can be
13: \item{year}{(numeric) year of pathway definition file. Must be in
25: fetch pathway definitions from downloads.baderlab.org
28: Fetches genesets compiled from multiple curated pathway
30: The file contains pathways from HumanCyc, NetPath, Reactome, NCI
31: Curated Pathways and mSigDB.
3: \name{fetchPathwayDefinitions}
4: \alias{fetchPathwayDefinitions}
7: fetchPathwayDefinitions(month = NULL, year = NULL, day = 1, verbose = FALSE)
36: fetchPathwayDefinitions("October",2021)
37: fetchPathwayDefinitions("October",2021)
38: fetchPathwayDefinitions(month=10,year=2021)
AnnotationForge:inst/AnnDbPkg-templates/ARABIDOPSIS.DB/man/PATH2TAIR.Rd: [ ]
1: \name{@ANNOBJPREFIX@PATH2TAIR}
2: \alias{@ANNOBJPREFIX@PATH2TAIR}
6:  @ANNOBJPREFIX@PATH2TAIR is an R object that provides mappings between
24:   Mappings were based on data provided by: @PATH2TAIRSOURCE@
46: xx <- as.list(@ANNOBJPREFIX@PATH2TAIR)
4:   pathway identifiers and TAIR Identifiers}
13:   particular pathway. An \code{NA} is reported for any KEGG identifier
16:   Pathway name for a given pathway identifier can be obtained using the KEGG
20:   Graphic presentations of pathways are searchable at
21:   \url{http://www.genome.ad.jp/kegg/pathway.html} using pathway
47: # Remove pathway identifiers that do not map to any tair id
OmnipathR:man/omnipath_set_cachedir.Rd: [ ]
7: omnipath_set_cachedir(path = NULL)
10: \item{path}{Character: path to the new cache directory. If don't exist,
11: the directories will be created. If the path is an existing cache
14: cache directory will be set to its default path.}
3: \name{omnipath_set_cachedir}
4: \alias{omnipath_set_cachedir}
24: omnipath_set_cachedir(tmp_cache)
26: omnipath_set_cachedir()
MungeSumstats:man/check_save_path.Rd: [ ]
2: % Please edit documentation in R/check_save_path.R
3: \name{check_save_path}
4: \alias{check_save_path}
5: \title{Check if save path and log folder is appropriate}
7: check_save_path(
8:   save_path,
17: \item{save_path}{File path to save formatted data. Defaults to
23: the name of the file specified in the save path parameter with the extension
40: Corrected \code{save_path}, the file type, the separator, corrected
44: Check if save path and log folder is appropriate
20: \item{log_folder}{Filepath to the directory for the log files and the log of
rsemmed:man/text_path.Rd: [ ]
3: \name{text_path}
4: \alias{text_path}
5: \title{Display path (text form)}
7: text_path(graph, path, print = TRUE)
12: \item{path}{A vertex sequence (\code{igraph.vs}) (the path to display)}
14: \item{print}{Print the path to screen?}
18: of nodes along the path.
21: Show a text display of a path and obtain output that can
22: be used to explore predications along the path. (A predication 
26: \code{text_path} invisibly returns a list of \code{tbl}'s containing
27: information on the predications on the path. Each list element is a 
29: the path. The \code{tbl} contains information on the subject and 
39: text_path(g_mini, paths[[1]][[1]])
40: result <- text_path(g_mini, paths[[1]][[1]], print = FALSE)
44: \code{\link{plot_path}} for plotting paths
38: paths <- find_paths(g_mini, from = node_cortisol, to = node_stress)
PloGO2:man/ExcelToPloPathway.Rd: [ ]
77: path <- system.file("files", package = "PloGO2")
79: res <- ExcelToPloPathway(file.path(path, "ResultsWGCNA_Input4PloGO2.xlsx"), 
80: 	colName="Uniprot", compareWithReference="AllData", DB.name=file.path(path, "pathwayDB.csv"),
81: 	data.file.name = file.path(path, "Abundance_data.csv") )
4: Function to add KEGG pathway annotation to an Excel spread sheet
7: Function to add KEGG pathway annotation to an Excel spread sheet
10: ExcelToPloPathway(fname, colName = "Uniprot", compareWithReference = "none", DB.name = "pathwayDB.csv", data.file.name = "none", outFolder = "PloGO2Output")
24: 	The DB file name for the pathway
37: 	The pathway counts matrix summarized for all files
41: 	The pathway percentages matrix summarized for all files
45: 	The pathway percentages matrix summarized for all files, ONLY generated if an
49: 	Aggregated abundance matrix by combination of tab and abundance file columns for all pathways
1: \name{ExcelToPloPathway}
2: \alias{ExcelToPloPathway}
NetPathMiner:man/predictPathCluster.Rd: [ ]
18: \code{posterior.probs} \tab a matrix of posterior probabilities for each path belonging to each cluster.
37:  ranked.p <- pathRanker(rgraph, method="prob.shortest.path",
49: Other Path clustering & classification methods: \code{\link{pathClassifier}},
62: \concept{Path clustering & classification methods}
2: % Please edit documentation in R/pathCluster.R
5: \title{Predicts new paths given a pathCluster model}
10: \item{pfit}{The pathway cluster model trained by \code{\link{pathCluster}} or \code{\link{pathClassifier}}.}
12: \item{newdata}{The binary pathway dataset to be assigned a cluster label.}
22: Predicts new paths given a pathCluster model.
36: 	## Get ranked paths using probabilistic shortest paths.
40: 	## Convert paths to binary matrix.
41: 	ybinpaths <- pathsToBinary(ranked.p)
42: 	p.cluster <- pathCluster(ybinpaths, M=2)
45: 	pclust.pred <- predictPathCluster(p.cluster,ybinpaths$paths)
50:   \code{\link{pathCluster}}, \code{\link{pathsToBinary}},
3: \name{predictPathCluster}
4: \alias{predictPathCluster}
7: predictPathCluster(pfit, newdata)
38: 					K=20, minPathSize=8)
53:   \code{\link{plotPathClassifier}},
54:   \code{\link{plotPathCluster}},
55:   \code{\link{predictPathClassifier}}
AnnotationForge:inst/AnnDbPkg-templates/ARABIDOPSISCHIP.DB/man/PATH2PROBE.Rd: [ ]
1: \name{@ANNOBJPREFIX@PATH2PROBE}
2: \alias{@ANNOBJPREFIX@PATH2PROBE}
6:  @ANNOBJPREFIX@PATH2PROBE is an R object that provides mappings between
22:   Mappings were based on data provided by: @PATH2PROBESOURCE@
43: xx <- as.list(@ANNOBJPREFIX@PATH2PROBE)
4:   pathway identifiers and Manufacturer Identifiers}
12:   that are found in that particular pathway. An \code{NA} is reported
15:   Pathway name for a given pathway identifier can be obtained using the KEGG
19:   Graphic presentations of pathways are searchable at
20:   \url{http://www.genome.ad.jp/kegg/pathway.html} using pathway identifiers as keys.
44: # Remove pathway identifiers that do not map to any probe id
sitePath:man/lineagePath.Rd: [ ]
75: see the impact of threshold on path number. The default is 10.}
77: \item{maxPath}{maximum number of path to return show in the plot. The number
78: of path in the raw tree can be far greater than trimmed tree. To better see
79: the impact of threshold on path number. This is preferably specified. The
82: \item{minPath}{minimum number of path to return show in the plot. To better
83: see the impact of threshold on path number. The default is 1.}
88: Lineage path represent by node number.
91:   lineagePath. There will be a simple dot plot between threshold and path
2: % Please edit documentation in R/lineagePath.R
3: \name{lineagePath}
4: \alias{lineagePath}
5: \alias{lineagePath.phylo}
6: \alias{lineagePath.treedata}
7: \alias{lineagePath.phyMSAmatched}
9: \alias{lineagePath.sneakPeekedPaths}
10: \alias{lineagePath.paraFixSites}
11: \title{Resolving lineage paths using SNP}
13: lineagePath(tree, similarity, ...)
15: \method{lineagePath}{phylo}(
26: \method{lineagePath}{treedata}(tree, ...)
28: \method{lineagePath}{phyMSAmatched}(
36: sneakPeek(tree, step = 9, maxPath = NULL, minPath = 0, makePlot = TRUE)
38: \method{lineagePath}{sneakPeekedPaths}(tree, similarity, ...)
40: \method{lineagePath}{paraFixSites}(tree, similarity = NULL, ...)
46: \item{similarity}{The parameter for identifying phylogenetic pathway using SNP. If
95: \code{lineagePath} finds the lineages of a phylogenetic tree
97:   'major SNPs' which usually accumulate along the evolutionary pathways.
101:   lineagePath. This plot is intended to give user a rough view about how many
103:   \code{\link{lineagePath}}. The number of lineagePath is preferably not be
104:   too many or too few. The result excludes where the number of lineagePath is
105:   greater than number of tips divided by 20 or user-defined maxPath. The zero
106:   lineagePath result will also be excluded.
109:   \code{lineagePath} with the closest \code{similarity} will be retrieved
119: lineagePath(tree)
122: lineagePath(x, similarity = 0.05)
AnnotationForge:inst/AnnDbPkg-templates/YEASTCHIP.DB/man/PATH2PROBE.Rd: [ ]
1: \name{@ANNOBJPREFIX@PATH2PROBE}
2: \alias{@ANNOBJPREFIX@PATH2PROBE}
6:  @ANNOBJPREFIX@PATH2PROBE is an R object that provides mappings between
22:   Mappings were based on data provided by: @PATH2PROBESOURCE@
44: xx <- as.list(@ANNOBJPREFIX@PATH2PROBE)
4:   pathway identifiers and Manufacturer Identifiers}
12:   that are found in that particular pathway. An \code{NA} is reported
15:   Pathway name for a given pathway identifier can be obtained using the KEGG
19:   Graphic presentations of pathways are searchable at
20:   \url{http://www.genome.ad.jp/kegg/pathway.html} using pathway identifiers as keys.
45: # Remove pathway identifiers that do not map to any probe id
OmnipathR:man/print_path_es.Rd: [ ]
3: \name{print_path_es}
4: \alias{print_path_es}
8: print_path_es(edgeSeq, G)
19: Pretty prints the interactions in a path.
24: print_path_es(
37:     \item{\code{\link{print_path_vs}}}
5: \alias{printPath_es}
6: \title{Prints network paths in an edge sequence}
22: interactions <- import_omnipath_interactions(resources = c('SignaLink3'))
25:     suppressWarnings(igraph::shortest_paths(
29:         output = 'epath'
30:     ))$epath[[1]],
rawrr:man/sampleFilePath.Rd: [ ]
11: file path of the sample.raw location.
3: \name{sampleFilePath}
4: \alias{sampleFilePath}
8: sampleFilePath()
33: sampleFilePath()
PloGO2:man/processPathFile.Rd: [ ]
52: \item{fname}{The filename without the file path}
4: Function to process a single pathway file in wego-like native format
7: For each pathway extract all ID's from the file.
16: 	The pathway file name, in either Wego native format or long format
19: 	The list of pathway annotation ID
38: ID's in the first column, and pathway identifiers in the second, separated by
42: followed by a pathway id, followed optionally by other columns which are ignored.
43: The pathway id's will first be aggregated for each identifier.  
47: \item{counts }{A vector of the same length as the list of pathway id's of interest giving the number of ID's in each category}
48: \item{ID.list}{The list of ID's for each pathway category }
50: \item{abundance}{A matrix with as many rows as the pathway list provided, and as many columns as the abundance data file }
1: \name{processPathFile}
2: \alias{processPathFile}
11: processPathFile(fname, AnnotIDlist, datafile=NULL, datafile.ignore.cols=1, 
76: processPathFile(fname, AnnotIDlist, datafile=datafile)
TrajectoryGeometry:man/generateRandomPaths.Rd: [ ]
5: \title{Produce random paths modeled on a given path}
8: path,
10: to = nrow(path),
11: d = ncol(path),
17: \item{path}{- This is an mxn dimensional matrix. Each row is
20: \item{from}{- The starting place along the path which will be
23: \item{to}{- The end point of the path.  This defaults to
24: nrow(path).}
27: ncol(path)}
37: This function returns a list of random paths.  Each path is
41: This function takes a path and produces N random paths of the same
43: permuting the entries in path or by taking steps from the initial
44: point of path.  Exact behaviour is controlled by
49: randomPaths = generateRandomPaths(crooked_path,from=6,to=nrow(crooked_path),
50:             d=ncol(crooked_path),randomizationParams=randomizationParams,
34: \item{N}{- The number of random paths required.}
3: \name{generateRandomPaths}
4: \alias{generateRandomPaths}
7: generateRandomPaths(
KEGGREST:man/mark.pathway.by.objects.Rd: [ ]
20:     pathway id. KEGG pathway ids consist of the string path followed by
22:     a number (e. g. "path:eco00020"). The three-letter organism code
58:     "path:eco00260", c("eco:b0002", "eco:c00263")
64:     "path:eco00260", c("eco:b0002", "eco:c00263"),
1: \name{mark.pathway.by.objects}
2: \alias{mark.pathway.by.objects}
3: \alias{color.pathway.by.objects}
5: \title{Client-side interface to obtain an url for a KEGG pathway diagram
8:   Given a KEGG pathway id and a set of KEGG gene ids, the functions
9:   return the URL of a KEGG pathway diagram with the elements
13: mark.pathway.by.objects(pathway.id, object.id.list)
14: color.pathway.by.objects(pathway.id, object.id.list,
19:   \item{pathway.id}{\code{pathway.id} a character string for a KEGG
34:     of the objects in a pathway diagram. The strings can either be a
38:     background color of the objects in a pathway diagram. The strings
42:   This function only returns the URL of the KEGG pathway diagram. Use
57:  url <- mark.pathway.by.objects(
63: url <- color.pathway.by.objects(
BioNetStat:man/pathPlot.Rd: [ ]
18:   file.name = "path"
88:   file.name="path")
2: % Please edit documentation in R/drawing_pathway.R
3: \name{pathPlot}
4: \alias{pathPlot}
5: \title{Variable values view in metabolic pathways}
7: pathPlot(
16:   pathway.id,
37: ...(27 bytes skipped)...ither the kegg code, scientific name or the common name of the target species. This applies to both pathway and gene.data or cpd.data. When KEGG ortholog pathway is considered, species="ko". Default species="hsa", it is equivalent to use either "Homo sapiens...(46 bytes skipped)...
39: \item{pathway.id}{character vector, the KEGG pathway ID(s), usually 5 digit, may also include the 3 letter KEGG species code.}
41: \item{kegg.native}{logical, whether to render pathway graph as native KEGG graph (.png) or using graphviz layout engine (.pdf). Default kegg.native=TR...(4 bytes skipped)...
43: \item{file.name}{character, the suffix to be added after the path...(69 bytes skipped)...es of the gene.data or cpd.data are also added when there are multiple samples. Default out.suffix="pathview".}
46: From viersion 1.9.3, pathview can accept either a single pathway or multiple pathway ids. The result returned by pathview function is a named list corresponding to the input pathway ids. Each element (for each pathway itself is a named list, with 2 elements ("plot.data.gene", "plot.data.cpd"). Both elements are d...(201 bytes skipped)...
56: x coordinate in the original KEGG pathway graph.
58: y coordinate in the original KEGG pathway graph.
60: node width in the original KEGG pathway graph.
62: node height in the original KEGG pathway graph.
68: Variable values view in KEGG metabolic pathways
71: Pathview maps and renders user data on relevant pathway graphs. Pathview is a stand alone program for pathway based data integration and visualization. It also seamlessly integrates with pathway and functional analysis tools for large-scale and fully automated analysis. Path...(22 bytes skipped)...upport for data Integration. It works with: 1) essentially all types of biological data mappable to pathways, 2) over 10 types of gene or protein IDs, and 20 types of compound or metabolite IDs, 3) path...(223 bytes skipped)...gene.idtype.list), to see mappable external compound related IDs do: data(rn.list); names(rn.list). Pathview generates both native KEGG view and Graphviz views for pathways. Currently only KEGG pathways are implemented. Hopefully, pathways from Reactome, NCI and other databases will be supported in the future.
86: pathPlot(gene.data=t(expr), cpd.data=NULL, labels=labels, varr.diff.list=vertexCentrality2,
87:  threshold=NULL, thr.value=1, FUN=median,species="hsa" , pathway.id="05200", kegg.native=TRUE,
91: Luo, W. and Brouwer, C., Pathview: an R/Bioconductor package for pathway based data integration and visualization. Bioinformatics, 2013, 29(14): 1830-1831, doi: 10.1093/...(21 bytes skipped)...
NetPathMiner:man/samplePaths.Rd: [ ]
5: \title{Creates a set of sample path p-values for each length given a weighted network}
7: samplePaths(graph, max.path.length, num.samples = 1000,
14: \item{max.path.length}{The maxmimum path length.}
23: A matrix where each row is a path length and each column is the number of paths sampled.
27: empirical pathway distribution for more accurate determination of path significance.
46: 	##   First, establish path score distribution by calling "samplePaths"
47:  pathsample <- samplePaths(rgraph, max.path.length=10,
56: Other Path ranking methods: \code{\link{extractPathNetwork}},
64: \concept{Path ranking methods}
2: % Please edit documentation in R/pathRank.R
16: \item{num.samples}{The numner of paths to sample}
18: \item{num.warmup}{The number of warm up paths to sample.}
26: Randomly traverses paths of increasing lengths within a set network to create an
45: 	## Get significantly correlated paths using "p-valvue" method.
50: 	##   Get all significant paths with p<0.1
51: 	significant.p <- pathRanker(rgraph, method = "pvalue",
52:                 sampledpaths = pathsample ,alpha=0.1)
57:   \code{\link{getPathsAsEIDs}}, \code{\link{pathRanker}}
3: \name{samplePaths}
4: \alias{samplePaths}
ChIPpeakAnno:man/getEnrichedPATH.Rd: [ ]
5: \title{Obtain enriched PATH that near the peaks}
33: \item{minPATHterm}{minimum count in a genome for a path to be included}
49: A dataframe of enriched path with the following variables.
50: \item{path.id}{KEGG PATH ID} \item{EntrezID}{Entrez ID}
51: \item{count.InDataset}{count of this PATH in this dataset}
52: \item{count.InGenome}{count of this PATH in the genome} \item{pvalue}{pvalue
53: from the hypergeometric test} \item{totaltermInDataset}{count of all PATH in
54: this dataset} \item{totaltermInGenome}{count of all PATH in the genome}
55: \item{PATH}{PATH name}
58: Obtain enriched PATH that are near the peaks using path package such as
59: reactome.db and path mapping package such as org.Hs.db.eg to obtain the path
69: enriched.PATH = getEnrichedPATH(annotatedPeak, orgAnn="org.Hs.eg.db",
73:  head(enriched.PATH)
2: % Please edit documentation in R/getEnrichedPATH.R
3: \name{getEnrichedPATH}
4: \alias{getEnrichedPATH}
7: getEnrichedPATH(
10:   pathAnn,
26: \item{pathAnn}{pathway annotation package such as KEGG.db, reactome.db, KEGGREST}
71:                  pathAnn="reactome.db", maxP=0.01,
74:  enrichedKEGG = getEnrichedPATH(annotatedPeak, orgAnn="org.Hs.eg.db",
76:                  pathAnn="KEGGREST", maxP=0.01,
13:   minPATHterm = 10,
72:                  minPATHterm=10, multiAdjMethod=NULL)
77:                  minPATHterm=10, multiAdjMethod=NULL)
BioNetStat:man/centralityPathPlot.Rd: [ ]
15:   file.name = "path",
89:  species="hsa" , pathway.id="05200", kegg.native=TRUE, file.name="path_example",
2: % Please edit documentation in R/drawing_pathway.R
5: \title{Structural measures of vertices view in metabolic pathways}
13:   pathway.id,
33: ...(27 bytes skipped)...ither the kegg code, scientific name or the common name of the target species. This applies to both pathway and gene.data or cpd.data. When KEGG ortholog pathway is considered, species="ko". Default species="hsa", it is equivalent to use either "Homo sapiens...(46 bytes skipped)...
35: \item{pathway.id}{character vector, the KEGG pathway ID(s), usually 5 digit, may also include the 3 letter KEGG species code.}
37: \item{kegg.native}{logical, whether to render pathway graph as native KEGG graph (.png) or using graphviz layout engine (.pdf). Default kegg.native=TR...(4 bytes skipped)...
39: \item{file.name}{character, the suffix to be added after the path...(69 bytes skipped)...es of the gene.data or cpd.data are also added when there are multiple samples. Default out.suffix="pathview".}
50: From viersion 1.9.3, pathview can accept either a single pathway or multiple pathway ids. The result returned by pathview function is a named list corresponding to the input pathway ids. Each element (for each pathway itself is a named list, with 2 elements ("plot.data.gene", "plot.data.cpd"). Both elements are d...(201 bytes skipped)...
60: x coordinate in the original KEGG pathway graph.
62: y coordinate in the original KEGG pathway graph.
64: node width in the original KEGG pathway graph.
66: node height in the original KEGG pathway graph.
72: Vertices centralities or clustering coefficient view in KEGG metabolic pathways.
73: centralityPathPlot and pathplot are functions based on pathview function of Pathview package. Pathview is a tool set for pathway based data integration and visualization. It maps and renders user data on relevant pathway graphs. All users need is to supply their gene or compound data and specify the target pathway. Pathview automatically downloads the pathway graph data, parses the data file, maps user data to the pathway, and render pathway graph with the mapped data. Pathview generates both native KEGG view and Graphviz views for pathways. keggview.native and keggview.graph are the two viewer functions, and pathview is the main function providing a unified interface to downloader, parser, mapper and viewer fun...(7 bytes skipped)...
76: This function uses pathview to visualize the vertex structural measures in metabolic maps. Pathview maps and renders user data on relevant pathway graphs. Pathview is a stand alone program for pathway based data integration and visualization. It also seamlessly integrates with pathway and functional analysis tools for large-scale and fully automated analysis. Path...(22 bytes skipped)...upport for data Integration. It works with: 1) essentially all types of biological data mappable to pathways, 2) over 10 types of gene or protein IDs, and 20 types of compound or metabolite IDs, 3) path...(223 bytes skipped)...gene.idtype.list), to see mappable external compound related IDs do: data(rn.list); names(rn.list). Pathview generates both native KEGG view and Graphviz views for pathways. Currently only KEGG pathways are implemented. Hopefully, pathways from Reactome, NCI and other databases will be supported in the future.
95: This function is an adaptation of Luo, W. and Brouwer, C., Pathview: an R/Bioconductor package for pathway based data integration and visualization. Bioinformatics, 2013, 29(14): 1830-1831, doi: 10.1093/...(21 bytes skipped)...
3: \name{centralityPathPlot}
4: \alias{centralityPathPlot}
7: centralityPathPlot(
88: centralityPathPlot(gene.data=vertexCentrality2, cpd.data=NULL, threshold="pvalue", thr.value=1,
PloGO2:man/PloPathway.Rd: [ ]
29: 	If the zip file is not provided, the path to the GO files
100: path <- system.file("files", package = "PloGO2")
102: res <- PloPathway( zipFile=paste(path, "PWFiles.zip", sep="/"), 
104: 	data.file.name = paste(path, "Abundance_data.csv", sep="/"),
4: Function to do steps of pathway annotation and annotation/abundance plots 
7: Summarize pathway categories for all the files in the zip,
12: PloPathway(zipFile = "none", reference = "none", data.file.name = "none", datafile.ignore.cols = 1, filesPath = ".", aggregateFun="sum", logAb=FALSE,...)
28:   \item{filesPath}{
42: Process all the pathway files provided, in the directory or the zip,
1: \name{PloPathway}
2: \alias{PloPathway}
101: # run PloPathway with list of id's, data file and reference
AnnotationForge:inst/AnnDbPkg-templates/NCBIORG.DB/man/PATH.Rd: [ ]
1: \name{@ANNOBJPREFIX@PATH}
2: \alias{@ANNOBJPREFIX@PATH}
3: \alias{@ANNOBJPREFIX@PATH2EG}
7:   for various organisms. @ANNOBJPREFIX@PATH maps entrez gene identifiers to the
41: x <- @ANNOBJPREFIX@PATH
47:   # Get the PATH for the first five genes
55: xx <- as.list(@ANNOBJPREFIX@PATH2EG)
4: \title{Mappings between Entrez Gene identifiers and KEGG pathway identifiers}
6:   KEGG (Kyoto Encyclopedia of Genes and Genomes) maintains pathway data
8:   identifiers used by KEGG for pathways
11:   Each KEGG pathway has a name and identifier. Pathway name for a given pathway
16:   Graphic presentations of pathways are searchable at
17:   url http://www.genome.ad.jp/kegg/pathway.html by using pathway identifiers as
20:   Mappings were based on data provided by: @PATHSOURCE@
42: # Get the entrez gene identifiers that are mapped to a KEGG pathway ID
56: # Remove pathway identifiers that do not map to any entrez gene id
OmnipathR:man/omnipath_reset_config.Rd: [ ]
10: \item{save}{If a path, the restored config will be also saved
12: config path (see \code{\link{omnipath_get_config_path}}).}
3: \name{omnipath_reset_config}
4: \alias{omnipath_reset_config}
7: omnipath_reset_config(save = NULL, reset_all = FALSE)
26: omnipath_reset_config()
27: omnipath_save_config()
32: \code{\link{omnipath_load_config}, \link{omnipath_save_config}}
PanomiR:man/pathwayGeneTab.Rd: [ ]
37: pathList <- list("Path1" = pathway1, "Path2" = pathway2)
3: \name{pathwayGeneTab}
4: \alias{pathwayGeneTab}
5: \title{Pathway-Gene Associations}
7: pathwayGeneTab(
8:   pathAdress = NA,
9:   pathwayList = NA,
16: \item{pathAdress}{Address to an RDS file containing list of pathways where
19: \item{pathwayList}{If you wish to use a list of pathways instead of a file
26: \item{outDir}{Address to save an RDS for a table of pathway-gene association}
29: pathExpTab Table of pathway-gene association.
32: Generates a table of pathways and genes associations.
35: pathway1 <- c("125", "3099", "126")
36: pathway2 <- c("5232", "5230", "5162")
38: res <- pathwayGeneTab(pathwayList = pathList)
41: pathwayGeneTab(pathwayList = msigdb_c2[1:2])
NetPathMiner:man/predictPathClassifier.Rd: [ ]
20: \item{path.probabilities}{The 3M path probabilities.}
40:  ranked.p <- pathRanker(rgraph, method="prob.shortest.path",
52: Other Path clustering & classification methods: \code{\link{pathClassifier}},
63: \concept{Path clustering & classification methods}
2: % Please edit documentation in R/pathClassifier.R
5: \title{Predicts new paths given a pathClassifier model.}
10: \item{mix}{The result from \code{\link{pathClassifier}}.}
12: \item{newdata}{A data.frame containing the new paths to be classified.}
19: \item{component}{The HME3M component membership for each pathway.}
24: Predicts new paths given a pathClassifier model.
39: 	## Get ranked paths using probabilistic shortest paths.
43: 	## Convert paths to binary matrix.
44: 	ybinpaths <- pathsToBinary(ranked.p)
45: 	p.class <- pathClassifier(ybinpaths, target.class = "BCR/ABL", M = 3)
48:  pclass.pred <- predictPathCluster(p.class, ybinpaths$paths)
53:   \code{\link{pathCluster}}, \code{\link{pathsToBinary}},
3: \name{predictPathClassifier}
4: \alias{predictPathClassifier}
7: predictPathClassifier(mix, newdata)
41: 					K=20, minPathSize=6)
56:   \code{\link{plotPathClassifier}},
57:   \code{\link{plotPathCluster}},
58:   \code{\link{predictPathCluster}}
PathoStat:man/readPathoscopeData.Rd: [ ]
10:   input.files.path.vec = NULL, input.files.name.vec = NULL)
20: \item{input.files.path.vec}{vector of pathoscope file paths}
5: \title{Reads the data from PathoScope reports and returns a list of
9:   pathoreport_file_suffix = "-sam-report.tsv", use.input.files = FALSE,
13: \item{input_dir}{Directory where the tsv files from PathoScope are located}
15: \item{pathoreport_file_suffix}{PathoScope report files suffix}
17: \item{use.input.files}{whether input dir to pathoscope files
18: or directly pathoscope files}
22: \item{input.files.name.vec}{vector of pathoscope file names}
28: Reads the data from PathoScope reports and returns a list of
32: example_data_dir <- system.file("example/data", package = "PathoStat")
33: pathoreport_file_suffix <- "-sam-report.tsv"
34: datlist <- readPathoscopeData(example_data_dir, pathoreport_file_suffix,
3: \name{readPathoscopeData}
4: \alias{readPathoscopeData}
8: readPathoscopeData(input_dir = ".",
AnnotationForge:inst/AnnDbPkg-templates/COELICOLOR.DB/man/PATH.Rd: [ ]
1: \name{@ANNOBJPREFIX@PATH}
2: \alias{@ANNOBJPREFIX@PATH}
3: \alias{@ANNOBJPREFIX@PATH2EG}
7:   for various organisms. @ANNOBJPREFIX@PATH maps entrez gene identifiers to the
41: x <- @ANNOBJPREFIX@PATH
47:   # Get the PATH for the first five genes
55: xx <- as.list(@ANNOBJPREFIX@PATH2EG)
4: \title{Mappings between Entrez Gene identifiers and KEGG pathway identifiers}
6:   KEGG (Kyoto Encyclopedia of Genes and Genomes) maintains pathway data
8:   identifiers used by KEGG for pathways
12:   Each KEGG pathway has a name and identifier. Pathway name for a given pathway
17:   Graphic presentations of pathways are searchable at
18:   url http://www.genome.ad.jp/kegg/pathway.html by using pathway identifiers as
21:   Mappings were based on data provided by: @PATHSOURCE@
42: # Get the entrez gene identifiers that are mapped to a KEGG pathway ID
56: # Remove pathway identifiers that do not map to any entrez gene id
TrajectoryGeometry:man/samplePath.Rd: [ ]
5: \title{Sample a path from single cell data}
19: sampledPath - A path consisting of a matrix of attributes of sampled
27: coordinates of the sampled path. The matrix of attribute values should
32: the sampled path give the window number a cell was sampled from.
3: \name{samplePath}
4: \alias{samplePath}
7: samplePath(attributes, pseudotime, nWindows = 10)
35: samplePath(chol_attributes, chol_pseudo_time_normalised)
36: samplePath(hep_attributes, hep_pseudo_time_normalised)
sparsenetgls:man/path_result_for_roc.Rd: [ ]
2: % Please edit documentation in R/path_result_for_roc.R
3: \name{path_result_for_roc}
4: \alias{path_result_for_roc}
5: \title{The path_result_for_roc() function}
7: path_result_for_roc(PREC_for_graph, OMEGA_path, pathnumber)
13: \item{OMEGA_path}{It is a matrix comprising of a series estimated precision 
14: matrices from a GGM model using a penalized path based on a range of structure
19: same number used in a penalized path.}
26: The path_result_for_roc function is designed to evaluate the 
38: rocpath <- path_result_for_roc(PREC_for_graph=prec1,OMEGA_path=Omega_est,
17: \item{pathnumber}{It represents the number of graph models 
18: (i.e. \eqn{\lambda}) for the evaluation.The value of pathnumber can be the 
39: pathnumber=3)
HumanTranscriptomeCompendium:man/path_doc4842.Rd: [ ]
3: \name{path_doc4842}
4: \alias{path_doc4842}
5: \title{return path to metadata csvs in zip file}
7: path_doc4842(cache = BiocFileCache::BiocFileCache())
13: path to zipfile
16: return path to metadata csvs in zip file
24: path_doc4842()
NetPathMiner:man/pathCluster.Rd: [ ]
18: \item{h}{The posterior probabilities that each path belongs to each cluster.}
21: \item{proportions}{The mixing proportions of each path.}
41:  ranked.p <- pathRanker(rgraph, method="prob.shortest.path",
55: Other Path clustering & classification methods: \code{\link{pathClassifier}},
69: \concept{Path clustering & classification methods}
2: % Please edit documentation in R/pathCluster.R
3: \name{pathCluster}
4: \alias{pathCluster}
5: \title{3M Markov mixture model for clustering pathways}
7: pathCluster(ybinpaths, M, iter = 1000)
10: \item{ybinpaths}{The training paths computed by \code{\link{pathsToBinary}}.}
26: 3M Markov mixture model for clustering pathways
40: 	## Get ranked paths using probabilistic shortest paths.
44: 	## Convert paths to binary matrix.
45: 	ybinpaths <- pathsToBinary(ranked.p)
46: 	p.cluster <- pathCluster(ybinpaths, M=2)
52: metabolic pathways using microarray expression profiles. SIGKDD Explor. News l. 5, 2 (Dec. 2003), 113-121.
56:   \code{\link{pathsToBinary}},
42: 					K=20, minPathSize=8)
47: 	plotClusters(ybinpaths, p.cluster)
59:   \code{\link{plotPathClassifier}},
60:   \code{\link{plotPathCluster}},
61:   \code{\link{predictPathClassifier}},
62:   \code{\link{predictPathCluster}}
AnnotationForge:inst/AnnDbPkg-templates/YEAST.DB/man/PATH.Rd: [ ]
1: \name{@ANNOBJPREFIX@PATH}
2: \alias{@ANNOBJPREFIX@PATH}
3: \alias{@ANNOBJPREFIX@PATH2ORF}
7:   for various organisms. @ANNOBJPREFIX@PATH maps ORF identifiers to the
9:   @ANNOBJPREFIX@PATH2ORF maps back from KEGG pathway IDs to the ORF
43: x <- @ANNOBJPREFIX@PATH
49:   # Get the PATH for the first five genes
55: xx <- as.list(@ANNOBJPREFIX@PATH2ORF)
4: \title{Mappings between ORF identifiers and KEGG pathway identifiers}
6:   KEGG (Kyoto Encyclopedia of Genes and Genomes) maintains pathway data
8:   identifiers used by KEGG for pathways.  The reverse map
13:   Each KEGG pathway has a name and identifier. Pathway name for a given pathway
18:   Graphic presentations of pathways are searchable at
19:   url http://www.genome.ad.jp/kegg/pathway.html by using pathway identifiers as
22:   Mappings were based on data provided by: @PATHSOURCE@
44: # Get the ORF identifiers that are mapped to a KEGG pathway ID
56: # Remove pathway identifiers that do not map to any ORF id
OmnipathR:man/print_path_vs.Rd: [ ]
3: \name{print_path_vs}
4: \alias{print_path_vs}
8: print_path_vs(nodeSeq, G)
19: Prints the interactions in the path in a nice format.
24: print_path_vs(
34: print_path_vs(
45: \code{\link{print_path_es}}
5: \alias{printPath_vs}
6: \title{Print networks paths given by node sequence}
22: interactions <- import_omnipath_interactions(resources=c('SignaLink3'))
25:     igraph::all_shortest_paths(
29:     )$vpath,
32: enzsub <- import_omnipath_enzsub(resources=c('PhosphoSite', 'SIGNOR'))
35:     igraph::all_shortest_paths(
SBGNview:man/highlightPath.Rd: [ ]
5: \title{Highlight shortest path between two nodes}
17:   path.node.color = "black",
18:   path.node.stroke.width = 10,
21:   path.stroke.width = 2,
44: \item{path.node.color}{A character string. Default: "black". Border color of nodes in the path.}
46: \item{path.node.stroke.width}{Integer. Default: 10. Adjust stroke width of path between nodes.}
52: \item{path.stroke.width}{Integer. Default: 2. The width of line in edges in the shortest paths.}
60: Given two nodes, find the shortest path between them and highlight the path. Other molecules/nodes and edges involved in reactions in the path are also highlighted. This function should be used as the second argument to function. Run \code{he...(39 bytes skipped)...
3: \name{highlightPath}
4: \alias{highlightPath}
7: highlightPath(
12:   glyphs.id.type = "pathwayCommons",
19:   n.shortest.paths.plot = 1,
20:   shortest.paths.cols = c("purple"),
34: \item{glyphs.id.type}{A character string. Default: "pathwayCommons". ID type of nodes in SBGN-ML file.}
48: \item{n.shortest.paths.plot}{Integer. Default: 1. There could be more than one shortest paths between two nodes. User can choose how many of them to plot.}
50: \item{shortest.path...(1 bytes skipped)....cols}{A vector of character string. Default: c("purple"). The colors of arcs in different shortest paths. The length of this vector (number of colors) should be the value of n.shortest.paths.plot. If one arc is in multiple shortest paths, its color will be set to the color that appears later in this vector.}
54: \item{tip.size}{Integer. Default: 4. The size of arc tip in edges of the shortest paths.}
64: obj.new <- SBGNview.obj + highlightPath(from.node = c('tyrosine'), 
OmnipathR:man/omnipath_save_config.Rd: [ ]
7: omnipath_save_config(path = NULL, title = "default", local = FALSE)
10: \item{path}{Path to the config file. Directories and the file will be
3: \name{omnipath_save_config}
4: \alias{omnipath_save_config}
30: options(omnipath.license = 'commercial')
31: omnipath_save_config()
casper:man/pathCounts-class.Rd: [ ]
9:   Stores exon path counts.
17:       island, it contains a named vector with exon path counts. The names indicate
31:       path counts were obtained from and RNA-seq experiment where strand
1: \name{pathCounts-class}
4: \alias{pathCounts-class}
5: \alias{show,pathCounts-method}
7: \title{Class "pathCounts"}
12:   Objects are created with a call to \code{pathCounts}.
38:     \item{show}{\code{signature(object = "pathCounts")}: Displays general information about the object. }
45: showClass("pathCounts")
TrajectoryGeometry:man/plotPathProjectionCenterAndCircle.Rd: [ ]
5: \title{Plot a path, its projection, its center and its circle}
8: path,
10: to = nrow(path),
23: \item{path}{- A path of dimension 3 in the form of an N x 3 matrix.}
29: \item{to}{- Likewise.  It defaults to nrow(path).}
32: path.}
38: \item{color}{- The color to use for this path and its associated
45: path. Defaults to 8.}
48: projected path. Defaults to 8.}
50: \item{scale}{- The path will be start (its actual start) at 0 and
65: This function assumes you have a path in dimension 3 and you have
68: appropriate statistic.  Scales the path to keep it comparable to
73: plotPathProjectionCenterAndCircle(path=straight_path,
74:                                 projection=straight_path_projection,
75:                                 center=straight_path_center,
76:                                 radius=straight_path_radius,
16: pathPointSize = 8,
44: \item{pathPointSize}{- Sets the size of points which represent the
54: here when plotting multiple paths.}
59: additional paths to the same figure.}
70: called repeatedly to add additional paths in different colors.
3: \name{plotPathProjectionCenterAndCircle}
4: \alias{plotPathProjectionCenterAndCircle}
7: plotPathProjectionCenterAndCircle(
GMRP:man/pathdiagram2.Rd: [ ]
7: This function is used to create two-level nested path...(3 bytes skipped)...gram to represent causal effects of risk factors on outcome and on the disease of study. The nested path is a child path, which is related to outcome and the outside path is parent path with respect to disease.
14: R object that is disease path...(23 bytes skipped)... of correlation matrix of causal variables to be identified in Mendelian randomization analysis and path coefficient vector of these variables directly causing the disease of study.
17: R object that is outcome path result data consisting of correlation matrix of causal variables and path...(63 bytes skipped)... outcome. This outcome variable may be or not be one of risk factors or causal variables in disease path data. These variables are the same with those in \emph{pathD}.
29: a required numeric parameter and its value is R-square obtained from path analysis of disease data.
32: a required numeric parameter and its value is R-square obtained from path analysis of outcome data.
36: Two path...(16 bytes skipped)...ontain correlation matrix of variables detected to be risk factor of disease and a vector of direct path coefficients obtained from path...(18 bytes skipped)...data of \verb{SNP}s on causal variables and disease. Columns must have shortened variable names and path word (see examples). \emph{pathdiagram2} requires two path data have the same causal variable names and the same name order. The outcome in the outcome path data must be the last variable in the correlation matrix in disease path data (see examples). Otherwise, \emph{pathdiagram2} would give an error message.
39: Null. Function \emph{pathdiagram2} creates a nested two-level path diagram labeled with color.
55: colnames(mypath)<-c("ldl","hdl","tg","path")
59: #        ldl       hdl        tg      path
71: colnames(pathD)<-c("ldl","hdl","tg","tc","path")
74: #        LDL       HDL        TG        TC      path
81: ## tc is outcome in my path
87: \keyword{path }
1: \name{pathdiagram2}
2: \alias{pathdiagram2}
4: Two-level Nested Pathdiagram
10: pathdiagram2(pathD, pathO, rangeD, rangeO, disease, R2D, R2O)
13:   \item{pathD}{
16:   \item{pathO}{
20: specifies column range for correlation coefficient matrix  in \emph{pathD}, for example, \code{rangeD=c(2:4)} means the correlation coefficient begins with column 2 and end...(13 bytes skipped)...
23: specifies column range for correlation coefficient matrix in \emph{pathO}, see example in \verb{rangeD}.
48:   \code{\link{pathdiagram}}, \code{\link[diagram]{plotmat}}, \code{\link[diagram]{plotweb}}
51: mypath<-matrix(NA,3,4)
52: mypath[1,]<-c(1.000000,-0.066678, 0.420036,0.764638)
53: mypath[2,]<-c(-0.066678,1.000000,-0.559718,0.496831)
54: mypath[3,]<-c(0.420036,-0.559718,1.000000,0.414346)
56: mypath<-DataFrame(mypath)
57: #mypath
65: #In this pathdiagram, the outcome is TC
66: pathD<-matrix(NA,4,5)
67: pathD[1,]<-c(1,	-0.070161,0.399038,0.907127,1.210474)
68: pathD[2,]<-c(-0.070161,	1,-0.552106,0.212201,0.147933)
69: pathD[3,]<-c(0.399038,-0.552106,1,0.44100,0.64229)
70: pathD[4,]<-c(0.907127	,0.212201,0.441007,1,-1.035677)
73: #pathD
80: pathD<-as.data.frame(pathD)
82: pathdiagram2(pathD=pathD,pathO=mypath,rangeD=c(1:4),rangeO=c(1:3),disease="CAD",
rsemmed:man/find_paths.Rd: [ ]
35: a single node sequence. The display functions (\code{text_path} and
36: \code{plot_path}) take care of showing the multiple edges leading to 
49: shortest path search
3: \name{find_paths}
4: \alias{find_paths}
5: \title{Shortest paths between node sets}
7: find_paths(graph, from, to, weights = NULL)
22: A list of shortest paths. List items correspond to the 
26: Find all shortest paths between sets of nodes
29: \code{find_paths} relies on \code{igraph::all_shortest_paths} to find all 
30: shortest paths between the nodes in \code{from} and \code{to}. This 
31: function searches for undirected paths.
34: paths with the same sequence of nodes. This function collapses these into 
37: repeated paths.
44: find_paths(g_mini, from = node_cortisol, to = node_stress)
OmnipathR:man/omnipath_load_config.Rd: [ ]
7: omnipath_load_config(path = NULL, title = "default", user = FALSE, ...)
10: \item{path}{Path to the config file.}
32: omnipath_load_config(path = 'my_custom_omnipath_config.yml')
3: \name{omnipath_load_config}
4: \alias{omnipath_load_config}
NoRCE:man/geneRegionPathwayEnricher.Rd: [ ]
82: \item{databaseFile}{Path of miRcancer.db file}
6: of mRNAs of interest, pathway enrichment analysis is carried out}
48: \item{gmtName}{Custom pathway gmt file}
88: Pathway enrichment object of the given input
92: of mRNAs of interest, pathway enrichment analysis is carried out
98: ncPath<-geneRegionPathwayEnricher(region = regionNC,
3: \name{geneRegionPathwayEnricher}
4: \alias{geneRegionPathwayEnricher}
8: geneRegionPathwayEnricher(
ShortRead:man/RochePath-class.Rd: [ ]
130:     \item{RocheSet}{\code{signature(path = "RochePath")}: create a
131:       \code{\linkS4class{RocheSet}} from \code{path}.}
139:       summarize the experiment path locations.}
142:       additional detail on the Roche path. All file paths are presented
1: \name{RochePath-class}
3: \alias{RochePath-class}
4: \alias{detail,RochePath-method}
5: \alias{read454,RochePath-method}
6: \alias{readFastaQual,RochePath-method}
8: \alias{readFasta,RochePath-method}
9: \alias{readPath}
12: \alias{readQual,RochePath-method}
13: \alias{readBaseQuality,RochePath-method}
17: \alias{qualPath}
18: \alias{runNames,RochePath-method}
20: \alias{RocheSet,RochePath-method}
21: \alias{runNames,RochePath-method}
22: \alias{show,RochePath-method}
24: \alias{RochePath}
26: \title{(Legacy) "RochePath" class representing a Roche (454) experiment location}
37:   Objects from the class are created with the \code{RochePath}
40:   \code{RochePath(experimentPath = NA_character_,
41:     readPath = experimentPath,
42:     qualPath = readPath, ..., verbose = FALSE)
47:     \item{experimentPath}{\code{character(1)} or
48:       \code{\linkS4class{RochePath}} pointing to the top-level directory
51:     \item{readPath}{\code{character()} of directories (typically in
52:       \code{experimentPath}) containing sequence (read) information. The
54:       \code{list.files(experimentPath, "run")}.}
56:     \item{qualPath}{\code{character()} of directories (typically in
57:       \code{experimentPath}) containing quality information. The default
58:       selects all directories matching \code{list.files(experimentPath,
61:     \item{verbose}{\code{logical(1)} indicating whether invalid paths
70:     \item{\code{readPath}:}{Object of class \code{"character"}, as
73:     \item{\code{qualPath}:}{Object of class \code{"character"}, as
76:     \item{\code{basePath}:}{Object of class \code{"character"},
77:       containing the \code{experimentPath}.}
82: Class \code{"\linkS4class{ExperimentPath}"}, directly.
84: Class \code{"\linkS4class{.ShortReadBase}"}, by class "ExperimentPath", distance 2.
88:   \code{RochePath} has the following methods or functions defined:
91:     \item{readFasta}{\code{signature(dirPath = "RochePath",
93:       from files matching \code{list.files(dirPath, pattern)} (when
94:       \code{dirPath="character"}) or
95:       \code{list.files(readPath(dir)[run], pattern)[sample]}. The
98:     \item{readQual}{\code{signature(dirPath = "RochePath", reads=NULL,
101:       \code{list.files(qualPath(dirPath)[run])[sample]}. Non-null
105:     \item{readFastaQual}{\code{signature(dirPath = "RochePath",
110:     \item{readFastaQual}{\code{signature(dirPath = "character",
112:         run = 1)}: wrapper for method above, coercing \code{dirPath}
113:       to a \code{RochePath} via \code{RochePath(dirPath)}.}
115:     \item{readBaseQuality}{\code{signature(dirPath = "RochePath", ...)}:
118:       \code{RochePath} supports more file types.
121:     \item{read454}{ \code{signature(dirPath = "RochePath", ...)}: Pass
124:     \item{readPath}{\code{signature(object = "RochePath")}: return the
125:       contents of the \code{readPath} slot.}
127:     \item{runNames}{\code{signature(object = "RochePath")}: return the
128:       \code{basename}s of \code{readPath(object)}.}
138:     \item{show}{\code{signature(object = "RochePath")}: Briefly
141:     \item{detail}{\code{signature(x = "RochePath")}: Provide
151:   \code{\linkS4class{ExperimentPath}}.
155: showClass("RochePath")
OmnipathR:man/omnipath_cache_set_ext.Rd: [ ]
23: version$path
25: httr::GET(bioc_url, httr::write_disk(version$path, overwrite = TRUE))
29: version$path
3: \name{omnipath_cache_set_ext}
4: \alias{omnipath_cache_set_ext}
7: omnipath_cache_set_ext(key, ext)
22: version <- omnipath_cache_latest_or_new(url = bioc_url)
26: key <- omnipath_cache_key(url = bioc_url)
27: omnipath_cache_set_ext(key = key, ext = 'html')
28: version <- omnipath_cache_latest_or_new(url = bioc_url)
31: record <- omnipath_cache_get(url = bioc_url)
34: omnipath_cache_remove(url = bioc_url) # cleaning up
24: # [1] "/home/denes/.cache/OmnipathR/41346a00fb20d2a9df03-1"
30: # [1] "/home/denes/.cache/OmnipathR/41346a00fb20d2a9df03-1.html"
PhosR:man/pathwayRankBasedEnrichment.Rd: [ ]
88: path_names = as.list(reactomePATHID2NAME)
89: name_id = match(names(pathways), names(path_names))
90: names(pathways) = unlist(path_names)[name_id]
95: pathways = lapply(pathways, function(path) {
96:     gene_name = unname(getSYMBOL(path, data = "org.Rn.eg"))
101: path2 <- pathwayRankBasedEnrichment(Tc.gene[,1],
2: % Please edit documentation in R/pathwayAnalysis.R
3: \name{pathwayRankBasedEnrichment}
4: \alias{pathwayRankBasedEnrichment}
7: pathwayRankBasedEnrichment(geneStats, annotation, alter = "greater")
13: \item{annotation}{a list of pathways with each element containing an array of
20: A matrix of pathways and their associated substrates and p-values.
85: # Preparing Reactome annotation for our pathways analysis
86: pathways = as.list(reactomePATHID2EXTID)
92: pathways = pathways[which(grepl("Rattus norvegicus", names(pathways), 
100: # 1D gene-centric pathway analysis
102:                                     annotation=pathways,
NetPathMiner:man/plotPaths.Rd: [ ]
7: plotPaths(paths, graph, path.clusters = NULL, col.palette = palette(),
15: \item{path.clusters}{The result from \code{\link{pathCluster}} or \code{\link{pathClassifier}}.}
28: This function plots a network highlighting ranked paths. If \code{path.clusters} are provided,
45:  ranked.p <- pathRanker(rgraph, method="prob.shortest.path",
56: 	plotPaths(ranked.p, ex_sbml, path.clusters=p.class)
2: % Please edit documentation in R/plotPath.R
5: \title{Plots an annotated igraph object higlighting ranked paths.}
11: \item{paths}{The result of \code{\link{pathRanker}}.}
24: Produces a plot of the network with paths highlighted. If paths are computed for several
29: paths in the same cluster are assigned similar colors.
44: 	## Get ranked paths using probabilistic shortest paths.
48: 	## Plot paths.
51: 	## Convert paths to binary matrix, build a classifier.
52: 	ybinpaths <- pathsToBinary(ranked.p)
53: 	p.class <- pathClassifier(ybinpaths, target.class = "BCR/ABL", M = 3)
3: \name{plotPaths}
4: \alias{plotPaths}
46: 					K=20, minPathSize=6)
49: 	plotPaths(ranked.p, rgraph)
67:   \code{\link{plotPathClassifier}}
AnnotationForge:inst/AnnDbPkg-templates/NCBICHIP.DB/man/PATH.Rd: [ ]
1: \name{@ANNOBJPREFIX@PATH}
2: \alias{@ANNOBJPREFIX@PATH}
3: \alias{@ANNOBJPREFIX@PATH2PROBE}
9:   @ANNOBJPREFIX@PATH maps probe identifiers to the identifiers used by
13:   @ANNOBJPREFIX@PATH2PROBE is an R object that provides mappings between
47: x <- @ANNOBJPREFIX@PATH
53:   # Get the PATH for the first five probes
59: x <- @ANNOBJPREFIX@PATH
61: # Now convert the @ANNOBJPREFIX@PATH2PROBE object to a list
4: \title{Mappings between probe identifiers and KEGG pathway identifiers}
6:   KEGG (Kyoto Encyclopedia of Genes and Genomes) maintains pathway data
10:   KEGG for pathways in which the genes represented by the probe
17:   Each KEGG pathway has a name and identifier. Pathway name for a given pathway
22:   Graphic presentations of pathways are searchable at
23:   url http://www.genome.ad.jp/kegg/pathway.html by using pathway identifiers as
26:   Mappings were based on data provided by: @PATHSOURCE@
48: # Get the probe identifiers that are mapped to a KEGG pathway ID
64:     # Get the probe identifiers for the first two pathway identifiers
idpr:man/chargeHydropathyPlot.Rd: [ ]
90: ##The path to the file as a character string
20: \item{sequence}{amino acid sequence (or pathway to a fasta file)
2: % Please edit documentation in R/chargeHydropathyPlot.R
3: \name{chargeHydropathyPlot}
4: \alias{chargeHydropathyPlot}
5: \title{Charge-Hydropathy Plot}
7: chargeHydropathyPlot(
46: data frame is returned with the Sequence(s), Average Scaled Hydropathy,
49: showing the Charge Hydropathy Plot (recommended).}
53: \link[idpr:meanScaledHydropathy]{idpr::meanScaledHydropathy()} or
57: Graphical values of Charge-Hydropathy Plot
61:   scaled hydropathy <H> and visualizes the data. There are known boundaries
66:   The plot returned is based on the charge-hydropathy plot from
91: chargeHydropathyPlot(sequence = aaString)
92: chargeHydropathyPlot( sequence = aaVector)
99: chargeHydropathyPlot(sequence = multipleSeq)
102: chargeHydropathyPlot(
106: chargeHydropathyPlot(
112: chargeHydropathyPlot(
121:   displaying the hydropathic character of a protein.
137:   \code{\link{meanScaledHydropathy}}
NoRCE:man/mirnaRegionPathwayEnricher.Rd: [ ]
85: \item{databaseFile}{Path of miRcancer.db file}
5: \title{Pathway enrichments of the microRNA regions with mRNAs that fall in the
51: \item{gmtName}{Custom pathway gmt file}
91: miRNA pathway enrichment object for the given input
94: Pathway enrichments of the microRNA regions with mRNAs that fall in the
3: \name{mirnaRegionPathwayEnricher}
4: \alias{mirnaRegionPathwayEnricher}
8: mirnaRegionPathwayEnricher(
102: a<- mirnaRegionPathwayEnricher(region = regionNC,
TargetSearch:man/ncdf4_convert_from_path.Rd: [ ]
3: \name{ncdf4_convert_from_path}
4: \alias{ncdf4_convert_from_path}
5: \title{Convert CDF files to CDF4 from a path automatically}
7: ncdf4_convert_from_path(cdf_path = ".", out_path = cdf_path, recursive = FALSE, ignore.case = TRUE, ...)
10:     \item{cdf_path}{Character string. The path(s) to scan for CDF files.}
12:     \item{out_path}{Character string. The output path(s) in which the converted files will be saved.}
26:     automatically. The function scans the given input path(s) for files with \code{"cdf"} extension.
32:     default the current path is scanned and files are converted and save in the same place.
34:     Multiple input directories can be given. If this is the case, the output path \code{out_path} must
35:     be either a single path (in which case all files will be copied to the same directory) or an equal
56: srcdir <- file.path(tempdir(), 'gc-ms-data')
62: ncdf4_convert_from_path(srcdir, outdir)
66: cdfpath <- tempdir() # (base path where we copy the CDF files)
67: ncdf4_convert_from_path(cdfpath, outdir, recursive=TRUE)
36:     number of paths, such that there is a corresponding match between input and output directories.
NetPathMiner:man/plotPathCluster.Rd: [ ]
5: \title{Plots the structure of specified path cluster}
14: \item{m}{The path cluster to view.}
21: Produces a plot of the paths with the path probabilities and cluster membership probabilities.
23:  (features) included within each path.}
24: \item{Right}{The training set posterior probabilities for each path belonging to the current 3M component.}
28: Plots the structure of specified path found by pathCluster.
43:  ranked.p <- pathRanker(rgraph, method="prob.shortest.path",
53: Other Path clustering & classification methods: \code{\link{pathClassifier}},
64: \concept{Path clustering & classification methods}
2: % Please edit documentation in R/pathCluster.R
10: \item{ybinpaths}{The training paths computed by \code{\link{pathsToBinary}}.}
12: \item{clusters}{The pathway cluster model trained by \code{\link{pathCluster}} or \code{\link{pathClassifier}}.}
22: \item{Center Plot}{An image of all paths the training dataset. Rows are the paths and columns are the genes
25: ...(11 bytes skipped)...ar Plots}{\code{Theta}, The 3M component probabilities - indicates the importance of each edge to a pathway.}
42: 	## Get ranked paths using probabilistic shortest paths.
46: 	## Convert paths to binary matrix.
47: 	ybinpaths <- pathsToBinary(ranked.p)
48: 	p.cluster <- pathCluster(ybinpaths, M=2)
54:   \code{\link{pathCluster}}, \code{\link{pathsToBinary}},
3: \name{plotPathCluster}
4: \alias{plotPathCluster}
7: plotPathCluster(ybinpaths, clusters, m, tol = NULL)
44: 					K=20, minPathSize=8)
49: 	plotPathCluster(ybinpaths, p.cluster, m=2, tol=0.05)
57:   \code{\link{plotPathClassifier}},
58:   \code{\link{predictPathClassifier}},
59:   \code{\link{predictPathCluster}}
netDx:man/readPathways.Rd: [ ]
18: \item{fname}{(char) path to pathway file in gmt format
5: \title{Parse GMT file and return pathways as list}
19: pathway score to include pathway in the filter list}
21: \item{MIN_SIZE}{(integer) min num genes allowed in a pathway. Pathways
24: \item{MAX_SIZE}{(integer) max num genes allowed in a pathway. Pathways
27: \item{EXCLUDE_KEGG}{(boolean) If TRUE exclude KEGG pathways. Our
33: If FALSE, pathway name.}
38: cleaned pathway names to the original names}
42: pathway name as key, vector of genes as value. If TRUE, returns list of
43: length two, (1) geneSets: pathway-gene mappings as default, 
47: Parse GMT file and return pathways as list
56: <pathway_full_name>%<pathway_source>%<pathway_source_id>
62: pathFile <- fetchPathwayDefinitions("October",2020)
63: pathwayList    <- readPathways(pathFile)
2: % Please edit documentation in R/readPathways.R
3: \name{readPathways}
4: \alias{readPathways}
7: readPathways(
splatter:man/kersplatSimPaths.Rd: [ ]
15: KersplatParams object with path means
18: Simulate gene means for each step along each path of a Kersplat simulation
26: genes) and cause changes in expression downstream. For each path a random
33: The path structure itself is specified by the \code{paths.design} parameter.
34: This is a \code{data.frame} with three columns: "Path", "From", and "Steps".
35: The Path field is an ID for each path while the Steps field controls the
36: length of each path. Increasing the number of steps will increase the
38: the originating point of each path. For example a From of \code{0, 0, 0}
40: would give a branching structure with Path 1 beginning at the origin and
41: Path 2 and Path 3 beginning at the end of Path 1.
5: \title{Simulate Kersplat paths}
21: The method of simulating paths is inspired by the method used in the PROSSTT
22: simulation. Changes in expression are controlled by \code{paths.nPrograms}
37: difference in expression between the ends of the paths. The From field sets
39: would indicate three paths from the origin while a From of \code{0, 1, 1}
3: \name{kersplatSimPaths}
4: \alias{kersplatSimPaths}
7: kersplatSimPaths(params, verbose)
NoRCE:man/mirnaPathwayEnricher.Rd: [ ]
87: \item{databaseFile}{Path of miRcancer.db file}
5: \title{Pathway enrichments of the microRNA genes with mRNAs that fall in the
53: \item{gmtName}{Custom pathway gmt file}
93: MiRNA pathway enrichment object for the given input
96: Pathway enrichments of the microRNA genes with mRNAs that fall in the
101: miPath <- mirnaPathwayEnricher(gene = brain_mirna,
3: \name{mirnaPathwayEnricher}
4: \alias{mirnaPathwayEnricher}
8: mirnaPathwayEnricher(
flowWorkspace:man/gs_get_pop_paths.Rd: [ ]
14:   path = "full",
23:   path = "full",
36: \item{path...(8 bytes skipped)...e{character} or \code{numeric} scalar. when \code{numeric}, it specifies the fixed length of gating path (length 1 displays terminal name).
37: When \code{character}, it can be either 'full' (full path, which is default) or 'auto' (display the shortest unique gating path from the bottom of gating tree).}
56:     gs_get_pop_paths(G, path = 1)#return node names (without prefix)
57:     gs_get_pop_paths(G, path = "full")#return the full path
58:     gs_get_pop_paths(G, path = 2)#return the path as length of two
59:     gs_get_pop_paths(G, path = "auto")#automatically determine the length of path
3: \name{gs_get_pop_paths}
4: \alias{gs_get_pop_paths}
5: \alias{gh_get_pop_paths}
10: gs_get_pop_paths(
19: gh_get_pop_paths(
44: gs_get_pop_paths returns a \code{character} vector of node/population names, ordered appropriately.
47: \code{gs_get_pop_paths} returns a character vector of names of the nodes (populations) in the \code{GatingSet}.
PhosR:man/pathwayOverrepresent.Rd: [ ]
95: path_names = as.list(reactomePATHID2NAME)
96: name_id = match(names(pathways), names(path_names))
97: names(pathways) = unlist(path_names)[name_id]
102: pathways = lapply(pathways, function(path) {
103:     gene_name = unname(getSYMBOL(path, data = "org.Rn.eg"))
109: path1 <- pathwayOverrepresent(geneSet, annotation=pathways,
2: % Please edit documentation in R/pathwayAnalysis.R
3: \name{pathwayOverrepresent}
4: \alias{pathwayOverrepresent}
7: pathwayOverrepresent(geneSet, annotation, universe, alter = "greater")
11: that match to your pathway annotation list).}
13: \item{annotation}{a list of pathways with each element containing an array of
23: A matrix of pathways and their associated substrates and p-values.
92: # Preparing Reactome annotation for our pathways analysis
93: pathways = as.list(reactomePATHID2EXTID)
99: pathways = pathways[which(grepl("Rattus norvegicus", names(pathways), 
108: # 1D gene-centric pathway analysis
Path2PPI:man/plot.Path2PPI.Rd: [ ]
1: \name{plot.Path2PPI}
2: \alias{plot.Path2PPI}
13: \method{plot}{Path2PPI}(x, type = "ppi", multiple.edges = FALSE, 
22: An object from the class \code{Path2PPI} where the PPI network already has 
108: ppi <- Path2PPI("Autophagy induction", "Podospora anserina", "5145")
ShortRead:man/SolexaPath-class.Rd: [ ]
51:     \item{scanPath}{(optional) Solexa GoldCrest image scan path.}
52:     \item{imageAnalysisPath}{(optional) Firecrest image analysis path.}
53:     \item{baseCallPath}{(optional) Bustard base call path.}
54:     \item{analysisPath}{(optional) Gerald analysis pipeline path.}
64:   specified path to the corresponding directory (described above) or
87:       Use \code{imageAnalysisPath(sp)[run]} as the directory path(s) and
97:       Use \code{baseCallPath(dirPath)[run]} as the directory path(s) and
114:       Use \code{analysisPath(dirPath)[run]} as the directory path(s) for
124:       Use \code{analysisPath(dirPath)[run]} as the directory path(s) and
133:       Use \code{baseCallPath(dirPath)[run]} as the directory path(s) and
143:       Use \code{analysisPath(dirPath)[run]} as the directory path and
153:       Use \code{analysisPath(dirPath)[run]} as the directory path and
164:       Use \code{analysisPath(dirPath)[run]} as the directory path(s) and
179:     \item{SolexaSet}{\code{signature(path = "SolexaPath")}: create a
180:       \code{\linkS4class{SolexaSet}} object based on \code{path}.}
1: \name{SolexaPath-class}
3: \alias{SolexaPath-class}
5: \alias{SolexaPath}
7: \alias{SolexaSet,SolexaPath-method}
8: \alias{qa,SolexaPath-method}
9: \alias{report,SolexaPath-method}
10: \alias{show,SolexaPath-method}
11: \alias{detail,SolexaPath-method}
13: \alias{readIntensities,SolexaPath-method}
14: \alias{readPrb,SolexaPath-method}
15: \alias{readQseq,SolexaPath-method}
16: \alias{readFasta,SolexaPath-method}
17: \alias{readFastq,SolexaPath-method}
18: \alias{readBaseQuality,SolexaPath-method}
19: \alias{readAligned,SolexaPath-method}
21: \title{(Legacy) "SolexaPath" class representing a standard output file hierarchy}
34:   \code{SolexaPath(experimentPath,
35:                    dataPath=.solexaPath(experimentPath, "Data"),
36:                    scanPath=.solexaPath(dataPath, "GoldCrest"),
37:                    imageAnalysisPath=.solexaPath(dataPath, "^(C|IPAR)"),
38:                    baseCallPath=.solexaPath(imageAnalysisPath,
40:                    analysisPath=.solexaPath(baseCallPath,
46:     \item{experimentPath}{\code{character(1)} object pointing to the
50:     \item{dataPath}{(optional) Solexa \sQuote{Data} folder .}
58:       \code{TRUE} results in warnings if paths do not exist.}
60:   All paths must be fully-specified.
63:   \code{SolexaPath} has the following slots, containing either a fully
67:     \item{\code{basePath}}{See \code{experimentPath}, above.}
68:     \item{\code{dataPath}}{See above.}
69:     \item{\code{scanPath}}{See above.}
70:     \item{\code{imageAnalysisPath}}{See above.}
71:     \item{\code{baseCallPath}}{See above.}
72:     \item{\code{analysisPath}}{See above.}
85:       \code{signature(dirPath = "SolexaPath", pattern=character(0), run, ...)}:
95:       \code{signature(dirPath = "SolexaPath", pattern=character(0), run, ...)}:
111:       \code{signature(dirPath, pattern = character(0), ...,
121:       \code{signature(dirPath = "SolexaPath", pattern = ".*_sequence.txt",
131:       \code{signature(dirPath = "SolexaPath", seqPattern = ".*_seq.txt", prbPattern = "s_[1-8]_prb.txt", run, ...)}: 
141: 	  \code{signature(directory="SolexaPath", pattern=".*_qseq.txt.*", run, ...., filtered=FALSE)}:
151:       \code{signature(dirPath = "SolexaPath", pattern = ".*_export.txt.*", run, ..., filter=srFilter())}: 
162:       \code{signature(dirPath="SolexaPath", pattern="character(0)", run, ...)}:
187:     \item{show}{\code{signature(object = "SolexaPath")}: briefly
188:       summarize the file paths of \code{object}. The
189:       \code{experimentPath} is given in full; the remaining paths are
192:     \item{detail}{\code{signature(x = "SolexaPath")}: summarize
193:       file paths of \code{x}. All file paths are presented in
200: showClass("SolexaPath")
201: showMethods(class="SolexaPath", where=getNamespace("ShortRead"))
203: sp <- SolexaPath(sf)
207: nfiles <- length(list.files(analysisPath(sp), "s_[1-8]_export.txt"))
213: nfiles <- length(list.files(analysisPath(sp), "s_[1-8]_export.txt"))
splineTimeR:man/pathEnrich.Rd: [ ]
51:    geneSets <- getGmt("/path/to/c2.all.v5.0.symbols.gmt")
64:    geneSets <- getGmt("/path/to/ReactomePathways.gmt")
1: \name{pathEnrich}
2: \alias{pathEnrich}
3: \title{Pathway enrichment analysis}
6: Function performs a pathway enrichment analysis of a definied set of genes.
8: \usage{pathEnrich(geneList, geneSets, universe=NULL)}
11:   \item{geneList}{vector of gene names to be used for pathway enrichment}
12:   \item{geneSets}{\code{"GeneSetColletion"} object with functional pathways gene sets}
17: ...(157 bytes skipped)...to be provided in Gene Matrix Transposed file format (*.gmt), where each gene set is described by a pathway name, a description, and the genes in the gene set. Two examples are shown to demonstrate how to...(45 bytes skipped)...
19: ...(168 bytes skipped)...rse} is not definied, \code{universe} is equal to the number of all genes that can be mapped to any pathways in chosen database.
24: \item{pathway}{names of enriched pathways}
26: \item{genes_in_pathway}{total number of known genes in the pathway}
27: \item{\%_match}{number of matched genes refered to the total number of known genes in the pathway given in \%}
30: \item{overlap}{genes from input genes list that overlap with all known genes in the pathway}
56:    ## use differentially expressed genes for pathway enrichment analysis
57:    enrichPath <- pathEnrich(geneList = rownames(diffExprs), geneSets = geneSets, universe = 6536)}
60:    ## Example 2 - using gene sets from the Reactome Pathway Database
62:    ## ("Reactome Pathways Gene Set" under "Specialized data formats") from the Reactome website
67:    enrichPath <- pathEnrich(geneList = rownames(diffExprs), geneSets = geneSets, universe = 6536)}
69: ## Small example with gene sets consist of KEGG pathways only
73: enrichPath <- pathEnrich(geneList = rownames(diffExprs), geneSets = geneSets, universe = 6536)
77: \keyword{pathway enrichment analysis}
61:    ## Download and unzip .gmt.zip file 'ReactomePathways.gmt.zip'
casper:man/pathCounts.Rd: [ ]
8:   Compute exon path counts
1: \name{pathCounts}
2: \alias{pathCounts}
3: \alias{pathCounts-method}
4: \alias{pathCounts,list-method}
5: \alias{pathCounts,procBam-method}
11:   Compute counts for exon paths visited by aligned reads
14: pathCounts(reads, DB, mc.cores = 1, verbose=FALSE) 
35:       Computes counts for exon paths from a list of procBam objects (usually reads
39:       Compute counts for exon paths from a procBam object of processed
45:   Named integer vector with counts of exon paths. Names are character
OmnipathR:man/omnipath_cache_download_ready.Rd: [ ]
30: httr::GET(bioc_url, httr::write_disk(new_version$path, overwrite = TRUE))
3: \name{omnipath_cache_download_ready}
4: \alias{omnipath_cache_download_ready}
7: omnipath_cache_download_ready(version, key = NULL)
25: new_version <- omnipath_cache_latest_or_new(url = bioc_url)
32: omnipath_cache_download_ready(new_version)
34: version <- omnipath_cache_latest_or_new(url = bioc_url)
39: omnipath_cache_remove(url = bioc_url) # cleaning up
MAGeCKFlute:man/arrangePathview.Rd: [ ]
17:   path.archive = ".",
42: \item{output}{Path to save plot to.}
44: \item{path.archive}{character, the directory of KEGG pathway data file (.xml) and image file
61: file3 = file.path(system.file("extdata", package = "MAGeCKFlute"),
6: \title{Kegg pathway view and arrange grobs on page}
10:   pathways = c(),
26: \item{pathways}{character vector, the KEGG pathway ID(s), usually 5 digit, may also
29: \item{top}{integer, specifying how many top enriched pathways to be visualized.}
38: the target species. This applies to both pathway and gene.data or cpd.data. When KEGG
39: ortholog pathway is considered, species="ko". Default species="hsa", it is equivalent
46:  of KEGG's (species code + pathway id, e.g. hsa04110.xml, hsa04110.png etc) in this
49: \item{kegg.native}{logical, whether to render pathway graph as native KEGG graph (.png)
58: Kegg pathway view and arrange grobs on page.
2: % Please edit documentation in R/KeggPathwayView.R
4: \name{arrangePathview}
5: \alias{arrangePathview}
8: arrangePathview(
65: # arrangePathview(dd, c("hsa00534"), title=NULL, sub=NULL, organism="hsa")
Rcpi:man/extractDrugChiPath.Rd: [ ]
5: \title{Calculate the Kier and Hall Chi Path Indices of Orders 0 to 7}
21: \item \code{SP.0, SP.1, ..., SP.7} - Simple path, orders 0 to 7
22: \item \code{VP.0, VP.1, ..., VP.7} - Valence path, orders 0 to 7
26: Calculate the Kier and Hall Chi Path Indices of Orders 0 to 7
29: Evaluates chi path descriptors. This function utilizes the graph isomorphism
2: % Please edit documentation in R/320-extractDrugChiPath.R
3: \name{extractDrugChiPath}
4: \alias{extractDrugChiPath}
7: extractDrugChiPath(molecules, silent = TRUE)
44: dat = extractDrugChiPath(mol)
NetPathMiner:man/pathsToBinary.Rd: [ ]
16: \item{pidx}{An matrix where each row specifies the location of that path within the \code{ypaths} object.}
27: specific binary path in the corresponding \code{ypaths} object simply use matrix index by calling
45:  ranked.p <- pathRanker(rgraph, method="prob.shortest.path",
55: Other Path clustering & classification methods: \code{\link{pathClassifier}},
67: \concept{Path clustering & classification methods}
2: % Please edit documentation in R/pathClassifier.R
3: \name{pathsToBinary}
4: \alias{pathsToBinary}
5: \title{Converts the result from pathRanker into something suitable for pathClassifier or pathCluster.}
7: pathsToBinary(ypaths)
10: \item{ypaths}{The result of \code{\link{pathRanker}}.}
14: \item{paths}{All paths within ypaths converted to a binary string and concatenated into the one matrix.}
19: Converts the result from pathRanker into something suitable for pathClassifier or pathCluster.
22: Converts a set of pathways from \code{\link{pathRanker}}
23: into a list of binary pathway matrices. If the pathways are grouped by a response label then the
24: \emph{pathsToBinary} returns a list labeled by response class where each element is the binary
25: pathway matrix for each class. If the pathways are from \code{\link{pathRanker}} then a list wiht
26: a single element containing the binary pathway matrix is returned. To look up the structure of a
28: \code{ypaths[[ybinpaths\$pidx[i,]]]}, where \code{i} is the row in the binary paths object you
44: 	## Get ranked paths using probabilistic shortest paths.
48: 	## Convert paths to binary matrix.
49: 	ybinpaths <- pathsToBinary(ranked.p)
50: 	p.cluster <- pathCluster(ybinpaths, M=3)
56:   \code{\link{pathCluster}},
46: 					K=20, minPathSize=6)
51: 	plotClusters(ybinpaths, p.cluster, col=c("red", "green", "blue") )
59:   \code{\link{plotPathClassifier}},
60:   \code{\link{plotPathCluster}},
61:   \code{\link{predictPathClassifier}},
62:   \code{\link{predictPathCluster}}
gep2pep:man/PathSEA.Rd: [ ]
78: repo_path <- file.path(tempdir(), "gep2pepTemp")
80: rp <- createRepository(repo_path, db)
108: unlink(repo_path, TRUE)
3: \name{PathSEA}
4: \alias{PathSEA}
5: \title{Performs Pathway Set Enrichment Analysis (PSEA)}
7: PathSEA(rp_peps, pathways, bgsets = "all", collections = "all",
15: \item{pathways}{A database of pathways in the same format as input
19: \item{bgsets}{Another list like \code{pathways}, representing the
21: default), all pathways that are in the repository and not in
22: \code{pathways} will be used.}
39: A list of 2, by names "PathSEA" and "details". The
40:     "PathSEA" entry is a 2-columns matrix including ESs and
42:     reports the rank of each pathway in \code{pathways} for each
46: PathSEA is analogous to the Gene Set Enrichment Analysis (GSEA),
47: but for pathways instead of single genes. It can therefore be used
48: to look for conditions under which a given set of pathways is
52: For each condition, all pathways are ranked by how much
56:     compare the ranks assigned to pathways in \code{pathways}
57:     against the ranks assigned to pathways in \code{bgsets}. A
59:     indicates whether each pathway is UP- (DOWN-) regulated by
64:     profiles, \code{PathSEA} can be used together with
65:     \code{gene2pathways} to perform gene2drug [1] analysis, which
84: pathways <- c("M11607", "M10817", "M16694",         ## from c3_TFT
86: w <- sapply(db, setIdentifier) \%in\% pathways
88: psea <- PathSEA(rp, db[w])
90: ## [15:35:29] Common pathway sets removed from bgset.
95: ## [15:35:29] Common pathway sets removed from bgset.
113:         pathway-based rational drug repositioning. Bioinformatics
PanomiR:man/pathwaySummary.Rd: [ ]
48:  "Path1",   "125",      "ENSG00000196616",
49:  "Path1",   "3099",     "ENSG00000159399",
50:  "Path2",   "5230",     "ENSG00000102144",
51:  "Path2",   "5162",     "ENSG00000168291"
3: \name{pathwaySummary}
4: \alias{pathwaySummary}
5: \title{Pathway Summary Statistics}
7: pathwaySummary(
9:   pathwayRef,
22: \item{pathwayRef}{Table of pathway-gene associations. Created from
23: \code{\link{pathwayGeneTab}} function.}
27: \item{zNormalize}{Normalization of pathway summary score.}
29: \item{method}{Choice of how to summarize gene ranks into pathway statistics.}
35: pathway summary statistics.}
40: pathExp Table of pathway activity profiles per sample.
43: Generates a table of pathway activity profiles per sample
46: pathTab <- tibble::tribble(
47:  ~Pathway, ~ENTREZID,  ~ENSEMBL,
54: rownames(exprsMat) <- pathTab$ENSEMBL
56: pathwaySummary(exprsMat, pathTab, method = "x2")
OmnipathR:man/omnipath_cache_move_in.Rd: [ ]
8:   path,
18: \item{path}{Path to the source file}
41: path <- tempfile()
42: saveRDS(rnorm(100), file = path)
43: omnipath_cache_move_in(path, url = 'the_download_address')
50: omnipath_cache_move_in(path = html_file, url = bioc_url)
3: \name{omnipath_cache_move_in}
4: \alias{omnipath_cache_move_in}
7: omnipath_cache_move_in(
51: omnipath_cache_remove(url = bioc_url) # cleaning up
55: \code{\link{omnipath_cache_save}}
CONFESS:man/pathEstimator.Rd: [ ]
7: pathEstimator(data, path.start = 1, path.type = c("circular",
13: \item{path.start}{Integer. A cluster number indicating the starting cluster that algorithm should use to
14: build the path. The cluster numbers refer to the plot generated by Fluo_inspection(). Default is 1.
15: If path.type = "circular" the number does not matter. If path.type = "A2Z" the user should inspect the
16: Fluo_inspection() plot to detect the beginning of the path. If path.type = "other", the function will
17: not estimate a path. The user has to manually insert the path progression (the cluster numbers) in
20: \item{path.type}{Character vector. A user-defined vector that characterizes the cell progression dynamics.
21:   The first element can be either "circular" or "A2Z" or "other". If "circular" the path progression is
22:   assummed to exhibit a circle-like behavior. If "A2Z" the path is assumed to have a well-defined start
25:   The second element can be either "clockwise" or "anticlockwise" depending on how the path is expected
28:   If path.type = "other", the function does not estimate a path. The exact path has to be manually inserted
36: The list of adjusted signal estimates, a progression path and the defined path type. The output is
38:   Path: the estimated path (visualized in the Fluo_Inspection() helper plot).
39:   path.type: the path.type that has been used to estimate the path.
42: It reads the generated groups of Fluo_inspection() and estimates the path cell progression
47: step3.1 <- pathEstimator(step3,path.start=6,path.type=c("circular","clockwise"))
3: \name{pathEstimator}
4: \alias{pathEstimator}
5: \title{pathEstimator}
OmnipathR:man/omnipath_cache_filter_versions.Rd: [ ]
38: httr::GET(bioc_url, httr::write_disk(version$path, overwrite = TRUE))
3: \name{omnipath_cache_filter_versions}
4: \alias{omnipath_cache_filter_versions}
7: omnipath_cache_filter_versions(
37: version <- omnipath_cache_latest_or_new(url = bioc_url)
39: omnipath_cache_download_ready(version)
40: record <- dplyr::first(omnipath_cache_search('biocond'))
43: version_numbers <- omnipath_cache_filter_versions(record, status = 'ready')
44: omnipath_cache_remove(url = bioc_url) # cleaning up
Rcpi:man/extractDrugWeightedPath.Rd: [ ]
5: \title{Descriptor that Calculates the Weighted Path (Molecular ID)}
23: \item \code{WTPT.3} - sum of path lengths starting from heteroatoms
24: \item \code{WTPT.4} - sum of path lengths starting from oxygens
25: \item \code{WTPT.5} - sum of path lengths starting from nitrogens
29: Descriptor that Calculates the Weighted Path (Molecular ID)
32: This descriptor calculates the weighted path (molecular ID)
2: % Please edit documentation in R/347-extractDrugWeightedPath.R
3: \name{extractDrugWeightedPath}
4: \alias{extractDrugWeightedPath}
7: extractDrugWeightedPath(molecules, silent = TRUE)
35: software package. Note that the descriptor is based on identifying all paths
43: dat = extractDrugWeightedPath(mol)
SplicingGraphs:man/txpath-methods.Rd: [ ]
54:   Each list element is an integer vector that describes the \emph{path}
1: \name{txpath-methods}
3: \alias{txpath-methods}
5: \alias{txpath}
6: \alias{txpath,GRangesList-method}
7: \alias{txpath,SplicingGraphs-method}
16:   Extract the transcript paths of a splicing graph
20:   \code{txpath} extracts the transcript paths of the splicing graph
25: txpath(x, as.matrix=FALSE)
35:     or a \link[GenomicRanges]{GRangesList} object for \code{txpath}.
99: ## 2. txpath()
104: txpath(sg["geneB"])
105: txpath(sg["geneD"])
108: txpath(sg["geneD"], as.matrix=TRUE)  # splicing matrix
NoRCE:man/genePathwayEnricher.Rd: [ ]
87: \item{databaseFile}{Path of miRcancer.db file}
6: mRNAs of interest, pathway enrichment analysis is carried out}
53: \item{gmtName}{Custom pathway gmt file}
93: Pathway enrichment object for the given input
97: mRNAs of interest, pathway enrichment analysis is carried out
101: #Pathway enrichment based on the gen sets that falls into the TAD regions
3: \name{genePathwayEnricher}
4: \alias{genePathwayEnricher}
8: genePathwayEnricher(
102: ncRNAPathway<-genePathwayEnricher(gene = brain_disorder_ncRNA ,
Rcpi:man/extractDrugChiPathCluster.Rd: [ ]
5: \title{Calculate the Kier and Hall Chi Path Cluster Indices of Orders 4, 5 and 6}
22: \item \code{SPC.4} - Simple path cluster, order 4
23: \item \code{SPC.5} - Simple path cluster, order 5
24: \item \code{SPC.6} - Simple path cluster, order 6
25: \item \code{VPC.4} - Valence path cluster, order 4
26: \item \code{VPC.5} - Valence path cluster, order 5
27: \item \code{VPC.6} - Valence path cluster, order 6
31: Calculate the Kier and Hall Chi Path Cluster Indices of Orders 4, 5 and 6
34: Evaluates chi path cluster descriptors.
2: % Please edit documentation in R/319-extractDrugChiPathCluster.R
3: \name{extractDrugChiPathCluster}
4: \alias{extractDrugChiPathCluster}
7: extractDrugChiPathCluster(molecules, silent = TRUE)
53: dat = extractDrugChiPathCluster(mol)
NetPathMiner:man/plotPathClassifier.Rd: [ ]
5: \title{Plots the structure of specified path found by pathClassifier.}
14: \item{m}{The path component to view.}
20: Produces a plot of the paths with the path probabilities and prediction probabilities and ROC curve overlayed.
22: included within each pathway.  A colour within image indicates if a particular gene (vertex) is included within a specific path.
23: Colours flag whether a path belongs to the current HME3M component (P > 0.5).}
24: \item{Center Right}{The training set posterior probabilities for each path belonging to the current 3M component.}
26: ...(14 bytes skipped)...Plots}{\code{Theta}: The 3M component probabilities - indicates the importance of each edge is to a path.
30: Plots the structure of specified path found by pathClassifier.
46:  ranked.p <- pathRanker(rgraph, method="prob.shortest.path",
59: Other Path clustering & classification methods: \code{\link{pathClassifier}},
78: \concept{Path clustering & classification methods}
2: % Please edit documentation in R/pathClassifier.R
10: \item{ybinpaths}{The training paths computed by \code{\link{pathsToBinary}}}
12: \item{obj}{The pathClassifier \code{\link{pathClassifier}}.}
21: \item{Center Plot}{An image of all paths the training dataset.  Rows are the paths and columns are the genes (vertices)
45: 	## Get ranked paths using probabilistic shortest paths.
49: 	## Convert paths to binary matrix.
50: 	ybinpaths <- pathsToBinary(ranked.p)
51: 	p.class <- pathClassifier(ybinpaths, target.class = "BCR/ABL", M = 3)
60:   \code{\link{pathCluster}}, \code{\link{pathsToBinary}},
3: \name{plotPathClassifier}
4: \alias{plotPathClassifier}
7: plotPathClassifier(ybinpaths, obj, m, tol = NULL)
47: 					K=20, minPathSize=6)
55: 	plotClusters(ybinpaths, p.class)
63:   \code{\link{plotPathCluster}},
64:   \code{\link{predictPathClassifier}},
65:   \code{\link{predictPathCluster}}
73:   \code{\link{plotNetwork}}, \code{\link{plotPaths}}
OmnipathR:man/find_all_paths.Rd: [ ]
33: maxlen = 3, then the longest path may consist of 3 edges and 4 nodes.}
38: List of vertex paths, each path is a character or integer vector.
44: path up to a defined length.
3: \name{find_all_paths}
4: \alias{find_all_paths}
5: \title{All paths between two groups of vertices}
7: find_all_paths(
32: \item{maxlen}{Integer: maximum length of paths in steps, i.e. if
41: Finds all paths up to length `maxlen` between specified groups of
43: `all_shortest_paths` finds only the shortest, not any
47: interactions <- import_omnipath_interactions()
49: paths <- find_all_paths(
rWikiPathways:man/readPathwayGMT.Rd: [ ]
10: \item{file}{Path to GMT file}
5: \title{Read Pathway GMT File}
13: Data frame of pathway-gene associations
17: pathway-gene associations useful in enrichment analyses and other 
21: The returned data frame includes pathway name, version, identifier,
2: % Please edit documentation in R/readPathwayGMT.R
3: \name{readPathwayGMT}
4: \alias{readPathwayGMT}
7: readPathwayGMT(file)
16: Reads a WikiPathways GMT file to produce a data frame of 
24: \code{downloadPathwayArchive(organism="Homo sapiens",format="gmt")}.
28: readPathwayGMT(system.file("extdata",
29:   "wikipathways-20201010-gmt-Homo_sapiens.gmt", package="rWikiPathways"))
37: downloadPathwayArchive
pathview:man/pathview.Rd: [ ]
46: = NULL, cols.ts.cpd = NULL, node.data, path.graph, pathway.name,
307:   \item{path.graph}{
1: \name{pathview}
2: \alias{pathview}
8: Pathway based data integration and visualization
11: Pathview is a tool set for pathway based data integration and
12: visualization. It maps and renders user data on relevant pathway
14: specify the target pathway. Pathview automatically downloads the pathway
15: graph data, parses the data file, maps user data to the pathway, and
16: render pathway graph with the mapped data.
17: Pathview generates both native KEGG view and Graphviz views for
18: pathways. keggview.native and keggview.graph are the two viewer
19: functions, and pathview is the main function providing a unified
23: pathview(gene.data = NULL, cpd.data = NULL, pathway.id,
35: cols.ts.gene = NULL, cols.ts.cpd = NULL, node.data, pathway.name,
36: out.suffix = "pathview", kegg.dir = ".", multi.state=TRUE, match.data =
47: out.suffix = "pathview", pdf.size = c(7, 7), multi.state=TRUE,
79:   \item{pathway.id}{
80:  character vector, the KEGG pathway ID(s), usually 5 digit, may also include the 3
85: the target species. This applies to both pathway and gene.data or
86: cpd.data. When KEGG ortholog pathway is considered,
91: character, the directory of KEGG pathway data file (.xml) and image file
93: naming convention of KEGG's (species code + pathway id,
116: "ortholog" for a pathway to be considered. Default min.nnodes=3.
119: logical, whether to render pathway graph as native KEGG graph (.png) or
123: logical, whether to map the NULL gene.data or cpd.data to pathway. When
124: NULL data are mapped, the gene or compound nodes in the pathway will be
135: pathways where it conflits with  converting reactions to edges. Default expand.node=FLASE.
142: pathways even without group nodes defined orginally. For these pathways,
239:   \item{pathway.name}{
240: character, the full KEGG pathway name in the format of 3-letter species
241:   code with 5-digit pathway id, eg "hsa04612". 
244: character, the suffix to be added after the pathway name as part of the
246:   cpd.data are also added when there are multiple samples. Default out.suffix="pathview".
265:     1) if node colors be plotted in the same layer as the pathway
281:     logical, whether pathview signature is added to the pathway
285:     logical, whether color key is added to the pathway
300: character, controlling the position of pathview signature. Only
312: a numeric vector of length 2, giving the width and height of the pathway
319: specifying the pathway graph layout direction. Only effective when
323: logical, if the pathway is treated as a signaling pathway, where all the
346: Pathview maps and renders user data on relevant pathway graphs. Pathview
347: is a stand alone program for pathway based data integration and
348: visualization. It also seamlessly integrates with pathway and functional
350: Pathview provides strong support for data Integration. It works with: 1)
351: essentially all types of biological data mappable to pathways, 2) over
353: IDs, 3) pathways for over 2000 species as well as KEGG orthology, 4)
359: Pathview generates both native KEGG view and Graphviz views for
360: pathways. Currently only KEGG pathways are implemented. Hopefully, pathways from
364:   From viersion 1.9.3, pathview can accept either a single pathway or
365:   multiple pathway ids. The result returned by pathview function is a
366:   named list corresponding to the input pathway ids. Each element (for
367:   each pathway itself is a named list, with 2
383:   \item{x}{x coordinate in the original KEGG pathway graph.
385:   \item{y}{y coordinate in the original KEGG pathway graph.
387:   \item{width}{node width in the original KEGG pathway graph.
389:   \item{height}{node height in the original KEGG pathway graph.
401:   Luo, W. and Brouwer, C., Pathview: an R/Bioconductor package for
402:   pathway based data integration and visualization. Bioinformatics,
417: data(demo.paths)
421: pv.out <- pathview(gene.data = gse16873.d[, 1], pathway.id =
422: demo.paths$sel.paths[i], species = "hsa", out.suffix = "gse16873",
429: pv.out <- pathview(gene.data = gse16873.d[, 1], pathway.id =
430: demo.paths$sel.paths[i], species = "hsa", out.suffix = "gse16873",
431: kegg.native = FALSE, sign.pos = demo.paths$spos[i])
437: print(demo.paths$sel.paths[i])
438: pv.out <- pathview(gene.data = gse16873.d[, 1], cpd.data = sim.cpd.data,
439: pathway.id = demo.paths$sel.paths[i], species = "hsa", out.suffix =
440: "gse16873.cpd", keys.align = "y", kegg.native = TRUE, key.pos = demo.paths$kpos1[i])
448: pv.out <- pathview(gene.data = gse16873.d[, 1:3], 
449:     cpd.data = sim.cpd.data2[, 1:2], pathway.id = demo.paths$sel.paths[i], 
457: ##more examples of pathview usages are shown in the vignette.
rhdf5filters:man/hdf5_plugin_path.Rd: [ ]
3: \name{hdf5_plugin_path}
4: \alias{hdf5_plugin_path}
7: hdf5_plugin_path()
10: A character string containing the path where the compiled filters
15: Setting the environment variable HDF5_PLUGIN_PATH to this value will allow
20: hdf5_plugin_path()
NetPathMiner:man/pathClassifier.Rd: [ ]
38: \item{path.probabilities}{The 3M probabilities for each path belonging to each component.}
42: \item{label}{The HME3M predicted label for each path.}
43: \item{component}{The HME3M component assignment for each path.}
66:  ranked.p <- pathRanker(rgraph, method="prob.shortest.path",
87: Other Path clustering & classification methods: \code{\link{pathCluster}},
99: \concept{Path clustering & classification methods}
2: % Please edit documentation in R/pathClassifier.R
3: \name{pathClassifier}
4: \alias{pathClassifier}
5: \title{HME3M Markov pathway classifier.}
7: pathClassifier(paths, target.class, M, alpha = 1, lambda = 2,
11: \item{paths}{The training paths computed by \code{\link{pathsToBinary}}}
14: as a label within the \code{paths\$y} object}
16: \item{M}{Number of components within the paths to be extracted.}
40: ...(16 bytes skipped)...ary response variable used by HME3M. A 1 indicates the location of the target.class labels in \code{paths\$y}}
46: HME3M Markov pathway classifier.
65: 	## Get ranked paths using probabilistic shortest paths.
69: 	## Convert paths to binary matrix.
70: 	ybinpaths <- pathsToBinary(ranked.p)
71: 	p.class <- pathClassifier(ybinpaths, target.class = "BCR/ABL", M = 3)
82: Hancock, Timothy, and Mamitsuka, Hiroshi: A Markov Classification Model for Metabolic Pathways, Workshop on Algorithms in Bioinformatics (WABI) , 2009
84: Hancock, Timothy, and Mamitsuka, Hiroshi: A Markov Classification Model for Metabolic Pathways, Algorithms for Molecular Biology 2010
88:   \code{\link{pathsToBinary}},
67: 					K=20, minPathSize=6)
74: 	table(ybinpaths$y,p.class$label)
78: 	plotClusters(ybinpaths, p.class)
91:   \code{\link{plotPathClassifier}},
92:   \code{\link{plotPathCluster}},
93:   \code{\link{predictPathClassifier}},
94:   \code{\link{predictPathCluster}}
rWikiPathways:man/downloadPathwayArchive.Rd: [ ]
22: \item{destpath}{(optional) Destination path for file to be downloaded to.
5: \title{Download Pathway Archive}
11:   destpath = "./"
29: Access the monthly archives of pathway content from WikiPathways.
2: % Please edit documentation in R/downloadPathwayArchive.R
3: \name{downloadPathwayArchive}
4: \alias{downloadPathwayArchive}
7: downloadPathwayArchive(
38: downloadPathwayArchive()  ## open in browser
39: downloadPathwayArchive(format="gmt")  ## open in browser
40: downloadPathwayArchive(date="20171010", format="svg")  ## open in browser
41: downloadPathwayArchive(date="20171010", organism="Mus musculus", format="svg")  ## download file
42: downloadPathwayArchive(organism="Mus musculus")  ## download file
46: readPathwayGMT
Rbowtie2:man/checkPathExist.Rd: [ ]
5: \title{Check if path exists}
10: \item{filePath}{\code{Character} scalar. Path of interest.}
15: Stops the function if the path does not exist.
19: of the package. It determines whether the path passed to the function exists.
7: checkPathExist(filePath, argname)
3: \name{checkPathExist}
4: \alias{checkPathExist}
NetPathMiner:man/pathRanker.Rd: [ ]
7: pathRanker(graph, method = c("prob.shortest.path", "pvalue"), start, end,
14: \item{method}{Which path ranking method to use.}
25: A list of paths where each path has the following items:
26: \item{gene}{The ordered sequence of genes visited along the path.}
27: \item{compounds}{The ordered sequence of compounds visited along the path.}
28: \item{weights}{The ordered sequence of the log(ECDF edge weights) along the path.}
29: \item{distance}{The sum of the log(ECDF edge weights) along each path.  (a sum of logs is a product)}
32: Given a weighted igraph object, path ranking finds a set of node/edge sequences (paths) to
34: \code{pathRanker(method="prob.shortest.path")} extracts the K most probable paths within
45: \code{pathRanker(method="prob.shortest.path")} finds the K most probable loopless paths given a weighted network.
49: edge weights allow for a significance test to determine if a path contains any functional structure or is
50: simply a random walk.  The probability of a path is simily the product of all ECDF weights along the path.
53: The follwing arguments can be passed to \code{pathRanker(method="prob.shortest.path")}:
56: \item{\code{minPathSize}}{The minimum number of edges for each extracted path. Defualts to 1.}
64: significant path is found it returns it. However, It doesn't search for the best path between the start and
66: all of them is time comsuming.  We just stop when the first significant path is found.
68: All provided edge weights are recaled from 0-1. Path significance is calculated based on the empirical distribution
92:  ranked.p <- pathRanker(rgraph, method="prob.shortest.path",
96: 	##   First, establish path score distribution by calling "samplePaths"
97:  pathsample <- samplePaths(rgraph, max.path.length=10,
108: Other Path ranking methods: \code{\link{extractPathNetwork}},
114: \concept{Path ranking methods}
2: % Please edit documentation in R/pathRank.R
3: \name{pathRanker}
4: \alias{pathRanker}
5: \title{Extracting and ranking paths from a network}
36: \code{pathRanker(method="pvalue")} extracts a list of paths whose sum of edge weights are
37: significantly higher than random paths of the same length.
44: \subsection{Probabilistic Shortest Paths}{
46: Before the paths are ranked the edge weights are converted into probabilistic edge weights using the Empirical
55: \item{\code{K}}{Maximum number of paths to extract. Defaults to 10.}
58: before extracting the paths. Defaults to TRUE.}
63: \code{pathRanker(method="pvalue")} searches all paths between the specified start and end vertices, and if a
65: terminal vertices,  as there could be many paths which lead to the same terminal vertex, and searching through
69: of random paths of the same length. This can be estimated using \code{\link{samplePaths}} and passed as an argument.
71: The follwing arguments can be passed to \code{pathRanker(method="pvalue")}:
91: 	## Get ranked paths using probabilistic shortest paths.
95: 	## Get significantly correlated paths using "p-valvue" method.
100: 	##   Get all significant paths with p<0.1
101: 	significant.p <- pathRanker(rgraph, method = "pvalue",
102:                 sampledpaths = pathsample ,alpha=0.1)
73: \item{\code{sampledpaths}}{The emripical results from \code{\link{samplePaths}}.}
93: 					K=20, minPathSize=6)
106: getPathsAsEIDs, extractPathNetwork