Found 32625 results in 8614 files, showing top 150 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()
ORFik:man/getGtfPathFromTxdb.Rd: [ ]
5: \title{Get path of GTF that created txdb}
16: a character file path, returns NULL if not valid
3: \name{getGtfPathFromTxdb}
4: \alias{getGtfPathFromTxdb}
7: getGtfPathFromTxdb(txdb, stop.error = TRUE)
TrajectoryGeometry:man/crooked_path_center.Rd: [ ]
4: \name{crooked_path_center}
5: \alias{crooked_path_center}
6: \title{Crooked path center}
11:     projection of crooked_path.
18: crooked_path_center
22:     the projection of crooked_path
TrajectoryGeometry:man/straight_path.Rd: [ ]
4: \name{straight_path}
5: \alias{straight_path}
6: \title{Straight path}
10: The path is roughly in the (1,0,0) direction.
18: straight_path
21: A path of n points in dimension d is an n x d matrix.  This
22: particular path is relatively straight.
CONFESS:man/path.initiator.Rd: [ ]
3: \name{path.initiator}
4: \alias{path.initiator}
5: \title{path.initiator}
7: path.initiator(data, where)
13: the starting point of the progression path.}
16: A starting point for the progression path
19: It finds the cluster that initiates the progression path.
splatter:man/getPathOrder.Rd: [ ]
5: \title{Get path order}
7: getPathOrder(path.from)
10: \item{path.from}{vector giving the path endpoints that each path originates
14: Vector giving the order to process paths in.
17: Identify the correct order to process paths so that preceding paths have
3: \name{getPathOrder}
4: \alias{getPathOrder}
StarBioTrek:man/path_KEGG.Rd: [ ]
4: \name{path_KEGG}
5: \alias{path_KEGG}
6: \title{All pathways data from KEGG}
7: \format{A list of pathways with the involved genes}
9: All pathways data from KEGG
ORFik:man/optimized_txdb_path.Rd: [ ]
3: \name{optimized_txdb_path}
4: \alias{optimized_txdb_path}
5: \title{Get path for optimization files for txdb}
7: optimized_txdb_path(txdb, create.dir = FALSE, stop.error = TRUE)
18: a character file path, returns NULL if not valid
22: Get path for optimization files for txdb
TrajectoryGeometry:man/straight_path_center.Rd: [ ]
4: \name{straight_path_center}
5: \alias{straight_path_center}
6: \title{Straight path center}
11:     projection of straight_path.
19: straight_path_center
23:     the projection so straight_path
TrajectoryGeometry:man/straight_path_projection.Rd: [ ]
4: \name{straight_path_projection}
5: \alias{straight_path_projection}
6: \title{Straight path projection}
10: The projection of straight_path[2:14,] onto the unit sphere as seen
11:     from straight_path[1,] .
19: straight_path_projection
22: The projection of straight_path onto the unit sphere.  This is a
ORFik:man/findFromPath.Rd: [ ]
10: \item{filepaths}{path to all files}
3: \name{findFromPath}
4: \alias{findFromPath}
7: findFromPath(filepaths, candidates, slot = "auto")
16: else must be a character vector of length 1 or equal length as filepaths.}
TrajectoryGeometry:man/crooked_path_radius.Rd: [ ]
4: \name{crooked_path_radius}
5: \alias{crooked_path_radius}
6: \title{Crooked path radius}
11: crooked_path to the point minimizing this mean distance.
19: crooked_path_radius
23: crooked_path to the point minimizing this mean distance.
cfDNAPro:man/examplePath.Rd: [ ]
5: \title{Get path to cfDNAPro example folder.}
11: If `NULL`, the path of extdata folder will be returned.}
14: A string. (i.e. the path.)
18: directory. This function helps get the path to the data.
2: % Please edit documentation in R/examplePath.R
3: \name{examplePath}
4: \alias{examplePath}
7: examplePath(data = NULL)
21: examplePath()
22: examplePath("groups_picard")
23: examplePath("step6")
TrajectoryGeometry:man/crooked_path.Rd: [ ]
4: \name{crooked_path}
5: \alias{crooked_path}
6: \title{Crooked path}
10: This path changes direction after the 5th point.
20: crooked_path
23: A path of n points in dimension d is an n x d matrix.  This
24: particular path is relatively crooked.
TrajectoryGeometry:man/straight_path_radius.Rd: [ ]
4: \name{straight_path_radius}
5: \alias{straight_path_radius}
6: \title{Straight path radius}
11: straight_path to the point minimizing this mean distance.
19: straight_path_radius
23: straight_path to the point minimizing this mean distance.
hipathia:man/path_vals.Rd: [ ]
4: \name{path_vals}
5: \alias{path_vals}
10: data(path_vals)
22: \code{path_vals <- get_paths_matrix(results)}
6: \title{Pathways matrix of the BRCA gene expression dataset}
7: \format{Matrix with 40 columns and 1868 rows. Row names are Pathway IDs
13: Matrix with 40 columns and 1868 rows. Row names are Pathway IDs
17: Matrix of pathway activation values for the BRCA dataset. This matrix is
19: by means of the \code{get_paths_matrix} function.
18: extracted from the Results object returned by the \code{hipathia} function
methylKit:man/getDBPath-methods.Rd: [ ]
10: \title{Get path to database of the methylDB objects}
27: The function returns the path to the flat file database that stores the data 
39: #The path to the database is returned
4: \name{getDBPath}
5: \alias{getDBPath}
6: \alias{getDBPath,methylRawListDB-method}
7: \alias{getDBPath,methylBaseDB-method}
8: \alias{getDBPath,methylRawDB-method}
9: \alias{getDBPath,methylDiffDB-method}
12: getDBPath(x)
14: \S4method{getDBPath}{methylRawListDB}(x)
16: \S4method{getDBPath}{methylBaseDB}(x)
18: \S4method{getDBPath}{methylRawDB}(x)
20: \S4method{getDBPath}{methylDiffDB}(x)
40: getDBPath(methylBaseDB.obj)
loci2path:man/getPathDescription-methods.Rd: [ ]
30:   loci=eset.list, path=biocarta)
31: path.des <- getPathDescription(result, biocarta)
2: % Please edit documentation in R/allGenerics.R, R/loci2pathResult-methods.R
6: \alias{getPathDescription,loci2pathResult-method}
7: \title{Extract description for enriched pathways from query result and 
12: \S4method{getPathDescription}{loci2pathResult}(res, geneset)
26: This function extracts the pathway description from geneSet object.
4: \name{getPathDescription}
5: \alias{getPathDescription}
10: getPathDescription(res, ...)
nethet:man/hugepath.Rd: [ ]
5: \title{Graphical Lasso path with huge package}
22: Graphical Lasso path with huge package
3: \name{hugepath}
4: \alias{hugepath}
7: hugepath(s, rholist, penalize.diagonal = NULL, trace = NULL)
BgeeCall:man/getWorkingPath.Rd: [ ]
8: \title{`working_path` Getter}
18: the value of the `working_path` slot of the object
21: Get value of the `working_path` slot
26: working_path <- getWorkingPath(user)
4: \name{getWorkingPath}
5: \alias{getWorkingPath}
6: \alias{getWorkingPath,UserMetadata-method}
7: \alias{getWorkingPath,userMetadata}
10: getWorkingPath(userObject)
12: \S4method{getWorkingPath}{UserMetadata}(userObject)
TrajectoryGeometry:man/crooked_path_projection.Rd: [ ]
4: \name{crooked_path_projection}
5: \alias{crooked_path_projection}
6: \title{Crooked path projection}
10: The projection of crooked_path[7:14,] onto the unit sphere as seen
11:     from crooked_path[6,] .
19: crooked_path_projection
22: The projection of the last 8 points on crooked_path onto the unit
StarBioTrek:man/GetPathData.Rd: [ ]
7: GetPathData(path_ALL)
10: \item{path_ALL}{variable. The user can select the variable as obtained by  GetData function}
19: pathway_ALL_GENE<-GetPathData(path_ALL=path[1:3])
5: \title{Get  genes inside pathways.}
13: a list of pathways
16: GetPathData creates a list of genes inside the pathways.
3: \name{GetPathData}
4: \alias{GetPathData}
ramwas:man/isAbsolutePath.Rd: [ ]
4:     Check if Path is Absolute.
7:     Check whether a path is relative or absolute.
10: isAbsolutePath(path)
13:     \item{path}{
14:         Path to be tested.
21:     \code{TRUE} if the path is absolute, \code{FALSE} otherwise.
29:     For instance, "~hi" is not an absolute path.
1: \name{isAbsolutePath}
2: \alias{isAbsolutePath}
18:     The function is designed to word with both Windows and Unix paths.
32:     See also \code{\link{makefullpath}}.
35: isAbsolutePath( "C:/123" )   # TRUE
36: isAbsolutePath( "~123" )     # FALSE
37: isAbsolutePath( "~/123" )    # TRUE
38: isAbsolutePath( "/123" )     # TRUE
39: isAbsolutePath( "\\\\123" )    # TRUE
40: isAbsolutePath( "asd\\\\123" ) # FALSE
41: isAbsolutePath( "a\\\\123" )   # FALSE
StarBioTrek:man/GetPathNet.Rd: [ ]
7: GetPathNet(path_ALL)
10: \item{path_ALL}{variable. The user can select the variable as obtained by  GetData function}
19: pathway_net<-GetPathNet(path_ALL=path[1:3])
5: \title{Get  interacting genes inside pathways.}
13: a list of pathways
16: GetPathNet creates a list of genes inside the pathways.
3: \name{GetPathNet}
4: \alias{GetPathNet}
MACSQuantifyR:man/setPath.Rd: [ ]
5: \title{sets custom output path}
7: setPath(MACSQuant,path=NULL)
14: \item{path}{user defined path, default is tempd}
17: object of class MACSQuant with updated path
20: This function allows the user to set the output directory path
26: user_path="."
27: #MACSQuant = setPath(MACSQuant,path=user_path)
3: \name{setPath}
4: \alias{setPath}
23: filepath <- system.file("extdata", "SingleDrugs.xlsx",
25: #MACSQuant = load_MACSQuant(filepath)
ggtree:man/get.path.Rd: [ ]
3: \name{get.path}
4: \alias{get.path}
5: \title{get.path}
7: get.path(phylo, from, to)
20: path from start node to end node
xcms:man/phenoDataFromPaths.Rd: [ ]
11: path) of the experiment's files.}
5: \title{Derive experimental design from file paths}
7: phenoDataFromPaths(paths)
10: \item{paths}{\code{character} representing the file names (including the full
3: \name{phenoDataFromPaths}
4: \alias{phenoDataFromPaths}
14: The \code{phenoDataFromPaths} function builds a \code{data.frame}
ramwas:man/makefullpath.Rd: [ ]
4:     Combine Path and Filename into  Filename with Path
7:     Combine a path with a filename into filename with path.
10: makefullpath(path, filename)
13:     \item{path}{
14:         Path, relative to which the filename is expected to be.
18:         Can be just filename, include relative path, or
19:         include absolute path.
23:     Function returns \code{filename} if it includes absolute path or
24:     if \code{path} is \code{NULL}.
27:     Filename with the path included.
42: # Path is ignored if the filename already includes absolute path
1: \name{makefullpath}
2: \alias{makefullpath}
33:     See also \code{\link{isAbsolutePath}}.
36: makefullpath("dir1/dir2", "file.txt")
39: makefullpath("dir1/dir2", "dir3/file.txt")
44: makefullpath("dir1/dir2", "/file.txt")
47: makefullpath("dir1/dir2", "C:/file.txt")
gespeR:man/path-methods.Rd: [ ]
4: \name{path<-}
5: \alias{path<-}
6: \alias{path<-,TargetRelations,character-method}
7: \title{path}
9: path(object) <- value
11: \S4method{path}{TargetRelations,character}(object) <- value
16: \item{value}{A string defining the path}
19: A \code{\linkS4class{TargetRelations}} object with set path
22: Set the path of a a \code{\linkS4class{TargetRelations}} object object
26: path(trels) <- "/dev/null"
hipathia:man/get_pathway_functions.Rd: [ ]
27: \item{unique}{Boolean, whether to return the first function for each path.}
3: \name{get_pathway_functions}
4: \alias{get_pathway_functions}
5: \title{Returns functions related to a pathway}
7: get_pathway_functions(
8:   pathigraph,
16: \item{pathigraph}{Pathway object}
24: nodes of the pathways or not. If FALSE, functions will refer to all the nodes
25: of the pathway.}
30: List of annotations from pathways to functions
33: Returns functions related to a pathway
sitadela:man/getsetDbPath.Rd: [ ]
4: \title{Get and set sitadela default database path}
10:     \item{db}{path to a valid SQLite database file.}
17:     used to set and get the path to a sitadela annotation
19:     \code{file.path(system.file(package="sitadela"),"annotation.sqlite")}.
21:     environment pointing to the desired path.
1: \name{getsetDbPath}
2: \alias{setDbPath}
3: \alias{getDbPath}
6:     setDbPath(db = NULL)
7:     getDbPath()
16:     The \code{setDbPath} and \code{getDbPath} functions are 
24: myPath <- "/home/me/test.sqlite"
25: setDbPath(myPath)
26: getDbPath()
CONFESS:man/estimatePath.Rd: [ ]
13: It can be either "clockwise" or "anticlockwise" depending on how the path is expected
16: \item{start}{Integer. The cluster number that is assigned as the path starting point}
19: The sorted cluster indices (path)
22: The main function for automatic path estimation .
3: \name{estimatePath}
4: \alias{estimatePath}
5: \title{estimatePath}
7: estimatePath(data, type, start)
systemPipeR:man/tryPath.Rd: [ ]
7: Function to check if the full path (file or directory) exists. 
10: tryPath(path)
13:   \item{path}{
14: a character vector of full path name.
18: This function produces a character vector of the file or directory name defined on the \code{path} argument.
21: A character vector containing the name of the file or directory. If the path does not exist, it will return an error message. 
28: tryPath(path=file)
1: \name{tryPath}
2: \alias{tryPath}
peakPantheR:man/spectraPaths_and_metadata_UI_helper.Rd: [ ]
16: \item{spectraMetadataPath}{NULL or path to a csv of spectra metadata, with
31: input_spectraPaths    <- c('./path/file1', './path/file2', './path/file3')
5: \title{UI data import helper - prepare file paths and metadata}
9:     spectraMetadataPath = NULL
13: \item{spectraPaths}{NULL or character vector of spectra file paths, to set
17: spectra as row and metadata as columns. (spectraPaths in column `filepath`)}
26: the `filepath` column
30: # spectraPath
36:                             dimnames=list(c(),c('filepath', 'testcol')),
40: spectraMetaPath <- tempfile(pattern="file", tmpdir=tempdir(), fileext='.csv')
43:                     file=spectraMetaPath,
48:                                     spectraMetadataPath = spectraMetaPath)
3: \name{spectraPaths_and_metadata_UI_helper}
4: \alias{spectraPaths_and_metadata_UI_helper}
7: spectraPaths_and_metadata_UI_helper(
8:     spectraPaths = NULL,
20: spectraPaths (str) and spectraMetadata (DataFrame or NULL) read from
24: Return spectraPaths and spectraMetadata from a .csv file (if available).
25: If reading from the spectraMetadata file, the spectraPaths are taken from
34: input_spectraMetadata <- data.frame(matrix(data=c(input_spectraPaths,
47: spectraPaths_and_metadata_UI_helper(spectraPaths = NULL,
NetPathMiner:man/NetPathMiner-package.Rd: [ ]
8: \title{General framework for network extraction, path mining.}
10: NetPathMiner implements a flexible module-based process flow for network path mining and visualization,
13: formats, enabling its utility to most common pathway databases.
15: thousands of output paths.
4: \name{NetPathMiner-package}
5: \alias{NetPathMiner-package}
6: \alias{NetPathMiner}
12: NetPathMiner supports construction of various types of genome scale networks from KGML, SBML and BioPAX
14: NetPathMiner also provides different visualization techniques to facilitate the analysis of even
netDx:man/getGMjar_path.Rd: [ ]
3: \name{getGMjar_path}
4: \alias{getGMjar_path}
7: getGMjar_path(verbose = FALSE)
13: (char) Path to local cached copy of GeneMANIA jar file..
20: getGMjar_path()
EventPointer:man/ArrayDatamultipath.Rd: [ ]
5: \title{Preprocessed arrays data with multi-path events}
23: Preprocessed arrays data with multi-path events
2: % Please edit documentation in R/ArrayDatamultipath.R
3: \name{ArrayDatamultipath}
4: \alias{ArrayDatamultipath}
12: data(ArrayDatamultipath)
15: ArrayDatamultipath object contains preprocessed junction
Category:man/probes2Path.Rd: [ ]
1: \name{probes2Path}
2: \alias{probes2Path}
9: probes2Path(pids, data = "hgu133plus2")
17:   This is a simple look up in the appropriate chip \code{PATH} data
30:  probes2Path(x, "hgu95av2.db")
3: \title{A function to map probe identifiers to pathways. }
6:  up all KEGG pathways that the probe is documented to be involved in.
21:  A list of pathway vectors. One element for each value of \code{pid}
22:  that is mapped to at least one pathway.
ggmanh:man/default_gds_path.Rd: [ ]
3: \name{default_gds_path}
4: \alias{default_gds_path}
5: \title{Path to Default GDS File}
7: default_gds_path()
13: Find path to the default gds file.
16: default_gds_path()
hipathia:man/normalize_paths.Rd: [ ]
7: normalize_paths(path_vals, metaginfo)
10: \item{path_vals}{SummarizedExperiment or matrix of the pathway values}
16: depending on the class of \code{path_vals}.
30: data(path_vals)
33: path_normalized <- normalize_paths(path_vals, pathways)
3: \name{normalize_paths}
4: \alias{normalize_paths}
5: \title{Normalize the pathway matrix by rows}
12: \item{metaginfo}{Pathways object}
15: SummarizedExperiment or matrix of normalized pathway values, 
19: Due to the nature of the Hipathia method, the length of a pathway may
31: pathways <- load_pathways(species = "hsa", pathways_list = c("hsa03320",
21: subpathways, we strongly recommend to normalize the matrix with this
25: This function removes the bias caused by the length of the subpathways
VanillaICE:man/parsedPath.Rd: [ ]
6: \title{Complete path to directory for keeping parsed files}
16: A character string indicating the complete path for storing parsed
3: \name{parsedPath}
4: \alias{parsedPath}
5: \alias{parsedPath,ArrayViews-method}
8: parsedPath(object)
10: \S4method{parsedPath}{ArrayViews}(object)
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)
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"
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}
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.
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
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"))
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
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
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()
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)}
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)
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
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()
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}
RCy3:man/getAbsSandboxPath.Rd: [ ]
16: Get absolute sandbox path.
3: \name{getAbsSandboxPath}
4: \alias{getAbsSandboxPath}
5: \title{getAbsSandboxPath}
7: getAbsSandboxPath(fileLocation)
20: getAbsSandboxPath()
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()
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
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]],
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(
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()
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.
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}
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
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}}
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}
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
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")
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(
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)
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()
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")
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)}
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}
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}
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}}
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"
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
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
37: Corrected \code{save_path}, the file type, the separator, corrected
41: 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
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_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
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/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}}
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)
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
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
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])