Found 5670 results in 1630 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])
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))
456:   GuideSeq = DNAStringSet(dat[["spacer"]])
751: #' @importFrom Biostrings DNAStringSet
753:     G <- DNAStringSet(x[["spacer"]])
48: #' mrnaSequence <- Biostrings::readDNAStringSet(filepath=fasta,
96: #mrnaSequence <- Biostrings::readDNAStringSet(filepath=fasta,
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))
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}}
ChIPanalyser:R/GenomicProfileGenericFunctions.R: [ ]
203: .scoreDNAStringSet <- function(PWM,DNASequenceSet, strand="+",
292:     if(class(object) == "DNAStringSet"){
173:     sequences <- readDNAStringSet(fileame)
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)))
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}}
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])))
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)),
vtpnet:R/unipsearch.R: [ ]
15: # bsg is any object answering seqnames and [[ seqname[i] ]] wih DNAString
motifcounter:R/score_wrapper.R: [ ]
136: #' @param seq A DNAString object
166:     stopifnot(is(seq, "DNAString"))
187: #' @param seq A DNAString object
219:     stopifnot(is(seq, "DNAString"))
234: #' @param seqs A DNAStringSet or DNAString object
265:     if (is(seqs, "DNAString")) {
338:     stopifnot(is(seq, "DNAString"))
404:     if (is(seqs, "DNAString")) {
267:         seqs = DNAStringSet(seqs)
270:     stopifnot (is(seqs, "DNAStringSet"))
273:         stop(paste(strwrap("All DNAStrings in 'seqs' must be of equal length
406:         seqs = DNAStringSet(seqs)
409:     stopifnot(is(seqs, "DNAStringSet"))
20: #' seqs = Biostrings::readDNAStringSet(seqfile)
86: #' seqs = Biostrings::readDNAStringSet(seqfile)
147: #' seqs = Biostrings::readDNAStringSet(seqfile)
199: #' seqs = Biostrings::readDNAStringSet(seqfile)
247: #' seqs = Biostrings::readDNAStringSet(seqfile)
322: #' seqs = Biostrings::readDNAStringSet(seqfile)
385: #' seqs = Biostrings::readDNAStringSet(seqfile)
447: #' seqs = Biostrings::readDNAStringSet(seqfile)
methylscaper:R/preprocessSingleMolecule.R: [ ]
27: #' @importFrom Biostrings DNAString DNA_ALPHABET reverseComplement mismatchTable
44:     ref_string <- DNAString(toupper(c2s(ref)))
167:         # if (maxAligns[i] == 1) SEQ2 <- s2c(paste(reverseComplement(DNAString(c2s(SEQ2)))))
197:     fasta_string <- DNAString(toupper(c2s(read)))
OmaDB:R/utils.R: [ ]
7: #' @importFrom Biostrings DNAString
144:             Biostrings::DNAString(content)
ChIPsim:R/nucSim.R: [ ]
991: 	if(is(genome, "DNAString")) genome <-  DNAStringSet(genome)
970: ## genome: an object of class 'DNAStringSet' or the name of a fasta file containing the genome sequence
992: 	if(!is(genome, "DNAStringSet")) 
993: 		genome <-  readDNAStringSet(genome, format="fasta")
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)