Class Bio::Sequence
In: lib/bio/sequence.rb  (CVS)
lib/bio/sequence/aa.rb  (CVS)
lib/bio/sequence/common.rb  (CVS)
lib/bio/sequence/compat.rb  (CVS)
lib/bio/sequence/format.rb  (CVS)
lib/bio/sequence/generic.rb  (CVS)
lib/bio/sequence/na.rb  (CVS)
Parent: Object

DESCRIPTION

Bio::Sequence objects represent annotated sequences in bioruby. A Bio::Sequence object is a wrapper around the actual sequence, represented as either a Bio::Sequence::NA or a Bio::Sequence::AA object. For most users, this encapsulation will be completely transparent. Bio::Sequence responds to all methods defined for Bio::Sequence::NA/AA objects using the same arguments and returning the same values (even though these methods are not documented specifically for Bio::Sequence).

USAGE

  # Create a nucleic or amino acid sequence
  dna = Bio::Sequence.auto('atgcatgcATGCATGCAAAA')
  rna = Bio::Sequence.auto('augcaugcaugcaugcaaaa')
  aa = Bio::Sequence.auto('ACDEFGHIKLMNPQRSTVWYU')

  # Print it out
  puts dna.to_s
  puts aa.to_s

  # Get a subsequence, bioinformatics style (first nucleotide is '1')
  puts dna.subseq(2,6)

  # Get a subsequence, informatics style (first nucleotide is '0')
  puts dna[2,6]

  # Print in FASTA format
  puts dna.output(:fasta)

  # Print all codons
  dna.window_search(3,3) do |codon|
    puts codon
  end

  # Splice or otherwise mangle your sequence
  puts dna.splicing("complement(join(1..5,16..20))")
  puts rna.splicing("complement(join(1..5,16..20))")

  # Convert a sequence containing ambiguity codes into a
  # regular expression you can use for subsequent searching
  puts aa.to_re

  # These should speak for themselves
  puts dna.complement
  puts dna.composition
  puts dna.molecular_weight
  puts dna.translate
  puts dna.gc_percent

Methods

aa   auto   auto   guess   guess   na   new   output   to_s   to_str  

Classes and Modules

Module Bio::Sequence::Common
Module Bio::Sequence::Format
Class Bio::Sequence::AA
Class Bio::Sequence::NA

Attributes

comments  [RW]  A comment String
date  [RW]  Date from sequence source. Often date of deposition.
dblinks  [RW]  An Array of Strings; links to other database entries.
definition  [RW]  A String with a description of the sequence
entry_id  [RW]  The sequence identifier. For example, for a sequence of Genbank origin, this is the accession number.
features  [RW]  An Array of Bio::Feature objects
keywords  [RW]  An Array of Strings
moltype  [RW]  Bio::Sequence::NA/AA
references  [RW]  An Array of Bio::Reference objects
seq  [RW]  The sequence object, usually Bio::Sequence::NA/AA, but could be a simple String
taxonomy  [RW]  A taxonomy String

Public Class methods

auto(str)

Given a sequence String, guess its type, Amino Acid or Nucleic Acid, and return a new Bio::Sequence object wrapping a sequence of the guessed type (either Bio::Sequence::AA or Bio::Sequence::NA) 

  s = Bio::Sequence.auto('atgc')
  puts s.seq.class                        #=> Bio::Sequence::NA

Arguments:

Returns:Bio::Sequence object

[Source]

# File lib/bio/sequence.rb, line 193
  def self.auto(str)
    seq = self.new(str)
    seq.auto
    return seq
  end
guess(str, *args)

Guess the class of a given sequence. Returns the class (Bio::Sequence::AA or Bio::Sequence::NA) guessed. In general, used by developers only, but if you know what you are doing, feel free. 

  puts .guess('atgc')        #=> Bio::Sequence::NA

There are three optional parameters: `threshold`, `length`, and `index`.

