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,

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")

4: \name{path}

5: \alias{path}

6: \title{pathway data list}

9: pathway data list

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}

3: \name{default_report_path}

4: \alias{default_report_path}

8: default_report_path()

11: A path

18: default_report_path()

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}

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)

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)

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()

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)

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

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.

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.

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}

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

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

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

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

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.}

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.

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")

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.

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.

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

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)

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, ...)

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)

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)

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

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}

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

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}

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)

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

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}

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")

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"

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

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()

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)

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}

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,

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

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()

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

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.

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()

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)

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

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)