49: .createVirtualFragmentLibrary_DNAString <- function(chosenGenome, firstCutter, secondCutter, readLength, onlyNonBlind = TRUE, useOnlyIndex ...(154 bytes skipped)...

78: .splitChromosome_DNAString <- function(firstCutter, secondCutter, chromosomeToSplit, chromosomeName) {

213:     signature=signature(chosenGenome="DNAString", firstCutter="character", secondCutter="character", readLength="numeric"),

214:     .createVirtualFragmentLibrary_DNAString)

217:     signature=signature(firstCutter="character", secondCutter="character", chromosomeToSplit="DNAString", chromosomeName="character"),

218:     .splitChromosome_DNAString)

15:         if (class(chromosomeToSplit) == "MaskedDNAString") {

84: .bcSeq_hamming_DNAString <- function(sampleFile, libFile, outFile, 

120: .bcSeq_edit_DNAString <- function(sampleFile, libFile, outFile, 

105:     res <- invisible(.Call("_bcSeq_CRISPR_matching_DNAString", 

145:         res <- invisible(.Call("_bcSeq_CRISPR_user_matching_DNAString", 

151:         res <- invisible(.Call("_bcSeq_CRISPR_matching_DNAString", 

176:         .bcSeq_hamming_DNAString(sampleFile = sampleFile, libFile = libFile, 

192:         .bcSeq_edit_DNAString(sampleFile, libFile, outFile, 

111: .srdistance_DNAStringSet_DNAString <- function(pattern, subject, ...)

98: .srdistance_DNAStringSet_character <- function(pattern, subject, ...)

121: .srdistance_DNAStringSet_DNAStringSet <- function(pattern, subject,

100:     strings <- lapply(subject, DNAString)

118: setMethod(srdistance, c("DNAStringSet", "DNAString"),

119:           .srdistance_DNAStringSet_DNAString)

7: setMethod(clean, "DNAStringSet", function(object, ...) {

11: setMethod(dustyScore, "DNAStringSet",

19:     triplets <- DNAStringSet(mkAllStrings(c("A", "C", "G", "T"), 3))

62: setMethod(writeFasta, "DNAStringSet",

108: setMethod(srdistance, c("DNAStringSet", "character"),

109:           .srdistance_DNAStringSet_character)

127: setMethod(srdistance, c("DNAStringSet", "DNAStringSet"),

128:           .srdistance_DNAStringSet_DNAStringSet)

293: getPeriodicity.DNAString <- function(

109: getPeriodicity.DNAStringSet <- function(

9: #' @param x a DNAString, DNAStringSet or GRanges object. 

291: #' @describeIn getPeriodicity S3 method for DNAString

26: #' @param genome genome ID, BSgenome or DNAStringSet object 

107: #' @describeIn getPeriodicity S3 method for DNAStringSet

299:     seq <- Biostrings::DNAStringSet(x)

38: .simulateDigestionChromosome_DNAString <- function(firstCutter, secondCutter, dnaSequence) {

28: .simulateDigestionChromosome_MaskedDNAString <- function(firstCutter, secondCutter, dnaSequence) {

68:     signature=signature(firstCutter="character", secondCutter="character", dnaSequence="DNAString"),

69:     .simulateDigestionChromosome_DNAString)

64:     signature=signature(firstCutter="character", secondCutter="character", dnaSequence="MaskedDNAString"),

65:     .simulateDigestionChromosome_MaskedDNAString)

365: SEXP CRISPR_matching_DNAString(

472: SEXP CRISPR_user_matching_DNAString(

352: seq_t decode_DNAString(SEXP dnaobject, int seq_type)

346:  * Decode DNAString object

348:  * @param dnaobject DNAString object

511:  * @param dnaobject DNAString object

556: 	seq_t dna = decode_DNAString(dnaobject, st[0]);

9: SEXP DNAString_to_twoBit(SEXP r_dna, SEXP r_mask, SEXP r_seqname) {

99:   PROTECT(r_ans = alloc_XRawList("DNAStringSet", "DNAString", r_ans_width));

189: .extractSpacersFromDNAString <- function(dnaString,

6: #' @param mrnaSequence A \code{DNAStringSet} represeting the mRNA sequence

62:     if (!is(mrnaSequence, "DNAStringSet")){

63:         stop("mrnaSequence must be a DNAStringSet")

104: #' @importFrom Biostrings DNAStringSet

113:     spacers <- .extractSpacersFromDNAString(mrnaSequence[[1]],

121:     spacerSet <- DNAStringSet(spacers) 

139:     protospacer <- reverseComplement(DNAStringSet(spacers$spacer))

457:   GuideSeq = DNAStringSet(dat[["spacer"]])

752: #' @importFrom Biostrings DNAStringSet

754:     G <- DNAStringSet(x[["spacer"]])

48: #'     mrnaSequence <- Biostrings::readDNAStringSet(filepath=fasta,

96: #mrnaSequence <- Biostrings::readDNAStringSet(filepath=fasta,

1682: 	DNAStringSet<-read.DNAStringSet(path)

146: 	probe <- DNAStringSet(as.character(sequences)) #need to remove names or PDict will crash

148: 	probe_directions <- DNAStringSet()

1684: 	for(i in 1:length(DNAStringSet)){

1687: 		readFASTAformatList[[i]][["desc"]]<- names(as.character(DNAStringSet))[i]

1688: 		readFASTAformatList[[i]][["seq"]]<- as.character(as.character(DNAStringSet)[i])

24: generateDNAString = function(len, bg) {

68: generateDNAStringSet = function(seqlen, bg) {

1: #' Generate DNAString

3: #' This function generates a random DNAString of a given length

9: #' @return A DNAString object

29:         return(Biostrings::DNAString(""))

40:     return(Biostrings::DNAString(ret[[1]]))

21: #' motifcounter:::generateDNAString(1000, bg)

43: #' Generate DNAStringSet

45: #' This function generates a DNAStringSet-object of the

53: #' @return A DNAStringSet object

73:         seqs = c(seqs, generateDNAString(seqlen[i], bg))

76:     return(Biostrings::DNAStringSet(seqs))

197:         seq = generateDNAString(seqlen, bg)

15: #' seqs = Biostrings::readDNAStringSet(seqfile)

23: #' @seealso \code{\link{generateDNAStringSet}}

59: #' seqs = Biostrings::readDNAStringSet(seqfile)

65: #' motifcounter:::generateDNAStringSet(10:50, bg)

67: #' @seealso \code{\link{generateDNAStringSet}}

100: #' seqs = Biostrings::readDNAStringSet(seqfile)

132:         seqs = generateDNAStringSet(seqlen, bg)

167: #' seqs = Biostrings::readDNAStringSet(seqfile)

248: #' seqs = Biostrings::readDNAStringSet(seqfile)

273:     seqs = generateDNAStringSet(rep(seqlen, nsim), bg)

28: DNAStringSetToList = function(x){

22: #' Convert DNAStringSet to list of DNAString objects

39: #' @param sequences either a list of DNAString objects, or a DNAStringSet

24: #' as.list doesn't seem to always work for DNAStringSets, so

27: #' @param x an object of class DNAStringSet

58: DNAStringSet2GRanges <- function(seqs) {

27:     if (is(dna, 'DNAString')) {

39:                 Biostrings::DNAString( paste(shuffled_charvec, collapse="") )

51:                 Biostrings::DNAString( as.character(seq) )

28:         dna <- Biostrings::DNAStringSet(dna)

31:         dna <- Biostrings::DNAStringSet(dna)

35:         shuffled <- Biostrings::DNAStringSet(

48:         shuffled <- Biostrings::DNAStringSet(

14: encodeDNAString <- function( ds ){

131: SEXP DNAStringSet_translate(SEXP x, SEXP skip_code, SEXP dna_codes,

148: 		      "DNAStringSet_translate(): length of 'lkup' "

152: 		      "DNAStringSet_translate(): 'lkup' and 'init_lkup' "

167: 			      "DNAStringSet_translate(): "

176: 			      "DNAStringSet_translate(): "

257: test_getSeqOccupancy_badDNAString <- function() {

12:     sequence <- DNAString("CACGTG")

34:     sequence <- DNAString("CACGTG")

55:     sequence <- DNAString("CACGTGCTGAAATGTCATGCATGCTAGCGTTTTGCCATGTCGATCTGACTCGTAGTGCTGTCGTTTGCGGATCGTTCGAGCTGCTGCGTATCGTGC")...(0 bytes skipped)...

247:     sequence <- DNAString("CACGTG")

268:     sequence <- DNAString("CACSTG")

91: .DNAString_to_twoBit <- function(object, seqname) {

74:             invisible(.TwoBits_export(mapply(.DNAString_to_twoBit, object,

94:   if (!is(object, "DNAString") && !is(object, "MaskedDNAString"))

95:     stop("'object' must be a DNAString")

101:   .Call(DNAString_to_twoBit, as.character(object), object_mask, seqname)

53:   object <- as(object, "DNAStringSet")

57: setMethod("export", c("DNAStringSet", "TwoBitFile"),

221: .all_have_DNAStringSet <- function(args){

230: .all_have_DNAStringSetList <- function(args){

219: #' test all TSEs have DNAStringSet in the referenceSeq slot

223:         is(x@referenceSeq, "DNAStringSet")

228: #' test all TSEs have DNAStringSetList in the referenceSeq slot

232:         is(x@referenceSeq, "DNAStringSetList")

247:     isDNA <- .all_have_DNAStringSet(args)

248:     isDNAList <- .all_have_DNAStringSetList(args)

251:     #   1) all TSEs have DNAStringSet 

252:     #   2) all TSEs have DNAStringSetList

258:              "NULL/DNAStringSet/DNAStringSetList ")

209: .GRanges2DNAStringSet <- function(x,

318: .string2DNAStringSet <- function(x,

173: .asDNAStringSet <- function(x,

346: .findSpacersFromDNAStringSet <- function(dna,

5: #'    \linkS4class{DNAString} or character vector of genomic sequences.

8: #'     \linkS4class{DNAString} object, or a character vector of genomic

189:     } else if (methods::is(x, "DNAString") || 

4: #'    sequence(s) contained in either a \linkS4class{DNAStringSet},

7: #' @param x Either a \linkS4class{GRanges}, a \linkS4class{DNAStringSet}, or a

171: # Extract a DNAStringSet object from a (bsgenome,granges) pair

185:         x <- .GRanges2DNAStringSet(x,

190:                methods::is(x, "DNAStringSet") ||

192:         x <- .string2DNAStringSet(x,

314: # Convenience function to transform a string into a DNAStringSet

315: #' @importFrom Biostrings DNAStringSet reverseComplement

321:     dna <- Biostrings::DNAStringSet(x)

340: # Find spacer sequences from a DNAStringSet object

103:     dna <- .asDNAStringSet(x,

107:     gs <- .findSpacersFromDNAStringSet(dna=dna,

203: # Helper function for .asDNAStringSet

66: static SEXP _tmpl_DNAStringSet()

69:     SEXP lkup = PROTECT(_get_lkup("DNAString"));

70:     SEXP ans = new_XRawList_from_CharAEAE("DNAStringSet", "DNAString",

112:     SET_VECTOR_ELT(tmpl, SEQ_IDX, _tmpl_DNAStringSet());

11: sequence_input.DNAStringSet <- function(input){

212: .from_BSgenomeViews_to_DNAStringSet <- function(from)

29:         elementType="DNAString"

168:             dna="DNAStringSet"

215: setAs("BSgenomeViews", "DNAStringSet", .from_BSgenomeViews_to_DNAStringSet)

216: setAs("BSgenomeViews", "XStringSet", .from_BSgenomeViews_to_DNAStringSet)

272: ### DNAStringSet methods

286: ### exact same formal args than in the method for DNAStringSet objects. This

422: ### TODO: Add more DNAStringSet methods...

1: .alignShortReads_DNAStringSet <- function(object, bsGenome, seqNames, ensemblNotation) {

75:     signature=signature(object="DNAStringSet", bsGenome="BSgenome",

77:     .alignShortReads_DNAStringSet)

85:     signature=signature(object="DNAStringSet", bsGenome="BSgenome",

88:         return(.alignShortReads_DNAStringSet(object, bsGenome, seqNames, FALSE))

99:     signature=signature(object="DNAStringSet", bsGenome="BSgenome",

102:         return(.alignShortReads_DNAStringSet(object, bsGenome, names(bsGenome)[1:24], ensemblNotation))

113:     signature=signature(object="DNAStringSet", bsGenome="BSgenome",

116:         return(.alignShortReads_DNAStringSet(object, bsGenome, names(bsGenome)[1:24], FALSE))

141: #  gSeqs = DNAStringSet(geneSeqs$gene_exon_intron)

124: scoss_wm_score_DNAStringSet(SEXP wmR, SEXP dnaStringSet, SEXP nscoR) {

122: /* entry point to wm_score_DNAStringSet */

65: SEXP dna_hash_as_DNAStringSet(struct dna_hash_t *dna)

117:                 "DNAStringSet", "DNAString", tag, ranges));

3: /* DNAStringSet -- hash */

115:     /* DNAStringSet */

53: alignment.DNAStringSet <- function(alignment, type)

51: ## Convert triplex alignment into DNAStringSet

65: 		a <- DNAStringSet(c(

78: 		a <- DNAStringSet(c(

91: 		a <- DNAStringSet(c(

104: 		a <- DNAStringSet(c(

117: 		a <- DNAStringSet(c(

130: 		a <- DNAStringSet(c(

143: 		a <- DNAStringSet(c(

156: 		a <- DNAStringSet(c(

178: 	alignment.DNAStringSet(alignment, type)

11: .get_DNAStringSet_seqinfo <- function(x)

8: ### seqinfo() getter and setter for DNAStringSet objects

30: setMethod("seqinfo", "DNAStringSet", .get_DNAStringSet_seqinfo)

32: ### We implement a restricted seqinfo() setter for DNAStringSet object 'x'

39: ### is all we need to make the seqlevelsStyle() setter work on a DNAStringSet

58: .set_DNAStringSet_seqinfo <-

91: setReplaceMethod("seqinfo", "DNAStringSet", .set_DNAStringSet_seqinfo)

197: test_ShortReadQ_coerce_DNAStringSet <- function()

210: test_ShortReadQ_coerce_QualityScaledDNAStringSet <- function()

11:     checkStringSet(sread(obj), "DNAStringSet", len, wd[[2]])

200:         as(ShortReadQ(), "DNAStringSet"),

201:         DNAStringSet(setNames(nm = character()))

206:     checkIdentical(sread(obj), unname(as(obj, "DNAStringSet")))

207:     checkIdentical(as.character(id(obj)), names(as(obj, "DNAStringSet")))

216:     checkIdentical(sread(obj), unname(as(res, "DNAStringSet")))

224:     checkIdentical(sread(obj), unname(as(res, "DNAStringSet")))

236:     checkIdentical(sread(obj), unname(as(res, "DNAStringSet")))

215:     res <- as(obj, "QualityScaledDNAStringSet")

223:     res <- as(obj, "QualityScaledDNAStringSet")

232:     checkException(as(obj, "QualityScaledDNAStringSet"), silent=TRUE)

235:     res <- as(obj, "QualityScaledDNAStringSet")

4: test_PatternMatrix_matrix_DNAStringSet = function()

29: test_PatternMatrix_character_DNAStringSet = function()

9:   windows = as(list(DNAString("AAAGCTAAAGGTAAAGCAAAA"),

10: 		    DNAString("AAAGCTAAAGGTAAAGCAAAA"),

11:                     DNAString("AAAGCTAAAGGTAAAGCAAAA")), "DNAStringSet")

19:   windows = as(list(DNAString("AAAGCTAAAGGTAAAGCAAAA"),

20:                     DNAString("AAAGCTAAAGGTAAAGCAAAA"),

21:                     DNAString("AAAGCTAAAGGTAAAGCAAAA")), "DNAStringSet")

33:   windows = as(list(DNAString("AAAGCTAAAGGTAAAGCAAAA"),

34: 		    DNAString("AAAGCTAAAGGTAAAGCAAAA"),

35:                     DNAString("AAAGCTAAAGGTAAAGCAAAA")), "DNAStringSet")

42:   windows = as(list(DNAString("NNNNNNNNNNNNNN"),

43:   		    DNAString("NNNNNNNNNNNNNN")), "DNAStringSet")

51:   windows = as(list(DNAString("AAAGCTAAAGGTAAAGCAAAA"),

52:                     DNAString("AAAGCTAAAGGTAAAGCAAAA"),

53:                     DNAString("AAAGCTAAAGGTAAAGCAAAA")), "DNAStringSet")

7:   patterns <- DNAStringSet(c("AAA", "AAA", "AAA"))

17:   patterns <- DNAStringSet(c("AAA", "AAA", "AAA"))

1: test_GmapGenome_constructor_DNAStringSet_noCreate <- function() {

8: test_GmapGenome_constructor_DNAStringSet_create <- function() {

2:   dna <- Biostrings::DNAStringSet("ACTGTGTCAG")

12:   dna <- Biostrings::DNAStringSet(seq)

46:   dna <- Biostrings::DNAStringSet("ACTGTGTCAG")

47:   names(dna) <- "testDNAString"

100:   dna <- Biostrings::DNAStringSet(c(testA = "ACTGTGTCAGTTCATGGGACCGTTGC",

19:   names(dna) <- "sampleDNAStringSet"

203: .scoreDNAStringSet <- function(PWM,DNASequenceSet, strand="+",

292:     if(class(object) == "DNAStringSet"){

173:     sequences <- readDNAStringSet(fileame)

4098: write.listedDNAStringSet <- function(dnaSet, filePath = ".",

902: #' @param patternSeq DNAString object or a sequence containing the query sequence to search. This is generally smaller than subjec...(7 bytes skipped)...

1082: #' @param patternSeq DNAString object or a sequence containing the query sequence to search with the primerID.

1151:   pattern1 <- as.character(subseq(DNAString(patternSeq), 1, primerIDpos[1] - 1))

1152:   pattern2 <- as.character(subseq(DNAString(patternSeq),

1282: #' @param patternSeq DNAString object or a sequence containing the query sequence to search. This is generally smaller than subjec...(7 bytes skipped)...

1433: #' @param patternSeq DNAString object or a sequence containing the query sequence to search.

1458:   patternSeq.rc <- as.character(reverseComplement(DNAString(patternSeq)))

3055: #' @param patternSeq DNAString object or a sequence containing the query sequence to search.

3108: #' @param Vector DNAString object containing vector sequence to be searched in reads.

3262:   stopifnot(class(dnaSet) %in% c("DNAStringSet", "DNAString"))

4194:       if(!grepl("DNAString", class(Vector))) {

4195:         stop("Vector paramter is not of DNAString class")

414: #' Removes duplicate sequences from DNAStringSet object.

416: #' Given a DNAStringSet object, the function dereplicates reads and 

419: #' @param dnaSet DNAStringSet object to dereplicate. 

421: #' @return DNAStringSet object with names describing frequency of repeat.

437:   if(!is(dnaSet,"DNAStringSet")) {

438:     dnaSet <- DNAStringSet(dnaSet)

456: #' Replicate sequences from DNAStringSet object using counts identifier or vector

458: #' Given a DNAStringSet object, the function replicates reads using counts=X 

461: #' @param dnaSet DNAStringSet object to replicate. 

467: #' @return DNAStringSet object.

485:   stopifnot(is(dnaSet,"DNAStringSet"))

512: #' Given a DNAStringSet object, the function removes any reads that has either repeating or total Ns which is greater th...(21 bytes skipped)...

514: #' @param dnaSet DNAStringSet object to evaluate. 

519: #' @return DNAStringSet object.

533:   if(!is(dnaSet,"DNAStringSet")) {

534:     dnaSet <- DNAStringSet(dnaSet)

568: #' chunkize(DNAStringSet(x), 5)

580: #' Split DNAStringSet object using first X number of bases defined by a vector.

582: #' Given a character vector of barcodes/MID to sample association and a DNAStringSet object, the function splits/demultiplexes the DNAStringSet object by first few bases dictated by length of barcodes/MID supplied. This is an accessory func...(39 bytes skipped)...

586: #' @param dnaSet DNAStringSet object to evaluate. 

594: #' @return DNAStringSet object split by sample name found in barcodesSample.

602: #' dnaSet <- DNAStringSet(c("read1" = "ACATCCATAGAGCTACGACGACATCGACATA",

645:   unmatched <- DNAStringSet(dnaSet[!good.row])

646:   dnaSet <- DNAStringSet(dnaSet[good.row], start = trimFrom)

678: #' @param dnaSet DNAStringSet object containing sequences to be decoded or 

697: #' appeneded to respective sample slots, else a named list of DNAStringSet 

709: #' dnaSet <- DNAStringSet(c("read1" = "ACATCCATAGAGCTACGACGACATCGACATA",

901: #' @param subjectSeqs DNAStringSet object containing sequences to be searched for the pattern. This is generally bigger than patter...(94 bytes skipped)...

952: #' subjectSeqs <- DNAStringSet(xscat("AAAAAAAAAA", subjectSeqs))

989:       badSeqs <- DNAStringSet()

1081: #' @param subjectSeqs DNAStringSet object containing sequences to be searched for the pattern. 

1121: #' primerIDAlignSeqs(DNAStringSet(subjectSeqs), patternSeq, doAnchored = TRUE)

1281: #' @param subjectSeqs DNAStringSet object containing sequences to be searched for the pattern. This is generally bigger than patter...(94 bytes skipped)...

1316: #' subjectSeqs <- DNAStringSet(xscat("AAAAAAAAAA", subjectSeqs))

1334:     badSeqs <- DNAStringSet()

1432: #' @param subjectSeqs DNAStringSet object containing sequences to be searched for the pattern. 

3056: #' @param subjectSeqs DNAStringSet object containing sequences to be searched for the pattern.

3062: #' @return DNAStringSet object with pattern sequence removed from the subject sequences. 

3074: #' subjectSeqs=DNAStringSet(c("AGACCCTTTTGAGCAGCAT","AGACCCTTGGTCGACTCA",

3107: #' @param reads DNAStringSet object containing sequences to be trimmed for vector.

3115: #' @return DNAString...(202 bytes skipped)... region and whether it was considered valid denoted by 'good.row'. The second element, "reads" is a DNAStringSet object with Vector sequence removed from the reads.

3238: #' This function trims a DNAStringSet object using the ranges from left, right, or middle of the sequence. This is a helper function u...(202 bytes skipped)...

3240: #' @param dnaSet DNAStringSet object containing sequences to be trimmed.

3245: #' @return a DNAStringSet object with trimmed sequences. 

3254: #' dnaSet <- DNAStringSet(c("AAAAAAAAAACCTGAATCCTGGCAATGTCATCATC", 

3358: #' @return a listed DNAStringSet object structed by sector then sample. 

3917: #' Given a sequence reads file path, the function returns a DNAStringSet object.

3925: #' @return if isPaired is FALSE, then a DNAStringSet object, else a list of 

3926: #' DNAStringSet objects of three elements corresponding to reads from 

4054: #' Given a listed DNAStringSet object return from \code{\link{extractSeqs}}, the

4057: #' @param dnaSet listed DNAStringSet object containing sequences to be written.

4583: #' Align a listed DNAStringSet to a reference using gfClient or standalone BLAT.

4585: #' Align sequences from a listed DNAStringSet object returned from 

4591: #' @param dnaSetList DNAStringSet object containing sequences to be aligned against the reference.

4605:     stop("dnaSetList is empty. Please supply a listed DNAStringSet ",

4666: #' Given a vector of sequences or DNAStringSet or a FASTA filename, the function 

4669: #' @param x a DNAStringSet object, or a FASTA filename.

4672: #' @param filename name of the file if x is a DNAStringSet object. 

4683: #' seqs <- DNAStringSet(sapply(sample(c(100:1000), 500),

4706:   } else if (class(x) == "DNAStringSet") {

4737: #' @param query an object of DNAStringSet, a character vector of filename(s), 

4739: #' @param subject an object of DNAStringSet, a character vector, or a path to 

4845:         subject <- DNAStringSet(subject)

4850:       ## subjectFile is still null so it means that subject is a DNAStringSet

4889:         query <- DNAStringSet(query)

4894:       ## queryFiles is still null so it means that query is a DNAStringSet           

6334:   } else if(is(x, "DNAStringSet")) {

6533: #' Prepend name attribute of a list to DNAStringSet

6535: #' Given a named listed DNAStringSet object returned from \code{\link{extractSeqs}}, 

6541: #' @return listed DNAStringSet with the names attribute prepended with the 

6542: #' name of the list. If flatten is TRUE, then a DNAStringSet object

6560:   if(all(sapply(dnaSet, class)=="DNAStringSet")) {

6561:     ## this would be list of DNAStringSets ##    

2396:         Vector <- readDNAStringSet(vectorFile)

2633:         write.listedDNAStringSet(seqs, filePrefix = paste0("processed", f))

2644:         write.listedDNAStringSet(seqs, filePrefix = paste0("processed", f))

2650:         write.listedDNAStringSet(seqs, filePrefix = paste0("processed", f))

4001:       dnaSet <- readDNAStringSet(x, format = 'fastq')      

4034:     dnaSet <- readDNAStringSet(seqFilePath)

4096: #' write.listedDNAStringSet(seqs)

6545: #' \code{\link{getSectorsForSamples}}, \code{\link{write.listedDNAStringSet}}

191:     fRDNAStringSet <- lapply(forwardReadList, function(forwardRead) {

200:     rRDNAStringSet <- lapply(reverseReadList, function(reverseRead) {

440:         primarySeq <- DNAString(paste(primary, collapse=""))

441:         secondarySeq <- DNAString(paste(secondary, collapse=""))

444:         primarySeq <- DNAString(paste(primary, collapse=""))

445:         secondarySeq <- DNAString(paste(secondary, collapse=""))

550:     DNASeqshift0 <- DNAString(substr(as.character(primarySeq),

558:     DNASeqshift1 <- DNAString(substr(as.character(primarySeq),

566:     DNASeqshift2 <- DNAString(substr(as.character(primarySeq),

49:     ### Creating SangerContigList DNAStringSet

55:     SangerContigDNASet <- DNAStringSet(SangerContigDNAList)

213:     ### DNAStringSet storing forward & reverse reads ! (Origin)

215:     frReadSet <- DNAStringSet(c(unlist(fRDNAStringSet),

342:     aln2 = c(aln, DNAStringSet(consensus))

345:     consensusGapfree = RemoveGaps(DNAStringSet(consensus))[[1]]

216:                                 unlist(rRDNAStringSet)))

217:     frReadFeatureList <- c(rep("Forward Reads", length(fRDNAStringSet)),

218:                            rep("Reverse Reads", length(rRDNAStringSet)))

96: .isDNAStringSet <- function(x){

336:     if (methods::is(seq, "DNAString") && (is.null(len) || len == 1)){

97:     methods::is(x, "DNAStringSet")

340:     if (is(seq, "DNAStringSet") && (is.null(len) || length(seq) == len)){

391: #' @importFrom Biostrings DNAStringSet reverseComplement

393:     x <- Biostrings::DNAStringSet(x)

229: .listOfDNAStringToDNAStringSet <- function(x)

225: ### Assumes 'x' is a list of DNAString objects and turns it into a

351:             return(ans[[1L]])  # turn 1st and unique element into DNAString

152:                 return(DNAStringSet())

187:     unsplit_list_of_XVectorList("DNAStringSet", dnaset_list,

226: ### DNAStringSet object.

228: ### efficient). Also maybe make this a "DNAStringSet" method for list objects.

232:         return(DNAStringSet())

234:     DNAStringSet(successiveViews(subject, elementNROWS(x)))

331:         ans <- rep.int(DNAStringSet(""), length(sseq_idx))

265:     .listOfDNAStringToDNAStringSet(ans)

93: .toDNAStringSetList <- function(x)

91: ## DNAStringSetList. Used in predictCoding(), genotypeToSnpMatrix()

99:     relist(DNAStringSet(xx), pbw)

103: ## a DNAStringSetList. Used in .scanVcfToVCF().

114:         relist(DNAStringSet(flat), x)

285:         mcols(res) <- DataFrame(REF=DNAStringSet(), ALT=DNAStringSetList(),

286:                                 varAllele=DNAStringSet(), CDSLOC=IRanges(),

73: .patternPWM_windowsDNAStringSet2matrix = function(pattern, windows, 

122: .patterncharacter_windowsDNAStringSet2matrix = function(pattern, windows, cores){

121: # pattern: character, windows: DNAStringSet

127:   # regionsSeq <- DNAStringSet(gsub("N", "+", regionsSeq)), 

199: #' @param windows \code{\link{GRanges}} object or \code{\link{DNAStringSet}} object 

214: #' a list of sequences (a DNAStringSet object)

216: #' in sequences (a DNAStringSet object).

228: #' windows = DNAStringSet(seqs)

247: #' @aliases patternMatrix,character,DNAStringSet-method

249: #' @usage  \\S4method{patternMatrix}{character,DNAStringSet}(pattern, windows,

252:           signature(pattern = "character", windows = "DNAStringSet"),

287:               stop("All sequences in the input DNAStringSet must have the same 

300:             # pattern: character, windows: DNAStringSet

305: #' @aliases patternMatrix,matrix,DNAStringSet-method

307: #' @usage  \\S4method{patternMatrix}{matrix,DNAStringSet}(pattern, windows,

311:           signature(pattern = "matrix", windows = "DNAStringSet"),

315:               stop("All sequences in the input DNAStringSet must have the same 

336:               stop("All sequences in the input DNAStringSet must have the same 

355:             # pattern: matrix, windows: DNAStringSet

361: #' @aliases patternMatrix,list,DNAStringSet-method

363: #' @usage  \\S4method{patternMatrix}{list,DNAStringSet}(pattern, windows,

367:           signature(pattern = "list", windows = "DNAStringSet"),

266:                 mat <- .patterncharacter_windowsDNAStringSet2matrix(pattern, windows, cores=cores)

271:                              function(i) .patterncharacter_windowsDNAStringSet2matrix(pattern[i],

319:             mat <- .patternPWM_windowsDNAStringSet2matrix(pattern, windows, 

211:         fRDNAStringSet <- lapply(object@forwardReadList, function(forwardRead) {

225:         rRDNAStringSet <- lapply(object@reverseReadList, function(reverseRead) {

240:         frReadSet <- DNAStringSet(c(unlist(fRDNAStringSet),

256:         writeTarget <- DNAStringSet(object@contigSeq)

224:         names(fRDNAStringSet) <- basename(names(fRDNAStringSet))

239:         names(rRDNAStringSet) <- basename(names(rRDNAStringSet))

241:                                     unlist(rRDNAStringSet)))

307: .toDNAStringSetOligo <- function(x) {

314: .toDNAStringSetAssay <- function(x) {

34: #' \code{Biostrings::DNAStringSet}

51: #' @importClassesFrom Biostrings DNAStringSet

89: #' ## Convert an RprimerOligo object to a DNAStringSet

94: #' as(x, "DNAStringSet")

96: #' ## Convert an RprimerAssay object to a DNAStringSet

101: #' as(x, "DNAStringSet")

289: setAs("RprimerOligo", "DNAStringSet", \(from) .toDNAStringSetOligo(from))

294: setAs("RprimerAssay", "DNAStringSet", \(from) .toDNAStringSetAssay(from))

310:         Biostrings::DNAStringSet()

317:         Biostrings::DNAStringSet()

320:         Biostrings::DNAStringSet() |>

325:             Biostrings::DNAStringSet()

173: 	myDNAStringSet <- reverse(myDNAStringSet)

29: 	if (is(leftPatterns, "DNAString") ||

37: 	if (is(rightPatterns, "DNAString") ||

17: 	if (!is(myDNAStringSet, "DNAStringSet"))

18: 		stop("myDNAStringSet must be a DNAStringSet.")

30: 		is(leftPatterns, "DNAStringSet")) {

33: 		stop("leftPatterns must be a DNAStringSet or character vector.")

38: 		is(rightPatterns, "DNAStringSet")) {

41: 		stop("rightPatterns must be a DNAStringSet or character vector.")

258: 		myDNAStringSet <- DNAStringSet()

1: TrimDNA <- function(myDNAStringSet,

25: 		any(width(myDNAStringSet) != width(quality)))

26: 		stop("The widths of myDNAStringSet must match the widths of quality.")

88: 		left <- numeric(length(myDNAStringSet))

94: 				myDNAStringSet,

120: 			x <- seq_len(length(myDNAStringSet))

130: 					.subset(myDNAStringSet, x),

153: 	lefts <- integer(length(myDNAStringSet))

172: 	dna <- myDNAStringSet

182: 	rights <- width(myDNAStringSet)

193: 		right <- width(myDNAStringSet) - .findPatternEnd(rightPatterns[k])

240: 	ns <- names(myDNAStringSet)

243: 		myDNAStringSet <- dna[w]

244: 		myDNAStringSet <- subseq(myDNAStringSet,

248: 		a <- alphabetFrequency(myDNAStringSet, as.prob=TRUE, baseOnly=TRUE)

251: 			myDNAStringSet <- myDNAStringSet[-x]

279: 		return(myDNAStringSet)

282: 			myDNAStringSet))

4: compDNAStringSet <- function(DNAStringSet1, DNAStringSet2){

2: ### Compare two DNAStringSet. Match is TRUE, Mismatch is FALSE.

5:   tmp <- cbind(strsplit(as.character(DNAStringSet1), ""), 

6:                strsplit(as.character(DNAStringSet2), ""))

33: seqToAlignment <- function(DNAStringSet){

34:   foo <- strsplit(as.character(DNAStringSet), "")

9: #system.time(foo<-compDNAStringSet(targetSeqs(myAxt), querySeqs(myAxt)))

5: \title{Convert DNAStringSet to list of DNAString objects}

3: \name{DNAStringSetToList}

4: \alias{DNAStringSetToList}

7: DNAStringSetToList(x)

10: \item{x}{an object of class DNAStringSet}

13: as.list doesn't seem to always work for DNAStringSets, so

41: \code{\link{modifyNucleotides}} and modify and existing DNAString or

44: A \code{ModDNAString} object can be converted into a \code{DNAString} object

63: # convert to DNAString

64: d1 <- DNAString(md1)

3: \name{ModDNAString}

4: \alias{ModDNAString}

5: \title{ModDNAString class}

7: ModDNAString(x = "", start = 1, nchar = NA)

13: the \code{ModDNAString} object (default \code{start = 1}).}

16: \code{ModDNAString} object (default \code{nchar = NA}). The end position is

20: a \code{ModDNAString} object

23: A \code{ModDNAString} object allows DNA sequences with modified nucleotides

27: The ModDNAString class contains the virtual \code{\link{ModString}} class,

32: The \code{\link{alphabet}} of the ModDNAString class consist of the 

35: modifications: \code{alphabet(ModDNAString())}.

42: ModDNAString object.

52: # Constructing ModDNAString containing an m6A

53: md1 <- ModDNAString("AGCT`")

56: # the alphabet of the ModDNAString class

5: \title{Generate DNAString}

15: A DNAString object

18: This function generates a random DNAString of a given length

3: \name{generateDNAString}

4: \alias{generateDNAString}

7: generateDNAString(len, bg)

31: motifcounter:::generateDNAString(1000, bg)

25: seqs = Biostrings::readDNAStringSet(seqfile)

35: \code{\link{generateDNAStringSet}}

217: ...(2 bytes skipped)...        Biostrings::substr(CDS.SequenceWT, mut$relativeCDSStart, mut$relativeCDSEnd) == Biostrings::DNAString(mut$refCDS)

185:           mutsPerCDS$refCDS <- as.character(Biostrings::reverseComplement(Biostrings::DNAStringSet(mutsPerCDS$ref)))

186:           mutsPerCDS$refAlt <- as.character(Biostrings::reverseComplement(Biostrings::DNAStringSet(mutsPerCDS$alt)))

226:           CDS.SequenceMut <- Biostrings::DNAStringSet(Biostrings::replaceAt(CDS.SequenceWT, at = IRanges::IRanges(mutsPerCDS$relativeCDSStart, mutsPer...(48 bytes skipped)...

241:             CDS.SequenceMut <- Biostrings::DNAStringSet(Biostrings::replaceAt(CDS.SequenceWT, at = IRanges::IRanges(mut$relativeCDSStart, mut$relativeCD...(27 bytes skipped)...

301:       # Add the CDS as names which the DNAStringset inherits.

332:           mutTx <- Biostrings::DNAStringSet(Biostrings::xscat(base::unlist(Tx.CDS.Current.SequenceWT.tmp)))

369:             mutTx <- Biostrings::DNAStringSet(Biostrings::xscat(base::unlist(Tx.CDS.Current.SequenceWT.tmp)))

412:           mutTx <- Biostrings::DNAStringSet(Biostrings::xscat(base::unlist(Tx.CDS.Current.SequenceWT.tmp)))

96:         tryCatch(DNAString(Lpattern), error = function(e) {

101:         tryCatch(DNAString(Rpattern), error = function(e) {

643:     subject <- DNAString("TAGTACCAGTTTCGGG")

641:     dict0 <- DNAStringSet(c("TACCNG", "TAGT", "CGGNT", "AGTAG", "TAGT"))

786:  *               rectangular DNAStringSet object;

501:           IRanges::ranges(Biostrings::matchPattern(Biostrings::DNAString(motif),

509:               Biostrings::reverseComplement(Biostrings::DNAString(motif)),

538:         IRanges::ranges(Biostrings::matchPattern(Biostrings::DNAString(motif),

544:           Biostrings::reverseComplement(Biostrings::DNAString(motif)),

37: #'@field ref The reference sequence for the target region, as a Biostrings::DNAString object

52: #'reference <- Biostrings::DNAString("GGTCTCTCGCAGGATGTTGCTGG")

62:              ref = "DNAString",

968:       ins.sites$seq <- as.character(reverseComplement(DNAStringSet(ins.sites$seq)))

1092: A DNAStringSet of the consensus sequences for the specified alleles,

1168:     seqs <- Biostrings::DNAStringSet(seqs)

1839:     circRNA_Sequence <- DNAString(paste(circRNA_Sequence,tmp,sep="",collapse = ""))

1842:   circRNA_Sequence <- DNAString(circRNA_Sequence)

3484:   	    amino_acid_seq <- Biostrings::translate(Biostrings::DNAString(tmp_seq))

3895: 	       concat_circRNA <- DNAString(paste(substr(tmp,i,nchar(tmp)),tmp,sep=""))

3952:       Sequence_to_examine <- DNAString(as.character(to_display[i,1]))

3623:         Read_One <- DNAStringSet(x=Read_One)

3624:         Read_Two <- reverseComplement(DNAStringSet(x=Read_Two))