Found 85001 results in 8409 files, showing top 50 files (show more).
NoRCE:R/pathway.R: [ ] |
---|
351: path <- merge(merge1, symb, by = "gene")
|
65: pathTable <- unique(keggPathwayDB(org_assembly))
|
71: pathfreq <- as.data.frame(table(annot$pathway))
|
99: pathT <- as.character(freq$Var1[enrich])
|
118: pathways <- data.frame(unique(pathT))
|
203: pathTable <- unique(reactomePathwayDB(org_assembly))
|
209: pathfreq <- as.data.frame(table(annot$pathway))
|
235: pathT <- as.character(freq$Var1[enrich])
|
540: pathTable <- unique(WikiPathwayDB(org_assembly))
|
545: pathfreq <- as.data.frame(table(annot$pathID))
|
571: pathT <- as.character(freq$Var1[enrich])
|
578: pathTerms <- as.character(r$pathTerm[match(pathT, r$pathID)])
|
628: pathwayEnrichment <- function(genes,
|
678: pathfreq <- as.data.frame(table(annot$pathTerm))
|
710: pathT <- as.character(freq$Var1[enrich])
|
718: pathTerms <- as.character(r$pathTerm[match(pathT, r$pathID)])
|
270: reactomePathwayDB <- function(org_assembly = c("hg19",
|
357: keggPathwayDB <- function(org_assembly = c("hg19",
|
433: WikiPathwayDB <- function(org_assembly = c("hg19",
|
15: #' @param gmtFile File path of the gmt file
|
91: file.path(x[1], x[2]))
|
95: file.path(x[1], x[2]))
|
155: #' @param gmtFile File path of the gmt file
|
228: file.path(x[1], x[2]))
|
231: file.path(x[1], x[2]))
|
353: return(path)
|
499: #' @param gmtFile File path of the gmt file
|
563: file.path(x[1], x[2]))
|
567: file.path(x[1], x[2]))
|
608: #' @param gmtFile File path of the gmt file
|
703: file.path(x[1], x[2]))
|
706: file.path(x[1], x[2]))
|
1: #' KEGG pathway enrichment
|
22: #' @return KEGG pathway enrichment results
|
68: annot <- pathTable[which(pathTable$symbol %in% genes$g),]
|
72: pathfreq <- pathfreq[which(pathfreq$Freq > 0),]
|
75: geneSize = length(unique(pathTable$symbol))
|
77: bckfreq <- as.data.frame(table(pathTable$pathway))
|
78: notGene <- bckfreq[bckfreq$Var1 %in% pathfreq$Var1,]
|
79: freq <- merge(pathfreq, notGene, by = "Var1")
|
104: r <- annot[annot$pathway %in% pathT,]
|
106: for (i in seq_along(pathT))
|
108: if (length(which(pathT[i] == r$pathway)) > 0)
|
113: as.character(r[which(pathT[i] == r$pathway),]$symbol)),
|
114: paste(pathT[i])))
|
119: tmp <- character(length(pathT))
|
120: if (nrow(pathways) > 0) {
|
122: unlist(lapply(seq_len(nrow(pathways)), function(x)
|
123: tmp[x] <- try(KEGGREST::keggGet(pathT[x])[[1]]$NAME)
|
129: ID = pathT,
|
141: #' Reactome pathway enrichment
|
163: #' @return Reactome pathway enrichment results
|
206: annot <- pathTable[which(pathTable$symbol %in% genes$g),]
|
210: pathfreq <- pathfreq[which(pathfreq$Freq > 0),]
|
212: geneSize = length(unique(pathTable$symbol))
|
214: bckfreq <- as.data.frame(table(pathTable$pathway))
|
215: notGene <- bckfreq[bckfreq$Var1 %in% pathfreq$Var1,]
|
216: freq <- merge(pathfreq, notGene, by = "Var1")
|
240: r <- annot[annot$pathway %in% pathT,]
|
244: for (i in seq_along(pathT))
|
246: if (length(which(pathT[i] == r$pathway)) > 0)
|
251: list(as.character(r[which(pathT[i] == r$pathway),]$symbol)),
|
252: paste(pathT[i])))
|
258: ID = pathT,
|
259: Term = as.character(rt[order(match(rt$pathway, pathT)), ]$name),
|
279: table1 <- data.frame(pathway = rep(names(xx), lapply(xx, length)),
|
282: pn <- data.frame(pathway = rep(names(pn), lapply(pn, length)),
|
288: ty <- table1[grepl("^R-HSA", table1$pathway),]
|
289: pn1 <- pn[grepl("^R-HSA", pn$pathway),]
|
296: ty <- table1[grepl("^R-MMU", table1$pathway),]
|
297: pn1 <- pn[grepl("^R-MMU", pn$pathway),]
|
304: ty <- table1[grepl("^R-DRE", table1$pathway),]
|
305: pn1 <- pn[grepl("^R-DRE", pn$pathway),]
|
312: ty <- table1[grepl("^R-RNO", table1$pathway),]
|
313: pn1 <- pn[grepl("^R-RNO", pn$pathway),]
|
320: ty <- table1[grepl("^R-CEL", table1$pathway),]
|
321: pn1 <- pn[grepl("^R-CEL", pn$pathway),]
|
328: ty <- table1[grepl("^R-SCE", table1$pathway),]
|
329: pn1 <- pn[grepl("^R-SCE", pn$pathway),]
|
342: ty <- table1[grepl("^R-DME", table1$pathway),]
|
343: pn1 <- pn[grepl("^R-DME", pn$pathway),]
|
349: by = "pathway",
|
369: kegg <- org.Hs.eg.db::org.Hs.egPATH2EG
|
377: kegg <- org.Mm.eg.db::org.Mm.egPATH2EG
|
385: kegg <- org.Dr.eg.db::org.Dr.egPATH2EG
|
393: kegg <- org.Rn.eg.db::org.Rn.egPATH2EG
|
401: kegg <- org.Ce.eg.db::org.Ce.egPATH2EG
|
409: kegg <- org.Sc.sgd.db::org.Sc.sgdPATH2ORF
|
417: kegg <- org.Dm.eg.db::org.Dm.egPATH2EG
|
423: pathTable <-
|
424: data.frame(pathway = paste0(prefix, rep(names(kegg2),
|
429: pathTable <- merge(pathTable, x, by = "gene")
|
430: return(pathTable)
|
472: do.call(rbind, strsplit(as.character(gmtFile$pathTerm), '%'))
|
478: pathID = tmp[, 3],
|
479: pathTerm = tmp[, 1]
|
506: #' @return Wiki Pathway Enrichment
|
543: annot <- pathTable[which(pathTable$gene %in% genes$g),]
|
546: pathfreq <- pathfreq[which(pathfreq$Freq > 0),]
|
548: geneSize = length(unique(pathTable$gene))
|
549: bckfreq <- as.data.frame(table(pathTable$pathID))
|
550: notGene <- bckfreq[bckfreq$Var1 %in% pathfreq$Var1,]
|
551: freq <- merge(pathfreq, notGene, by = "Var1")
|
576: r <- annot[annot$pathID %in% pathT,]
|
579: for (i in seq_along(pathT))
|
581: if (length(which(pathT[i] == r$pathID)) > 0)
|
585: list(as.character(r[which(pathT[i] == r$pathID),]$gene)),
|
586: paste(pathT[i])))
|
593: ID = pathT,
|
594: Term = pathTerms,
|
604: #' For a given gmt file of a specific pathway database, pathway enrichment
|
626: #' @return Pathway Enrichment
|
670: pathTable <-
|
675: pathTable <- geneListEnrich(f = gmtFile, isSymbol = isSymbol)
|
677: annot <- pathTable[which(pathTable$symbol %in% genes$g),]
|
679: pathfreq <- pathfreq[which(pathfreq$Freq > 0),]
|
683: geneSize = length(unique(pathTable$symbol))
|
688: bckfreq <- as.data.frame(table(pathTable$pathTerm))
|
690: notGene <- bckfreq[bckfreq$Var1 %in% pathfreq$Var1,]
|
691: freq <- merge(pathfreq, notGene, by = "Var1")
|
716: r <- annot[annot$pathTerm %in% pathT,]
|
720: for (i in seq_along(pathT))
|
722: if (length(which(pathT[i] == r$pathTerm)) > 0)
|
725: list(as.character(r[which(pathT[i] == r$pathTerm),]$symbol)),
|
726: paste(pathT[i])))
|
731: ID = pathT,
|
732: Term = pathTerms,
|
742: #' Convert gmt formatted pathway file to the Pathway ID, Entrez, symbol
|
745: #' @param gmtName Custom pathway gmt file
|
814: colnames(f) <- c('pathTerm', 'Entrez', 'symbol')
|
829: colnames(f) <- c('pathTerm', 'symbol', 'Entrez')
|
851: colnames(f) <- c('pathTerm', 'Entrez', 'symbol')
|
862: colnames(f) <- c('pathTerm', 'symbol', 'Entrez')
|
278: xx <- as.list(reactome.db::reactomePATHID2EXTID)
|
281: pn <- as.list(reactome.db::reactomePATHID2NAME)
|
443: rWikiPathways::downloadPathwayArchive(organism = "Homo sapiens",
|
447: rWikiPathways::downloadPathwayArchive(organism = "Mus musculus",
|
451: rWikiPathways::downloadPathwayArchive(organism = "Danio rerio",
|
455: rWikiPathways::downloadPathwayArchive(organism = "Rattus norvegicus",
|
459: rWikiPathways::downloadPathwayArchive(
|
463: rWikiPathways::downloadPathwayArchive(
|
467: rWikiPathways::downloadPathwayArchive(
|
485: #' WikiPathways Enrichment
|
seq2pathway:R/seq2pathway.r: [ ] |
---|
928: path <-paste(system.file(package="seq2pathway"),
|
856: get_python3_command_path <- function()
|
859: python3_command_path <- Sys.which2("python")
|
1029: script_path <- file.path(tempdir(), name)
|
275: pathwaygene<-length(intersect(toupper(gene_list[[i]]),
|
484: pathwaygene<-length(intersect(toupper(gsmap$genesets[[i]]),
|
843: cmdpath <- Sys.which(cmdname)
|
1051: runseq2pathway<-function(inputfile,
|
1161: gene2pathway_result<-list()
|
1310: gene2pathway_test<-function(dat,DataBase="GOterm",FisherTest=TRUE,
|
1344: gene2pathway_result<-list()
|
854: #get_python3_command_path: funtion from Herve Pages, Bioconductor Maintainance Team, Oct 9 2020
|
858: # python3_command_path <- Sys.which2("python3") #3/3/2021 by Holly
|
860: if (python3_command_path != "")
|
864: return(python3_command_path)}
|
873: # python3_command_path <- Sys.which2("python")
|
874: python3_command_path <- Sys.which2("python3") #3/3/2021 by Holly
|
875: if (python3_command_path != ""){
|
876: print(paste0("python3 found: ",python3_command_path))
|
877: return(python3_command_path)}
|
880: " 'python3' (or 'python') executable is in your PATH.")
|
924: ### assign the path of main function
|
932: path <-paste(system.file(package="seq2pathway"),
|
976: sink(file.path(tempdir(),name,fsep = .Platform$file.sep))}
|
994: cat("'", path, "').load_module()",sep="")
|
1030: if (!file.exists(script_path))
|
1032: mypython <- get_python3_command_path()
|
1034: response <- system2(mypython, args=script_path,
|
75: data(gencode_coding,package="seq2pathway.data")
|
155: data(gencode_coding,package="seq2pathway.data")
|
214: ####load GP pathway information
|
216: data(GO_BP_list,package="seq2pathway.data")
|
217: data(GO_MF_list,package="seq2pathway.data")
|
218: data(GO_CC_list,package="seq2pathway.data")
|
219: data(Des_BP_list,package="seq2pathway.data")
|
220: data(Des_MF_list,package="seq2pathway.data")
|
221: data(Des_CC_list,package="seq2pathway.data")
|
223: data(GO_BP_list,package="seq2pathway.data")
|
224: data(Des_BP_list,package="seq2pathway.data")
|
226: data(GO_MF_list,package="seq2pathway.data")
|
227: data(Des_MF_list,package="seq2pathway.data")
|
229: data(GO_CC_list,package="seq2pathway.data")
|
230: data(Des_CC_list,package="seq2pathway.data")
|
237: data(GO_GENCODE_df_hg_v36,package="seq2pathway.data")
|
240: data(GO_GENCODE_df_hg_v19,package="seq2pathway.data")
|
243: data(GO_GENCODE_df_mm_vM25,package="seq2pathway.data")
|
246: data(GO_GENCODE_df_mm_vM1,package="seq2pathway.data")
|
280: c<-pathwaygene-a
|
289: mdat[i,7]<-pathwaygene
|
321: pathwaygene<-length(intersect(toupper(GO_BP_list[[i]]),
|
326: c<-pathwaygene-a
|
335: mdat[i,7]<-pathwaygene
|
367: pathwaygene<-length(intersect(toupper(GO_CC_list[[i]]),
|
372: c<-pathwaygene-a
|
381: mdat[i,7]<-pathwaygene
|
413: pathwaygene<-length(intersect(toupper(GO_MF_list[[i]]),
|
418: c<-pathwaygene-a
|
427: mdat[i,7]<-pathwaygene
|
455: data(Msig_GENCODE_df_hg_v36,package="seq2pathway.data")
|
458: data(Msig_GENCODE_df_hg_v19,package="seq2pathway.data")
|
461: data(Msig_GENCODE_df_mm_vM25,package="seq2pathway.data")
|
464: data(Msig_GENCODE_df_mm_vM1,package="seq2pathway.data")
|
489: c<-pathwaygene-a
|
498: mdat[i,7]<-pathwaygene
|
549: data(gencode_coding,package="seq2pathway.data")
|
647: rungene2pathway <-
|
704: colnames(res) <- c(paste(colnames(dat),"2pathscore",sep=""))
|
705: print("gene2pathway calculates score....... done")
|
711: rungene2pathway_EmpiricalP <-
|
770: colnames(res) <- c(paste(colnames(dat),"2pathscore",sep=""))
|
829: colnames(res_p) <- c(paste(colnames(dat),"2pathscore_Pvalue",sep=""))
|
832: print("pathwayscore Empirical Pvalue calculation..........done")
|
849: success <- grepl(pattern1, cmdpath, fixed=TRUE) ||
|
850: grepl(pattern2, cmdpath, fixed=TRUE)
|
851: if (success) cmdpath else ""
|
1007: #cat(paste("inputpath=","'",inputpath,"/'",sep=""),sep="\n")
|
1009: #cat(paste("outputpath=","'",outputpath,"/'",sep=""),sep="\n")
|
1018: cat(paste("pwd=","'",system.file(package="seq2pathway.data"),"/extdata/'",sep=""),sep="\n")
|
1103: data(GO_BP_list,package="seq2pathway.data")
|
1104: data(GO_MF_list,package="seq2pathway.data")
|
1105: data(GO_CC_list,package="seq2pathway.data")
|
1106: data(Des_BP_list,package="seq2pathway.data")
|
1107: data(Des_CC_list,package="seq2pathway.data")
|
1108: data(Des_MF_list,package="seq2pathway.data")
|
1134: #############################rungene2pathway,normalization,empiricalP,summary table
|
1166: GO_BP_FAIME<-rungene2pathway(dat=dat_CP,gsmap=GO_BP_list,alpha=alpha,logCheck=logCheck,
|
1171: GO_BP_FAIME_Pvalue<-rungene2pathway_EmpiricalP(dat=dat_CP,gsmap=GO_BP_list,
|
1174: ########gene2pathway table
|
1190: gene2pathway_result[[n.list]]<-GO_BP_N_P
|
1191: names(gene2pathway_result)[n.list]<-c("GO_BP")
|
1195: GO_MF_FAIME<-rungene2pathway(dat=dat_CP,gsmap=GO_MF_list,alpha=alpha,logCheck=logCheck,
|
1198: GO_MF_FAIME_Pvalue<-rungene2pathway_EmpiricalP(dat=dat_CP,gsmap=GO_MF_list,
|
1215: gene2pathway_result[[n.list]]<-GO_MF_N_P
|
1216: names(gene2pathway_result)[n.list]<-c("GO_MF")
|
1220: GO_CC_FAIME<-rungene2pathway(dat=dat_CP,gsmap=GO_CC_list,alpha=alpha,logCheck=logCheck,
|
1223: GO_CC_FAIME_Pvalue<-rungene2pathway_EmpiricalP(dat=dat_CP,gsmap=GO_CC_list,
|
1241: gene2pathway_result[[n.list]]<-GO_CC_N_P
|
1242: names(gene2pathway_result)[n.list]<-c("GO_CC")
|
1245: dat_FAIME<-rungene2pathway(dat=dat_CP,gsmap=DataBase,alpha=alpha,logCheck=logCheck,
|
1248: dat_FAIME_Pvalue<-rungene2pathway_EmpiricalP(dat=dat_CP,gsmap=DataBase,
|
1255: colnames(DB_N_P)<-c("score2pathscore_Normalized","score2pathscore_Pvalue")
|
1274: gene2pathway_result<-DB_N_P[,c(ncol(DB_N_P),1:(ncol(DB_N_P)-1))]
|
1276: print("gene2pathway analysis is done")
|
1279: if(exists("gene2pathway_result")&exists("FS_test")){
|
1283: TotalResult[[2]]<-gene2pathway_result
|
1284: names(TotalResult)[2]<-"gene2pathway_result.FAIME"
|
1286: names(TotalResult)[3]<-"gene2pathway_result.FET"
|
1289: }else if(exists("gene2pathway_result")&exists("FS_test")==FALSE){
|
1293: TotalResult[[2]]<-gene2pathway_result
|
1294: names(TotalResult)[2]<-"gene2pathway_result.FAIME"
|
1298: else if(exists("gene2pathway_result")==FALSE&exists("FS_test")){
|
1303: names(TotalResult)[2]<-"gene2pathway_result.FET"
|
1326: data(GO_BP_list,package="seq2pathway.data")
|
1327: data(GO_MF_list,package="seq2pathway.data")
|
1328: data(GO_CC_list,package="seq2pathway.data")
|
1329: data(Des_BP_list,package="seq2pathway.data")
|
1330: data(Des_CC_list,package="seq2pathway.data")
|
1331: data(Des_MF_list,package="seq2pathway.data")
|
1346: #############################rungene2pathway,normalization,empiricalP,summary table
|
1348: gene2pathway_result<-list()
|
1352: GO_BP_method<-rungene2pathway(dat=dat,gsmap=GO_BP_list,alpha=alpha,logCheck=logCheck,
|
1358: GO_BP_method_Pvalue<-rungene2pathway_EmpiricalP(dat=dat,gsmap=GO_BP_list,alpha=alpha,
|
1364: ########gene2pathway table
|
1376: gene2pathway_result[[n.list]]<-GO_BP_N_P
|
1377: names(gene2pathway_result)[n.list]<-c("GO_BP")
|
1380: GO_MF_method<-rungene2pathway(dat=dat,gsmap=GO_MF_list,alpha=alpha,logCheck=logCheck,
|
1384: GO_MF_method_Pvalue<-rungene2pathway_EmpiricalP(dat=dat,gsmap=GO_MF_list,alpha=alpha,
|
1402: gene2pathway_result[[n.list]]<-GO_MF_N_P
|
1403: names(gene2pathway_result)[n.list]<-c("GO_MF")
|
1406: GO_CC_method<-rungene2pathway(dat=dat,gsmap=GO_CC_list,alpha=alpha,logCheck=logCheck,
|
1410: GO_CC_method_Pvalue<-rungene2pathway_EmpiricalP(dat=dat,gsmap=GO_CC_list,alpha=alpha,
|
1427: gene2pathway_result[[n.list]]<-GO_CC_N_P
|
1428: names(gene2pathway_result)[n.list]<-c("GO_CC")
|
1431: dat_method<-rungene2pathway(dat=dat,gsmap=DataBase,alpha=alpha,logCheck=logCheck,
|
1435: dat_method_Pvalue<-rungene2pathway_EmpiricalP(dat=dat,gsmap=DataBase,alpha=alpha,
|
1443: colnames(DB_N_P)<-c("score2pathscore_Normalized","score2pathscore_Pvalue")
|
1464: gene2pathway_result<-DB_N_P[,c(ncol(DB_N_P),1:(ncol(DB_N_P)-1))]
|
1466: print("gene2pathway analysis is done")
|
1470: if(exists("gene2pathway_result")&exists("FS_test")){
|
1472: TResult[[1]]<-gene2pathway_result
|
1473: names(TResult)[1]<-"gene2pathway_result.2"
|
1475: names(TResult)[2]<-"gene2pathway_result.FET"
|
1476: }else if(exists("gene2pathway_result")&exists("FS_test")==FALSE){
|
1477: TResult<-gene2pathway_result
|
1479: else if(exists("gene2pathway_result")==FALSE&exists("FS_test")){
|
CHRONOS:R/pathwayToGraph.R: [ ] |
---|
101: path <- paste(dir, file, sep='//')
|
34: paths <- list.files(xmlDir)
|
83: pathwayToGraph <- function (i, ...)
|
3: createPathwayGraphs <- function(org, pathways, edgeTypes, doubleEdges, choice,
|
141: getPathwayType <- function(filepath, file)
|
159: metabolicPathwayToGraph <- function(filepath)
|
347: nonMetabolicPathwayToGraph <- function(filepath, doubleEdges, groupMode)
|
102: gr <- metabolicPathwayToGraph(path)
|
119: path <- paste(dir, file, sep='//')
|
120: gr <- nonMetabolicPathwayToGraph(path, doubleEdges, groupMode)
|
225: removeCompoundsMetabolicGraph <- function(path)
|
228: if(path$name != gsub('ec','',path$name)) { nodeType<-"enzyme" }
|
229: enzymes <- which(path$vertices$type == nodeType)
|
230: vid <- path$vertices$id
|
233: if ( length(path$edges) > 0 )
|
243: for (r1 in path$edges[path$edges$e1 ==
|
244: path$vertices[,'id'][enzymes[j]],]$e2)
|
247: for (r2 in path$edges[path$edges$e1 ==
|
248: path$vertices[,'id'][which(vid == r1)],]$e2)
|
252: nid <- vid[which(path$vertices$id == r2)]
|
267: xid <- path$vertices$id[enzymes]
|
268: names <- path$vertices$names[enzymes]
|
513: removeCompoundsNonMetabolicGraph <- function(path, unique, edgeTypes)
|
515: if (is.null(path)) return(NULL)
|
516: vid <- as.numeric(path$vertices$id)
|
517: etype <- path$vertices$type
|
519: if(path$name != gsub('ko','',path$name)) { nodeType <- "ortholog" }
|
522: genesIndx <- which(path$vertices$type == nodeType)
|
528: neighbors <- path$edges$e2[path$edges$e1 == vid[gi]]
|
546: idx1 <- which( path$edges$e1 == vid[gi] )
|
547: idx2 <- which( path$edges$e2 == vid[nbrId] )
|
549: TT <- c( TT, paste((path$edges$type[idx]), collapse='_') )
|
557: cpdNeighbors <- path$edges$e2[
|
558: which(path$edges$e1 == vid[nbrId]) ]
|
586: names <- unique(path$vertices$names[genesIndx])
|
598: idx1 <- which(path$vertices$id == source[i])
|
599: idx2 <- which(path$vertices$id == destin[i])
|
600: source[i] <- names[ names == path$vertices$names[idx1] ]
|
601: destin[i] <- names[ names == path$vertices$names[idx2] ]
|
623: gids <- path$vertices$id[genesIndx]
|
624: names <- unname(path$vertices$names[genesIndx])
|
31: # Choose valid pathways
|
32: if (missing(pathways))
|
37: if (!missing(pathways))
|
39: paths <- paste(org, pathways, '.xml', sep='')
|
44: # Create compact adjacency matrices for given pathways.
|
45: types <- getPathwayType(paste(xmlDir, paths, sep='//'))
|
46: N <- length(paths)
|
56: funcName=pathwayToGraph,
|
59: N=length(paths),
|
61: xmlDir, paths, types, FALSE, edgeTypes,
|
64: names(cAdjMats) <- gsub('.xml', '', paths)
|
67: eAdjMats <- .doSafeParallel(funcName=pathwayToGraph,
|
70: N=length(paths),
|
72: xmlDir, paths, types, TRUE, edgeTypes,
|
75: names(eAdjMats) <- gsub('.xml', '', paths)
|
143: types <- vector(mode='numeric', length=length(filepath))
|
144: for (i in 1:length(filepath))
|
146: num <- tail(unlist(strsplit(filepath[i], '//')), 1)
|
156: # Graph from Metabolic Pathways
|
161: xmlDoc <- tryCatch(xmlTreeParse(filepath,error=NULL),
|
344: # Graph from Mon Metabolic Pathways
|
350: xmlDoc <- tryCatch(xmlTreeParse(filepath,error=NULL),
|
49: 'nonMetabolicPathwayToGraph', 'expandMetabolicGraph',
|
51: 'metabolicPathwayToGraph', 'expandNonMetabolicGraph',
|
609: # Set new interaction types to apathetic
|
732: # apathetic 3
|
biodbKegg:R/KeggPathwayConn.R: [ ] |
---|
61: path <- self$getEntry(path.id)
|
59: for (path.id in id) {
|
127: for (path.id in id) {
|
304: path_idx <- sub('^[^0-9]+', '', id)
|
322: path_idx <- sub('^[^0-9]+', '', id)
|
29: KeggPathwayConn <- R6::R6Class("KeggPathwayConn",
|
40: super$initialize(db.name='pathway', db.abbrev='path', ...)
|
62: if ( ! is.null(path) && path$hasField('kegg.module.id')) {
|
65: for (mod.id in path$getFieldValue('kegg.module.id')) {
|
144: graph[[path.id]]=list(vertices=vert, edges=edg)
|
147: graph[[path.id]]=NULL
|
309: params=c(org_name='map', mapno=path_idx,
|
325: img_filename <- paste0('pathwaymap-', path_idx)
|
331: biodb::error0('Impossible to find pathway image path inside',
|
335: tmp_file <- file.path(cache$getTmpFolderPath(),
|
2: #' The connector class to KEGG Pathway database.
|
16: #' conn=mybiodb$getFactory()$createConn('kegg.pathway')
|
18: #' # Retrieve all reactions related to a mouse pathway:
|
21: #' # Get a pathway graph
|
44: #' Retrieves all reactions part of a KEGG pathway. Connects to
|
45: #' KEGG databases, and walk through all pathways submitted, and
|
58: # Loop on all Pathway IDs
|
89: #' Takes a list of pathways IDs and converts them to the specified organism,
|
92: #' @param org The organism in which to search for pathways, as a KEGG organism
|
113: #' Builds a pathway graph in the form of two tables of vertices and edges,
|
115: #' @param id A character vector of KEGG pathway entry IDs.
|
120: #' @return A named list whose names are the pathway IDs, and values are lists
|
126: # Loop on all pathway IDs
|
158: #' Builds a pathway graph, as an igraph object, using KEGG database.
|
159: #' @param id A character vector of KEGG pathway entry IDs.
|
196: #' Create a pathway graph picture, with some of its elements colorized.
|
197: #' @param id A KEGG pathway ID.
|
227: #' Extracts shapes from a pathway map image.
|
228: #' @param id A KEGG pathway ID.
|
303: # Extract pathway number
|
308: 'show_pathway'),
|
329: 'src="([^"]+)"(\\s+.*)?\\s+(name|id)="pathwayimage"')
|
332: ' HTML page for pathway ID ', id, '.')
|
342: img_file <- cache$getFilePath(cid, img_filename, 'png')
|
22: #' graph=conn$buildPathwayGraph('mmu00260')
|
98: convertToOrgPathways=function(id, org) {
|
122: buildPathwayGraph=function(id, directed=FALSE, drop=TRUE) {
|
166: getPathwayIgraph=function(id, directed=FALSE, drop=TRUE) {
|
173: g <- self$buildPathwayGraph(id=id, directed=directed, drop=FALSE)
|
210: pix <- private$getPathwayImage(id)
|
213: shapes <- self$extractPathwayMapShapes(id=id, color2ids=color2ids)
|
233: ,extractPathwayMapShapes=function(id, color2ids) {
|
237: html <- private$getPathwayHtml(id)
|
301: ,getPathwayHtml=function(id) {
|
319: getPathwayImage=function(id) {
|
321: html <- private$getPathwayHtml(id)
|
cisPath:inst/extdata/D3/cisPath.js: [ ] |
---|
127: var path = svg.append('svg:g').selectAll('path'),
|
2499: function ShowShortestPath(){
|
2: var basePath1="./PPIinfo/";
|
3: var basePath2="./PPIinfo/";
|
2630: function ShowShortestPath1(){
|
2711: var swiss2paths={};
|
2765: function showPath10(){
|
2778: function addResultPath10(p){
|
2784: function addFirstPath10(p){
|
2800: function addLastPath10(p){
|
2823: function addPreviousPath10(p){
|
2842: function addNextPath10(p){
|
2560: var resultPaths=[];
|
2561: function ShowPaths(allPaths){
|
2616: function ShowPathView(index){
|
2712: function generatePaths(swiss, root){
|
2729: function ShowShortestPathExp(){
|
2763: var showPathFirst=0;
|
2764: var showPathEnd=10;
|
3044: function getCisPathJS(){
|
3065: function getCisPathJSRetry(urltry){
|
3096: function getPathsForTargetProtein(swissID){
|
3118: function getPathsForTargetProteinRetry(urltry){
|
53: .append('svg:path')
|
68: .append('svg:path')
|
94: .append('svg:path')
|
109: .append('svg:path')
|
115: var drag_line = svg.append('svg:path')
|
166: path.attr('d', function(d) {
|
360: // path (link) group
|
381: path = path.data(links);
|
384: path.classed('selected', function(d) { return d === selected_link; })
|
393: path.enter().append('svg:path')
|
414: path.exit().remove();
|
2384: ///////////////////////////////////////////////////////////////////////shortest path
|
2504: alert("No path between this two proteins!");
|
2508: alert("No path between this two proteins!");
|
2568: addTh(mycurrent_row, "Path");
|
2601: mycurrent_button.id = "path"+x;
|
2614: ShowPathView("path0");
|
2701: alert("Sorry, detect no path from "+swiss1+" to "+ swiss2);
|
3097: var url="./js/"+swissID+"_path.js";
|
954: document.getElementById("detectPath").disabled=true;
|
1380: idx=pathLen-1-idx;
|
1415: var url=basePath2+sourceSwiss+".js";
|
1679: var url=basePath2+swiss1+".js";
|
1684: if(this.url==(basePath2+swiss1+".js")){
|
1820: var url=basePath2+"A0A5B9.js";
|
1827: debugObj("basePath1:"+basePath1);
|
1831: basePath1="../geneset20140628/";
|
1832: basePath2="../20140628PPI/";
|
1833: debugObj("basePath1:"+basePath1);
|
1845: var url=basePath2+"gene2swiss.js";
|
1899: var url=basePath2+"swiss2gene.js";
|
1954: var url=basePath2+"swiss2swiss.js";
|
2021: var url=basePath1+"PPI.js";
|
2411: ShowShortestPath();
|
2421: document.getElementById("detectPath").disabled=false;
|
2426: document.getElementById("detectPath").disabled=true;
|
2438: document.getElementById("detectPath").disabled=false;
|
2443: document.getElementById("detectPath").disabled=true;
|
2515: document.getElementById("detectPath").disabled=true;
|
2530: document.getElementById("detectPath").disabled=false;
|
2543: setTimeout("ShowShortestPath1()",1000);
|
2549: setTimeout("ShowShortestPath1()",1000);
|
2574: mycurrent_row.id="pathrow"+x;
|
2608: showPath10();
|
2611: document.getElementById("detectPath").disabled=false;
|
2625: document.getElementById("pathrow"+x).className="rowNotSelected";
|
2627: document.getElementById("pathrow"+i).className="rowSelected";
|
2705: swiss2paths={};
|
2707: debugObj(swiss2paths[swiss2]);
|
2708: debugObj(swiss2paths[swiss2].length);
|
2709: ShowPaths(swiss2paths[swiss2]);
|
2713: swiss2paths[swiss]=[];
|
2715: swiss2paths[swiss].push(swiss);
|
2724: for(var y in swiss2paths[nodes[x]]){
|
2725: swiss2paths[swiss].push(swiss2paths[nodes[x]][y]+"#"+swiss);
|
2760: ShowShortestPath();
|
2771: addResultPath10(p);
|
2772: addFirstPath10(p);
|
2773: addPreviousPath10(p);
|
2774: addNextPath10(p);
|
2775: addLastPath10(p);
|
2796: resultSPAN.addEventListener("click", function(e){showPathFirst=0;showPath10();}, false);
|
2819: resultSPAN.addEventListener("click", function(e){showPathFirst=newFirst;showPath10();}, false);
|
2838: resultSPAN.addEventListener("click", function(e){showPathFirst=newFirst;showPath10();}, false);
|
2857: resultSPAN.addEventListener("click", function(e){showPathFirst=newFirst;showPath10();}, false);
|
2879: document.getElementById("pathrow"+i).style.display="none";
|
2882: document.getElementById("pathrow"+i).style.display="";
|
3020: ...(31 bytes skipped)...ange", function(e){document.getElementById('targetPtxt').value=this.value;checkValid2();ShowShortestPath();}, false);
|
3108: json.paths.pop();
|
3109: ShowPaths(json.paths);
|
3138: json.paths.pop();
|
3139: ShowPaths(json.paths);
|
956: document.getElementById("allShortestPaths").style.display="none";
|
957: document.getElementById("allShortestPathsP").style.display="none";
|
1253: graphName = "cisPathValue#"+graphName;
|
1267: if(key.substr(0,13)!="cisPathValue#"){
|
1285: graphName = "cisPathValue#"+graphName;
|
1306: graphName = "cisPathValue#"+graphName;
|
1327: if(key.substr(0,13)!="cisPathValue#"){
|
1418: callback: "cisPathCallBack",
|
1682: callback: "cisPathCallBack",
|
1823: callback: "cisPathCallBack",
|
1850: callback: "cisPathCallBack",
|
1880: callback: "cisPathCallBack",
|
1905: callback: "cisPathCallBack",
|
1935: callback: "cisPathCallBack",
|
1960: callback: "cisPathCallBack",
|
1990: callback: "cisPathCallBack",
|
2025: callback: "cisPathCallBack",
|
2063: callback: "cisPathCallBack",
|
2110: getCisPathJS();
|
2378: var graphName="cisPathHTML";
|
2476: function ShowShortestPathWorker(){
|
2477: var worker = new Worker("./D3/cisPathWorker.js");
|
2480: var resultPaths=event.data.resultPaths;
|
2481: ShowPaths(resultPaths);
|
2484: var resultPaths=[];
|
2485: ShowPaths(resultPaths);
|
2514: document.getElementById("detectPathExp").disabled=true;
|
2521: document.getElementById("allShortestPaths").style.display="none";
|
2522: document.getElementById("allShortestPathsP").style.display="none";
|
2529: document.getElementById("detectPathExp").disabled=false;
|
2533: getPathsForTargetProtein(swiss2);
|
2539: ShowShortestPathWorker();
|
2562: resultPaths=allPaths;
|
2563: var table=document.getElementById("allShortestPaths");
|
2571: for(var x in allPaths){
|
2572: var nodes=allPaths[x].split("#");
|
2602: mycurrent_button.addEventListener("click", function(e){ShowPathView(this.id);}, false);
|
2607: showPathFirst=0;
|
2610: document.getElementById("detectPathExp").disabled=false;
|
2612: document.getElementById("allShortestPaths").style.display="";
|
2613: document.getElementById("allShortestPathsP").style.display="";
|
2617: var total=resultPaths.length;
|
2619: var nodes=resultPaths[i].split("#");
|
2706: generatePaths(swiss2, swiss1);
|
2723: generatePaths(nodes[x], root);
|
2767: var p=document.getElementById("allShortestPathsP");
|
2780: var content="Results: "+showPathFirst+"-"+showPathEnd+" of "+resultPaths.length+" ";
|
2790: if(showPathFirst==0){
|
2805: var newFirst=(resultPaths.length-resultPaths.length%10);
|
2806: if(newFirst==resultPaths.length){
|
2807: newFirst=resultPaths.length-10;
|
2813: if(showPathEnd==resultPaths.length){
|
2828: if(showPathFirst==0){
|
2834: var newFirst=showPathFirst-10;
|
2847: if(showPathEnd==resultPaths.length){
|
2853: var newFirst=showPathFirst+10;
|
2854: if(newFirst >= resultPaths.length){
|
2855: newFirst = (resultPaths.length-resultPaths.length%10);
|
2863: var total=resultPaths.length;
|
2864: if(showPathFirst >= total){
|
2865: showPathFirst=(total-total%10);
|
2867: if(showPathFirst == total){
|
2868: showPathFirst = total-10;
|
2870: if(showPathFirst < 0){
|
2871: showPathFirst = 0;
|
2873: showPathFirst=showPathFirst-(showPathFirst%10);
|
2874: showPathEnd=showPathFirst+10;
|
2875: if(showPathEnd > total){
|
2876: showPathEnd = total;
|
2881: for(var i=showPathFirst;i<showPathEnd;i++){
|
3049: callback: "cisPathCallBack",
|
3061: getCisPathJSRetry(this.url);
|
3078: callback: "cisPathCallBack",
|
3090: getCisPathJSRetry(this.url);
|
3101: callback: "cisPathCallBack",
|
3114: getPathsForTargetProteinRetry(this.url);
|
3131: callback: "cisPathCallBack",
|
3144: getPathsForTargetProteinRetry(this.url);
|
3151: document.getElementById("detectPathExp").disabled=true;
|
3156: document.getElementById("detectPathExp").disabled=false;
|
cisPath:inst/extdata/D3/cisPathWeb.js: [ ] |
---|
127: var path = svg.append('svg:g').selectAll('path'),
|
2501: function ShowShortestPath(){
|
2: var basePath1="./PPIinfo/";
|
3: var basePath2="./PPIinfo/";
|
2632: function ShowShortestPath1(){
|
2719: var swiss2paths={};
|
2753: function showPath10(){
|
2766: function addResultPath10(p){
|
2772: function addFirstPath10(p){
|
2788: function addLastPath10(p){
|
2811: function addPreviousPath10(p){
|
2830: function addNextPath10(p){
|
2548: var resultPaths=[];
|
2549: function ShowPaths(allPaths){
|
2615: function ShowPathView(index){
|
2720: function generatePaths(swiss, root){
|
2737: function ShowShortestPathExp(){
|
2751: var showPathFirst=0;
|
2752: var showPathEnd=10;
|
53: .append('svg:path')
|
68: .append('svg:path')
|
94: .append('svg:path')
|
109: .append('svg:path')
|
115: var drag_line = svg.append('svg:path')
|
166: path.attr('d', function(d) {
|
360: // path (link) group
|
381: path = path.data(links);
|
384: path.classed('selected', function(d) { return d === selected_link; })
|
393: path.enter().append('svg:path')
|
414: path.exit().remove();
|
2386: ///////////////////////////////////////////////////////////////////////shortest path
|
2506: alert("No path between this two proteins!");
|
2510: alert("No path between this two proteins!");
|
2554: alert("Sorry, detect no path from "+swiss1+" to "+ swiss2);
|
2566: addTh(mycurrent_row, "Path");
|
2599: mycurrent_button.id = "path"+x;
|
2613: ShowPathView("path0");
|
2705: alert("Sorry, detect no path from "+name1+" to "+ name2);
|
954: document.getElementById("detectPath").disabled=true;
|
1380: idx=pathLen-1-idx;
|
1415: var url=basePath2+sourceSwiss+".js";
|
1679: var url=basePath2+swiss1+".js";
|
1684: if(this.url==(basePath2+swiss1+".js")){
|
1820: var url=basePath2+"A0A5B9.js";
|
1827: debugObj("basePath1:"+basePath1);
|
1831: basePath1="../geneset20140628/";
|
1832: basePath2="../20140628PPI/";
|
1833: debugObj("basePath1:"+basePath1);
|
1845: var url=basePath2+"gene2swiss.js";
|
1899: var url=basePath2+"swiss2gene.js";
|
1954: var url=basePath2+"swiss2swiss.js";
|
2021: var url=basePath1+"PPI.js";
|
2413: ShowShortestPath();
|
2423: document.getElementById("detectPath").disabled=false;
|
2428: document.getElementById("detectPath").disabled=true;
|
2440: document.getElementById("detectPath").disabled=false;
|
2445: document.getElementById("detectPath").disabled=true;
|
2517: document.getElementById("detectPath").disabled=true;
|
2531: setTimeout("ShowShortestPath1()",1000);
|
2537: setTimeout("ShowShortestPath1()",1000);
|
2558: document.getElementById("detectPath").disabled=false;
|
2572: mycurrent_row.id="pathrow"+x;
|
2606: showPath10();
|
2610: document.getElementById("detectPath").disabled=false;
|
2627: document.getElementById("pathrow"+x).className="rowNotSelected";
|
2629: document.getElementById("pathrow"+i).className="rowSelected";
|
2709: document.getElementById("detectPath").disabled=false;
|
2713: swiss2paths={};
|
2715: debugObj(swiss2paths[swiss2]);
|
2716: debugObj(swiss2paths[swiss2].length);
|
2717: ShowPaths(swiss2paths[swiss2]);
|
2721: swiss2paths[swiss]=[];
|
2723: swiss2paths[swiss].push(swiss);
|
2732: for(var y in swiss2paths[nodes[x]]){
|
2733: swiss2paths[swiss].push(swiss2paths[nodes[x]][y]+"#"+swiss);
|
2748: ShowShortestPath();
|
2759: addResultPath10(p);
|
2760: addFirstPath10(p);
|
2761: addPreviousPath10(p);
|
2762: addNextPath10(p);
|
2763: addLastPath10(p);
|
2784: resultSPAN.addEventListener("click", function(e){showPathFirst=0;showPath10();}, false);
|
2807: resultSPAN.addEventListener("click", function(e){showPathFirst=newFirst;showPath10();}, false);
|
2826: resultSPAN.addEventListener("click", function(e){showPathFirst=newFirst;showPath10();}, false);
|
2845: resultSPAN.addEventListener("click", function(e){showPathFirst=newFirst;showPath10();}, false);
|
2867: document.getElementById("pathrow"+i).style.display="none";
|
2870: document.getElementById("pathrow"+i).style.display="";
|
956: document.getElementById("allShortestPaths").style.display="none";
|
957: document.getElementById("allShortestPathsP").style.display="none";
|
1253: graphName = "cisPathValue#"+graphName;
|
1267: if(key.substr(0,13)!="cisPathValue#"){
|
1285: graphName = "cisPathValue#"+graphName;
|
1306: graphName = "cisPathValue#"+graphName;
|
1327: if(key.substr(0,13)!="cisPathValue#"){
|
1418: callback: "cisPathCallBack",
|
1682: callback: "cisPathCallBack",
|
1823: callback: "cisPathCallBack",
|
1850: callback: "cisPathCallBack",
|
1880: callback: "cisPathCallBack",
|
1905: callback: "cisPathCallBack",
|
1935: callback: "cisPathCallBack",
|
1960: callback: "cisPathCallBack",
|
1990: callback: "cisPathCallBack",
|
2025: callback: "cisPathCallBack",
|
2063: callback: "cisPathCallBack",
|
2380: var graphName="cisPathHTML";
|
2478: function ShowShortestPathWorker(){
|
2479: var worker = new Worker("./D3/cisPathWorker.js");
|
2482: var resultPaths=event.data.resultPaths;
|
2483: ShowPaths(resultPaths);
|
2486: var resultPaths=[];
|
2487: ShowPaths(resultPaths);
|
2516: document.getElementById("detectPathExp").disabled=true;
|
2523: document.getElementById("allShortestPaths").style.display="none";
|
2524: document.getElementById("allShortestPathsP").style.display="none";
|
2527: ShowShortestPathWorker();
|
2550: resultPaths=allPaths;
|
2551: if(resultPaths.length==0){
|
2557: document.getElementById("detectPathExp").disabled=false;
|
2561: var table=document.getElementById("allShortestPaths");
|
2569: for(var x in allPaths){
|
2570: var nodes=allPaths[x].split("#");
|
2600: mycurrent_button.addEventListener("click", function(e){ShowPathView(this.id);}, false);
|
2605: showPathFirst=0;
|
2609: document.getElementById("detectPathExp").disabled=false;
|
2611: document.getElementById("allShortestPaths").style.display="";
|
2612: document.getElementById("allShortestPathsP").style.display="";
|
2616: var total=resultPaths.length;
|
2618: if(i>=resultPaths.length){
|
2621: var nodes=resultPaths[i].split("#");
|
2708: document.getElementById("detectPathExp").disabled=false;
|
2714: generatePaths(swiss2, swiss1);
|
2731: generatePaths(nodes[x], root);
|
2755: var p=document.getElementById("allShortestPathsP");
|
2768: var content="Results: "+showPathFirst+"-"+showPathEnd+" of "+resultPaths.length+" ";
|
2778: if(showPathFirst==0){
|
2793: var newFirst=(resultPaths.length-resultPaths.length%10);
|
2794: if(newFirst==resultPaths.length){
|
2795: newFirst=resultPaths.length-10;
|
2801: if(showPathEnd==resultPaths.length){
|
2816: if(showPathFirst==0){
|
2822: var newFirst=showPathFirst-10;
|
2835: if(showPathEnd==resultPaths.length){
|
2841: var newFirst=showPathFirst+10;
|
2842: if(newFirst >= resultPaths.length){
|
2843: newFirst = (resultPaths.length-resultPaths.length%10);
|
2851: var total=resultPaths.length;
|
2852: if(showPathFirst >= total){
|
2853: showPathFirst=(total-total%10);
|
2855: if(showPathFirst == total){
|
2856: showPathFirst = total-10;
|
2858: if(showPathFirst < 0){
|
2859: showPathFirst = 0;
|
2861: showPathFirst=showPathFirst-(showPathFirst%10);
|
2862: showPathEnd=showPathFirst+10;
|
2863: if(showPathEnd > total){
|
2864: showPathEnd = total;
|
2869: for(var i=showPathFirst;i<showPathEnd;i++){
|
2942: document.getElementById("detectPathExp").disabled=true;
|
2947: document.getElementById("detectPathExp").disabled=false;
|
rtracklayer:R/ucsc.R: [ ] |
---|
1597: path <- ucscURLTable[key]
|
364: label_path <- "//select[@name = 'hgta_track']/option/text()"
|
366: track_path <- "//select[@name = 'hgta_track']/option/@value"
|
365: labels <- sub("\n.*$", "", sapply(getNodeSet(doc, label_path), xmlValue))
|
367: tracks <- unlist(getNodeSet(doc, track_path))
|
1572: upload <- fileUpload(path(object), "text/plain")
|
1598: if (is.na(path))
|
1601: path <- paste0(path, '?redirect="manual"')
|
1603: paste(object@url, path, sep="")
|
famat:R/compl_data.R: [ ] |
---|
568: path<-h[2]
|
710: path<-paste(stringr::str_sub(k, 1, 3),
|
858: path<-stringr::str_split(s[1], "__")[[1]]
|
366: notin_path<-vapply(elem_names, function(e){
|
369: nb_path<-length(first_item[first_item %in% "X"])
|
387: kegg_path<-pathways[stringr::str_sub(pathways, 1, 3) == "hsa"]
|
390: path_walks_k<-vapply(kegg_path, function(x){
|
396: wp_path<-pathways[stringr::str_sub(pathways, 1, 2) == "WP"]
|
397: path_walks_w<-vapply(wp_path, function(x){
|
404: path_walks_r<-vapply(first_walks_r, function(x){
|
425: path_walks<-rbind(final_walks_r, path_walks_k,path_walks_w)
|
536: cluster_elem<-save_cluster_elem<-listele[[1]];notin_path<-listele[[2]]
|
585: path_inter<-tagged[tagged$path == path,]
|
601: heatmap<-listhtmp[[1]]; notin_path<-listhtmp[[2]]; hierapath<-listhtmp[[3]]
|
670: rea_path<-sorted_path[stringr::str_sub(sorted_path, 1, 3) == "R-H"]
|
708: kegg_path<-sorted_path[stringr::str_sub(sorted_path, 1, 3) == "hsa"]
|
740: wp_path<-sorted_path[stringr::str_sub(sorted_path, 1, 2) == "WP"]
|
771: type_path<-function(sorted_path, hierapath){
|
800: path_types<-unique(types$root)
|
802: type_path<-types[types[, 2] %in% p, 1]#concerned pathways
|
948: filter_path<-function(tagged,size){
|
949: path_inter<-as.vector(tagged[,4])
|
950: sorted_path<-apply(size,1,function(x){ #sort pathways obtained
|
951: path_elem<-as.integer(x[4])+as.integer(x[8])
|
965: central<-listparam[[5]]; no_path<-listparam[[6]];
|
969: sorted_path<-filter_path(tagged,size)
|
971: path_walks<-listpath[[1]]; max<-listpath[[2]]
|
977: heatmap<-listtab[[1]]; notin_path<-listtab[[2]]; hierapath<-listtab[[3]]
|
996: path_cat<-stringr::str_split(i[6], ", ")[[1]]
|
435: pathidtoname <- as.list(reactome.db::reactomePATHID2NAME)
|
516: hierapath<-vapply(root_ids, function(r){
|
542: heatmap<-listhiera[[1]]; hierapath<-listhiera[[2]]
|
963: size<-listparam[[1]]; pathways<-listparam[[2]]; tagged<-listparam[[3]];
|
970: listpath<-sort_hiera(sorted_path)
|
370: if(element == TRUE && nb_path == 0){list(e)}
|
373: notin_path<-unname(unlist(notin_path))
|
381: if (element == TRUE){return(list(cluster, notin_path))}
|
388: kegg_path<-paste(stringr::str_sub(kegg_path,1,3),
|
389: stringr::str_sub(kegg_path,5),sep="")
|
393: path_walks_k<-as.data.frame(sort(unlist(path_walks_k)))
|
394: if(ncol(path_walks_k) == 0){path_walks_k<-data.frame(walks=character())}
|
400: path_walks_w<-as.data.frame(sort(unlist(path_walks_w)))
|
401: if(ncol(path_walks_w) == 0){path_walks_w<-data.frame(walks=character())}
|
412: path_walks_r<-rm_vector(unname(unlist(path_walks_r)))
|
413: path_walks_r<-path_walks_r[stringr::str_detect(path_walks_r, ">")]
|
415: final_walks_r<-vapply(path_walks_r, function(x){
|
416: dupl<-which(stringr::str_detect(path_walks_r, x))
|
417: dupl<-dupl[-which(dupl == which(path_walks_r == x))]
|
424: names(final_walks_r)<-names(path_walks_w)<-names(path_walks_k)<-"walks"
|
426: max<-max(stringr::str_count(path_walks[,1],">"))+1
|
427: return(list(path_walks, max))
|
434: treeview, no_path, list_elem){
|
455: paste("'", size[size$path == node, 2], "/",
|
456: size[size$path == node, 4], sep=""),
|
457: paste("'", size[size$path == node, 6], "/",
|
458: size[size$path == node, 8], sep=""),NA)
|
463: colnames(heatmap)<-c("path_name", "path_id", "meta_ratio", "gene_ratio",
|
466: heatmap[which(heatmap[, 4] == "'/"), 4]<-"'0/0";tags<-no_path$tag
|
480: cluster_hiera<-function(heatmap, size, tagged, no_path){
|
532: cluster_htmp<-function(heatmap, tags, size, tagged, no_path){
|
538: cluster_elem<-cluster_elem[!(cluster_elem %in% notin_path)]
|
539: heatmap<-heatmap[,c("path_name", "path_id", "meta_ratio", "gene_ratio",
|
541: listhiera<-cluster_hiera(heatmap, size, tagged, no_path)
|
550: if(x[2] %in% tagged$path){
|
556: names(heatmap)<-c("path_name", "path_id", "meta_ratio", "gene_ratio",
|
558: return(list(heatmap, notin_path, hierapath, save_cluster_elem))
|
562: final_tab<-function(build_hm, pathways, size, sorted_path, no_path,
|
564: heatmap<-hiera_info(pathways, size, sorted_path, build_hm,
|
565: no_path, list_elem)
|
566: sub_htmp<-heatmap[2:nrow(heatmap),]; tags<-no_path$tag #direct interactions
|
569: pre_elem<-c(size[size$path %in% path, 3], size[size$path %in% path, 7])
|
586: path_inter<-path_inter[path_inter$tag ==
|
588: if(nrow(path_inter)>0){list("X")}
|
600: listhtmp<-cluster_htmp(heatmap, tags, size, tagged, no_path)
|
603: return(list(heatmap, notin_path, hierapath, save_cluster_elem))
|
625: infos_elem<-function(genes, notin_path, meta, keggchebiname, no_path,
|
634: genetab<-pre_genetab[which(!(pre_genetab[,1] %in% notin_path)),]
|
635: gene_notin<-pre_genetab[which(pre_genetab[,1] %in% notin_path),]
|
653: intetab<-apply(no_path, 1, function(p){
|
664: "go", "path", "type")
|
669: type_reactome<-function(sorted_path){
|
672: rea_types<-vapply(rea_path,function(r){
|
707: type_kegg<-function(sorted_path){
|
709: kegg_types<-vapply(kegg_path, function(k){
|
712: hiera<-kegg_hiera[stringr::str_detect(kegg_hiera[, 1], path), ]
|
725: else if (path == "hsa01100"){
|
739: type_wp<-function(sorted_path){
|
741: wp_types<-vapply(wp_path, function(w){
|
772: kegg_type<-type_kegg(sorted_path)#kegg types
|
773: rea_types<-type_reactome(sorted_path)#Reactome types
|
774: wp_types<-type_wp(sorted_path)#wikipathways types
|
801: hieratypes<-vapply(path_types, function(p){
|
804: if(length(intersect(type_path, h[["name"]]))>0){h[["index"]]}
|
807: if(length(intersect(type_path, h[["name"]]))>0){h[["name"]]}
|
872: list(paste("x : ",element,"\ny : ",path[length(path)],
|
881: list(paste("x : ", element, "\ny : ", path[length(path)],
|
952: if (path_elem>0){
|
954: if(num/path_elem>=0.2){x[1]}
|
957: sorted_path<-unname(unlist(sorted_path))
|
958: sorted_path<-rm_vector(c(sorted_path[!is.na(sorted_path)],path_inter))
|
959: return(sorted_path)
|
972: path_walks<-tidyr::separate(path_walks, 1, as.character(c(seq_len(max))),
|
974: treeview<-tree_view(path_walks);names(treeview)<-c(seq_len(ncol(treeview)))
|
975: listtab<-final_tab(treeview, pathways, size, sorted_path, no_path,
|
981: listelm<-infos_elem(gene_list, notin_path, meta_list, keggchebiname,
|
982: no_path, go_genelist)
|
986: listype<-type_path(sorted_path, hierapath)
|
998: %in% path_cat),2]), collapse=", ")
|
1002: names(intetab)<-c("tag", "first_item", "link", "sec_item", "go", "path",
|
341: ##find which elements are found in the same pathways, and put them together
|
342: ##find which pathways contain the same elements also
|
343: ##if element=T, also return user's elements which aren't in pathways
|
385: #filter entire pathways hierarchy to build a hierarchy concerning our pathways
|
386: sort_hiera<-function(pathways){
|
406: if(length(pathways[pathways %in% rea_walks])>0){
|
407: rea_walks<-rm_vector(rea_walks[c(1, which(rea_walks%in%pathways))])
|
430: #add informations about pathway hierarchies to the final heatmap
|
432: #names and ids of pathways in hierarchies
|
433: hiera_info<-function(pathways, size, sorted_pathways,
|
443: name<-pathways[pathways[,2] == node, 1]
|
447: pathways[pathways[,2] == node, 1], sep=""))
|
450: htmp<-c(htmp,paste(space, stringr::str_sub(pathidtoname[[node]],
|
451: 15, nchar(pathidtoname[[node]])), sep=""))
|
479: ##the hierarchy pathways are added to the root
|
527: hierapath[length(hierapath)]=NULL
|
528: return(list(heatmap, hierapath))
|
544: hierapath<-lapply(hierapath,function(x){
|
549: heatmap<-apply(heatmap,1,function(x){#pathway with direct interaction ?
|
561: ##build heatmap of hierarchies of pathways and elements included in them
|
668: #reactome pathways types
|
706: #kegg pathways types
|
738: #wikipathways pathways types
|
747: if(root%in%c("classic metabolic pathway", "regulatory pathway")
|
770: #pathways types=roots of pathways hierarchy
|
799: ##list of concerned hierarchies by pathways types
|
803: index<-lapply(hierapath, function(h){
|
806: name<-lapply(hierapath, function(h){
|
947: #filter pathways regarding user's element ratio and direct interactions
|
1010: hierapath, save_cluster_elem, centrality, inter_values,
|
671: mapnameid <- as.list(reactome.db::reactomePATHID2NAME) #id-name mapping
|
scde:R/functions.R: [ ] |
---|
5439: path <- env[['PATH_INFO']]
|
6044: path <- env[['PATH_INFO']]
|
2147: pathsizes <- unlist(tapply(vi, gcll, length))
|
5059: pathway.pc.correlation.distance <- function(pcc, xv, n.cores = 10, target.ndf = NULL) {
|
6173: pathcl <- ifelse(is.null(req$params()$pathcl), 1, as.integer(req$params()$pathcl))
|
1877: pagoda.pathway.wPCA <- function(varinfo, setenv, n.components = 2, n.cores = detectCores(), min.pathway.size = 10, max.pathway.size = 1e3, n.randomizations = 10, n.internal.shuffles = 0, n.starts = 10, center = TRUE, batch....(55 bytes skipped)...
|
5558: t.view.pathways <- function(pathways, mat, matw, env, proper.names = rownames(mat), colcols = NULL, zlim = NULL, labRow = NA, vhc = ...(145 bytes skipped)...
|
5684: pagoda.show.pathways <- function(pathways, varinfo, goenv = NULL, n.genes = 20, two.sided = FALSE, n.pc = rep(1, length(pathways)), colcols = NULL, zlim = NULL, showRowLabels = FALSE, cexCol = 1, cexRow = 1, nstarts = 10, ce...(117 bytes skipped)...
|
5698: c.view.pathways <- function(pathways, mat, matw, goenv = NULL, batch = NULL, n.genes = 20, two.sided = TRUE, n.pc = rep(1, length(pathways)), colcols = NULL, zlim = NULL, labRow = NA, vhc = NULL, cexCol = 1, cexRow = 1, nstarts = 50, ...(93 bytes skipped)...
|
461: ##' @param name URL path name for this app
|
5443: switch(path,
|
6047: switch(path,
|
1: ##' Single-cell Differential Expression (with Pathway And Gene set Overdispersion Analysis)
|
6: ##' The scde package also contains the pagoda framework which applies pathway and gene set overdispersion analysis
|
9: ##' See vignette("pagoda") for a brief tutorial on pathway and gene set overdispersion analysis to identify and characterize cell subpopulations.
|
1292: ...(39 bytes skipped)...lowed for the estimated adjusted variance (capping of adjusted variance is recommended when scoring pathway overdispersion relative to randomly sampled gene sets)
|
1789: ##' such as ribosomal pathway variation) and subtracts it from the data so that it is controlled
|
1815: ##' cc.pattern <- pagoda.show.pathways(ls(go.env)[1:2], varinfo, go.env, show.cell.dendrogram = TRUE, showRowLabels = TRUE) # Look at...(30 bytes skipped)...
|
1845: ##' @param min.pathway.size minimum number of observed genes that should be contained in a valid gene set
|
1846: ##' @param max.pathway.size maximum number of observed genes in a valid gene set
|
1847: ...(103 bytes skipped)...ith each gene set (can be kept at 5 or 10, but should be increased to 50-100 if the significance of pathway overdispersion will be determined relative to random gene set models)
|
1873: ##' pwpca <- pagoda.pathway.wPCA(varinfo, go.env, n.components=1, n.cores=10, n.internal.shuffles=50)
|
1901: gsl <- gsl[gsl.ng >= min.pathway.size & gsl.ng<= max.pathway.size]
|
1905: message("processing ", length(gsl), " valid pathways")
|
1954: ##' @param pwpca result of the pagoda.pathway.wPCA() call with n.randomizations > 1
|
1965: ##' pwpca <- pagoda.pathway.wPCA(varinfo, go.env, n.components=1, n.cores=10, n.internal.shuffles=50)
|
2148: names(pathsizes) <- pathsizes
|
2151: rsdv <- unlist(lapply(names(pathsizes), function(s) {
|
2156: return(data.frame(n = as.integer(pathsizes), var = unlist(sdv), round = i, rvar = rsdv))
|
2160: data.frame(n = as.integer(pathsizes), var = unlist(sdv), round = i)
|
2216: ##' @param pwpca output of pagoda.pathway.wPCA()
|
2242: ##' pwpca <- pagoda.pathway.wPCA(varinfo, go.env, n.components=1, n.cores=10, n.internal.shuffles=50)
|
2393: # determine genes driving significant pathways
|
2435: ##' @param pwpca output of pagoda.pathway.wPCA()
|
2453: ##' pwpca <- pagoda.pathway.wPCA(varinfo, go.env, n.components=1, n.cores=10, n.internal.shuffles=50)
|
2460: pclc <- pathway.pc.correlation.distance(c(pwpca, clpca$cl.goc), tam$xv, target.ndf = 100, n.cores = n.cores)
|
2521: ##' pwpca <- pagoda.pathway.wPCA(varinfo, go.env, n.components=1, n.cores=10, n.internal.shuffles=50)
|
2603: ##' pwpca <- pagoda.pathway.wPCA(varinfo, go.env, n.components=1, n.cores=10, n.internal.shuffles=50)
|
2654: ##' @param tamr Combined pathways that show similar expression patterns. Output of \code{\link{pagoda.reduce.redundancy}}
|
2655: ##' @param row.clustering Dendrogram of combined pathways clustering
|
2667: ##' pwpca <- pagoda.pathway.wPCA(varinfo, go.env, n.components=1, n.cores=10, n.internal.shuffles=50)
|
2724: ##' @param tamr Combined pathways that show similar expression patterns. Output of \code{\link{pagoda.reduce.redundancy}}
|
2725: ##' @param tam Combined pathways that are driven by the same gene sets. Output of \code{\link{pagoda.reduce.loading.redundancy}}...(0 bytes skipped)...
|
2728: ...(15 bytes skipped)...a Weighted PC magnitudes for each gene set provided in the \code{env}. Output of \code{\link{pagoda.pathway.wPCA}}
|
2732: ##' @param row.clustering Dendrogram of combined pathways clustering. Default NULL.
|
2733: ##' @param title Title text to be used in the browser label for the app. Default, set as 'pathway clustering'
|
2739: ...(47 bytes skipped)... env, pwpca, clpca = NULL, col.cols = NULL, cell.clustering = NULL, row.clustering = NULL, title = "pathway clustering", zlim = c(-1, 1)*quantile(tamr$xv, p = 0.95)) {
|
2764: # prepare pathway df
|
3559: .onUnload <- function(libpath) {
|
3560: library.dynam.unload("scde", libpath, verbose = TRUE)
|
5108: #set scale at top pathway?
|
5560: lab <- which(proper.names %in% na.omit(unlist(mget(pathways, envir = env, ifnotfound = NA))))
|
5564: lab <- which(proper.names %in% pathways)
|
5569: #table(rownames(mat) %in% mget(pathways, envir = env))
|
5660: ##' View pathway or gene weighted PCA
|
5662: ##' Takes in a list of pathways (or a list of genes), runs weighted PCA, optionally showing the result.
|
5663: ##' @param pathways character vector of pathway or gene names
|
5665: ##' @param goenv environment mapping pathways to genes
|
5668: ...(5 bytes skipped)...param n.pc optional integer vector giving the number of principal component to show for each listed pathway
|
5681: ##' @param ... additional arguments are passed to the \code{c.view.pathways}
|
5687: x <- c.view.pathways(pathways, varinfo$mat, varinfo$matw, goenv, batch = varinfo$batch, n.genes = n.genes, two.sided = two.si...(213 bytes skipped)...
|
5695: # takes in a list of pathways with a list of corresponding PC numbers
|
5696: # recalculates PCs for each individual pathway, weighting gene loading in each pathway and then by total
|
5697: # pathway variance over the number of genes (rough approximation)
|
5699: # are these genes or pathways being passed?
|
5701: x <- pathways %in% ls(goenv)
|
5703: x <- rep(FALSE, length(pathways))
|
5705: if(sum(x) > 0) { # some pathways matched
|
5707: message("WARNING: partial match to pathway names. The following entries did not match: ", paste(pathways[!x], collapse = " "))
|
5709: # look up genes for each pathway
|
5710: pathways <- pathways[x]
|
5711: p.genes <- mget(pathways, goenv, ifnotfound = NA)
|
5713: x <- pathways %in% rownames(mat)
|
5716: ...(9 bytes skipped)... message("WARNING: partial match to gene names. The following entries did not match: ", paste(pathways[!x], collapse = " "))
|
5718: p.genes <- list("genes" = pathways[x])
|
5719: pathways <- c("genes");
|
5720: } else { # neither genes nor pathways are passed
|
5721: stop("ERROR: provided names do not match either gene nor pathway names (if the pathway environment was provided)")
|
5728: # recalculate wPCA for each pathway
|
5729: ppca <- pagoda.path...(130 bytes skipped)...s), n.cores = 1, n.randomizations = 0, n.starts = 2, n.components = max(n.pc), verbose = FALSE, min.pathway.size = 0, max.pathway.size = Inf, n.internal.shuffles = 0)
|
5731: if(length(ppca) > 1) { # if more than one pathway was supplied, combine genes using appropriate loadings and use consensus PCA (1st PC) as a patte...(2 bytes skipped)...
|
5733: scaled.gene.loadings <- unlist(lapply(seq_along(pathways), function(i) {
|
5734: gl <- ppca[[pathways[i]]]$xp$rotation[, n.pc[i], drop = TRUE]*as.numeric(ppca[[pathways[i]]]$xp$sd)[n.pc[i]]/sqrt(ppca[[pathways[i]]]$n)
|
5735: names(gl) <- rownames(ppca[[pathways[i]]]$xp$rotation)
|
5777: } else { # only one pathway was provided
|
5970: ##' @field results Output of the pathway clustering and redundancy reduction
|
5972: ##' @field pathways
|
5983: fields = c('results', 'genes', 'pathways', 'mat', 'matw', 'goenv', 'renv', 'name', 'trim', 'batch'),
|
5986: initialize = function(results, pathways, genes, mat, matw, goenv, batch = NULL, name = "pathway overdispersion", trim = 1.1/ncol(mat)) {
|
5995: pathways <<- pathways
|
6012: gcl <- t.view.pathways(genes, mat = mat, matw = matw, env = goenv, vhc = results$hvc, plot = FALSE, trim = ltrim)
|
6058: ...(21 bytes skipped)... <link rel = "stylesheet" type = "text/css" href = "http://pklab.med.harvard.edu/sde/pathcl.css" / >
|
6064: ...(10 bytes skipped)... <script type = "text/javascript" src = "http://pklab.med.harvard.edu/sde/pathcl.js" > </script >
|
6072: '/pathcl.json' = { # report pathway clustering heatmap data
|
6126: '/pathwaygenes.json' = { # report heatmap data for a selected set of genes
|
6133: x <- c.view.pathways(gsub("^#PC\\d+# ", "", pws), mat, matw, goenv = goenv, n.pc = n.pcs, n.genes = ngenes, two.side...(75 bytes skipped)...
|
6134: #x <- t.view.pathways(gsub("^#PC\\d+# ", "", pws), mat, matw, env = goenv, vhc = results$hvc, plot = FALSE, trim = lt...(14 bytes skipped)...
|
6174: ii <- which(results$ct == pathcl)
|
6251: '/pathways.json' = {
|
6252: lgt <- pathways
|
diffHic:src/report_hic_pairs.cpp: [ ] |
---|
313: std::string path;
|
208: Bamfile(const char * path) : holding(false) {
|
209: in = sam_open(path, "rb");
|
212: out << "failed to open BAM file at '" << path << "'";
|
267: path=converter.str();
|
292: out=std::fopen(path.c_str(), "a");
|
294: out=std::fopen(path.c_str(), "w"); // Overwrite any existing file, just to be safe.
|
298: err << "failed to open output file at '" << path << "'";
|
326: const Rcpp::String bampath=check_string(bamfile, "BAM file path");
|
512: outpaths[j]=collected[i][j].path;
|
595: Rcpp::String bampath=check_string(incoming, "BAM file path");
|
334: Bamfile input(bampath.get_cstring());
|
596: Bamfile input(bampath.get_cstring());
|
507: Rcpp::List filepaths(nc);
|
509: Rcpp::StringVector outpaths(i+1);
|
515: filepaths[i]=outpaths;
|
518: return Rcpp::List::create(filepaths,
|
GSCA:inst/shiny/server.R: [ ] |
---|
357: path <- system.file("extdata",package=paste0(input$Summarycompselect,"Expr"))
|
716: path <- system.file("extdata",package=paste0(input$Summarycompselect,"Expr"))
|
358: load(paste0(path,"/geneid.rda"))
|
378: load(paste0(path,"/quality.rda"))
|
388: load(paste0(path,"/quality.rda"))
|
475: path <- system.file("extdata",package=paste0(input$Summarycompselect,"Expr"))
|
482: tmpgeneexpr <- rbind(tmpgeneexpr,t(h5read(paste0(path,"/data",h5id,".h5"),"expr",index=list(NULL,match(currenth5gene,h5gene))))/1000)
|
485: tmpgeneexpr <- t(h5read(paste0(path,"/data.h5"),"expr",index=list(NULL,match(currentgeneset[,2],Maindata$geneid))))/1000
|
724: ...(9 bytes skipped)... tmpgeneexpr <- rbind(tmpgeneexpr,t(h5read(paste0(path,"/data",h5id,".h5"),"expr",index=list(NULL,match(currenth5gene,h5gene))))/1000)
|
727: tmpgeneexpr <- t(h5read(paste0(path,"/data.h5"),"expr",index=list(NULL,match(currentgeneset[,2],Maindata$geneid))))/1000
|
118: tmpfile <- read.table(GenesetFileHandle$datapath,header=input$InputGenesetheader,sep=input$InputGenesetsep,quote=input$InputGenesetquote,stringsAsFa...(30 bytes skipped)...
|
401: tmptab <- read.table(input$Summaryuploadtabfile$datapath,stringsAsFactors=F,blank.lines.skip=TRUE)
|
405: ...(8 bytes skipped)... Maindata$uploadgeneexpr <- as.matrix(read.table(input$Summaryuploadgeneexprfile$datapath,stringsAsFactors=F,blank.lines.skip=TRUE,row.names=1))
|
1917: tmp <- read.table(input$GSCAinteractiveload$datapath)
|
1946: ...(35 bytes skipped)... updateTextInput(session,"Formulainputtext","Input Formula",readLines(input$GSCAinteractiveload$datapath))
|
2412: Utidata$Maindata <- Utidata$rawdata <- read.table(UtiFileHandle$datapath,header=input$Utiheader,sep=input$Utisep,quote=input$Utiquote,stringsAsFactors=F,blank.lines.skip=TR...(15 bytes skipped)...
|
HiCBricks:R/Brick_functions.R: [ ] |
---|
2002: Path <- Create_Path(c(Root.folders['matrices'],chr,chr))
|
498: Bintable.group.path <- Create_Path(
|
1361: Group.path <- Create_Path(c(Reference.object$hdf.matrices.root,chr1,chr2))
|
1456: Group.path <- Create_Path(c(Reference.object$hdf.matrices.root,chr,chr))
|
2522: Group.path <- Create_Path(c(Reference.object$hdf.matrices.root,
|
2585: Group_path <- Create_Path(c(Reference_object$hdf.matrices.root,
|
2678: Group.path <- Create_Path(c(Reference.object$hdf.matrices.root, chr1,
|
205: Config_filepath <- .make_configuration_path(output_directory)
|
895: Brick_filepath <- BrickContainer_get_path_to_file(Brick,
|
964: Brick_filepath <- BrickContainer_get_path_to_file(Brick,
|
1339: Brick_filepath <- BrickContainer_get_path_to_file(Brick,
|
1434: Brick_filepath <- BrickContainer_get_path_to_file(Brick,
|
1849: Brick_filepath <- BrickContainer_get_path_to_file(Brick = Brick,
|
2034: Brick_filepath <- BrickContainer_get_path_to_file(Brick = Brick,
|
2524: Brick_filepath <- BrickContainer_get_path_to_file(Brick = Brick,
|
2587: Brick_filepath <- BrickContainer_get_path_to_file(Brick = Brick,
|
2676: Brick_filepath <- BrickContainer_get_path_to_file(Brick = Brick,
|
703: Brick_paths <- BrickContainer_get_path_to_file(Brick = Brick,
|
760: Brick_filepaths <- BrickContainer_list_files(Brick = Brick,
|
812: Brick_filepaths <- BrickContainer_get_path_to_file(Brick,
|
18: #' A string containing the path to the file to load as the binning table for
|
141: #' Bintable.path <- system.file(file.path("extdata", "Bintable_100kb.bins"),
|
143: #' out_dir <- file.path(tempdir(), "Creator_test")
|
145: #' My_BrickContainer <- Create_many_Bricks(BinTable = Bintable.path,
|
178: "without an explicit path", "definition!", "If you want to create",
|
180: "please provide", "the complete path. Or, you can",
|
182: paste("file.path(getwd())", sep = ""),
|
300: #' the function will provide the path to the created/tracked HDF file.
|
306: #' out_dir <- file.path(tempdir(),"mcool_test_dir")
|
307: #' dir.create(path = out_dir)
|
311: #' destfile = file.path(out_dir,"H1-hESC-HiC-4DNFI7JNCNFB.mcool"))
|
313: #' mcool <- file.path(out_dir,"H1-hESC-HiC-4DNFI7JNCNFB.mcool")
|
332: stop("mcool must be provided as mcool= /path/to/something")
|
339: mcool.version <- GetAttributes(Path = Create_Path(
|
355: mcool.version <- GetAttributes(Path = NULL, File=mcool,
|
391: #' out_dir <- file.path(tempdir(),"mcool_test_dir")
|
392: #' dir.create(path = out_dir)
|
397: #' destfile = file.path(out_dir,"H1-hESC-HiC-4DNFI7JNCNFB.mcool"))
|
399: #' mcool <- file.path(out_dir,"H1-hESC-HiC-4DNFI7JNCNFB.mcool")
|
452: #' out_dir <- file.path(tempdir(), "mcool_test_dir")
|
453: #' dir.create(path = out_dir)
|
457: #' destfile = file.path(out_dir, "H1-hESC-HiC-4DNFI7JNCNFB.mcool"))
|
459: #' mcool <- file.path(out_dir, "H1-hESC-HiC-4DNFI7JNCNFB.mcool")
|
476: mcool.version <- GetAttributes(Path = NULL, File=mcool,
|
502: Bintable.group.path <- Create_Path(Bintable.group)
|
504: Handler <- ._Brick_Get_Something_(Group.path = Bintable.group.path,
|
517: #' A string specifying the path to the Brick store created with
|
534: #' Bintable_path <- system.file(file.path("extdata", "Bintable_100kb.bins"),
|
537: #' out_dir <- file.path(tempdir(), "HiCBricks_chrominfo_test")
|
541: #' My_BrickContainer <- Create_many_Bricks(BinTable = Bintable_path,
|
670: #' Bintable.path <- system.file(file.path("extdata", "Bintable_100kb.bins"),
|
673: #' out_dir <- file.path(tempdir(), "add_ranges_test")
|
677: #' My_BrickContainer <- Create_many_Bricks(BinTable = Bintable.path,
|
709: bplapply(Brick_paths, function(Brick_path){
|
710: ._Brick_Add_Ranges_(Brick = Brick_path,
|
711: Group.path = Create_Path(c(Reference.object$hdf.ranges.root,
|
739: #' Bintable.path <- system.file(file.path("extdata", "Bintable_100kb.bins"),
|
742: #' out_dir <- file.path(tempdir(), "list_matrices_test")
|
746: #' My_BrickContainer <- Create_many_Bricks(BinTable = Bintable.path,
|
766: Path = Create_Path(
|
794: #' Bintable.path <- system.file(file.path("extdata", "Bintable_100kb.bins"),
|
797: #' out_dir <- file.path(tempdir(), "list_rangekeys_test")
|
801: #' My_BrickContainer <- Create_many_Bricks(BinTable = Bintable.path,
|
815: Group.path = Create_Path(Reference.object$hdf.ranges.root),
|
836: #' Bintable.path <- system.file(file.path("extdata", "Bintable_100kb.bins"),
|
839: #' out_dir <- file.path(tempdir(), "list_rangekeys_exists_test")
|
843: #' My_BrickContainer <- Create_many_Bricks(BinTable = Bintable.path,
|
876: #' Bintable.path <- system.file(file.path("extdata", "Bintable_100kb.bins"),
|
879: #' out_dir <- file.path(tempdir(), "list_ranges_mcols_test")
|
883: #' My_BrickContainer <- Create_many_Bricks(BinTable = Bintable.path,
|
936: #' Bintable.path <- system.file(file.path("extdata", "Bintable_100kb.bins"),
|
939: #' out_dir <- file.path(tempdir(), "list_get_ranges_test")
|
943: #' My_BrickContainer <- Create_many_Bricks(BinTable = Bintable.path,
|
971: chromosomes <- ._Brick_Get_Something_(Group.path = Create_Path(
|
980: Group.path = Create_Path(
|
985: Lengths <- ._Brick_Get_Something_(Group.path = Create_Path(
|
995: Dataset <- ._Brick_Get_Something_(Group.path = Create_Path(
|
1020: Group.path = Create_Path(
|
1038: Group.path = Create_Path(c(
|
1071: #' Bintable.path <- system.file(file.path("extdata", "Bintable_100kb.bins"),
|
1074: #' out_dir <- file.path(tempdir(), "list_get_bintable_test")
|
1077: #' My_BrickContainer <- Create_many_Bricks(BinTable = Bintable.path,
|
1134: #' Bintable.path <- system.file(file.path("extdata", "Bintable_100kb.bins"),
|
1137: #' out_dir <- file.path(tempdir(), "fetch_range_index_test")
|
1140: #' My_BrickContainer <- Create_many_Bricks(BinTable = Bintable.path,
|
1232: #' Bintable.path <- system.file(file.path("extdata", "Bintable_100kb.bins"),
|
1235: #' out_dir <- file.path(tempdir(), "region_position_test")
|
1238: #' My_BrickContainer <- Create_many_Bricks(BinTable = Bintable.path,
|
1303: #' Bintable.path <- system.file(file.path("extdata", "Bintable_100kb.bins"),
|
1306: #' out_dir <- file.path(tempdir(), "matrix_load_test")
|
1309: #' My_BrickContainer <- Create_many_Bricks(BinTable = Bintable.path,
|
1314: #' Matrix_file <- system.file(file.path("extdata",
|
1367: Matrix.file = matrix_file, delim = delim, Group.path = Group.path,
|
1400: #' Bintable.path <- system.file(file.path("extdata", "Bintable_100kb.bins"),
|
1403: #' out_dir <- file.path(tempdir(), "matrix_load_dist_test")
|
1406: #' My_BrickContainer <- Create_many_Bricks(BinTable = Bintable.path,
|
1411: #' Matrix_file <- system.file(file.path("extdata",
|
1462: Matrix.file = matrix_file, delim = delim, Group.path = Group.path,
|
1481: #' @param mcool \strong{Required}. Path to an mcool file.
|
1504: #' out_dir <- file.path(tempdir(),"mcool_load_test")
|
1505: #' dir.create(path = out_dir)
|
1509: #' destfile = file.path(out_dir,"H1-hESC-HiC-4DNFI7JNCNFB.mcool"))
|
1511: #' mcool <- file.path(out_dir,"H1-hESC-HiC-4DNFI7JNCNFB.mcool")
|
1568: RetVar <- .process_mcool(Brick = Brick, mcool_path = mcool,
|
1585: #' Bintable.path <- system.file(file.path("extdata", "Bintable_100kb.bins"),
|
1588: #' out_dir <- file.path(tempdir(), "matrix_isdone_test")
|
1591: #' My_BrickContainer <- Create_many_Bricks(BinTable = Bintable.path,
|
1596: #' Matrix_file <- system.file(file.path("extdata",
|
1629: #' Bintable.path <- system.file(file.path("extdata", "Bintable_100kb.bins"),
|
1632: #' out_dir <- file.path(tempdir(), "matrix_issparse_test")
|
1635: #' My_BrickContainer <- Create_many_Bricks(BinTable = Bintable.path,
|
1640: #' Matrix_file <- system.file(file.path("extdata",
|
1681: #' Bintable.path <- system.file(file.path("extdata", "Bintable_100kb.bins"),
|
1684: #' out_dir <- file.path(tempdir(), "matrix_maxdist_test")
|
1687: #' My_BrickContainer <- Create_many_Bricks(BinTable = Bintable.path,
|
1692: #' Matrix_file <- system.file(file.path("extdata",
|
1736: #' Bintable.path <- system.file(file.path("extdata", "Bintable_100kb.bins"),
|
1739: #' out_dir <- file.path(tempdir(), "matrix_exists_test")
|
1742: #' My_BrickContainer <- Create_many_Bricks(BinTable = Bintable.path,
|
1747: #' Matrix_file <- system.file(file.path("extdata",
|
1775: #' Bintable.path <- system.file(file.path("extdata", "Bintable_100kb.bins"),
|
1778: #' out_dir <- file.path(tempdir(), "matrix_minmax_test")
|
1781: #' My_BrickContainer <- Create_many_Bricks(BinTable = Bintable.path,
|
1786: #' Matrix_file <- system.file(file.path("extdata",
|
1821: #' Bintable.path <- system.file(file.path("extdata", "Bintable_100kb.bins"),
|
1824: #' out_dir <- file.path(tempdir(), "matrix_dimension_test")
|
1827: #' My_BrickContainer <- Create_many_Bricks(BinTable = Bintable.path,
|
1832: #' Matrix_file <- system.file(file.path("extdata",
|
1851: Extents <- ._GetDimensions(group.path = Create_Path(
|
1853: dataset.path = Reference.object$hdf.matrix.name,
|
1870: #' Bintable.path <- system.file(file.path("extdata", "Bintable_100kb.bins"),
|
1873: #' out_dir <- file.path(tempdir(), "matrix_filename_test")
|
1876: #' My_BrickContainer <- Create_many_Bricks(BinTable = Bintable.path,
|
1881: #' Matrix_file <- system.file(file.path("extdata",
|
1936: #' Bintable.path <- system.file(file.path("extdata", "Bintable_100kb.bins"),
|
1939: #' out_dir <- file.path(tempdir(), "val_by_dist_test")
|
1942: #' My_BrickContainer <- Create_many_Bricks(BinTable = Bintable.path,
|
1947: #' Matrix_file <- system.file(file.path("extdata",
|
2040: diag(._Brick_Get_Something_(Group.path = Path, Brick = Brick_filepath,
|
2087: #' Bintable.path <- system.file(file.path("extdata", "Bintable_100kb.bins"),
|
2090: #' out_dir <- file.path(tempdir(), "get_matrix_coords_test")
|
2093: #' My_BrickContainer <- Create_many_Bricks(BinTable = Bintable.path,
|
2098: #' Matrix_file <- system.file(file.path("extdata",
|
2200: #' Bintable.path <- system.file(file.path("extdata", "Bintable_100kb.bins"),
|
2203: #' out_dir <- file.path(tempdir(), "get_matrix_test")
|
2206: #' My_BrickContainer <- Create_many_Bricks(BinTable = Bintable.path,
|
2211: #' Matrix_file <- system.file(file.path("extdata",
|
2309: #' Bintable.path <- system.file(file.path("extdata", "Bintable_100kb.bins"),
|
2312: #' out_dir <- file.path(tempdir(), "get_row_vector_test")
|
2315: #' My_BrickContainer <- Create_many_Bricks(BinTable = Bintable.path,
|
2320: #' Matrix_file <- system.file(file.path("extdata",
|
2463: #' Bintable.path <- system.file(file.path("extdata", "Bintable_100kb.bins"),
|
2466: #' out_dir <- file.path(tempdir(), "get_vector_val_test")
|
2472: #' My_BrickContainer <- Create_many_Bricks(BinTable = Bintable.path,
|
2477: #' Matrix_file <- system.file(file.path("extdata",
|
2526: Vector <- ._Brick_Get_Something_(Group.path = Group.path,
|
2550: #' Bintable.path <- system.file(file.path("extdata", "Bintable_100kb.bins"),
|
2553: #' out_dir <- file.path(tempdir(), "get_vector_val_test")
|
2558: #' My_BrickContainer <- Create_many_Bricks(BinTable = Bintable.path,
|
2563: #' Matrix_file <- system.file(file.path("extdata",
|
2589: dataset_handle <- ._Brick_Get_Something_(Group.path = Group_path,
|
2625: #' Bintable.path <- system.file(file.path("extdata", "Bintable_100kb.bins"),
|
2628: #' out_dir <- file.path(tempdir(), "get_matrix_mcols_test")
|
2631: #' My_BrickContainer <- Create_many_Bricks(BinTable = Bintable.path,
|
2636: #' Matrix_file <- system.file(file.path("extdata",
|
2680: Vector <- ._Brick_Get_Something_(Group.path = Group.path,
|
2694: #' Bintable.path <- system.file(file.path("extdata", "Bintable_100kb.bins"),
|
2697: #' out_dir <- file.path(tempdir(), "list_matrix_mcols_test")
|
2700: #' My_BrickContainer <- Create_many_Bricks(BinTable = Bintable.path,
|
2717: #' BrickContainer, a string of length 1 as resolution and a path specifying
|
2724: #' @param out_file Path to the output file to write.
|
2735: #' Bintable.path <- system.file(file.path("extdata", "Bintable_100kb.bins"),
|
2738: #' out_dir <- file.path(tempdir(), "write_file")
|
2741: #' My_BrickContainer <- Create_many_Bricks(BinTable = Bintable.path,
|
2746: #' Matrix_file <- system.file(file.path("extdata",
|
2755: #' out_file = file.path(out_dir, "example_out.txt"),
|
2768: stop(out_file, " already exists at path")
|
2820: #' Bintable.path <- system.file(file.path("extdata", "Bintable_100kb.bins"),
|
2823: #' out_dir <- file.path(tempdir(), "get_vector_val_test")
|
2828: #' My_BrickContainer <- Create_many_Bricks(BinTable = Bintable.path,
|
2833: #' Matrix_file <- system.file(file.path("extdata",
|
2870: #' @param table_file Path to the file that will be loaded
|
2887: #' Bintable.path <- system.file(file.path("extdata", "Bintable_100kb.bins"),
|
2890: #' out_dir <- file.path(tempdir(), "get_vector_val_test")
|
2895: #' My_BrickContainer <- Create_many_Bricks(BinTable = Bintable.path,
|
2900: #' Matrix_file <- system.file(file.path("extdata",
|
2909: #' out_file = file.path(out_dir, "example_out.txt"),
|
2914: #' table_file = file.path(out_dir, "example_out.txt"),
|
188: output_directory <- normalizePath(output_directory)
|
219: if(file.exists(Config_filepath)){
|
223: Container <- load_BrickContainer(Config_filepath)
|
282: Config_filepath)
|
283: .write_configuration_file(Container, Config_filepath)
|
907: mcol.df <- .prepare_ranges_metadata_mcols(Brick = Brick_filepath,
|
973: Brick = Brick_filepath,
|
982: Brick = Brick_filepath,
|
987: Brick = Brick_filepath,
|
997: Brick = Brick_filepath,
|
1022: Brick = Brick_filepath, Name = FUN_name, Start = m.start,
|
1040: rangekey)), Brick = Brick_filepath,
|
1341: if(length(Brick_filepath) == 0){
|
1366: RetVar <- ._ProcessMatrix_(Brick = Brick_filepath,
|
1436: if(length(Brick_filepath) == 0){
|
1461: RetVar <- ._Process_matrix_by_distance(Brick = Brick_filepath,
|
1854: File = Brick_filepath, return.what = "size")
|
2527: Brick = Brick_filepath, Name = Reference.object$hdf.matrix.name,
|
2590: Brick = Brick_filepath, Name = Reference_object$hdf.matrix.name,
|
2681: Brick = Brick_filepath, Name = what, return.what = "data")
|
2781: Brick_filepath = a_row$filepath,
|
763: chr1.list <- lapply(seq_len(nrow(Brick_filepaths)), function(i){
|
764: Row <- Brick_filepaths[i,]
|
770: File = Row$filepaths,
|
816: Brick = Brick_filepaths[1], return.what = "group_handle")
|
SMITE:R/SMITE.R: [ ] |
---|
1277: path <- goseq::goseq(pwf, "hg19", "knownGene",
|
1196: PATHID2NAME <- AnnotationDbi::as.list(reactome.db::reactomePATHID2NAME)
|
1210: pathways <- KEGGREST::keggList("pathway", "hsa") ## returns the list of human pathways
|
1279: path <- cbind(path,(as.character(sapply(
|
1280: path$category, function(i){PATHID2NAME[[i]]}))))
|
1281: colnames(path)[6] <- "cat_name"
|
1282: subset(path, path$over_represented_pvalue < p_thresh)
|
1189: AnnotationDbi::as.list(reactome.db::reactomeEXTID2PATHID)
|
1201: link_kegg<- KEGGREST::keggLink("pathway", "hsa") ## returns pathways for each kegg gene
|
1202: list_link <- split(unname(link_kegg), names(link_kegg)) ## combines each pathway into list object for each gene
|
1211: PATHID2NAME <- as.list(pathways)
|
MOGAMUN:R/MOGAMUN_FUN.R: [ ] |
---|
1232: for (Path in Dirs) {
|
1233: PathForPlots <- ExperimentsPath <- paste0(Path, "/") # path for plots
|
1659: GeneralPath <- ExperimentDir
|
1666: ExpPath <- paste0(GeneralPath, "/", d, "/")
|
1289: # get all files in the path that match the pattern
|
1763: # ExperimentsPath - path to the results
|
1234: Population <- GetIndividualsAllRuns(ExperimentsPath) # get results
|
1249: SimilarityBetweenRunsBoxplot(PathForPlots, Nodes1stRank_AllRuns)
|
1253: AccPF <- ObtainAccParetoFront(PathForPlots, Inds1stRank_AllRuns,
|
1258: FilterNetworks(ExperimentsPath, LoadedData, AccPF)
|
1265: SaveFilteredAccPF(DiversePopulation, ExperimentsPath, Threshold)
|
1278: # INPUT: ExperimentsPath - folder containing the results to be processed
|
1280: GetIndividualsAllRuns <- function(ExperimentsPath) {
|
1290: ResFiles <- list.files(ExperimentsPath, pattern = PatResFiles)
|
1295: con <- base::file(paste0(ExperimentsPath, ResFiles[counter]), open="r")
|
1328: # INPUTS: PathForPlots - folder to save the plot
|
1331: SimilarityBetweenRunsBoxplot <- function(PathForPlots, Nodes1stRank_AllRuns) {
|
1362: svg(paste0(PathForPlots, "A_Boxplot_similarities_between_runs.svg"))
|
1372: # INPUTS: PathForPlots - folder to save the plot
|
1378: ObtainAccParetoFront <- function(PathForPlots, Inds1stRank_AllRuns,
|
1389: svg(paste0(PathForPlots, "A_ScatterPlot_AccPF_ALL_INDS.svg"))
|
1397: svg(paste0(PathForPlots, "A_ScatterPlot_AccPF_LEGEND_ALL_INDS.svg"))
|
1409: svg(paste0(PathForPlots, "A_ScatterPlot_AccPF.svg"))
|
1466: # INPUTS: ExperimentsPath - folder to save the filtered networks
|
1471: FilterNetworks <- function(ExperimentsPath, LoadedData, AccPF) {
|
1495: write.table(MyFilteredNetwork, file = paste0(ExperimentsPath,
|
1501: myDataFiles <- list.files(ExperimentsPath, pattern = '_FILTERED.csv')
|
1508: data <- read.table(paste0(ExperimentsPath, myDataFiles[i]),
|
1516: write.table(myFullListOfInteractions, file = paste0(ExperimentsPath,
|
1614: # ExperimentsPath - folder to save the filtered networks
|
1617: SaveFilteredAccPF <- function(DiversePopulation, ExperimentsPath, Threshold) {
|
1621: write(paste(Ind, collapse=" ", sep=""), file = paste0(ExperimentsPath,
|
1643: write.csv(AllNodesDF_Acc, paste0(ExperimentsPath,
|
1662: Dirs <- list.dirs(GeneralPath, recursive = FALSE, full.names = FALSE)
|
1669: Network <- read.csv( paste0(ExpPath,
|
1698: CreateActiveModules(d, ExpPath)
|
1703: filename = paste0(ExpPath, "A_Acc_PF_", d))
|
1704: } else { saveSession(filename = paste0(ExpPath, "A_Acc_PF_", d)) }
|
1765: CreateActiveModules <- function(d, ExperimentsPath) {
|
1772: read.csv(paste0(ExperimentsPath, list.files(ExperimentsPath,
|
1799: MogamunBody <- function(RunNumber, LoadedData, BestIndsPath) {
|
1800: BestIndsFile <- paste0(BestIndsPath, "_Run_", RunNumber, ".txt")
|
1829: file = paste0(BestIndsPath,"StatisticsPerGeneration_Run", RunNumber,
|
maigesPack:R/plot-methods.R: [ ] |
---|
190: Path <- list(Type1=new("graphNEL", vertices, edgeL=arestas1),
|
326: Path <- new("graphNEL", vertices, edgeL=arestas)
|
167: graphPath <- function(data=NULL, cuttoffPvalue) {
|
309: graphPath <- function(data=NULL, cuttoffCor=NULL, cuttoffP=NULL) {
|
194: return(Path)
|
327: return(Path)
|
287: graph <- graphPath(x, cutPval)
|
426: graph <- graphPath(x, cutCor, NULL)
|
431: graph <- graphPath(x, NULL, cutPval)
|
TPP2D:R/import_funcs.R: [ ] |
---|
348: Experiment <- Path <- Compound <- NULL
|
570: Path <- label <- conc <- Compound <- Experiment <-
|
371: givenPaths <- NULL
|
253: "Experiment", "Path", "Path",
|
254: "Path", "Condition", "Replicate",
|
334: #' @param infoTable character string of a file path to
|
372: if (any("Path" %in% colnames(infoTable))) {
|
373: if (all(infoTable$Path == "") || all(is.na(infoTable$Path))) {
|
374: message("Removing empty 'Path' column from config table")
|
375: infoTable <- infoTable %>% select(-Path)
|
378: givenPaths <- infoTable$Path
|
443: #' @param configTable character string of a file path to a config table
|
485: files <- configTable$Path
|
511: "RefCol", "Path", "Condition")
|
573: if(any(grepl("Path", colnames(configWide)))){
|
575: dplyr::select(-Path) %>%
|
756: #' @param configTable character string of a file path to a config table
|
433: expCond = infoTable$Condition, files = givenPaths,
|
RepViz:R/plotGeneTrack.R: [ ] |
---|
125: host = "grch37.ensembl.org", path = "/biomart/martservice",
|
130: host = "grch38.ensembl.org", path = "/biomart/martservice",
|
138: host = "grch37.ensembl.org", path = "/biomart/martservice",
|
AffiXcan:R/AffiXcan.R: [ ] |
---|
642: for(path in tbaPaths) {
|
643: tba <- readRDS(path)
|
6: #' @param tbaPaths A vector of strings, which are the paths to
|
186: #' @param tbaPaths A vector of strings, which are the paths to
|
623: #' @param tbaPaths, A vector of strings, which are the paths to
|
654: #' @param tbaPaths A vector of strings, which are the paths to
|
1064: #' @param tbaPaths A vector of strings, which are the paths to
|
38: #' objects listed in the param tbaPaths. Each of these lists contain two
|
92: #' trainingTbaPaths <- system.file("extdata","training.tba.toydata.rds",
|
102: #' tbaPaths=trainingTbaPaths, regionAssoc=regionAssoc, cov=trainingCovariates,
|
105: affiXcanTrain <- function(exprMatrix, assay, tbaPaths, regionAssoc, cov=NULL,
|
107: regionsCount <- overlookRegions(tbaPaths)
|
131: pca <- affiXcanPca(tbaPaths, varExplained, scale, regionsCount,
|
141: pcs <- affiXcanPcs(tbaPaths, affiXcanTraining, scale, BPPARAM,
|
194: #' every MultiAssayExperiment RDS object indicated in the param tbaPaths; it is
|
200: #' of MultiAssayExperiment objects from tbaPaths) of the samples that have to
|
205: #' listed in the param tbaPaths. Each of these lists contain two objects:
|
221: #' tbaPaths <- system.file("extdata","training.tba.toydata.rds",
|
223: #' regionsCount <- overlookRegions(tbaPaths)
|
235: #' pca <- affiXcanPca(tbaPaths=tbaPaths, varExplained=80, scale=TRUE,
|
238: affiXcanPca <- function(tbaPaths, varExplained=80, scale=TRUE, regionsCount,
|
244: for(i in seq(1,length(tbaPaths))) {
|
246: tbaMatrixMAE <- readRDS(tbaPaths[i])
|
376: #' of MultiAssayExperiment objects from tbaPaths) of the samples that have to
|
401: #' tbaPaths <- system.file("extdata","training.tba.toydata.rds",
|
403: #' regionsCount <- overlookRegions(tbaPaths)
|
416: #' pca <- affiXcanPca(tbaPaths=tbaPaths, varExplained=80, scale=TRUE,
|
516: #' tbaPaths <- system.file("extdata","training.tba.toydata.rds",
|
518: #' regionsCount <- overlookRegions(tbaPaths)
|
531: #' pca <- affiXcanPca(tbaPaths=tbaPaths, varExplained=80, scale=TRUE,
|
627: #' MultiAssayExperiment RDS object indicated in the param tbaPaths
|
633: #' testingTbaPaths <- system.file("extdata","testing.tba.toydata.rds",
|
636: #' regionsCount <- overlookRegions(tbaPaths=testingTbaPaths)
|
638: overlookRegions <- function(tbaPaths) {
|
663: #' of MultiAssayExperiment objects from tbaPaths) of the samples that have not
|
680: #' trainingTbaPaths <- system.file("extdata","training.tba.toydata.rds",
|
682: #' testingTbaPaths <- system.file("extdata","testing.tba.toydata.rds",
|
688: #' tbaPaths=trainingTbaPaths, regionAssoc=regionAssoc, cov=trainingCovariates,
|
691: #' pcs <- affiXcanPcs(tbaPaths=testingTbaPaths, affiXcanTraining=training,
|
694: affiXcanPcs <- function(tbaPaths, affiXcanTraining, scale, BPPARAM=bpparam(),
|
700: for(i in seq(1,length(tbaPaths))) {
|
703: tbaMatrixMAE <- readRDS(tbaPaths[i])
|
746: #' trainingTbaPaths <- system.file("extdata","training.tba.toydata.rds",
|
756: #' tbaPaths=trainingTbaPaths, regionAssoc=regionAssoc, cov=trainingCovariates,
|
801: #' trainingTbaPaths <- system.file("extdata","training.tba.toydata.rds",
|
811: #' tbaPaths=trainingTbaPaths, regionAssoc=regionAssoc, cov=trainingCovariates,
|
814: #' testingTbaPaths <- system.file("extdata","testing.tba.toydata.rds",
|
817: #' pcs <- affiXcanPcs(tbaPaths=testingTbaPaths, affiXcanTraining=training,
|
863: #' trainingTbaPaths <- system.file("extdata","training.tba.toydata.rds",
|
873: #' tbaPaths=trainingTbaPaths, regionAssoc=regionAssoc, cov=trainingCovariates,
|
876: #' testingTbaPaths <- system.file("extdata","testing.tba.toydata.rds",
|
879: #' pcs <- affiXcanPcs(tbaPaths=testingTbaPaths, affiXcanTraining=training,
|
967: #' trainingTbaPaths <- system.file("extdata","training.tba.toydata.rds",
|
977: #' tbaPaths=trainingTbaPaths, regionAssoc=regionAssoc, cov=trainingCovariates,
|
980: #' imputedExpr <- affiXcanImpute(tbaPaths=trainingTbaPaths,
|
1029: #' trainingTbaPaths <- system.file("extdata","training.tba.toydata.rds",
|
1039: #' tbaPaths=trainingTbaPaths, regionAssoc=regionAssoc, cov=trainingCovariates,
|
1042: #' imputedExpr <- affiXcanImpute(tbaPaths=trainingTbaPaths,
|
1078: #' trainingTbaPaths <- system.file("extdata","training.tba.toydata.rds",
|
1088: #' tbaPaths=trainingTbaPaths, regionAssoc=regionAssoc,
|
1091: #' testingTbaPaths <- system.file("extdata","testing.tba.toydata.rds",
|
1094: #' exprmatrix <- affiXcanImpute(tbaPaths=testingTbaPaths,
|
1096: affiXcanImpute <- function(tbaPaths, affiXcanTraining, scale=TRUE,
|
1098: regionsCount <- overlookRegions(tbaPaths)
|
1104: tbaPaths refers to ", regionsCount, " regions\n"))
|
1109: pcs <- affiXcanPcs(tbaPaths, affiXcanTraining, scale, BPPARAM)
|
qusage:R/qusage.R: [ ] |
---|
532: path = q$pathways[[i]]
|
537: path = QSarray$pathways[[i]]
|
379: PDFs = pathMeans = Sizes = NULL
|
792: SDPath = apply(calcBayesCI(QSarray,low=0.5,up=0.8413448)[,path.index,drop=F],2,function(x)x[2]-x[1])
|
800: XPath = getXcoords(QSarray,i,addVIF=addVIF)
|
808: PDFPath<-approx( XPath, QSarray$path.PDF[,i],X_Sample,rule=2)$y
|
47: qs.results.comb$path.mean = 2 * qs.results.comb$path.mean
|
59: for(i in c("var.method","labels","pairVector","pathways","path.size")){
|
408: geneResults$path.mean = pathMeans
|
409: geneResults$path.size = Sizes
|
412: geneResults$path.PDF = PDFs
|
503: if(!is.null(geneResults$path.PDF)){ ##if defined, rescale the pdf with the new vif values
|
504: geneResults$path.PDF = t(t(geneResults$path.PDF) / pdfScaleFactor(geneResults))
|
524: if(is.null(QSarray$path.PDF)){stop("convolution results not found.")}
|
525: p = sapply(1:ncol(QSarray$path.PDF), function(i){
|
526: if(!is.null(QSarray$path.size) && QSarray$path.size[i]==0){return(NA)}
|
533: mean(q$mean[-path])
|
538: null.hyp = mean(QSarray$mean[-path])
|
545: # path = QSarray$pathways[[i]]
|
546: # null.hyp=mean(getExAbs(QSarray$dof[path])*QSarray$SD[path])
|
551: PDF_NORM<-QSarray$path.PDF[,i]/sum(QSarray$path.PDF[,i])
|
552: # sum(QSarray$path.PDF[1:findInterval(0,x),i]) / sum(QSarray$path.PDF[,i])
|
571: twoWay.pVal <- function(grp1, grp2, path.index1 = 1:numPathways(grp1), path.index2 = 1:numPathways(grp2),
|
575: return(twoCurve.pVal(grp1, grp2, path.index1, path.index2, alternative, direction,addVIF))
|
582: path.index1 = 1:numPathways(grp1),
|
583: path.index2 = 1:numPathways(grp2),
|
589: # if(ncol(grp1$path.PDF)!=ncol(grp2$path.PDF) | all(colnames(grp1$path.PDF) != colnames(grp2$path.PDF))){
|
592: if(length(path.index1)!=length(path.index2)){
|
595: # if(sum(names(grp1$path.mean[path.index1])!=names(grp2$path.mean[path.index2]))){
|
599: x1 = sapply(path.index1,function(i){getXcoords(grp1,i,addVIF=addVIF)})
|
600: x2 = sapply(path.index2,function(i){getXcoords(grp2,i,addVIF=addVIF)})
|
605: p = sapply(1:length(path.index1), function(i){
|
607: PDF1<-approx( x1[,i], grp1$path.PDF[,path.index1[i]],seq(Min[i],Max[i],length.out=Length1+Length2),rule=2)$y
|
608: PDF2<-approx( x2[,i], grp2$path.PDF[,path.index2[i]],seq(Min[i],Max[i],length.out=Length1+Length2),rule=2)$y
|
615: ## path.index can either be an integer between 1 and length(path.means), or the name of the pathway.
|
618: getXcoords = function(QSarray,path.index=1, addVIF=!is.null(QSarray$vif)){ #,absolute=FALSE){
|
619: if(length(path.index)>1){stop("path.index must be of length 1")}
|
622: sif = ifelse(addVIF,sqrt(QSarray$vif[path.index]),1)
|
626: seq(-1,1,length.out=QSarray$n.points)* QSarray$ranges[path.index]* sif + QSarray$path.mean[path.index]
|
630: # MeanAbs<-mean(abs(QSarray$mean[QSarray$pathways[[path.index]]]))
|
631: # seq(-1,1,length.out=QSarray$n.points)* QSarray$ranges[path.index]* sif / QSarray$path.size[path.index] + MeanAbs
|
642: pdfSum = colSums(QSarray$path.PDF)
|
655: cis = sapply(1:ncol(QSarray$path.PDF), function(i){
|
657: any(is.na(QSarray$path.PDF[,i]))){return(c(NA,NA))}
|
659: cdf = cumsum(QSarray$path.PDF[,i])
|
668: colnames(cis) = colnames(QSarray$path.PDF)
|
771: path.index=1:numPathways(QSarray), ##The pathways to calculate the pVals for.
|
778: ##check path.index
|
779: if(is.character(path.index)){
|
780: path.index = match(path.index, names(QSarray$pathways))
|
793: if(!addVIF)SDPath = SDPath / sqrt(QSarray$vif[path.index])
|
799: for(i in path.index){
|
824: TMP<-pnorm( ( Means[j] - QSarray$path.mean[i] ) / sqrt( SDPath[i]^2 + (DOF[j])/(DOF[j]-2)*SD[j]^2) )
|
835: for(i in path.index){
|
842: if(compareTo=="mean")SUBSTRACT=QSarray$path.mean[i]
|
875: if(!CompareWithZero)SUBSTRACT=QSarray$path.mean[i]
|
17: geneSets, ##a list of pathways to be compared. Each item in the list is a vector of names that correspond to the row names of ...(5 bytes skipped)...
|
74: geneSets, ##a list of pathways to be compared. Each item in the list is a vector of names that correspond to the row names of ...(5 bytes skipped)...
|
308: if(!is.null(QSarray$pathways)){stop("too late...aggregateGeneSet already being called")}
|
320: ##Simple function to read in a .gmt file and return a list of pathways
|
322: if(!grepl("\\.gmt$",file)[1]){stop("Pathway information must be a .gmt file")}
|
331: #######Combine individual gene differential expresseion for each pathway (Neg) ~ 1 minute
|
334: geneSets, ##a list of pathways to be compared, each item in the list is a vector of names that correspond to the gene names fr...(25 bytes skipped)...
|
336: silent=TRUE ##If false, print a "." every fifth pathway, as a way to keep track of progress
|
401: pathMeans = c(pathMeans, mean(Means[Indexes]))
|
405: colnames(PDFs) = names(pathMeans) = names(Sizes) = names(geneSets)
|
407: geneResults$pathways = geneSets
|
425: # geneSets=NULL, ##a list of pathways calculate the vif for, each item in the list is a vector of names that correspond to the gene n...(32 bytes skipped)...
|
430: if(is.null(geneResults$pathways)){stop("Pathway Information not found. Please provide a list of gene sets.")}
|
431: geneSets = geneResults$pathways
|
439: # geneResults$pathways = geneSets
|
516: ## function for calculating a p-value for each pathway convolution as output by aggregateGeneSet.
|
519: ...(59 bytes skipped)... true (and alternative="two.sided"), p-values will be returned as eiter positive or negative if the pathway is greater or less than 0, respectively.
|
521: ...(15 bytes skipped)... selfContained=TRUE ##If false, rather than comparing to 0, it will compare the pathway mean to the mean of all genes not in the pathway.
|
578: ## A method to compare the pathway convolutions in two QSarray objects.
|
588: ##if the names of the pathways don't match,
|
590: # stop("Pathways in grp1 do not match pathways in grp2")
|
593: stop("Number of pathways in grp1 do not match number of pathways in grp2")
|
596: # warning("Some of the comparisons are made between different pathways")
|
614: ## Calculates the x-coordinates for the PDF of a given pathway.
|
629: # ###First calculate the new mean of the pathway based on the absolute values of the means
|
656: if( (!is.null(QSarray$pathways) && length(QSarray$pathways[[i]])==0 ) ||
|
772: silent=TRUE, ##If false, print a "." every fifth pathway, as a way to keep track of progress
|
784: if(is.null(QSarray$pathways)){stop("Pathway Information not found. Please run aggregateGeneSet first.")}
|
785: geneSets = QSarray$pathways
|
805: Min<-min(c(XGene[1]+ Means[Indexes],XPath[1]))
|
806: Max<-max(c(XGene[NPoints]+ Means[Indexes],XPath[QSarray$n.points]))
|
815: PS<-c(PS,compareTwoDistsFaster(PDFGene,PDFPath, alternative="two.sided"))
|
860: ...(17 bytes skipped)... CompareWithZero=TRUE ###Logical, if TRUE compares with mean of zero, else with mean of pathway
|
862: if(is.null(QSarray$pathways)){stop("Pathway Information not found. Please provide a list of gene sets.")}
|
863: geneSets = QSarray$pathways
|
898: # geneSets=NULL, ##a list of pathways calculate the vif for, each item in the list is a vector of names that correspond to the gene n...(32 bytes skipped)...
|
901: if(is.null(geneResults$pathways)){stop("Pathway Information not found. Please provide a list of gene sets.")}
|
902: geneSets = geneResults$pathways
|
640: sif = sapply(1:numPathways(QSarray),function(i){ifelse(addVIF,sqrt(QSarray$vif[i]),1)})
|
Rqc:R/utils.R: [ ] |
---|
94: path <- dirname(file)
|
99: data.frame(filename, pair, format, group, reads, total.reads, path,
|
MuData:R/write_h5mu.R: [ ] |
---|
313: path <- paste(H5Iget_name(parent), key, sep="/")
|
315: filepath=file, name=path, chunkdim=chunkdim, parent=parent, datasetname=key)
|
snapcount:R/basic_query_functions.R: [ ] |
---|
273: path <- paste(compilation, paste0(endpoint, "?"), sep = "/")
|
319: paste0(pkg_globals$snaptron_host, path, paste(query, collapse = "&"))
|
MetaboSignal:R/General_internal_functions.R: [ ] |
---|
185: path = all_paths[maxBW, ]
|
140: path_individual = as.character(row)
|
278: path_as_network = function(path) {
|
123: shortpath = rownames(as.matrix(unlist(ASP)))
|
347: pathM = convertTable(response)
|
122: ASP_paths = function (ASP) {
|
360: all_pathsGM_names = all_pathsGM
|
341: MS_FindPathway = function(match = NULL, organism_code = NULL) {
|
141: BW = sapply(path_individual, get_bw_score, BW_matrix)
|
180: ## Get global BW score for each path
|
186: path = as.character(path)
|
187: all_paths = matrix(path, ncol = length(path))
|
277: ##################### path_as_network ######################
|
280: for (i in 1:(length(path) - 1)) {
|
281: edge = c(path[i], path[i + 1])
|
348: colnames(pathM) = c("path_ID", "path_Description")
|
17: #metabolite is a substrate. It is used to calculate shortest paths with SP mode.
|
121: ####################### ASP_paths #######################
|
124: return(shortpath)
|
150: BW_ranked_SP = function (all_paths, BW_matrix, networkBW_i, mode) {
|
152: all_nodes = unique(as.vector(all_paths))
|
181: Global_BW_score = sapply (split(all_paths, row(all_paths)), get_global_BW_score,
|
189: return(all_paths)
|
342: file = paste("http://rest.kegg.jp/list/pathway/", organism_code, sep = "")
|
345: stop("A valid organism_code is required for KEGG_entry = pathway")
|
349: rownames(pathM) = NULL
|
351: target_matrix = pathM
|
352: target_column = pathM[, 2]
|
355: } else (return(pathM))
|
359: network_names = function(all_pathsGM, organism_code) {
|
361: all_nodes = unique(as.vector(all_pathsGM[, 1:2]))
|
365: all_pathsGM_names[all_pathsGM_names == all_nodes[i]] = all_names[i]
|
367: return(all_pathsGM_names)
|
340: #################### MS_FindPathway ####################
|
sevenbridges:inst/extdata/app/flow_star.json: [ ] |
---|
272: "path": "/demo/test-files/chr20.gtf"
|
280: "path": "/sbgenomics/test-data/chr20.fa"
|
476: "path": "/path/to/fastq.ext"
|
818: "path": "/root/dir/example.tested.bam"
|
2894: "path": "genome.ext"
|
2936: "path": "/test-data/mate_1.fastq.bz2"
|
2995: "path": "/demo/test-data/chr20.gtf"
|
349: ...(34 bytes skipped)...r sjFormat = \"False\"\n var gtfgffFormat = \"False\"\n var list = $job.inputs.sjdbGTFfile\n var paths_list = []\n var joined_paths = \"\"\n \n if (list) {\n list.forEach(function(f){return paths_list.push(f.path)})\n joined_paths = paths_list.join(\" \")\n\n\n path...(355 bytes skipped)...ne\") {\n if (sjFormat == \"True\") {\n return \"--sjdbFileChrStartEnd \".concat(joined_path...(5 bytes skipped)... }\n else if (gtfgffFormat == \"True\") {\n return \"--sjdbGTFfile \".concat(joined_paths)\n }\n }\n }\n}",
|
445: "sbg:cmdPreview": "python /opt/sbg_fastq_quality_scale_detector.py --fastq /path/to/fastq.ext /path/to/fastq.ext",
|
898: "script": "{\n filename = $job.inputs.input_bam.path\n ext = $job.inputs.output_type\n\nif (ext === \"BAM\")\n{\n return filename.split('.').slice(0...(372 bytes skipped)...
|
910: "script": "{\n filename = $job.inputs.input_bam.path\n \n /* figuring out output file type */\n ext = $job.inputs.output_type\n if (ext === \"BAM\")...(657 bytes skipped)...
|
992: "script": "$job.inputs.genome.path",
|
1606: ...(48 bytes skipped)...concat($job.inputs.reads)\n \n var resp = []\n \n if (list.length == 1){\n resp.push(list[0].path...(178 bytes skipped)...etadata != null){\n if (list[index].metadata.paired_end == 1){\n left = list[index].path\n }else if (list[index].metadata.paired_end == 2){\n right = list[index].path...(297 bytes skipped)...data != null){\n if (list[index].metadata.paired_end == 1){\n left.push(list[index].path)\n }else if (list[index].metadata.paired_end == 2){\n right.push(list[index].path)\n }\n }\n }\n left_join = left.join()\n right_join = right.join()\n if (le...(200 bytes skipped)...
|
3224: "script": "{\n file = [].concat($job.inputs.reads)[0].path\n extension = /(?:\\.([^.]+))?$/.exec(file)[1]\n if (extension == \"gz\") {\n return \"--readF...(107 bytes skipped)...
|
3232: ...(34 bytes skipped)...r sjFormat = \"False\"\n var gtfgffFormat = \"False\"\n var list = $job.inputs.sjdbGTFfile\n var paths_list = []\n var joined_paths = \"\"\n \n if (list) {\n list.forEach(function(f){return paths_list.push(f.path)})\n joined_paths = paths_list.join(\" \")\n\n\n path...(355 bytes skipped)...ne\") {\n if (sjFormat == \"True\") {\n return \"--sjdbFileChrStartEnd \".concat(joined_path...(5 bytes skipped)... }\n else if (gtfgffFormat == \"True\") {\n return \"--sjdbGTFfile \".concat(joined_paths)\n }\n }\n }\n}",
|
3280: ...(138 bytes skipped)...gth, i= 0;\n while(i<L && a1.charAt(i)=== a2.charAt(i)) i++;\n return a1.substring(0, i);\n }\n path_list = []\n arr = [].concat($job.inputs.reads)\n arr.forEach(function(f){return path_list.push(f.path.replace(/\\\\/g,'/').replace( /.*\\//, '' ))})\n common_prefix = sharedStart(path_list)\n intermediate = common_prefix.replace( /\\-$|\\_$|\\.$/, '' ).concat(\"._STARgenome\")\n s...(262 bytes skipped)...
|
3289: ...(138 bytes skipped)...gth, i= 0;\n while(i<L && a1.charAt(i)=== a2.charAt(i)) i++;\n return a1.substring(0, i);\n }\n path_list = []\n arr = [].concat($job.inputs.reads)\n arr.forEach(function(f){return path_list.push(f.path.replace(/\\\\/g,'/').replace( /.*\\//, '' ))})\n common_prefix = sharedStart(path_list)\n return \"./\".concat(common_prefix.replace( /\\-$|\\_$|\\.$/, '' ), \".\")\n}",
|
3298: ...(138 bytes skipped)...gth, i= 0;\n while(i<L && a1.charAt(i)=== a2.charAt(i)) i++;\n return a1.substring(0, i);\n }\n path_list = []\n arr = [].concat($job.inputs.reads)\n arr.forEach(function(f){return path_list.push(f.path.replace(/\\\\/g,'/').replace( /.*\\//, '' ))})\n common_prefix = sharedStart(path_list)\n mate1 = common_prefix.replace( /\\-$|\\_$|\\.$/, '' ).concat(\".Unmapped.out.mate1\")\n m...(463 bytes skipped)...
|
MesKit:R/phyloTreeAnno.R: [ ] |
---|
672: path <- list()
|
570: trunkPath <- rev(c(mainTrunk,rootNode))
|
674: subPath <- c()
|
509: ## label represents the common evolution path of samples
|
688: path[[name]] <- subPath
|
695: result <- path[[names(which.max(distanceTable))]]
|
571: if(length(trunkPath) > 0){
|
572: # subdat_list <- lapply(2:length(trunkPath), function(i){
|
573: # x1 <- treeData[treeData$end_num == trunkPath[i-1],]$x2
|
574: # y1 <- treeData[treeData$end_num == trunkPath[i-1],]$y2
|
577: # distance <- treeEdge[treeEdge$endNum == trunkPath[i],]$length
|
589: # 'node' = trunkPath[i-1],'end_num' = trunkPath[i])
|
596: for(i in 2:length(trunkPath)){
|
597: x1 <- treeData[treeData$end_num == trunkPath[i-1],]$x2
|
598: y1 <- treeData[treeData$end_num == trunkPath[i-1],]$y2
|
601: distance <- treeEdge[treeEdge$endNum == trunkPath[i],]$length
|
613: 'node' = trunkPath[i-1],'end_num' = trunkPath[i])
|
682: subPath <- append(subPath,end)
|
VarCon:inst/extdata/app.R: [ ] |
---|
235: path <- reactiveValues(
|
240: path2 <- reactiveValues(
|
244: path3 <- reactiveValues(
|
24: uploadReferenceDNA <- eventReactive(path$pth,{
|
26: testFASTA <- strsplit(path$pth,"\\.")[[1]]
|
28: referenceDnaStringSet2 <- readDNAStringSet(path$pth, format="fasta",use.names=TRUE)
|
34: load(path$pth)
|
42: uploadTranscriptTable <- eventReactive(path3$pth3,{
|
45: testCSV <- strsplit(path3$pth3,"\\.")[[1]]
|
47: transCoord <- read.csv(path3$pth3, sep=";")
|
48: }else{ transCoord <- readRDS(path3$pth3)}
|
78: gene2transcript <- read.csv(path2$pth2, sep=";", stringsAsFactors=FALSE)
|
99: gene2transcript <- read.csv(path2$pth2, sep=";", stringsAsFactors=FALSE)
|
126: gene2transcript <- read.csv(path2$pth2, sep=";", stringsAsFactors=FALSE)
|
145: gene2transcript <- read.csv(path2$pth2, sep=";", stringsAsFactors=FALSE)
|
176: gene2transcript <- read.csv(path2$pth2, sep=";", stringsAsFactors=FALSE)
|
205: gene2transcript <- read.csv(path2$pth2, sep=";", stringsAsFactors=FALSE)
|
251: path$pth <- file.choose()
|
255: path2$pth2 <- file.choose()
|
259: path3$pth3 <- file.choose()
|
234: ## Define reactive paths
|
exomeCopy:R/main_functions.R: [ ] |
---|
199: path <- viterbiPath(nm.fit$par,fx.par,data,nstates,stFn,trFn,emFn)
|
105: V.path <- matrix(0,nrow=nstates,ncol=T)
|
90: viterbiPath <- function(par,fx.par,data,nstates,stFn,trFn,emFn) {
|
106: ...(78 bytes skipped)...start.probs=as.double(start.probs),A=as.double(A),emit.probs=as.double(emit.probs),V=as.double(V),V.path=as.integer(V.path),path=as.integer(numeric(T)),trans.prob=as.double(numeric(nstates^2)),trans.prob.max=as.double(numeric(ns...(57 bytes skipped)...
|
107: return(viterbi.call$path + 1)
|
201: log.odds <- log(emit.probs[cbind(path,seq(path))]+1e-6) - log(emit.probs[normal.state,]+1e-6)
|
203: fit <- new("ExomeCopy",sample.name=sample.name,type=type,path=Rle(path),ranges=granges(gr),O.norm=as.numeric(O/mu.hat),log.odds=log.odds,fx.par=fx.par,init.par=init.par,f...(89 bytes skipped)...
|
Rgraphviz:src/graphviz/lib/common/types.h: [ ] |
---|
105: typedef struct path { /* internal specification for an edge spline */
|
110: } path;
|
656: Ppolyline_t path;
|
685: #define ED_path(e) (((Agedgeinfo_t*)AGDATA(e))->path)
|
714: #define ED_path(e) (e)->u.path
|
97: typedef struct pathend_t {
|
103: } pathend_t;
|
158: /* we would have called it a path if that term wasn't already used */
|
174: * It is used as the clipping path */
|
182: int (*pboxfn)(node_t* n, port* p, int side, boxf rv[], int *kptr); /* finds box path to reach port */
|
34: #include "pathgeom.h"
|
GBScleanR:R/Methods-GbsrGenotypeData.R: [ ] |
---|
424: path <- paste0("annotation/info/", var)
|
449: path <- paste0("annotation/format/AD/", "norm")
|
525: path <- ifelse(.existGdsNode(object, node),
|
1308: path <- .getNodeIndex(object, node)
|
1420: path <- paste0("annotation/format/AD/", node)
|
1521: path <- .getNodeIndex(object, "annotation/format/AD/norm")
|
18: ## Get the index of the specified path in the GDS file.
|
20: .getNodeIndex <- function(object, path){
|
21: return(index.gdsn(.getGdsfmtObj(object), path))
|
83: .existGdsNode <- function(object, path){
|
84: return(exist.gdsn(.getGdsfmtObj(object), path))
|
426: if(!.existGdsNode(object, path)){
|
427: warning("No data at ", path)
|
430: info_node <- .getNodeIndex(object, path)
|
451: path <- paste0("annotation/format/AD/", "filt.data")
|
453: path <- paste0("annotation/format/AD/", "data")
|
455: if(!.existGdsNode(object, path)){
|
458: ad_node <- .getNodeIndex(object, path)
|
529: genotype_node <- .getNodeIndex(object, path)
|
1327: path,
|
1336: path,
|
1346: .countGenotypeScan <- function(object, path, sel, has_flipped, valid_flipped){
|
1347: df <- apply.gdsn(path, 1, selection=sel, as.is="list",
|
1380: .countGenotypeSnp <- function(object, path, sel, has_flipped, valid_flipped){
|
1381: df <- apply.gdsn(path, 2, selection=sel, as.is="list",
|
1421: if(.existGdsNode(object, path)){
|
1422: path <- .getNodeIndex(object, path)
|
1437: path,
|
1446: path,
|
1454: .countReadScan <- function(object, path, sel, has_flipped, valid_flipped){
|
1455: df <- apply.gdsn(path, 1, selection=sel, as.is="list",
|
1478: .countReadSnp <- function(object, path, sel, has_flipped, valid_flipped){
|
1479: df <- apply.gdsn(path, 2, sum, sel, "list")
|
1526: path,
|
1536: path,
|
1570: path,
|
1575: df <- apply.gdsn(path, 1, selection=sel, as.is="list",
|
1615: path,
|
1620: df <- apply.gdsn(path, 2, selection=sel, as.is="list",
|
2509: stop("Failed to create a new file to the following path \n",
|
interactiveDisplay:inst/www/js/d3.v2.js: [ ] |
---|
6081: function path(d, i) {
|
1451: function d3_layout_bundlePath(link) {
|
1910: function d3_path_circle(radius) {
|
1119: var i = 0, n = points.length, p = points[0], path = [ p[0], ",", p[1] ];
|
1120: while (++i < n) path.push("V", (p = points[i])[1], "H", p[0]);
|
1121: return path.join("");
|
1124: var i = 0, n = points.length, p = points[0], path = [ p[0], ",", p[1] ];
|
1125: while (++i < n) path.push("H", (p = points[i])[0], "V", p[1]);
|
1126: return path.join("");
|
1141: var quad = points.length != tangents.length, path = "", p0 = points[0], p = points[1], t0 = tangents[0], t = t0, pi = 1;
|
1143: path += "Q" + (p[0] - t0[0] * 2 / 3) + "," + (p[1] - t0[1] * 2 / 3) + "," + p[0] + "," + p[1];
|
1151: path += "C" + (p0[0] + t0[0]) + "," + (p0[1] + t0[1]) + "," + (p[0] - t[0]) + "," + (p[1] - t[1]) + "," ...(21 bytes skipped)...
|
1155: path += "S" + (p[0] - t[0]) + "," + (p[1] - t[1]) + "," + p[0] + "," + p[1];
|
1160: path += "Q" + (p[0] + t[0] * 2 / 3) + "," + (p[1] + t[1] * 2 / 3) + "," + lp[0] + "," + lp[1];
|
1162: return path;
|
1176: ...(44 bytes skipped)...s[0], x0 = pi[0], y0 = pi[1], px = [ x0, x0, x0, (pi = points[1])[0] ], py = [ y0, y0, y0, pi[1] ], path = [ x0, ",", y0 ];
|
1177: d3_svg_lineBasisBezier(path, px, py);
|
1184: d3_svg_lineBasisBezier(path, px, py);
|
1192: d3_svg_lineBasisBezier(path, px, py);
|
1194: return path.join("");
|
1198: var path = [], i = -1, n = points.length, pi, px = [ 0 ], py = [ 0 ];
|
1204: path.push(d3_svg_lineDot4(d3_svg_lineBasisBezier3, px) + "," + d3_svg_lineDot4(d3_svg_lineBasisBezier3, ...(6 bytes skipped)...
|
1212: d3_svg_lineBasisBezier(path, px, py);
|
1214: return path.join("");
|
1217: var path, i = -1, n = points.length, m = n + 4, pi, px = [], py = [];
|
1223: path = [ d3_svg_lineDot4(d3_svg_lineBasisBezier3, px), ",", d3_svg_lineDot4(d3_svg_lineBasisBezier3, py)...(4 bytes skipped)...
|
1231: d3_svg_lineBasisBezier(path, px, py);
|
1233: return path.join("");
|
1251: function d3_svg_lineBasisBezier(path, x, y) {
|
1252: path.push("C", d3_svg_lineDot4(d3_svg_lineBasisBezier1, x), ",", d3_svg_lineDot4(d3_svg_lineBasisBezier1...(207 bytes skipped)...
|
4383: var tick = g.selectAll("g").data(ticks, String), tickEnter = tick.enter().insert("g", "path").style("opacity", 1e-6), tickExit = d3.transition(tick.exit()).style("opacity", 1e-6).remove(), ti...(67 bytes skipped)...
|
4384: var range = d3_scaleRange(scale), path = g.selectAll(".domain").data([ 0 ]), pathEnter = path.enter().append("path").attr("class", "domain"), pathUpdate = d3.transition(path);
|
6080: d3.geo.path = function() {
|
6082: if (typeof pointRadius === "function") pointCircle = d3_path_circle(pointRadius.apply(this, arguments));
|
6111: var pointRadius = 4.5, pointCircle = d3_path_circle(pointRadius), projection = d3.geo.albersUsa(), buffer = [];
|
6178: var areaType = path.area = d3_geo_type({
|
6201: var centroidType = path.centroid = d3_geo_type({
|
6220: path.projection = function(x) {
|
6222: return path;
|
6224: path.pointRadius = function(x) {
|
6227: pointCircle = d3_path_circle(pointRadius);
|
6229: return path;
|
6231: return path;
|
4401: pathUpdate.attr("d", "M" + range[0] + "," + tickEndSize + "V0H" + range[1] + "V" + tickEndSize);
|
4414: pathUpdate.attr("d", "M" + range[0] + "," + -tickEndSize + "V0H" + range[1] + "V" + -tickEndSize);
|
4427: pathUpdate.attr("d", "M" + -tickEndSize + "," + range[0] + "H0V" + range[1] + "H" + -tickEndSize);
|
4440: pathUpdate.attr("d", "M" + tickEndSize + "," + range[0] + "H0V" + range[1] + "H" + tickEndSize);
|
4923: var paths = [], i = -1, n = links.length;
|
4924: while (++i < n) paths.push(d3_layout_bundlePath(links[i]));
|
4925: return paths;
|
6083: pathType(d);
|
6112: var pathType = d3_geo_type({
|
6115: while (++i < n) buffer.push(pathType(features[i].geometry));
|
6118: pathType(o.geometry);
|
6175: while (++i < n) buffer.push(pathType(geometries[i]));
|
cTRAP:R/shinyInterface.R: [ ] |
---|
475: if (is.function(path)) path <- path()
|
418: path=".", globalUI=FALSE) {
|
476: ENCODEsamples <- loadENCODEsamples(ENCODEmetadata, path=path)
|
1194: inputFile <- file.path(token, sprintf("input_%s.Rda", rand))
|
1195: outputFile <- file.path(token, sprintf("output_%s.rds", rand))
|
1380: .predictTargetingDrugsServer <- function(id, x, path=".", globalUI=FALSE,
|
1405: corMatrix, path=path)
|
1469: .drugSetEnrichmentAnalyserServer <- function(id, x, path=NULL) {
|
1492: path=path)
|
1665: file="ENCODEmetadata.rds", path=".") {
|
1670: .diffExprENCODEloaderServer(id, metadata, cellLine, gene, path=path)
|
GeneGeneInteR:R/PLSPM.R: [ ] |
---|
207: Path = inner_results[[2]]
|
1162: Path = path_matrix
|
2176: Path <- pathmod[[2]]
|
48: my.path <- rbind(Gene1,Gene2)
|
209: Path_effects = get_effects(Path)
|
363: check_path <- function(path_matrix)
|
1173: path_lm = summary(lm(Y_lvs[,k1] ~ Y_lvs[,k2]))
|
1202: path_effects = as.list(seq_len(lvs-1))
|
2177: path.orig <- as.vector(Path[path_matrix==1])
|
2179: Path.efs <- get_effects(Path)
|
2186: path.labs <- NULL
|
2175: pathmod <- get_paths(path_matrix, Y.lvs)
|
2194: PATHS <- matrix(NA, bootnum, sum(path_matrix))
|
1805: get_path_scheme <- function(path_matrix, LV)
|
1156: get_paths <- function(path_matrix, Y_lvs, full=TRUE)
|
1207: indirect_paths = matrix(c(0,0,0,0), 2, 2)
|
1208: total_paths = Path
|
55: try(mod1 <- plspm(XCases,my.path,my.blocks, modes = my.modes), silent=TRUE)
|
59: res <- list(statistic=NA,p.value=NA,method="Partial Least Squares Path Modeling",parameter=list.param)
|
64: try(mod0 <- plspm(XControls,my.path,my.blocks, modes = my.modes),silent=TRUE)
|
68: res <- list(statistic=NA,p.value=NA,method="Partial Least Squares Path Modeling",parameter=list.param)
|
91: try(mod1 <- plspm(XCases,my.path,my.blocks, modes = my.modes), silent=TRUE)
|
93: try(mod0 <- plspm(XControls,my.path,my.blocks, modes = my.modes),silent=TRUE)
|
110: # res <- list(statistic=stat,p.value=pval,method="Partial Least Squares Path Modeling",parameter=list.param)
|
123: method="Gene-based interaction based on Partial Least Squares Path Modeling",
|
138: function(Data, path_matrix, blocks, modes = NULL, scaling = NULL,
|
146: valid = check_args(Data=Data, path_matrix=path_matrix, blocks=blocks,
|
153: path_matrix = valid$path_matrix
|
167: gens = get_generals(MV, path_matrix)
|
188: weights = get_weights(X, path_matrix, blocks, specs)
|
194: weights = get_weights_nonmetric(X, path_matrix, blocks, specs)
|
203: # Path coefficients and total effects
|
205: inner_results = get_paths(path_matrix, LV)
|
241: inner_summary = get_inner_summary(path_matrix, blocks, specs$modes,
|
245: gof = get_gof(communality, R2, blocks, path_matrix)
|
259: bootstrap = get_boots(MV, path_matrix, blocks, specs, br)
|
264: model = list(IDM=path_matrix, blocks=blocks, specs=specs,
|
270: path_coefs = Path,
|
274: effects = Path_effects,
|
289: cat("Partial Least Squares Path Modeling (PLS-PM)", "\n")
|
294: cat("\n3 $path_coefs ", "path coefficients matrix")
|
314: function(Data, path_matrix, blocks, scaling, modes, scheme,
|
319: path_matrix = check_path(path_matrix)
|
327: good_model = check_model(path_matrix, blocks)
|
331: path_matrix = path_matrix,
|
365: if (is_not_matrix(path_matrix))
|
366: stop("\n'path_matrix' must be a matrix.")
|
368: if (!is_square_matrix(path_matrix))
|
369: stop("\n'path_matrix' must be a square matrix.")
|
371: if (nrow(path_matrix) == 1)
|
372: stop("\n'path_matrix' must have more than one row")
|
374: if (!is_lower_triangular(path_matrix))
|
375: stop("\n'path_matrix' must be a lower triangular matrix")
|
378: for (j in seq_len(ncol(path_matrix)))
|
380: for (i in seq_len(nrow(path_matrix)))
|
382: if (length(intersect(path_matrix[i,j], c(1,0))) == 0)
|
383: stop("\nElements in 'path_matrix' must be '1' or '0'")
|
387: if (lacks_dimnames(path_matrix)) {
|
388: LV_names = paste("LV", seq_len(ncol(path_matrix)), sep = "")
|
389: dimnames(path_matrix) = list(LV_names, LV_names)
|
391: if (has_rownames(path_matrix) && lacks_colnames(path_matrix)) {
|
392: colnames(path_matrix) = rownames(path_matrix)
|
394: if (has_colnames(path_matrix) && lacks_rownames(path_matrix)) {
|
395: rownames(path_matrix) = colnames(path_matrix)
|
399: path_matrix
|
458: check_model <- function(path_matrix, blocks)
|
460: # compatibility between path_matrix and blocks
|
461: if (length(blocks) != nrow(path_matrix))
|
462: stop("\nNumber of rows in 'path_matrix' different from length of 'blocks'.")
|
687: SCHEMES = c("centroid", "factorial", "path")
|
884: get_generals <- function(MV, path_matrix)
|
890: lvs = nrow(path_matrix),
|
891: lvs_names = rownames(path_matrix))
|
1035: get_weights <- function(X, path_matrix, blocks, specs)
|
1037: lvs = nrow(path_matrix)
|
1055: "centroid" = sign(cor(Y) * (path_matrix + t(path_matrix))),
|
1056: "factorial" = cor(Y) * (path_matrix + t(path_matrix)),
|
1057: "path" = get_path_scheme(path_matrix, Y))
|
1083: dimnames(W) = list(colnames(X), rownames(path_matrix))
|
1158: lvs_names = colnames(path_matrix)
|
1159: endogenous = as.logical(rowSums(path_matrix))
|
1164: R2 = rep(0, nrow(path_matrix))
|
1171: k2 = which(path_matrix[k1,] == 1)
|
1174: Path[k1,k2] = path_lm$coef[-1,1]
|
1175: residuals[[aux]] = path_lm$residuals
|
1176: R2[k1] = path_lm$r.squared
|
1177: inn_val = c(path_lm$r.squared, path_lm$coef[,1])
|
1180: rownames(path_lm$coefficients) = inn_labels
|
1181: results[[aux]] <- path_lm$coefficients
|
1184: # paste(rep("path_",length(k2)),names(k2),sep=""))
|
1192: list(results, Path, R2, residuals)
|
1195: get_effects <- function(Path)
|
1198: lvs = nrow(Path)
|
1199: lvs_names = rownames(Path)
|
1203: path_effects[[1]] = Path
|
1212: path_effects[[k]] = path_effects[[k-1]] %*% Path
|
1215: for (k in 2:length(path_effects)) {
|
1216: indirect_paths = indirect_paths + path_effects[[k]]
|
1218: total_paths = Path + indirect_paths
|
1227: direct = c(direct, Path[i,j])
|
1325: function(path_matrix, blocks, modes, communality, redundancy, R2)
|
1328: exo_endo = rep("Exogenous", nrow(path_matrix))
|
1329: exo_endo[rowSums(path_matrix) != 0] = "Endogenous"
|
1330: avg_comu = rep(0, nrow(path_matrix))
|
1331: avg_redu = rep(0, nrow(path_matrix))
|
1332: AVE = rep(0, nrow(path_matrix))
|
1334: for (k in seq_len(nrow(path_matrix)))
|
1352: row.names = rownames(path_matrix))
|
1355: get_gof <- function(comu, R2, blocks, path_matrix)
|
1357: lvs = nrow(path_matrix)
|
1359: endo = rowSums(path_matrix)
|
1392: get_weights <- function(X, path_matrix, blocks, specs)
|
1394: lvs = nrow(path_matrix)
|
1412: "centroid" = sign(cor(Y) * (path_matrix + t(path_matrix))),
|
1413: "factorial" = cor(Y) * (path_matrix + t(path_matrix)),
|
1414: "path" = get_path_scheme(path_matrix, Y))
|
1440: dimnames(W) = list(colnames(X), rownames(path_matrix))
|
1478: function(X, path_matrix, blocks, specs)
|
1480: lvs = nrow(path_matrix)
|
1541: link = t(path_matrix) + path_matrix
|
1556: "path" = get_path_scheme(path_matrix, Y))
|
1751: dimnames(W) = list(colnames(X), rownames(path_matrix))
|
1752: dimnames(Y) = list(rownames(X), rownames(path_matrix))
|
1808: E = path_matrix
|
1810: for (k in seq_len(ncol(path_matrix)))
|
1813: follow <- path_matrix[k,] == 1
|
1817: predec <- path_matrix[,k] == 1
|
2141: function(DM, path_matrix, blocks, specs, br)
|
2146: lvs = nrow(path_matrix)
|
2147: lvs.names = rownames(path_matrix)
|
2151: endo = sign(rowSums(path_matrix))
|
2162: out.ws = get_weights(X, path_matrix, blocks, specs)
|
2168: out.ws = get_weights_nonmetric(X, path_matrix, blocks, specs)
|
2190: if (path_matrix[i,j]==1)
|
2191: path.labs <- c(path.labs, paste(lvs.names[j],"->",lvs.names[i]))
|
2195: TOEFS <- matrix(NA, bootnum, nrow(Path.efs))
|
2207: w.boot = get_weights(X.boot, path_matrix, blocks, specs)
|
2215: w.boot = get_weights_nonmetric(X.boot, path_matrix, blocks, specs)
|
2225: pathmod <- get_paths(path_matrix, Y.boot)
|
2228: PATHS[i,] <- as.vector(P.boot[path_matrix==1])
|
2249: # Path coefficients
|
2250: colnames(PATHS) = path.labs
|
2251: PB = get_boot_stats(PATHS, path.orig)
|
2256: colnames(TOEFS) = Path.efs[, 1]
|
2257: TE = get_boot_stats(TOEFS, Path.efs[,4])
|
1214: indirect_paths = matrix(0, lvs, lvs)
|
1228: indirect = c(indirect, indirect_paths[i,j])
|
1229: total = c(total, total_paths[i,j])
|
2178: r2.orig <- pathmod[[3]][endo==1]
|
2226: P.boot <- pathmod[[2]]
|
2230: RSQRS[i,] <- pathmod[[3]][endo==1]
|
2262: paths = PB,
|
ChemmineR:R/AllClasses.R: [ ] |
---|
1734: path <- conMA(x, exclude="H")
|
1979: path <- .linearCon(x=con)
|
1800: conpath <- t(sapply(path, function(x) x[c(1, length(x))]))
|
1812: pathlist <- cyclist$path
|
1813: conpath <- cyclist$conpath
|
1814: pathlistnew <- list()
|
1735: noconnect <- rowSums(path) != 0 # Removes atoms with no connections
|
1736: path <- path[noconnect, noconnect]
|
1737: if(all(dim(path) == 0)) { return(path) }
|
1738: term <- which(rowSums(path > 0)==1)
|
1740: path <- path[-term,-term]
|
1741: if(any(dim(path) == 0) | is.vector(path)) { break() }
|
1742: term <- which(rowSums(path > 0)==1)
|
1744: return(path)
|
1779: .update <- function(con, path) {
|
1780: ## Remove non-terminal atoms in each path
|
1781: center_atoms <- unique(unlist(lapply(path, function(x) x[-c(1, length(x))])))
|
1791: path <- c(path, remainbonds)
|
1792: names(path) <- seq(along=path)
|
1794: ## Collect complete rings and remove them from path object
|
1795: index <- unlist(lapply(path, function(y) any(duplicated(y))))
|
1796: rings <- path[index]
|
1797: path <- path[!index]
|
1798: names(path) <- seq(along=path)
|
1799: ## Connection list for path component
|
1806: return(list(con=con, conpath=conpath, path=path, rings=rings))
|
1850: ## Collect complete rings and remove them from path object
|
1980: cyclist <- .update(con=con, path=path)
|
13: .sdfDownload <- function(mypath="ftp://ftp.ncbi.nih.gov/pubchem/Compound/CURRENT-Full/SDF/", myfile="Compound_00650001_00675000.sdf...(7 bytes skipped)...
|
14: system(paste("wget ", mypath, myfile, sep=""))
|
17: # .sdfDownload(mypath="ftp://ftp.ncbi.nih.gov/pubchem/Compound/CURRENT-Full/SDF/", myfile="Compound_00650001_00675000.sdf...(6 bytes skipped)...
|
1747: ## (b) Function to return the longest possible linear bond paths where:
|
1801: ends <- unique(as.vector(conpath))
|
1802: conpath <- lapply(ends, function(x) as.numeric(names(which(rowSums(conpath==x) > 0))))
|
1803: names(conpath) <- ends
|
1804: conpath <- conpath[sapply(conpath, length) > 1] # removes ends that occur only once
|
1816: ## Loop to join linear paths/fragments stored in pathlist
|
1817: for(i in names(conpath)) {
|
1818: if(length(conpath) == 0 | !any(names(conpath) == i)) { next() }
|
1819: pos <- t(combn(conpath[[i]], m=2))
|
1821: p1 <- pathlist[[pos[j,1]]]
|
1822: p2 <- pathlist[[pos[j,2]]]
|
1827: pathlistnew[[length(pathlistnew)+1]] <- c(rev(p2[-1]), p1)
|
1830: pathlistnew[[length(pathlistnew)+1]] <- c(p1, rev(p2[-length(p2)]))
|
1833: pathlistnew[[length(pathlistnew)+1]] <- c(p2, p1[-1])
|
1836: pathlistnew[[length(pathlistnew)+1]] <- c(p1, p2[-1])
|
1840: if(length(pathlistnew) == 0) { next() }
|
1842: dups <- duplicated(sapply(pathlistnew, function(x) paste(sort(unique(x)), collapse="_")))
|
1843: pathlistnew <- pathlistnew[!dups]
|
1846: l <- sapply(pathlistnew, length)
|
1847: pathlistnew <- pathlistnew[l <= upper]
|
1848: if(length(pathlistnew) == 0) { next() }
|
1851: index <- unlist(lapply(pathlistnew, function(y) any(duplicated(y[c(1, length(y))]))))
|
1852: rings[[length(rings)+1]] <- pathlistnew[index]
|
1853: pathlistnew <- pathlistnew[!index]
|
1854: ## Remove paths with internal duplicates
|
1855: if(length(pathlistnew) > 0) {
|
1856: index <- unlist(lapply(pathlistnew, function(y) any(duplicated(y))))
|
1857: pathlistnew <- pathlistnew[!index]
|
1859: ## Update pathlist and conpath
|
1860: pathlist <- c(pathlist[-conpath[[i]]], pathlistnew)
|
1861: dups <- duplicated(sapply(pathlist, function(x) paste(sort(unique(x)), collapse="_")))
|
1862: pathlist <- pathlist[!dups]
|
1863: names(pathlist) <- seq(along=pathlist)
|
1864: conpath <- t(sapply(pathlist, function(x) x[c(1, length(x))]))
|
1865: ends <- unique(as.vector(conpath))
|
1866: conpath <- lapply(ends, function(x) as.numeric(names(which(rowSums(conpath==x) > 0))))
|
1867: names(conpath) <- ends
|
1868: conpath <- conpath[sapply(conpath, length) > 1] # removes ends that occur only once
|
1869: pathlistnew <- list()
|
epivizrServer:R/middleware-plus-supporting.R: [ ] |
---|
438: path <- req$PATH_INFO
|
217: abs.path <- file.path(dir, relpath)
|
446: abs.path <- resolve(root, path)
|
367: pathPattern <- paste("^\\Q", prefix, "\\E/", sep = "")
|
371: origPath <- req$PATH_INFO
|
376: pathInfo <- substr(req$PATH_INFO, nchar(prefix)+1, nchar(req$PATH_INFO))
|
402: pathPattern <- paste("^\\Q", prefix, "\\E/", sep = "")
|
407: origPath <- req$PATH_INFO
|
412: pathInfo <- substr(req$PATH_INFO, nchar(prefix)+1, nchar(req$PATH_INFO))
|
205: # Attempt to join a path and relative path, and turn the result into a
|
206: # (normalized) absolute path. The result will only be returned if it is an
|
218: if (!file.exists(abs.path))
|
220: abs.path <- normalizePath(abs.path, winslash='/', mustWork=TRUE)
|
224: if (nchar(abs.path) <= nchar(dir) + 1)
|
226: if (substr(abs.path, 1, nchar(dir)) != dir ||
|
227: substr(abs.path, nchar(dir)+1, nchar(dir)+1) != '/') {
|
230: return(abs.path)
|
344: # `PATH_INFO` field, but since it's such a common need, let's make it simple by
|
349: # the route off of the `PATH_INFO` (and add it to the end of `SCRIPT_NAME`).
|
351: # path has already been matched via routing.
|
369: if (isTRUE(grepl(pathPattern, req$PATH_INFO))) {
|
374: req$PATH_INFO <- origPath
|
378: req$PATH_INFO <- pathInfo
|
405: if (isTRUE(grepl(pathPattern, req$PATH_INFO))) {
|
410: req$PATH_INFO <- origPath
|
414: req$PATH_INFO <- pathInfo
|
440: if (is.null(path))
|
443: if (path == '/')
|
444: path <- '/index.html'
|
447: if (is.null(abs.path))
|
450: content.type <- mime::guess_type(abs.path)
|
451: response.content <- readBin(abs.path, 'raw', n=file.info(abs.path)$size)
|
216: resolve <- function(dir, relpath) {
|
221: dir <- normalizePath(dir, winslash='/', mustWork=TRUE)
|
295: # representing paths to be used instead of handlers; any such strings we
|
DMRforPairs:R/functions.R: [ ] |
---|
457: path = "figures"
|
450: dir.create(file.path(getwd(), experiment.name))
|
452: dir.create(file.path(paste(getwd(), experiment.name, sep = "/"),
|
456: setwd(file.path(getwd(), experiment.name))
|
485: path = path)
|
487: tested$Figure[cr] = paste("<a href=\"./", path, "/",
|
490: tested$Statistics[cr] = paste("<a href=\"./", path, "/",
|
493: write.table(file = paste("./", path, "/", tested$regionID[cr],
|
507: scores = FALSE, path = path)
|
509: tested$Figure[cr] = paste("<a href=\"./", path, "/",
|
512: tested$Statistics[cr] = paste("<a href=\"./", path, "/",
|
519: write.table(file = paste("./", path, "/", tested$regionID[cr],
|
533: scores = FALSE, path = path)
|
539: tested$Figure[cr] = paste("<a href=\"./", path, "/",
|
542: tested$Statistics[cr] = paste("<a href=\"./", path, "/",
|
545: write.table(file = paste("./", path, "/", tested$regionID[cr],
|
606: path, "/", tested_4html_selected$ID, ".png\" height=\"63\" width=\"125\">",
|
624: path, "/", tested_4html_selected$ID, ".png\" height=\"63\" width=\"125\">",
|
639: regionID, clr = NA, annotate = TRUE, scores = TRUE, path) {
|
642: path = paste("./", path, "/", sep = "")
|
651: clr = clr, annotate = annotate, scores = scores, path = path)
|
656: annotate = TRUE, path) {
|
659: path = paste("./", path, "/", sep = "")
|
673: annotate = annotate, scores = TRUE, path = path)
|
679: ID = "CustomRegion", clr = NA, annotate = TRUE, path) {
|
680: path = paste("./", path, "/", sep = "")
|
693: annotate = annotate, scores = TRUE, path = path)
|
699: ID = NA, clr = NA, annotate = TRUE, scores = NA, path) {
|
730: png(paste(path, ID, ".png", sep = ""), width = 500, height = 250)
|
750: pdf(paste(path, ID, ".pdf", sep = ""), width = 10, height = 10)
|
mAPKL:R/mAPKL.R: [ ] |
---|
64: path <- as.integer(dataType)
|
54: ## path : 6-ratio data without normalization or
|
69: cluster_analysis <- cluster.Sim(ordIntensities_f[,start:end], path, min.clu,
|
PoTRA:R/PoTRA_corN.R: [ ] |
---|
76: path<-data.frame(matrix(0,length.intersect,(Num.sample.normal+Num.sample.case)))
|
56: graph.path<-igraph.from.graphNEL(g)
|
42: pathwaynames <- c()
|
40: length.pathway<-c()
|
58: #plot(graph.path, edge.arrow.size=.5, vertex.color="gold", vertex.size=5,
|
66: graph.path<-induced_subgraph(graph.path, as.character(intersect(unlist(nodelist),unlist(genelist_reformatted))))
|
67: #plot(graph.path)
|
82: path[j,]<-mydata[which(genelist_reformatted==a[j]),] #collect expression data of genes for a specific pathway across normal and tumor samples.
|
87: cor.normal <- apply(path[,1:Num.sample.normal], 1, function(x) { apply(path[,1:Num.sample.normal], 1, function(y) { cor.test(x,y)[[3]] })})
|
103: cor.case <- apply(path[,(Num.sample.normal+1):(Num.sample.normal+Num.sample.case)], 1, function(x) { apply(path[,(Num.sample.normal+1):(Num.sample.normal+Num.sample.case)], 1, function(y) { cor.test(x,y)[[3]] })...(2 bytes skipped)...
|
1: #' The PoTRA analysis is based on topological ranks of genes in biological pathways. PoTRA can be used to detect pathways involved in disease. The PoTRA package contains one function for creating the PoTRA results obj...(4 bytes skipped)...
|
7: #' @param Pathway.database The pathway database, such as KEGG, Reactome, Biocarta and PharmGKB.
|
14: ...(29 bytes skipped)...ta=mydata, genelist=genelist, Num.sample.normal=Num.sample.normal, Num.sample.case=Num.sample.case, Pathway.database=Pathway.database, PR.quantile=PR.quantile)
|
16: #' Pathway.database (options):
|
17: #' humanKEGG=pathways('hsapiens','kegg')
|
18: #' humanReactome=pathways('hsapiens','reactome')
|
19: #' humanBiocarta=pathways('hsapiens','biocarta')
|
20: #' humanPharmGKB=pathways('hsapiens','pharmgkb')
|
22: #' Pathway.database=humanKEGG
|
23: #' Pathway.database=humanReactome
|
24: #' Pathway.database=humanBiocarta
|
25: #' Pathway.database=humanPharmGKB
|
28: PoTRA.corN <- function(mydata,genelist,Num.sample.normal,Num.sample.case,Pathway.database,PR.quantile) {
|
44: #humanPharmGKB <- pathways("hsapiens", "pharmgkb")
|
45: #humanBiocarta <- pathways("hsapiens", "biocarta")
|
46: #humanKEGG <- pathways("hsapiens", "kegg")
|
48: for (x in 1:length(Pathway.database[1:length(Pathway.database)])){
|
51: p0 <-Pathway.database[[x]]
|
52: pathwaynames[x] <- p0@title
|
54: g<-pathwayGraph(p)
|
65: length.pathway[x]<-length.intersect
|
74: #collect expression data of genes for a specific pathway across normal and tumor samples.
|
162: return(list(Fishertest.p.value=Fishertest,KStest.p.value=kstest,LengthOfPathway=length.path...(62 bytes skipped)...rOfHubGenes.case=TheNumOfHubGene.case,TheNumberOfEdges.normal=E.normal,TheNumberOfEdges.case=E.case,PathwayName=pathwaynames))
|
NxtIRFcore:R/BuildRef.R: [ ] |
---|
984: path <- tryCatch(BiocFileCache::bfcadd(bfc, url),
|
483: .validate_path <- function(reference_path, subdirs = NULL) {
|
577: map_path <- file.path(normalizePath(reference_path), "Mappability")
|
836: r_path <- file.path(reference_path, "resource")
|
837: gtf_path <- file.path(r_path, "transcripts.gtf.gz")
|
10: #' subdirectory within the given `reference_path`. Resources are retrieved via
|
12: #' 1. User-supplied FASTA and GTF file. This can be a file path, or a web link
|
44: #' file, open the file specified in the path returned by
|
49: #' @param reference_path (REQUIRED) The directory path to store the generated
|
51: #' @param fasta The file path or web link to the user-supplied genome
|
54: #' been run using the same `reference_path`.
|
55: #' @param gtf The file path or web link to the user-supplied transcript
|
59: #' `reference_path`.
|
65: #' the file `IRFinder.ref.gz` is present inside `reference_path`.
|
112: #' * `reference_path/resource/genome.2bit`: Local copy of the genome sequences
|
114: #' * `reference_path/resource/transcripts.gtf.gz`: Local copy of the gene
|
117: #' which is written to the given directory specified by `reference_path`.
|
119: #' * `reference_path/settings.Rds`: An RDS file containing parameters used
|
121: #' * `reference_path/IRFinder.ref.gz`: A gzipped text file containing collated
|
123: #' * `reference_path/fst/`: Contains fst files for subsequent easy access to
|
125: #' * `reference_path/cov_data.Rds`: An RDS file containing data required to
|
129: #' subdirectory inside the designated `reference_path`
|
131: #' For `GetNonPolyARef`: Returns the file path to the BED file for
|
137: #' example_ref <- file.path(tempdir(), "Reference")
|
139: #' reference_path = example_ref,
|
144: #' reference_path = example_ref
|
149: #' example_ref <- file.path(tempdir(), "Reference")
|
151: #' reference_path = example_ref,
|
156: #' # Get the path to the Non-PolyA BED file for hg19
|
167: #' reference_path = "./Reference_user",
|
179: #' reference_path = "./Reference_FTP",
|
214: #' reference_path = "./Reference_AH",
|
226: #' reference_path = "./Reference_UCSC",
|
236: #' # inside the given `reference_path`.
|
241: #' reference_path = "./Reference_with_STAR",
|
251: #' reference_path = "./Reference_with_STAR",
|
255: #' reference_path = reference_path,
|
260: #' reference_path = "./Reference_with_STAR",
|
274: #' of the given reference path
|
277: reference_path = "./Reference",
|
282: reference_path = reference_path,
|
292: #' given reference path
|
295: reference_path = "./Reference",
|
301: .validate_path(reference_path)
|
303: file.exists(file.path(reference_path, "IRFinder.ref.gz"))) {
|
307: extra_files <- .fetch_genome_defaults(reference_path,
|
313: reference_path = reference_path,
|
322: .process_gtf(reference_data$gtf_gr, reference_path)
|
329: .process_introns(reference_path, reference_data$genome,
|
333: .gen_irf(reference_path, extra_files, reference_data$genome, chromosomes)
|
338: .gen_nmd(reference_path, reference_data$genome))
|
341: .gen_splice(reference_path)
|
342: if (file.exists(file.path(reference_path, "fst", "Splice.fst"))) {
|
344: .gen_splice_proteins(reference_path, reference_data$genome)
|
354: cov_data <- .prepare_covplot_data(reference_path)
|
355: saveRDS(cov_data, file.path(reference_path, "cov_data.Rds"))
|
358: settings.list <- readRDS(file.path(reference_path, "settings.Rds"))
|
366: saveRDS(settings.list, file.path(reference_path, "settings.Rds"))
|
369: #' @describeIn BuildReference Returns the path to the BED file containing
|
405: reference_path,
|
417: file.exists(file.path(reference_path, "IRFinder.ref.gz"))) {
|
424: GetReferenceResource(reference_path = reference_path,
|
428: STAR_buildRef(reference_path = reference_path,
|
432: BuildReference(reference_path = reference_path,
|
440: Get_Genome <- function(reference_path, validate = TRUE,
|
442: if (validate) .validate_reference(reference_path)
|
443: twobit <- file.path(reference_path, "resource", "genome.2bit")
|
446: } else if (file.exists(file.path(reference_path, "settings.Rds"))) {
|
447: settings <- readRDS(file.path(reference_path, "settings.Rds"))
|
450: .log("In Get_Genome, invalid reference_path supplied")
|
458: Get_GTF_file <- function(reference_path) {
|
459: .validate_reference(reference_path)
|
460: if (file.exists(file.path(reference_path,
|
462: return(file.path(reference_path, "resource", "transcripts.gtf.gz"))
|
464: .log("In Get_GTF_file, invalid reference_path supplied")
|
485: reference_path != "" &&
|
487: ifelse(normalizePath(dirname(reference_path)) != "", TRUE, TRUE),
|
493: .log(paste("Error in 'reference_path',",
|
494: paste0("base path of '", reference_path, "' does not exist")
|
498: base <- normalizePath(dirname(reference_path))
|
499: if (!dir.exists(file.path(base, basename(reference_path))))
|
500: dir.create(file.path(base, basename(reference_path)))
|
504: dir_to_make <- file.path(base, basename(reference_path), subdirs)
|
508: return(file.path(base, basename(reference_path)))
|
511: .validate_reference_resource <- function(reference_path, from = "") {
|
512: ref <- normalizePath(reference_path)
|
517: "in reference_path =", reference_path,
|
518: ": this path does not exist"))
|
520: if (!file.exists(file.path(ref, "settings.Rds"))) {
|
522: "in reference_path =", reference_path,
|
525: settings.list <- readRDS(file.path(ref, "settings.Rds"))
|
529: "in reference_path =", reference_path,
|
535: .validate_reference <- function(reference_path, from = "") {
|
536: ref <- normalizePath(reference_path)
|
541: "in reference_path =", reference_path,
|
542: ": this path does not exist"))
|
544: if (!file.exists(file.path(ref, "settings.Rds"))) {
|
546: "in reference_path =", reference_path,
|
549: if (!file.exists(file.path(ref, "IRFinder.ref.gz"))) {
|
551: "in reference_path =", reference_path,
|
554: settings.list <- readRDS(file.path(ref, "settings.Rds"))
|
558: "in reference_path =", reference_path,
|
564: .fetch_genome_defaults <- function(reference_path, genome_type,
|
578: map_file <- file.path(map_path, "MappabilityExclusion.bed.gz")
|
586: genome_type, as_type = "bed.gz", path = map_path, overwrite = TRUE)
|
638: .get_reference_data <- function(reference_path, fasta, gtf,
|
644: .validate_path(reference_path, subdirs = "resource")
|
646: twobit <- file.path(reference_path, "resource", "genome.2bit")
|
650: gtf <- file.path(reference_path, "resource", "transcripts.gtf.gz")
|
668: reference_path = reference_path,
|
675: reference_path = reference_path,
|
682: reference_path = reference_path
|
685: saveRDS(settings.list, file.path(reference_path, "settings.Rds"))
|
687: settings.list <- readRDS(file.path(reference_path, "settings.Rds"))
|
720: reference_path = "./Reference",
|
727: .fetch_fasta_save_2bit(genome, reference_path, overwrite)
|
731: twobit <- file.path(reference_path, "resource", "genome.2bit")
|
735: genome <- Get_Genome(reference_path, validate = FALSE,
|
746: twobit <- file.path(reference_path, "resource", "genome.2bit")
|
750: genome <- Get_Genome(reference_path, validate = FALSE,
|
764: .fetch_fasta_save_2bit(genome, reference_path, overwrite)
|
769: genome <- Get_Genome(reference_path, validate = FALSE,
|
794: .fetch_fasta_save_fasta <- function(genome, reference_path, overwrite) {
|
795: genome.fa <- file.path(reference_path, "resource", "genome.fa")
|
806: .fetch_fasta_save_2bit <- function(genome, reference_path, overwrite) {
|
807: genome.2bit <- file.path(reference_path, "resource", "genome.2bit")
|
809: normalizePath(rtracklayer::path(genome)) ==
|
819: file.exists(rtracklayer::path(genome))) {
|
820: file.copy(rtracklayer::path(genome), genome.2bit)
|
831: reference_path = "./Reference",
|
841: if (overwrite || !file.exists(gtf_path)) {
|
845: if (file.exists(gtf_path)) file.remove(gtf_path)
|
846: file.copy(cache_loc, gtf_path)
|
856: if (!file.exists(gtf_path) ||
|
857: normalizePath(gtf_file) != normalizePath(gtf_path)) {
|
858: if (overwrite || !file.exists(gtf_path)) {
|
863: if (file.exists(gtf_path)) file.remove(gtf_path)
|
864: file.copy(gtf_file, gtf_path)
|
866: gzip(filename = gtf_file, destname = gtf_path,
|
990: if (identical(path, NA)) {
|
1059: .process_gtf <- function(gtf_gr, reference_path) {
|
1061: .validate_path(reference_path, subdirs = "fst")
|
1064: Genes_group <- .process_gtf_genes(gtf_gr, reference_path)
|
1066: .process_gtf_transcripts(gtf_gr, reference_path)
|
1068: .process_gtf_misc(gtf_gr, reference_path)
|
1070: .process_gtf_exons(gtf_gr, reference_path, Genes_group)
|
1076: .process_gtf_genes <- function(gtf_gr, reference_path) {
|
1121: file.path(reference_path, "fst", "Genes.fst")
|
1130: .process_gtf_transcripts <- function(gtf_gr, reference_path) {
|
1178: file.path(reference_path, "fst", "Transcripts.fst")
|
1182: .process_gtf_misc <- function(gtf_gr, reference_path) {
|
1193: file.path(reference_path, "fst", "Proteins.fst")
|
1204: file.path(reference_path, "fst", "Misc.fst")
|
1208: .process_gtf_exons <- function(gtf_gr, reference_path, Genes_group) {
|
1251: file.path(reference_path, "fst", "Exons.fst"))
|
1254: file.path(reference_path, "fst", "Exons.Group.fst")
|
1316: .process_introns <- function(reference_path, genome,
|
1321: data <- .process_introns_data(reference_path, genome,
|
1335: file.path(reference_path, "fst", "junctions.fst"))
|
1340: .process_introns_data <- function(reference_path, genome,
|
1343: read.fst(file.path(reference_path, "fst", "Exons.fst")),
|
1346: read.fst(file.path(reference_path, "fst", "Transcripts.fst")),
|
1349: read.fst(file.path(reference_path, "fst", "Proteins.fst")),
|
1352: read.fst(file.path(reference_path, "fst", "Exons.Group.fst")),
|
1665: .gen_irf <- function(reference_path, extra_files, genome, chromosome_aliases) {
|
1670: data <- .gen_irf_prep_data(reference_path)
|
1682: ), stranded = TRUE, reference_path, data2[["introns.unique"]]
|
1689: ), stranded = FALSE, reference_path, data2[["introns.unique"]]
|
1692: ref.cover <- .gen_irf_refcover(reference_path)
|
1694: ref.ROI <- .gen_irf_ROI(reference_path, extra_files, genome,
|
1697: readcons <- .gen_irf_readcons(reference_path,
|
1700: ref.sj <- .gen_irf_sj(reference_path)
|
1712: .gen_irf_final(reference_path, ref.cover, readcons, ref.ROI, ref.sj, chr)
|
1719: .gen_irf_prep_data <- function(reference_path) {
|
1721: read.fst(file.path(reference_path, "fst", "Genes.fst")),
|
1734: read.fst(file.path(reference_path, "fst", "junctions.fst"))
|
1737: read.fst(file.path(reference_path, "fst", "Exons.fst")),
|
1741: read.fst(file.path(reference_path, "fst", "Transcripts.fst")),
|
1948: reference_path, introns.unique) {
|
2003: rtracklayer::export(IntronCover, file.path(reference_path,
|
2006: write.fst(IntronCover.summa, file.path(
|
2007: reference_path, "fst",
|
2064: .gen_irf_refcover <- function(reference_path) {
|
2065: tmpdir.IntronCover <- fread(file.path(
|
2066: reference_path, "tmpdir.IntronCover.bed"
|
2069: tmpnd.IntronCover <- fread(file.path(
|
2070: reference_path, "tmpnd.IntronCover.bed"
|
2083: .gen_irf_ROI <- function(reference_path, extra_files, genome,
|
2145: .gen_irf_readcons <- function(reference_path,
|
2174: .gen_irf_sj <- function(reference_path) {
|
2178: read.fst(file.path(reference_path, "fst", "junctions.fst"))
|
2199: .gen_irf_final <- function(reference_path,
|
2203: IRF_file <- file.path(reference_path, "IRFinder.ref")
|
2242: if (file.exists(file.path(reference_path, "tmpdir.IntronCover.bed"))) {
|
2243: file.remove(file.path(reference_path, "tmpdir.IntronCover.bed"))
|
2245: if (file.exists(file.path(reference_path, "tmpnd.IntronCover.bed"))) {
|
2246: file.remove(file.path(reference_path, "tmpnd.IntronCover.bed"))
|
2253: .gen_nmd <- function(reference_path, genome) {
|
2255: Exons.tr <- .gen_nmd_exons_trimmed(reference_path)
|
2256: protein.introns <- .gen_nmd_protein_introns(reference_path, Exons.tr)
|
2264: write.fst(NMD.Table, file.path(reference_path, "fst", "IR.NMD.fst"))
|
2269: .gen_nmd_exons_trimmed <- function(reference_path) {
|
2271: read.fst(file.path(reference_path, "fst", "Exons.fst"))
|
2274: read.fst(file.path(reference_path, "fst", "Misc.fst"))
|
2305: .gen_nmd_protein_introns <- function(reference_path, Exons.tr) {
|
2307: read.fst(file.path(reference_path, "fst", "junctions.fst"))
|
2310: read.fst(file.path(reference_path, "fst", "Misc.fst"))
|
2612: .gen_splice <- function(reference_path) {
|
2615: read.fst(file.path(reference_path, "fst", "junctions.fst"))
|
2618: reference_path, candidate.introns)
|
2649: introns_found_RI <- .gen_splice_RI(candidate.introns, reference_path)
|
2665: .gen_splice_save(AS_Table, candidate.introns, reference_path)
|
2676: .gen_splice_skipcoord <- function(reference_path, candidate.introns) {
|
2678: read.fst(file.path(reference_path, "fst", "Genes.fst"))
|
3216: .gen_splice_RI <- function(candidate.introns, reference_path) {
|
3218: read.fst(file.path(reference_path, "fst", "Exons.fst")),
|
3222: read.fst(file.path(reference_path, "fst", "Introns.Dir.fst")))
|
3257: .gen_splice_save <- function(AS_Table, candidate.introns, reference_path) {
|
3269: reference_path)
|
3270: AS_Table <- .gen_splice_name_events(AS_Table, reference_path)
|
3300: reference_path) {
|
3302: read.fst(file.path(reference_path, "fst", "Exons.fst")),
|
3390: file.path(reference_path, "fst", "Splice.options.fst"))
|
3396: .gen_splice_name_events <- function(AS_Table, reference_path) {
|
3444: file.path(reference_path, "fst", "Splice.fst"))
|
3452: .gen_splice_proteins <- function(reference_path, genome) {
|
3457: read.fst(file.path(reference_path, "fst", "Splice.fst"))
|
3460: read.fst(file.path(reference_path, "fst", "Proteins.fst"))
|
3499: file.path(reference_path, "fst", "Splice.Extended.fst"))
|
14: #' to specify the files or web paths to use.
|
199: #' # rdatapath, sourceurl, sourcetype
|
810: normalizePath(genome.2bit)) {
|
981: res <- BiocFileCache::bfcquery(bfc, url, "fpath", exact = TRUE)
|
982: if (nrow(res) > 0 & !force_download) return(res$rpath[nrow(res)])
|
993: return(res$rpath[nrow(res)]) # fetch local copy if available
|
996: res <- BiocFileCache::bfcquery(bfc, url, "fpath", exact = TRUE)
|
998: return(res$rpath[nrow(res)])
|
recountmethylation:inst/extdata/scripts/data_analyses.R: [ ] |
---|
26: path <- system.file("extdata", "metadata", package = "recountmethylation")
|
20: savepath <- paste(dfp, env.name, sep = "/")
|
27: mdpath <- paste(path, list.files(path)[1], sep = "/")
|
327: save(ds, file = file.path("data_analyses", "df-l2med-signals.rda"))
|
28: md <- get(load(mdpath))
|
ORFik:R/experiment.R: [ ] |
---|
296: for (path in filepaths) {
|
42: cbu.path <- "/export/valenfs/data/processed_data/experiment_tables_for_R/"
|
240: cbu.path <- "/export/valenfs/data/processed_data/experiment_tables_for_R/"
|
925: cbu.path <- "/export/valenfs/data/processed_data/experiment_tables_for_R/"
|
287: findFromPath <- function(filepaths, candidates, slot = "auto") {
|
511: filepath <- function(df, type, basename = FALSE) {
|
515: paths <- lapply(df$filepath, function(x, df, type) {
|
652: paths <- filepath(df, type)
|
368: reversePaths <- df$reverse[!(df$reverse %in% c("", "paired-end"))]
|
7: #' @param file relative path to a ORFik experiment. That is a .csv file following
|
10: #' also be full path to file, then in.dir argument is ignored.
|
13: #' it to disc. Does not apply if file is not a path, but a data.frame. Also
|
14: #' does not apply if file was given as full path.
|
30: #' # save.experiment(df, file = "path/to/save/experiment")
|
32: #' # read.experiment("path/to/save/experiment")
|
34: #' # read.experiment("experiment", in.dir = "path/to/save/")
|
43: if (file.exists(pasteDir(cbu.path, basename(file))))
|
44: file <- pasteDir(cbu.path, basename(file))
|
109: #' @param txdb A path to TxDb (prefered) or gff/gtf (not adviced, slower)
|
111: #' @param fa A path to fasta genome/sequences used for libraries, remember the
|
178: #' # Save with: save.experiment(df, file = "path/to/save/experiment.csv")
|
241: if (dir.exists(cbu.path)) { # This will only trigger on CBU server @ UIB
|
243: message(cbu.path)
|
244: saveDir <- cbu.path
|
263: #' #save.experiment(df, file = "path/to/save/experiment.csv")
|
265: #' #save.experiment(df, file = "path/to/save/experiment")
|
280: #' @param filepaths path to all files
|
297: hit <- names(unlist(sapply(candidates, grep, x = path)))
|
300: hitRel <- names(unlist(sapply(candidates, grep, x = gsub(".*/", "", path))))
|
841: fext[compressed] <-file_ext(file_path_sans_ext(files[compressed],
|
914: #' ## Path above is default path, so no dir argument needed
|
918: #' #list.experiments(dir = "MY/CUSTOM/PATH)
|
923: experiments <- list.files(path = dir, pattern = "\\.csv")
|
926: if (dir.exists(cbu.path)) { # If on UIB SERVER
|
927: dir <- cbu.path
|
928: experiments <- list.files(path = dir, pattern = "\\.csv")
|
24: #' df <- read.experiment(filepath) # <- valid ORFik .csv file
|
207: df[4,] <- c("libtype", "stage", "rep", "condition", "fraction","filepath",
|
214: df[4,] <- c("libtype", "stage", "rep", "condition", "fraction","filepath")
|
217: # set file paths
|
220: df[5:(5+length(files)-1), 1] <- findFromPath(files, libNames(), libtype)
|
223: df[5:(5+length(files)-1), 2] <- findFromPath(files, stages, stage)
|
225: df[5:(5+length(files)-1), 3] <- findFromPath(files, repNames(), rep)
|
227: df[5:(5+length(files)-1), 4] <- findFromPath(files, conditionNames(), condition)
|
229: df[5:(5+length(files)-1), 5] <- findFromPath(files, fractionNames(), fraction)
|
365: files <- df$filepath
|
366: if (length(df$filepath) == 0) stop("df have no filepaths!")
|
436: #' Get variable name per filepath in experiment
|
498: #' Get relative paths instead of full. Only use for inspection!
|
499: #' @return a character vector of paths, or a list of character with 2 paths per,
|
506: #' filepath(df, "default")
|
508: #' # filepath(df, "bedo")
|
510: #' # filepath(df, "pshifted")
|
516: i <- which(df$filepath == x)
|
519: out.dir <- paste0(dirname(df$filepath[1]), "/pshifted/")
|
549: out.dir <- paste0(dirname(df$filepath[1]), "/",type,"/")
|
565: if (is.null(input)) stop("filepath type not valid!")
|
569: if (all(lengths(paths) == 1)) {
|
570: paths <- unlist(paths)
|
572: return(paths)
|
653: libs <- bplapply(seq_along(paths),
|
654: function(i, paths, df, chrStyle, param, strandMode, varNames) {
|
656: fimport(paths[i], chrStyle, param, strandMode)
|
657: }, BPPARAM = BPPARAM, paths = paths, chrStyle = chrStyle, df = df,
|
698: #' dirname(df$filepath[1]),
|
726: out.dir = dirname(df$filepath[1]),
|
768: remove.file_ext(df$filepath[i], basename = TRUE),
|
284: #' else must be a character vector of length 1 or equal length as filepaths.
|
289: if(length(slot) != 1 & length(slot) != length(filepaths)) {
|
369: files <- c(files, reversePaths)
|
388: stop("Duplicated filepaths in experiment!")
|
488: #' Get filepaths to ORFik experiment
|
492: #' default filepaths without warning. \cr
|
ArrayExpress:R/parseMAGE.r: [ ] |
---|
516: path = mageFiles$path
|
30: isOneChannel = function(sdrf,path){
|
31: ph = try(read.AnnotatedDataFrame(sdrf, path = path, row.names = NULL, blank.lines.skip = TRUE, fill = TRUE, varMetadata.char = "$", quote="\""))
|
39: readPhenoData = function(sdrf,path){
|
42: ph = try(read.AnnotatedDataFrame(sdrf, path = path, row.names = NULL, blank.lines.skip = TRUE, fill = TRUE, varMetadata.char = "$", quote="\""))
|
105: readAEdata = function(path,files,dataCols,green.only){
|
108: source = getDataFormat(path,files)
|
121: rawdata = try(oligo::read.celfiles(filenames = file.path(path,unique(files))))
|
123: stop("Unable to read cel files in",path)
|
130: dataCols= try(getDataColsForAE1(path,files))
|
133: rawdata = try(read.maimages(files=files,path=path,source="generic",columns=dataCols,annotation=headers$ae1))
|
138: rawdata = try(read.maimages(files=files,path=path,source=source,columns=dataCols,green.only=green.only))
|
142: rawdata = try(read.maimages(files=files,path=path,source="generic",columns=dataCols,green.only=green.only))
|
149: stop("Unable to read data files in",path)
|
169: readFeatures<-function(adf,path,procADFref=NULL){
|
173: lines2skip = skipADFheader(adf,path,!is.null(procADFref))
|
174: features = try(read.table(file.path(path, adf), row.names = NULL, blank.lines.skip = TRUE, fill = TRUE, sep="\t", na.strings=c('?','NA'), sk...(40 bytes skipped)...
|
223: readExperimentData = function(idf, path){
|
224: idffile = scan(file.path(path,idf),character(),sep = "\n",encoding="UTF-8")
|
264: skipADFheader<-function(adf,path,proc=F){
|
270: con = file(file.path(path, adf), "r")
|
319: getDataFormat=function(path,files){
|
326: allcnames = scan(file.path(path,files[1]),what = "",nlines = 200, sep = "\t",quiet=TRUE)
|
329: allcnames = scan(file.path(path,files[1]),what = "",nlines = 200, sep = "\t",quiet=TRUE,encoding="latin1")
|
345: allcnames = scan(file.path(path,files[1]),what = "",nlines = 1, sep = "\n",quiet=TRUE)
|
352: getDataColsForAE1 = function(path,files){
|
362: file.path(system.file("doc", package = "ArrayExpress"),"QT_list.txt"),
|
375: allcnames = scan(file.path(path,files[1]),what = "",nlines = 1, sep = "\t",quiet=TRUE)
|
430: if(!all(sapply(2:length(files), function(i) readLines(file.path(path,files[1]),1) == readLines(file.path(path,files[i]),1))))
|
518: try(file.remove(file.path(path, mageFiles$rawFiles)))
|
519: try(file.remove(file.path(path, mageFiles$processedFiles)))
|
521: try(file.remove(file.path(path, mageFiles$sdrf)))
|
522: try(file.remove(file.path(path, mageFiles$idf)))
|
523: try(file.remove(file.path(path, mageFiles$adf)))
|
524: try(file.remove(file.path(path, mageFiles$rawArchive)))
|
525: try(file.remove(file.path(path, mageFiles$processedArchive)))
|
methylPipe:R/Allfunctions.R: [ ] |
---|
223: path <- paste0(files_location,"/",all_files[[i]])
|
28: filename <- file.path(output_folder,
|
31: filename <- file.path(output_folder,
|
58: all_files <- list.files(path = files_location, pattern = ".sam")
|
63: output.files[[read.context]] <- file.path(output_folder,
|
66: read.files <- file.path(files_location, all_files)
|
97: asBam(file.path(files_location, all_files[i]), destination=file.path(temp_folder, sample_name[i]), overwrite=TRUE)
|
101: bam.files <- file.path(path = temp_folder, paste(sample_name, ".bam", sep=""))
|
112: filename <- file.path(output_folder, paste0(sample_name[[i]],"_uncov", ".Rdata"))
|
220: all_files <- list.files(path = files_location, pattern = ".txt")
|
224: temp_data <- fread(path,nrows=10)
|
227: cmd <- paste("sed -i 's/\"//g'",path)
|
229: cmd <- paste("sed -i 's/^/chr/'",path)
|
268: Tabix_files <- list.files(path = files_location, pattern = "_tabix.txt")
|
11: output_folder <- normalizePath(output_folder)
|
50: files_location <- normalizePath(files_location)
|
51: output_folder <- normalizePath(output_folder)
|
132: files_location <- normalizePath(files_location)
|
186: BSprepare <- function(files_location, output_folder, tabixPath, bc=1.5/100) {
|
191: if(!is.character(tabixPath))
|
192: stop('tabixPath has to be of class character ..')
|
193: if(!file.exists(paste(tabixPath, '/tabix', sep='')))
|
194: stop('tabix not found at tabixPath ..')
|
195: if(!file.exists(paste(tabixPath, '/bgzip', sep='')))
|
196: stop('bgzip not found at tabixPath ..')
|
198: files_location <- normalizePath(files_location)
|
199: output_folder <- normalizePath(output_folder)
|
200: tabixPath <- normalizePath(tabixPath)
|
276: str <- paste0(tabixPath, '/bgzip ', output_folder, "/", filetb_name,"_out.txt")
|
280: str <- paste(tabixPath, '/tabix -s 1 -b 2 -e 2 -f ', fileoutgz, sep='')
|
PloGO2:inst/script/WGCNA_proteomics.R: [ ] |
---|
106: path <- system.file("files", package="PloGO2")
|
107: allDat = read.csv(file.path(path,"rice.csv") )
|
108: Group = read.csv(file.path(path, "group_rice.csv") ) [,2]
|
R453Plus1Toolbox:R/methods-AVASet.R: [ ] |
---|
270: path = file.path(dirname, s, r)
|
370: path = file.path(dirname, s, r)
|
774: path = unique(c(subset(RData, sample==s)$currentPath, subset(RData, sample==s)$currentPath))
|
23: dir_root = file.path(dirname, "Amplicons")
|
24: dir_results = file.path(dir_root,"Results")
|
25: dir_projectDef = file.path(dir_root,"ProjectDef")
|
26: dir_variants = file.path(dir_results, "Variants")
|
27: dir_align = file.path(dir_results, "Align")
|
37: | !file.exists(file.path(dir_variants, "currentVariantDefs.txt"))
|
38: | !file.exists(file.path(dir_projectDef, "ampliconsProject.txt"))
|
95: doAmplicon = file.path(avaBin, "doAmplicon")
|
217: file_sample = file.path(dirname, file_sample)
|
218: file_amp = file.path(dirname, file_amp)
|
219: file_reference = file.path(dirname, file_reference)
|
220: file_variant = file.path(dirname, file_variant)
|
221: file_variantHits = file.path(dirname, file_variantHits)
|
271: files = list.files(path)
|
281: amps_align[[i]]= readLines(file.path(path, file))
|
325: file_sample = file.path(dirname, file_sample)
|
326: file_amp = file.path(dirname, file_amp)
|
327: file_reference = file.path(dirname, file_reference)
|
371: files = list.files(path)
|
381: amps_align[[i]]= readLines(file.path(path, file))
|
675: text = readLines(file.path(dir_projectDef, "ampliconsProject.txt"))
|
689: warning(paste("sample information missing in", file.path(dir_projectDef, "ampliconsProject.txt")))
|
757: warning(paste("Read data or MID entries missing in", file.path(dir_projectDef, "ampliconsProject.txt")))
|
775: if(!any(is.na(path))){
|
776: path = sapply(strsplit(path, split="\\."), function(x)x[1])
|
777: ptp = paste(substr(path, 1, nchar(path)-2), collapse=",")
|
778: lane = paste(substr(path, nchar(path)-1, nchar(path)), collapse=",")
|
822: variantDefs=read.table(file=file.path(dir_variants, "currentVariantDefs.txt"), sep="\t",
|
902: if(file.exists(file.path(dir_variants, s_id))){
|
903: detections = dir(file.path(dir_variants, s_id), pattern=".txt$", ignore.case=FALSE)
|
905: det = read.table(file.path(dir_variants, s_id, d), sep="\t",
|
949: pfLines=readLines(file.path(dir_projectDef, "ampliconsProject.txt"))
|
997: pfLines=readLines(file.path(dir_projectDef, "ampliconsProject.txt"))
|
1052: thisSampleDir=file.path(dir_align, samples$SampleID[s])
|
1055: thisRefDir=file.path(thisSampleDir, r)
|
1056: alignFile=file.path(thisRefDir, paste(samples$SampleID[s],
|
700: "annotation", "currentPath", "name", "originalPath", "readDataGroup", "sequenceBlueprint"),
|
760: RData = data.frame(sample=samples, currentPath=rep(NA, numSamples),
|
ribor:R/helper_functions.R: [ ] |
---|
163: path <- path(ribo.object)
|
66: ribo.path <- ribo
|
11: #' file.path <- system.file("extdata", "HEK293_ingolia.ribo", package = "ribor")
|
12: #' sample <- Ribo(file.path)
|
18: return(h5read(path(ribo.object),
|
25: row.names <- h5read(path(ribo.object),
|
27: lengths <- h5read(path(ribo.object),
|
50: #' @param ribo a path to the ribo file or a 'Ribo' object
|
58: #' file.path <- system.file("extdata", "HEK293_ingolia.ribo", package = "ribor")
|
59: #' sample <- Ribo(file.path, rename = rename_default)
|
65: #ensure that the ribo path is retrieved
|
68: ribo.path <- path(ribo)
|
73: original <- h5read(ribo.path,
|
113: get_content_info <- function(ribo.path) {
|
114: file_info <- h5ls(ribo.path, recursive = TRUE, all = FALSE)
|
126: ls <- h5ls(ribo.path)
|
135: attribute <- h5readAttributes(ribo.path, name)
|
164: attribute <- h5readAttributes(path, "/")
|
264: path,
|
267: experiment <- strsplit(path, split="/")[[1]][3]
|
268: output <- t(h5read(file=file, index=index, name=path))
|
epivizrStandalone:R/startStandalone.R: [ ] |
---|
95: path=paste0("/", index_file),
|
217: path <- NULL
|
92: server <- epivizrServer::createServer(static_site_path = webpath, non_interactive=non_interactive, ...)
|
219: server <- epivizrServer::createServer(static_site_path = webpath, non_interactive=non_interactive, ...)
|
84: webpath <- system.file("www", package = "epivizrStandalone")
|
215: webpath <- ""
|
222: path=path,
|
biodb:R/BiodbConn.R: [ ] |
---|
734: path <- cch$getFilePath(self$getCacheId(), name='download', ext=ext)
|
147: #' Get the path to the persistent cache file.
|
727: #' Gets the path where the downloaded content is written.
|
728: #' @return The path where the downloaded database is written.
|
736: logDebug0('Download path of ', self$getId(), ' is "', path, '".')
|
738: return(path)
|
743: #' @param src Path to the downloaded file.
|
151: #' containing the paths to the cache files corresponding to the requested
|
156: fp <- c$getFilePath(self$getCacheId(), entry.id, self$getEntryFileExt())
|
729: getDownloadPath=function() {
|
793: if ( ! file.exists(self$getDownloadPath()))
|
795: self$getDownloadPath())
|
CONFESS:R/internal_fluo_NBE.R: [ ] |
---|
1419: path <- c(data$UpdatedPath, data$UpdatedPath[1])
|
2092: path <- do.call(rbind, res)[, 1]
|
1493: path.update <- path[1:(length(path) - 1)]
|
2432: path.initiator <- function(data, where) {
|
1381: fixPath <- function(data, groups) {
|
2060: estimatePath <- function(data, type, start) {
|
2116: pathUpdater <- function(data, path) {
|
2246: updateCentroidsPaths <- function(data, estimates, path.type) {
|
1370: #' It tests whether the path has been appropariately defined and produces an error if not.
|
1383: stop("Insert the cell progression path using the labels of Fluo_inspection")
|
1387: "Error in cell progression path: you have specified different number of groups than the one estimated"
|
1396: #' It sort the adjusted (and transfomed) fluorescence signals according to the path progression.
|
1399: #' @param path.start Integer. A cluster number indicating the starting cluster that algorithm should use to
|
1400: #' build the path. The cluster numbers refer to the plot generated by Fluo_inspection(). Default is 1.
|
1401: #' If path.type = "circular" the number does not matter. If path.type = "A2Z" the user should inspect the
|
1402: #' Fluo_inspection() plot to detect the beginning of the path. If path.type = "other", the function will
|
1403: #' not estimate a path. The user has to manually insert the path progression (the cluster numbers) in
|
1414: orderFluo <- function(data, path.type, updater = FALSE) {
|
1415: if (path.type[1] != "circular" & path.type[1] != "A2Z") {
|
1416: stop("The path.type is not correctly specified")
|
1424: path <- c(1:max(data$Updated.groups), 1)
|
1435: for (i in 1:(length(path) - 1)) {
|
1436: center1 <- as.numeric(ms[which(ms[, 1] == path[i]), 2:3])
|
1437: center2 <- as.numeric(ms[which(ms[, 1] == path[(i + 1)]), 2:3])
|
1438: ww <- which(groups == path[(i + 1)])
|
1462: for (i in 1:(length(path) - 1)) {
|
1464: as.numeric(ms[which(ms[, 1] == path[(length(path) - i + 1)]), 2:3])
|
1466: as.numeric(ms[which(ms[, 1] == path[(length(path) - i)]), 2:3])
|
1467: ww <- which(groups == path[(length(path) - i)])
|
1492: if (path.type[1] == "A2Z") {
|
1494: ww <- which(as.numeric(all[, 4]) == path.update[1])
|
1497: which(as.numeric(all[, 4]) == path.update[length(path.update)])
|
1505: wh <- which(mydata[, 4] == path[length(path)])
|
1611: #' @param path.type Character vector. A user-defined vector that characterizes the cell progression dynamics.
|
1612: #' The first element can be either "circular" or "A2Z" or "other". If "circular" the path progression is
|
1613: #' assummed to exhibit a circle-like behavior. If "A2Z" the path is assumed to have a well-defined start
|
1629: path.type,
|
1643: path.type = path.type)
|
1644: if (path.type[1] != "other") {
|
1657: path.type = path.type)
|
2027: #' It can be either "clockwise" or "anticlockwise" depending on how the path is expected
|
2049: #' The main function for automatic path estimation .
|
2053: #' It can be either "clockwise" or "anticlockwise" depending on how the path is expected
|
2055: #' @param start Integer. The cluster number that is assigned as the path starting point
|
2057: #' @return The sorted cluster indices (path)
|
2093: path <- rep(path, 2)
|
2094: if (length(which(path == start)) == 0) {
|
2097: if (start != path[1]) {
|
2098: w <- which(path == start)
|
2099: path <- path[w[1]:(w[2] - 1)]
|
2101: path <- path[1:(length(path) / 2)]
|
2103: return(path)
|
2108: #' A helper that updates the path sorted clusters after re-estimation by change-point analysis.
|
2110: #' @param data Data matrix. A matrix of centroids with their path progression indices.
|
2111: #' @param path Numeric vector. The path progression indices.
|
2113: #' @return The sorted cluster indices (path)
|
2118: for (i in 1:length(path)) {
|
2120: matrix(rbind(res, data[which(data[, 4] == path[i]),]), ncol = ncol(res))
|
2142: #' @return The sorted transformed signal differences (path) and the associated change-points
|
2231: #' It updates the path sorted clusters after re-estimation by change-point analysis.
|
2236: #' @param path.type Character vector. A user-defined vector that characterizes the cell progression dynamics.
|
2237: #' The first element can be either "circular" or "A2Z" or "other". If "circular" the path progression is
|
2238: #' assummed to exhibit a circle-like behavior. If "A2Z" the path is assumed to have a well-defined start
|
2242: #' @return A list of adjusted fluorescence signals and the updated path after the change-point analysis
|
2258: if (path.type[1] != "other" & length(estimates[[2]]) > 0) {
|
2268: estimatePath(trigs, type = path.type[2], start =
|
2271: pathUpdater(data = estimates[[1]], path = data$UpdatedPath)
|
2421: #' path.initiator
|
2423: #' It finds the cluster that initiates the progression path.
|
2427: #' the starting point of the progression path.
|
2429: #' @return A starting point for the progression path
|
2455: stop("Invalid starting point. Revise init.path parameter!")
|
2539: ...(7 bytes skipped)...stimates the average difference between the original and the CV estimated pseudotimes. For circular path
|
2541: #' maximum pseudotime is 300) in a circular path, two pseudotimes 1 and 300 differ only by 1 and not by 299.
|
2544: #' @param path.type Character. The input of path.type parameter in pathEstimator().
|
2552: aveDiff <- function(data, path.type, maxPseudo) {
|
2553: if (path.type != "circular") {
|
2557: if (path.type == "circular") {
|
1368: #' FixPath
|
1390: return(c(data, list(UpdatedPath = groups)))
|
1563: nn <- data$UpdatedPath
|
2047: #' estimatePath
|
2106: #' pathUpdater
|
2267: data$UpdatedPath <-
|
1641: updateCentroidsPaths(data = data,
|
1655: updateCentroidsPaths(data = res1[[1]],
|
2229: #' updateCentroidsPaths
|
oligoClasses:R/methods-GenomeAnnotatedDataFrame.R: [ ] |
---|
259: path <- system.file("extdata", package=pkgname)
|
260: if(path=="") stop("Are you sure ", pkgname, " is installed?")
|
262: snpBuilds <- list.files(path, pattern="snpProbes_")
|
Director:inst/www/js/d3.v3.js: [ ] |
---|
4199: d3.geo.path = function() {
|
4201: function path(object) {
|
6082: function d3_layout_bundlePath(link) {
|
3936: var d3_geo_pathAreaSum, d3_geo_pathAreaPolygon, d3_geo_pathArea = {
|
3963: var d3_geo_pathBoundsX0, d3_geo_pathBoundsY0, d3_geo_pathBoundsX1, d3_geo_pathBoundsY1;
|
3971: function d3_geo_pathBoundsPoint(x, y) {
|
4022: function d3_geo_pathBufferCircle(radius) {
|
4038: function d3_geo_pathCentroidPoint(x, y) {
|
4057: function d3_geo_pathCentroidLineEnd() {
|
4246: function d3_geo_pathProjectStream(project) {
|
4209: path.area = function(object) {
|
4214: path.centroid = function(object) {
|
4219: path.bounds = function(object) {
|
4224: path.projection = function(_) {
|
4229: path.context = function(_) {
|
4235: path.pointRadius = function(_) {
|
4238: return path;
|
4242: return path;
|
4244: return path.projection(d3.geo.albersUsa()).context(null);
|
7979: var rc, cr, rp, ap, p0 = 0, p1 = 0, x0, y0, x1, y1, x2, y2, x3, y3, path = [];
|
8027: path.push("M", t30[0], "A", rc1, ",", rc1, " 0 0,", cr, " ", t30[1], "A", r1, ",", r1, " 0 ", 1 - cw ^ d...(128 bytes skipped)...
|
8029: path.push("M", t30[0], "A", rc1, ",", rc1, " 0 1,", cr, " ", t12[0]);
|
8032: path.push("M", x0, ",", y0);
|
8037: path.push("L", t21[0], "A", rc0, ",", rc0, " 0 0,", cr, " ", t21[1], "A", r0, ",", r0, " 0 ", cw ^ d3_sv...(128 bytes skipped)...
|
8039: path.push("L", t21[0], "A", rc0, ",", rc0, " 0 0,", cr, " ", t03[0]);
|
8042: path.push("L", x2, ",", y2);
|
8045: path.push("M", x0, ",", y0);
|
8046: if (x1 != null) path.push("A", r1, ",", r1, " 0 ", l1, ",", cw, " ", x1, ",", y1);
|
8047: path.push("L", x2, ",", y2);
|
8048: if (x3 != null) path.push("A", r0, ",", r0, " 0 ", l0, ",", 1 - cw, " ", x3, ",", y3);
|
8050: path.push("Z");
|
8051: return path.join("");
|
8195: var i = 0, n = points.length, p = points[0], path = [ p[0], ",", p[1] ];
|
8196: while (++i < n) path.push("H", (p[0] + (p = points[i])[0]) / 2, "V", p[1]);
|
8197: if (n > 1) path.push("H", p[0]);
|
8198: return path.join("");
|
8201: var i = 0, n = points.length, p = points[0], path = [ p[0], ",", p[1] ];
|
8202: while (++i < n) path.push("V", (p = points[i])[1], "H", p[0]);
|
8203: return path.join("");
|
8206: var i = 0, n = points.length, p = points[0], path = [ p[0], ",", p[1] ];
|
8207: while (++i < n) path.push("H", (p = points[i])[0], "V", p[1]);
|
8208: return path.join("");
|
8224: var quad = points.length != tangents.length, path = "", p0 = points[0], p = points[1], t0 = tangents[0], t = t0, pi = 1;
|
8226: path += "Q" + (p[0] - t0[0] * 2 / 3) + "," + (p[1] - t0[1] * 2 / 3) + "," + p[0] + "," + p[1];
|
8234: path += "C" + (p0[0] + t0[0]) + "," + (p0[1] + t0[1]) + "," + (p[0] - t[0]) + "," + (p[1] - t[1]) + "," ...(20 bytes skipped)...
|
8238: path += "S" + (p[0] - t[0]) + "," + (p[1] - t[1]) + "," + p[0] + "," + p[1];
|
8243: path += "Q" + (p[0] + t[0] * 2 / 3) + "," + (p[1] + t[1] * 2 / 3) + "," + lp[0] + "," + lp[1];
|
8245: return path;
|
8259: ...(44 bytes skipped)...s[0], x0 = pi[0], y0 = pi[1], px = [ x0, x0, x0, (pi = points[1])[0] ], py = [ y0, y0, y0, pi[1] ], path = [ x0, ",", y0, "L", d3_svg_lineDot4(d3_svg_lineBasisBezier3, px), ",", d3_svg_lineDot4(d3_svg_lin...(21 bytes skipped)...
|
8267: d3_svg_lineBasisBezier(path, px, py);
|
8270: path.push("L", pi);
|
8271: return path.join("");
|
8275: var path = [], i = -1, n = points.length, pi, px = [ 0 ], py = [ 0 ];
|
8281: path.push(d3_svg_lineDot4(d3_svg_lineBasisBezier3, px) + "," + d3_svg_lineDot4(d3_svg_lineBasisBezier3, ...(5 bytes skipped)...
|
8289: d3_svg_lineBasisBezier(path, px, py);
|
8291: return path.join("");
|
8294: var path, i = -1, n = points.length, m = n + 4, pi, px = [], py = [];
|
8300: path = [ d3_svg_lineDot4(d3_svg_lineBasisBezier3, px), ",", d3_svg_lineDot4(d3_svg_lineBasisBezier3, py)...(3 bytes skipped)...
|
8308: d3_svg_lineBasisBezier(path, px, py);
|
8310: return path.join("");
|
8329: function d3_svg_lineBasisBezier(path, x, y) {
|
8330: path.push("C", d3_svg_lineDot4(d3_svg_lineBasisBezier1, x), ",", d3_svg_lineDot4(d3_svg_lineBasisBezier1...(206 bytes skipped)...
|
8987: var range = d3_scaleRange(scale1), path = g.selectAll(".domain").data([ 0 ]), pathUpdate = (path.enter().append("path").attr("class", "domain"),
|
8988: d3.transition(path));
|
3941: d3_geo_pathAreaPolygon = 0;
|
3942: d3_geo_pathArea.lineStart = d3_geo_pathAreaRingStart;
|
3945: d3_geo_pathArea.lineStart = d3_geo_pathArea.lineEnd = d3_geo_pathArea.point = d3_noop;
|
3946: d3_geo_pathAreaSum += abs(d3_geo_pathAreaPolygon / 2);
|
3949: function d3_geo_pathAreaRingStart() {
|
3951: d3_geo_pathArea.point = function(x, y) {
|
3952: d3_geo_pathArea.point = nextPoint;
|
3956: d3_geo_pathAreaPolygon += y0 * x - x0 * y;
|
3959: d3_geo_pathArea.lineEnd = function() {
|
3964: var d3_geo_pathBounds = {
|
3965: point: d3_geo_pathBoundsPoint,
|
3972: if (x < d3_geo_pathBoundsX0) d3_geo_pathBoundsX0 = x;
|
3973: if (x > d3_geo_pathBoundsX1) d3_geo_pathBoundsX1 = x;
|
3974: if (y < d3_geo_pathBoundsY0) d3_geo_pathBoundsY0 = y;
|
3975: if (y > d3_geo_pathBoundsY1) d3_geo_pathBoundsY1 = y;
|
3977: function d3_geo_pathBuffer() {
|
3978: var pointCircle = d3_geo_pathBufferCircle(4.5), buffer = [];
|
3993: pointCircle = d3_geo_pathBufferCircle(_);
|
4025: var d3_geo_pathCentroid = {
|
4026: point: d3_geo_pathCentroidPoint,
|
4027: lineStart: d3_geo_pathCentroidLineStart,
|
4028: lineEnd: d3_geo_pathCentroidLineEnd,
|
4030: d3_geo_pathCentroid.lineStart = d3_geo_pathCentroidRingStart;
|
4033: d3_geo_pathCentroid.point = d3_geo_pathCentroidPoint;
|
4034: d3_geo_pathCentroid.lineStart = d3_geo_pathCentroidLineStart;
|
4035: d3_geo_pathCentroid.lineEnd = d3_geo_pathCentroidLineEnd;
|
4043: function d3_geo_pathCentroidLineStart() {
|
4045: d3_geo_pathCentroid.point = function(x, y) {
|
4046: d3_geo_pathCentroid.point = nextPoint;
|
4047: d3_geo_pathCentroidPoint(x0 = x, y0 = y);
|
4054: d3_geo_pathCentroidPoint(x0 = x, y0 = y);
|
4058: d3_geo_pathCentroid.point = d3_geo_pathCentroidPoint;
|
4060: function d3_geo_pathCentroidRingStart() {
|
4062: d3_geo_pathCentroid.point = function(x, y) {
|
4063: d3_geo_pathCentroid.point = nextPoint;
|
4064: d3_geo_pathCentroidPoint(x00 = x0 = x, y00 = y0 = y);
|
4075: d3_geo_pathCentroidPoint(x0 = x, y0 = y);
|
4077: d3_geo_pathCentroid.lineEnd = function() {
|
4081: function d3_geo_pathContext(context) {
|
4117: context.closePath();
|
4210: d3_geo_pathAreaSum = 0;
|
4211: d3.geo.stream(object, projectStream(d3_geo_pathArea));
|
4212: return d3_geo_pathAreaSum;
|
4216: d3.geo.stream(object, projectStream(d3_geo_pathCentroid));
|
4220: d3_geo_pathBoundsX1 = d3_geo_pathBoundsY1 = -(d3_geo_pathBoundsX0 = d3_geo_pathBoundsY0 = Infinity);
|
4221: d3.geo.stream(object, projectStream(d3_geo_pathBounds));
|
4222: return [ [ d3_geo_pathBoundsX0, d3_geo_pathBoundsY0 ], [ d3_geo_pathBoundsX1, d3_geo_pathBoundsY1 ] ];
|
4226: projectStream = (projection = _) ? _.stream || d3_geo_pathProjectStream(_) : d3_identity;
|
4231: contextStream = (context = _) == null ? new d3_geo_pathBuffer() : new d3_geo_pathContext(_);
|
6077: var paths = [], i = -1, n = links.length;
|
6078: while (++i < n) paths.push(d3_layout_bundlePath(links[i]));
|
6079: return paths;
|
8995: pathUpdate.attr("d", "M" + range[0] + "," + sign * outerTickSize + "V0H" + range[1] + "V" + sign * outer...(10 bytes skipped)...
|
8999: pathUpdate.attr("d", "M" + sign * outerTickSize + "," + range[0] + "H0V" + range[1] + "H" + sign * outer...(10 bytes skipped)...
|