The `threshold` value (defaults to 0.9) is the frequency of nucleic acid bases [AGCTUagctu] required in the sequence for this method to produce a Bio::Sequence::NA "guess". In the default case, if less than 90% of the bases (after excluding [Nn]) are in the set [AGCTUagctu], then the guess is Bio::Sequence::AA. 

  puts Bio::Sequence.guess('atgcatgcqq')      #=> Bio::Sequence::AA
  puts Bio::Sequence.guess('atgcatgcqq', 0.8) #=> Bio::Sequence::AA
  puts Bio::Sequence.guess('atgcatgcqq', 0.7) #=> Bio::Sequence::NA

The `length` value is how much of the total sequence to use in the guess (default 10000). If your sequence is very long, you may want to use a smaller amount to reduce the computational burden. 

  # limit the guess to the first 1000 positions
  puts Bio::Sequence.guess('A VERY LONG SEQUENCE', 0.9, 1000)

The `index` value is where to start the guess. Perhaps you know there are a lot of gaps at the start… 

  puts Bio::Sequence.guess('-----atgcc')             #=> Bio::Sequence::AA
  puts Bio::Sequence.guess('-----atgcc',0.9,10000,5) #=> Bio::Sequence::NA

Arguments:

  • (required) str: String or Bio::Sequence::NA/AA object
  • (optional) threshold: Float in range 0,1 (default 0.9)
  • (optional) length: Fixnum (default 10000)
  • (optional) index: Fixnum (default 1)
Returns:Bio::Sequence::NA/AA

[Source]

# File lib/bio/sequence.rb, line 291
  def self.guess(str, *args)
    self.new(str).guess(*args)
  end
new(str)

Create a new Bio::Sequence object 

  s = Bio::Sequence.new('atgc')
  puts s                                  #=> 'atgc'

Note that this method does not intialize the contained sequence as any kind of bioruby object, only as a simple string 

  puts s.seq.class                        #=> String

See Bio::Sequence#na, Bio::Sequence#aa, and Bio::Sequence#auto for methods to transform the basic String of a just created Bio::Sequence object to a proper bioruby object

Arguments:

Returns:Bio::Sequence object

[Source]

# File lib/bio/sequence.rb, line 91
  def initialize(str)
    @seq = str
  end

Public Instance methods

aa()

Transform the sequence wrapped in the current Bio::Sequence object into a Bio::Sequence::NA object. This method will change the current object. This method does not validate your choice, so be careful! 

  s = Bio::Sequence.new('atgc')
  puts s.seq.class                        #=> String
  s.aa
  puts s.seq.class                        #=> Bio::Sequence::AA !!!

However, if you know your sequence type, this method may be constructively used after initialization, 

  s = Bio::Sequence.new('RRLE')
  s.aa
Returns:Bio::Sequence::AA

[Source]

# File lib/bio/sequence.rb, line 332
  def aa
    @seq = AA.new(@seq)
    @moltype = AA
  end
auto()

Guess the type of sequence, Amino Acid or Nucleic Acid, and create a new sequence object (Bio::Sequence::AA or Bio::Sequence::NA) on the basis of this guess. This method will change the current Bio::Sequence object. 

  s = Bio::Sequence.new('atgc')
  puts s.seq.class                        #=> String
  s.auto
  puts s.seq.class                        #=> Bio::Sequence::NA
Returns:Bio::Sequence::NA/AA object

[Source]

# File lib/bio/sequence.rb, line 174
  def auto
    @moltype = guess
    if @moltype == NA
      @seq = NA.new(@seq)
    else
      @seq = AA.new(@seq)
    end
  end
guess(threshold = 0.9, length = 10000, index = 0)

Guess the class of the current sequence. Returns the class (Bio::Sequence::AA or Bio::Sequence::NA) guessed. In general, used by developers only, but if you know what you are doing, feel free. 

  s = Bio::Sequence.new('atgc')
  puts s.guess                            #=> Bio::Sequence::NA

There are three parameters: `threshold`, `length`, and `index`.

