Found 5729 results in 1660 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));
crisprScore:R/getCasRxRFScores.R: [ ]
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,
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 ")
crisprDesign:R/findSpacers.R: [ ]
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
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)
Biostrings:R/seqinfo-methods.R: [ ]
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)
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"
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) {
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)))
crisprDesign:R/utils.R: [ ]
84: .isDNAStringSet <- function(x){
324:     if (methods::is(seq, "DNAString") && (is.null(len) || len == 1)){
85:     methods::is(x, "DNAStringSet")
328:     if (is(seq, "DNAStringSet") && (is.null(len) || length(seq) == len)){
379: #' @importFrom Biostrings DNAStringSet reverseComplement
381:     x <- Biostrings::DNAStringSet(x)
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: [ ]
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)))
rprimer:R/AllClasses.R: [ ]
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()
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}}
methylPipe:R/Allfunctions.R: [ ]
588:     if(!is(chrseq,"DNAString"))
589:         stop('chrseq has to be of class DNAString (unmasked) ..')
592:     typeD <- DNAString(seqContext)
593:     typeDr <- reverse(DNAString(seqContext))
597:     vls <- as(chrv,'DNAStringSet')
CrispRVariants:R/CrisprSet.R: [ ]
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)
scanMiR:R/scanning.R: [ ]
475:   mir.3p <- as.character(DNAString(substr(x=mirseq,
479:   if(!is(seqs, "XStringSet") && !is(seqs, "XString")) seqs <- DNAString(seqs)
6: #' @param seqs A character vector or `DNAStringSet` of DNA sequences in which to
85:   if(is.character(seqs)) seqs <- DNAStringSet(seqs)
285:       seed <- as.character(reverseComplement(DNAStringSet(substr(mirseq,2,8))))
614:   if(is.character(seqs)) seqs <- DNAStringSet(seqs)
motifbreakR:R/scoreMotif.R: [ ]
1227:     addedN <- DNAString(paste0(rep.int(".", reflen), collapse = ""))
1234:     addedN <- DNAString(paste0(rep.int(".", altlen), collapse = ""))
55:     snp.sequence.alt.indel <- DNAStringSet(Map(replaceAt,
1237:     refseq <- DNAStringSet(replaceAt(x = refseq, at = at, addedN))
1248:   altseq <- DNAStringSet(altseq)
MutationalPatterns:R/context_potential_damage_analysis.R: [ ]
323:     Biostrings::DNAString() %>%
327:     Biostrings::DNAString() %>%
389:   ori_bases_biostring <- Biostrings::DNAString(ori_bases)
423: #' @param seq DNAString containing the cds for one gene
181: #' @return DNAStringSet containing the cds sequences
191:     Biostrings::DNAStringSet()
285: #' @param seqs DNAStringSet containing the cds sequences
331:     Biostrings::DNAStringSet() %>%
367: #' @param seqs DNAStringSet containing the cds sequences
446:   ref_codons <- Biostrings::DNAStringSet(exon_codons[codon_nr])
474:   ref_codons_sum <- Biostrings::DNAStringSet(counts$dna)
479:     Biostrings::DNAStringSet()
573: #' @param splice_seqs DNAStringSet of splice site sequences
582:   splice_seqs <- Biostrings::DNAStringSet(names(splice_seqs_table))
586:   ori_bases <- Biostrings::DNAStringSet(contexts_tb$ori_bases)
603: #' @param splice_seqs DNAStringSet of splice site sequences
627: #' @return DNAStringSet containing the splice site sequences
Motif2Site:R/Motif2Site.R: [ ]
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)),