Found 5222 results in 1523 files, showing top 50 files (show more).
bcSeq:R/bcSeq.R: [ ]
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, 
Basic4Cseq:R/createVirtualFragmentLibrary.r: [ ]
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") {
ShortRead:R/methods-Misc.R: [ ]
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)
periodicDNA:R/periodicity.R: [ ]
286: getPeriodicity.DNAString <- function(
102: getPeriodicity.DNAStringSet <- function(
9: #' @param x a DNAString, DNAStringSet or GRanges object. 
284: #' @describeIn getPeriodicity S3 method for DNAString
26: #' @param genome genome ID, BSgenome or DNAStringSet object 
100: #' @describeIn getPeriodicity S3 method for DNAStringSet
292:     seq <- Biostrings::DNAStringSet(x)
Basic4Cseq:R/simulateDigestion.r: [ ]
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)
bcSeq:src/CRISPR_matching.cpp: [ ]
365: SEXP CRISPR_matching_DNAString(
472: SEXP CRISPR_user_matching_DNAString(
triplex:src/search_interface.c: [ ]
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]);
rtracklayer:src/twoBit.c: [ ]
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));
GeneRegionScan:R/creationFunctions.R: [ ]
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])
motifcounter:R/simulate_wrapper.R: [ ]
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)
PWMEnrich:R/misc.R: [ ]
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
periodicDNA:R/utils.R: [ ]
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(
h5vc:R/helpers.R: [ ]
14: encodeDNAString <- function( ds ){
Biostrings:src/translate.c: [ ]
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(): "
MatrixRider:inst/unitTests/test_getSeqOccupancy.R: [ ]
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")
rtracklayer:R/twobit.R: [ ]
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"),
TreeSummarizedExperiment:R/internal_utils.R: [ ]
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 ")
Rsamtools:src/io_sam.c: [ ]
68: static SEXP _tmpl_DNAStringSet()
71:     SEXP lkup = PROTECT(_get_lkup("DNAString"));
72:     SEXP ans = new_XRawList_from_CharAEAE("DNAStringSet", "DNAString",
114:     SET_VECTOR_ELT(tmpl, SEQ_IDX, _tmpl_DNAStringSet());
memes:R/input_methods.R: [ ]
11: sequence_input.DNAStringSet <- function(input){
BSgenome:R/BSgenomeViews-class.R: [ ]
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...
R453Plus1Toolbox:R/alignShortReads.R: [ ]
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)
VariantFiltering:src/methods-WeightMatrix.c: [ ]
123: scoss_wm_score_DNAStringSet(SEXP wmR, SEXP dnaStringSet, SEXP nscoR) {
121: /* entry point to wm_score_DNAStringSet */
VariantAnnotation:src/dna_hash.c: [ ]
65: SEXP dna_hash_as_DNAStringSet(struct dna_hash_t *dna)
117:                 "DNAStringSet", "DNAString", tag, ranges));
3: /* DNAStringSet -- hash */
115:     /* DNAStringSet */
triplex:R/triplex.align.R: [ ]
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)
ShortRead:inst/unitTests/test_ShortReadQ.R: [ ]
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")
genomation:inst/unitTests/test_PatternMatrix.R: [ ]
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"))
gmapR:inst/unitTests/test_GmapGenome.R: [ ]
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"
Biostrings:inst/unitTests/test_XStringSetList.R: [ ]
111: test_DNAStringSetList_constructor <- function()
114: test_DNAStringSetList_unlist <- function()
117: test_DNAStringSetList_append <- function()
131: test_DNAStringSetList_showAsCell <- function()
110: ## DNAStringSet
112:     .XStringSetList_constructor(DNAStringSet, DNAStringSetList, DNA_ALPHABET)
115:     .XStringSetList_unlist(DNAStringSet, DNAStringSetList, DNA_ALPHABET)
118:     .XStringSetList_append(DNAStringSet, DNAStringSetList, DNA_ALPHABET)
133:     dna <- showAsCell(DNAStringSetList())
135:     dna <- showAsCell(DNAStringSetList(DNA_ALPHABET))
ChIPanalyser:R/GenomicProfileGenericFunctions.R: [ ]
203: .scoreDNAStringSet <- function(PWM,DNASequenceSet, strand="+",
292:     if(class(object) == "DNAStringSet"){
173:     sequences <- readDNAStringSet(fileame)
hiReadsProcessor:R/hiReadsProcessor.R: [ ]
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}}
sangeranalyseR:R/UtilitiesFunc.R: [ ]
191:     fRDNAStringSet <- lapply(forwardReadList, function(forwardRead) {
200:     rRDNAStringSet <- lapply(reverseReadList, function(reverseRead) {
441:         primarySeq <- DNAString(paste(primary, collapse=""))
442:         secondarySeq <- DNAString(paste(secondary, collapse=""))
445:         primarySeq <- DNAString(paste(primary, collapse=""))
446:         secondarySeq <- DNAString(paste(secondary, collapse=""))
551:     DNASeqshift0 <- DNAString(substr(as.character(primarySeq),
559:     DNASeqshift1 <- DNAString(substr(as.character(primarySeq),
567:     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),
343:     aln2 = c(aln, DNAStringSet(consensus))
346:     consensusGapfree = RemoveGaps(DNAStringSet(consensus))[[1]]
216:                                 unlist(rRDNAStringSet)))
217:     frReadFeatureList <- c(rep("Forward Reads", length(fRDNAStringSet)),
218:                            rep("Reverse Reads", length(rRDNAStringSet)))
BSgenome:R/getSeq-methods.R: [ ]
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)
VariantAnnotation:R/AllUtilities.R: [ ]
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(),
genomation:R/patternMatrix.R: [ ]
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, 
sangeranalyseR:R/MethodSangerContig.R: [ ]
209:         fRDNAStringSet <- lapply(object@forwardReadList, function(forwardRead) {
223:         rRDNAStringSet <- lapply(object@reverseReadList, function(reverseRead) {
238:         frReadSet <- DNAStringSet(c(unlist(fRDNAStringSet),
254:         writeTarget <- DNAStringSet(object@contigSeq)
222:         names(fRDNAStringSet) <- basename(names(fRDNAStringSet))
237:         names(rRDNAStringSet) <- basename(names(rRDNAStringSet))
239:                                     unlist(rRDNAStringSet)))
rprimer:R/AllClasses.R: [ ]
306: .toDNAStringSetOligo <- function(x) {
313: .toDNAStringSetAssay <- function(x) {
33: #' \code{Biostrings::DNAStringSet}
50: #' @importClassesFrom Biostrings DNAStringSet
88: #' ## Convert an RprimerOligo object to a DNAStringSet
93: #' as(x, "DNAStringSet")
95: #' ## Convert an RprimerAssay object to a DNAStringSet
100: #' as(x, "DNAStringSet")
288: setAs("RprimerOligo", "DNAStringSet", \(from) .toDNAStringSetOligo(from))
293: setAs("RprimerAssay", "DNAStringSet", \(from) .toDNAStringSetAssay(from))
309:         Biostrings::DNAStringSet()
316:         Biostrings::DNAStringSet()
319:         Biostrings::DNAStringSet() |>
324:             Biostrings::DNAStringSet()
DECIPHER:R/TrimDNA.R: [ ]
174: 	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.")
255: 		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))
173: 	dna <- myDNAStringSet
183: 	rights <- width(myDNAStringSet)
193: 		right <- width(myDNAStringSet) - .findPatternEnd(rightPatterns[k])
237: 	ns <- names(myDNAStringSet)
240: 		myDNAStringSet <- dna[w]
241: 		myDNAStringSet <- subseq(myDNAStringSet,
245: 		a <- alphabetFrequency(myDNAStringSet, as.prob=TRUE, baseOnly=TRUE)
248: 			myDNAStringSet <- myDNAStringSet[-x]
275: 		return(myDNAStringSet)
278: 			myDNAStringSet))
CNEr:R/utils.R: [ ]
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)))
PWMEnrich:man/DNAStringSetToList.Rd: [ ]
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
Modstrings:man/ModDNAString.Rd: [ ]
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
motifcounter:man/generateDNAString.Rd: [ ]
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}}
EventPointer:R/AuxFunctions.R: [ ]
4703:             {return(as.character(reverseComplement(DNAString(x))))}}
Ularcirc:inst/shiny-app/circRNA/Server.R: [ ]
1689:     circRNA_Sequence <- DNAString(paste(circRNA_Sequence,tmp,sep="",collapse = ""))
1692:   circRNA_Sequence <- DNAString(circRNA_Sequence)
3483: 	       concat_circRNA <- DNAString(paste(substr(tmp,i,nchar(tmp)),tmp,sep=""))
3256:         Read_One <- DNAStringSet(x=Read_One)
3257:         Read_Two <- reverseComplement(DNAStringSet(x=Read_Two))
vtpnet:R/unipsearch.R: [ ]
15: # bsg is any object answering seqnames and [[ seqname[i] ]] wih DNAString
BSgenome:R/BSgenomeForge.R: [ ]
159:         seq <- seq[[1L]] # now 'seq' is a DNAString object
183:         seq <- seq[[1]] # now 'seq' is a DNAString object
290:     seqs <- DNAStringSet(seqs)
150:     seq <- readDNAStringSet(srcpath, "fasta")
174:     seq <- readDNAStringSet(srcpath, "fasta")
202:         seq <- readDNAStringSet(srcpath, "fasta")
277:         seq <- readDNAStringSet(srcpath, "fasta")
DECIPHER:R/FindGenes.R: [ ]
155: 	up_region <- DNAString("WWGGDVDTGATCCWKCYGCASVTTCMSSTACRGMW")
157: 	SD <- DNAString("AAGGAGGT")
199: 		p <- DNAStringSet(pattern(p))
414: 	if (!is(myDNAStringSet, "DNAStringSet"))
415: 		stop("myDNAStringSet must be a DNAStringSet.")
732: 	upstream <- DNAStringSet(upstream)
792: 		foldLeft <- DNAStringSet(unlist(foldLeft))
793: 		foldRight <- DNAStringSet(unlist(foldRight))
1280: 				motif <- DNAStringSet(motif)
347: FindGenes <- function(myDNAStringSet,
416: 	if (sum(width(myDNAStringSet))==0)
417: 		stop("myDNAStringSet must contain sequences.")
418: 	a <- vcountPattern("-", myDNAStringSet)
420: 		stop("Gap characters ('-') must be removed from myDNAStringSet.")
421: 	a <- vcountPattern(".", myDNAStringSet)
423: 		stop("Unknown characters ('.') must be removed from myDNAStringSet.")
500: 		myDNAStringSet,
514: 		stop("myDNAStringSet does not contain any open reading frames.")
604: 	GC <- oligonucleotideFrequency(myDNAStringSet,
612: 		myDNAStringSet,
620: 		myDNAStringSet,
627: 		myDNAStringSet,
635: 		myDNAStringSet,
718: 		myDNAStringSet,
731: 	SD <- .extractSD(myDNAStringSet)
755: 				myDNAStringSet,
763: 				myDNAStringSet,
774: 				myDNAStringSet,
782: 				myDNAStringSet,
911: 			myDNAStringSet,
960: 					myDNAStringSet,
968: 					myDNAStringSet,
974: 				myDNAStringSet,
985: 						myDNAStringSet,
990: 						myDNAStringSet,
1029: 				myDNAStringSet,
1048: 				myDNAStringSet,
1059: 				myDNAStringSet,
1065: 				myDNAStringSet,
1081: 				myDNAStringSet,
1087: 				myDNAStringSet,
1102: 				myDNAStringSet,
1108: 				myDNAStringSet,
1123: 				myDNAStringSet,
1129: 				myDNAStringSet,
1144: 				myDNAStringSet,
1150: 				myDNAStringSet,
1166: 				myDNAStringSet,
1172: 				myDNAStringSet,
1187: 				myDNAStringSet,
1195: 				myDNAStringSet,
1823: 	attr(ans, "widths") <- setNames(width(myDNAStringSet),
1824: 		names(myDNAStringSet))
ProteoDisco:R/method_incorporateGenomicMutations.R: [ ]
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)))
genbankr:R/genbankReader.R: [ ]
397:                bp = DNAString(chars),
498:     ##DNAString to DNAStringSet
443: ##' \code{ret.anno} is \code{FALSE}, a \code{DNAStringSet} object containing
503:         ## dss = DNAStringSet(lapply(GRanges(ranges(srcs), function(x) origin[x])))
ShortRead:R/methods-QA.R: [ ]
96:         tryCatch(DNAString(Lpattern), error = function(e) {
101:         tryCatch(DNAString(Rpattern), error = function(e) {
sangerseqR:R/sangerseqmethods.R: [ ]
51:     basecalls1 <- DNAString(substr(basecalls1,1,length(obj@data$PLOC.2)))
66:       basecalls2 <- DNAString(substr(basecalls2,1,length(obj@data$PLOC.2)))
69:       basecalls2 <- DNAString("")
102:     res@primarySeq <- DNAString(obj@basecalls)
104:     res@secondarySeq <- DNAString("")
179:     obj@primarySeq <- DNAString(paste(primary, collapse=""))
181:     obj@secondarySeq <- DNAString(paste(secondary, collapse=""))
317:     refseq <- DNAString(refseq)
325:     paRC <- pairwiseAlignment(seedseq, reverseComplement(DNAString(refseq)), 
379:     primarySeq(obj) <- DNAString(primaryseq)
383:     secondarySeq(obj) <- DNAString(secondaryseq)
440:     if(class(value)!="DNAString") value <- DNAString(value)
450:     if(class(value)!="DNAString") value <- DNAString(value)