The `threshold` value (defaults to 0.9) is the frequency of nucleic acid bases [AGCTUagctu] required in the sequence for this method to produce a Bio::Sequence::NA "guess". In the default case, if less than 90% of the bases (after excluding [Nn]) are in the set [AGCTUagctu], then the guess is Bio::Sequence::AA. 

  s = Bio::Sequence.new('atgcatgcqq')
  puts s.guess                            #=> Bio::Sequence::AA
  puts s.guess(0.8)                       #=> Bio::Sequence::AA
  puts s.guess(0.7)                       #=> Bio::Sequence::NA

The `length` value is how much of the total sequence to use in the guess (default 10000). If your sequence is very long, you may want to use a smaller amount to reduce the computational burden. 

  s = Bio::Sequence.new(A VERY LONG SEQUENCE)
  puts s.guess(0.9, 1000)  # limit the guess to the first 1000 positions

The `index` value is where to start the guess. Perhaps you know there are a lot of gaps at the start… 

  s = Bio::Sequence.new('-----atgcc')
  puts s.guess                            #=> Bio::Sequence::AA
  puts s.guess(0.9,10000,5)               #=> Bio::Sequence::NA

Arguments:

  • (optional) threshold: Float in range 0,1 (default 0.9)
  • (optional) length: Fixnum (default 10000)
  • (optional) index: Fixnum (default 1)
Returns:Bio::Sequence::NA/AA

[Source]

# File lib/bio/sequence.rb, line 238
  def guess(threshold = 0.9, length = 10000, index = 0)
    str = @seq.to_s[index,length].to_s.extend Bio::Sequence::Common
    cmp = str.composition

    bases = cmp['A'] + cmp['T'] + cmp['G'] + cmp['C'] + cmp['U'] +
            cmp['a'] + cmp['t'] + cmp['g'] + cmp['c'] + cmp['u']

    total = str.length - cmp['N'] - cmp['n']

    if bases.to_f / total > threshold
      return NA
    else
      return AA
    end
  end
na()

Transform the sequence wrapped in the current Bio::Sequence object into a Bio::Sequence::NA object. This method will change the current object. This method does not validate your choice, so be careful! 

  s = Bio::Sequence.new('RRLE')
  puts s.seq.class                        #=> String
  s.na
  puts s.seq.class                        #=> Bio::Sequence::NA !!!

However, if you know your sequence type, this method may be constructively used after initialization, 

  s = Bio::Sequence.new('atgc')
  s.na
Returns:Bio::Sequence::NA

[Source]

# File lib/bio/sequence.rb, line 311
  def na
    @seq = NA.new(@seq)
    @moltype = NA
  end
output(style)

Using Bio::Sequence::Format, return a String with the Bio::Sequence object formatted in the given style.

Formats currently implemented are: ‘fasta’, ‘genbank’, and ‘embl‘ 

  s = Bio::Sequence.new('atgc')
  puts s.output(:fasta)                   #=> "> \natgc\n"

The style argument is given as a Ruby Symbol(www.ruby-doc.org/core/classes/Symbol.html)

Arguments:

  • (required) style: :fasta, :genbank, or :embl
Returns:String object

[Source]

# File lib/bio/sequence.rb, line 150
  def output(style)
    extend Bio::Sequence::Format
    case style
    when :fasta
      format_fasta
    when :gff
      format_gff
    when :genbank
      format_genbank
    when :embl
      format_embl
    end
  end
to_s()

Return sequence as String. The original sequence is unchanged. 

  seq = Bio::Sequence.new('atgc')
  puts s.to_s                             #=> 'atgc'
  puts s.to_s.class                       #=> String
  puts s                                  #=> 'atgc'
  puts s.class                            #=> Bio::Sequence
Returns:String object

[Source]

# File lib/bio/sequence/compat.rb, line 32
  def to_s
    String.new(@seq)
  end
to_str()

Alias for to_s

[Validate]