bio 0.7.1 → 1.0.0

data/lib/bio/sequence/aa.rb

@@ -0,0 +1,64 @@
+#
+# = bio/sequence/aa.rb - amino acid sequence class
+#
+# Copyright::   Copyright (C) 2006
+#               Toshiaki Katayama <k@bioruby.org>
+# License::     Ruby's
+#
+# $Id: aa.rb,v 1.2 2006/02/06 14:11:31 k Exp $
+#
+
+require 'bio/sequence/common'
+
+module Bio
+
+  autoload :AminoAcid, 'bio/data/aa'
+
+class Sequence
+
+
+# Amino Acid sequence
+class AA < String
+
+  include Bio::Sequence::Common
+
+  # Generate a amino acid sequence object from a string.
+  def initialize(str)
+    super
+    self.upcase!
+    self.tr!(" \t\n\r",'')
+  end
+
+
+  # Estimate the weight of this protein.
+  def molecular_weight
+    Bio::AminoAcid.weight(self)
+  end
+
+  def to_re
+    Bio::AminoAcid.to_re(self)
+  end
+
+  # Generate the list of the names of the each residue along with the
+  # sequence (3 letters code).
+  def codes
+    array = []
+    self.each_byte do |x|
+      array.push(Bio::AminoAcid.names[x.chr])
+    end
+    return array
+  end
+
+  # Similar to codes but returns long names.
+  def names
+    self.codes.map do |x|
+      Bio::AminoAcid.names[x]
+    end
+  end
+
+end # AA
+
+end # Sequence
+
+end # Bio
+

data/lib/bio/sequence/common.rb

@@ -0,0 +1,175 @@
+#
+# = bio/sequence/common.rb - common methods for biological sequence
+#
+# Copyright::   Copyright (C) 2006
+#               Toshiaki Katayama <k@bioruby.org>
+# License::     Ruby's
+#
+# $Id: common.rb,v 1.2 2006/02/06 14:16:17 k Exp $
+#
+
+module Bio
+
+  autoload :Locations, 'bio/location'
+
+class Sequence
+
+# This module provides common methods for biological sequence classes
+# which must inherit String.
+module Common
+
+  def to_s
+    String.new(self)
+  end
+  alias to_str to_s
+
+  # Force self to re-initialize for clean up (remove white spaces,
+  # case unification).
+  def seq
+    self.class.new(self)
+  end
+
+  # Similar to the 'seq' method, but changes the self object destructively.
+  def normalize!
+    initialize(self)
+    self
+  end
+  alias seq! normalize!
+
+  def <<(*arg)
+    super(self.class.new(*arg))
+  end
+  alias concat <<
+
+  def +(*arg)
+    self.class.new(super(*arg))
+  end
+
+  # Returns the subsequence of the self string.
+  def subseq(s = 1, e = self.length)
+    raise "Error: start/end position must be a positive integer" unless s > 0 and e > 0
+    s -= 1
+    e -= 1
+    self[s..e]
+  end
+
+  # This method iterates on sub string with specified length 'window_size'.
+  # By specifing 'step_size', codon sized shifting or spliting genome
+  # sequence with ovelapping each end can easily be yielded.
+  #
+  # The remainder sequence at the terminal end will be returned.
+  #
+  # Example:
+  #   # prints average GC% on each 100bp
+  #   seq.window_search(100) do |subseq|
+  #     puts subseq.gc
+  #   end
+  #   # prints every translated peptide (length 5aa) in the same frame
+  #   seq.window_search(15, 3) do |subseq|
+  #     puts subseq.translate
+  #   end
+  #   # split genome sequence by 10000bp with 1000bp overlap in fasta format
+  #   i = 1
+  #   remainder = seq.window_search(10000, 9000) do |subseq|
+  #     puts subseq.to_fasta("segment #{i}", 60)
+  #     i += 1
+  #   end
+  #   puts remainder.to_fasta("segment #{i}", 60)
+  #
+  def window_search(window_size, step_size = 1)
+    i = 0
+    0.step(self.length - window_size, step_size) do |i| 
+      yield self[i, window_size]                        
+    end                          
+    return self[i + window_size .. -1] 
+  end
+
+  # This method receive a hash of residues/bases to the particular values,
+  # and sum up the value along with the self sequence.  Especially useful
+  # to use with the window_search method and amino acid indices etc.
+  def total(hash)
+    hash.default = 0.0 unless hash.default
+    sum = 0.0
+    self.each_byte do |x|
+      begin
+        sum += hash[x.chr]
+      end
+    end
+    return sum
+  end
+
+  # Returns a hash of the occurrence counts for each residue or base.
+  def composition
+    count = Hash.new(0)
+    self.scan(/./) do |x|
+      count[x] += 1
+    end
+    return count
+  end
+
+  # Returns a randomized sequence keeping its composition by default.
+  # The argument is required when generating a random sequence from the empty
+  # sequence (used by the class methods NA.randomize, AA.randomize).
+  # If the block is given, yields for each random residue/base.
+  def randomize(hash = nil)
+    length = self.length
+    if hash
+      count = hash.clone
+      count.each_value {|x| length += x}
+    else
+      count = self.composition
+    end
+
+    seq = ''
+    tmp = {}
+    length.times do 
+      count.each do |k, v|
+        tmp[k] = v * rand
+      end
+      max = tmp.max {|a, b| a[1] <=> b[1]}
+      count[max.first] -= 1
+
+      if block_given?
+        yield max.first
+      else
+        seq += max.first
+      end
+    end
+    return self.class.new(seq)
+  end
+
+  # Generate a new random sequence with the given frequency of bases
+  # or residues.  The sequence length is determined by the sum of each
+  # base/residue occurences.
+  def self.randomize(*arg, &block)
+    self.new('').randomize(*arg, &block)
+  end
+
+  # Receive a GenBank style position string and convert it to the Locations
+  # objects to splice the sequence itself.  See also: bio/location.rb
+  def splice(position)
+    unless position.is_a?(Locations) then
+      position = Locations.new(position)
+    end
+    s = ''
+    position.each do |location|
+      if location.sequence
+        s << location.sequence
+      else
+        exon = self.subseq(location.from, location.to)
+        begin
+          exon.complement! if location.strand < 0
+        rescue NameError
+        end
+        s << exon
+      end
+    end
+    return self.class.new(s)
+  end
+  alias splicing splice
+
+end # Common
+
+end # Sequence
+
+end # Bio

data/lib/bio/sequence/compat.rb

@@ -0,0 +1,68 @@
+#
+# = bio/sequence/compat.rb - methods for backward compatibility
+#
+# Copyright::   Copyright (C) 2006
+#               Toshiaki Katayama <k@bioruby.org>
+# License::     Ruby's
+#
+# $Id: compat.rb,v 1.2 2006/02/06 14:18:03 k Exp $
+#
+
+
+module Bio
+
+class Sequence
+
+  autoload :Common, 'bio/sequence/common'
+  autoload :NA,     'bio/sequence/na'
+  autoload :AA,     'bio/sequence/aa'
+
+  def to_s
+    String.new(@seq)
+  end
+  alias to_str to_s
+
+
+module Common
+
+  # Output the FASTA format string of the sequence.  The 1st argument is
+  # used as the comment string.  If the 2nd option is given, the output
+  # sequence will be folded.
+  def to_fasta(header = '', width = nil)
+    warn "Bio::Sequence#to_fasta is obsolete. Use Bio::Sequence#output(:fasta) instead" if $DEBUG
+    ">#{header}\n" +
+    if width
+      self.to_s.gsub(Regexp.new(".{1,#{width}}"), "\\0\n")
+    else
+      self.to_s + "\n"
+    end
+  end
+
+end # Common
+
+
+class NA
+
+  def self.randomize(*arg, &block)
+    self.new('').randomize(*arg, &block)
+  end
+
+  def pikachu
+    self.dna.tr("atgc", "pika") # joke, of course :-)
+  end
+
+end # NA
+
+
+class AA
+
+  def self.randomize(*arg, &block)
+    self.new('').randomize(*arg, &block)
+  end
+
+end # AA
+
+
+end # Sequence
+
+end # Bio

data/lib/bio/sequence/format.rb

@@ -0,0 +1,134 @@
+#
+# = bio/sequence/format.rb - various output format of the biological sequence
+#
+# Copyright::   Copyright (C) 2006
+#               Toshiaki Katayama <k@bioruby.org>,
+#               Naohisa Goto <ng@bioruby.org>
+# License::     Ruby's
+#
+# = TODO
+#
+# porting from N. Goto's feature-output.rb on BioRuby list.
+#
+# $Id: format.rb,v 1.2 2006/02/06 14:20:35 k Exp $
+#
+
+
+module Bio
+
+  autoload :Sequence, 'bio/sequence'
+
+class Sequence
+
+module Format
+
+  # Output the FASTA format string of the sequence.  The 1st argument is
+  # used in the comment line.  If the 2nd argument (integer) is given,
+  # the output sequence will be folded.
+  def format_fasta(header = nil, width = nil)
+    header ||= "#{@entry_id} #{@definition}"
+
+    ">#{header}\n" +
+    if width
+      @seq.to_s.gsub(Regexp.new(".{1,#{width}}"), "\\0\n")
+    else
+      @seq.to_s + "\n"
+    end
+  end
+
+  def format_gff
+    raise NotImplementedError
+  end
+
+  def format_genbank
+    prefix = ' ' * 5
+    indent = prefix + ' ' * 16
+    fwidth = 79 - indent.length
+
+    format_features(prefix, indent, fwidth)
+  end
+
+  def format_embl
+    prefix = 'FT   '
+    indent = prefix + ' ' * 16
+    fwidth = 80 - indent.length
+
+    format_features(prefix, indent, fwidth)
+  end
+
+
+  private
+
+  def format_features(prefix, indent, width)
+    result = ''
+    @features.each do |feature|
+      result << prefix + sprintf("%-16s", feature.feature)
+
+      position = feature.position
+      #position = feature.locations.to_s
+
+      head = ''
+      wrap(position, width).each_line do |line|
+        result << head << line
+        head = indent
+      end
+
+      result << format_qualifiers(feature.qualifiers, width)
+    end
+    return result
+  end
+
+  def format_qualifiers(qualifiers, indent, width)
+    qualifiers.each do |qualifier|
+      q = qualifier.qualifier
+      v = qualifier.value.to_s
+
+      if v == true
+        lines = wrap('/' + q, width)
+      elsif q == 'translation'
+        lines = fold('/' + q + '=' + val, width)
+      else
+        if v[/\D/]
+          #v.delete!("\x00-\x1f\x7f-\xff")
+          v.gsub!(/"/, '""')
+          v = '"' + v + '"'
+        end
+        lines = wrap('/' + q + '=' + val, width)
+      end
+
+      return lines.gsub(/^/, indent)
+    end
+  end
+
+  def fold(str, width)
+    str.gsub(Regexp.new("(.{1,#{width}})"), "\\1\n")
+  end
+
+  def wrap(str, width)
+    result = []
+    left = str.dup
+    while left and left.length > width
+      line = nil
+      width.downto(1) do |i|
+        if left[i..i] == ' ' or /[,;]/ =~ left[(i-1)..(i-1)]  then
+          line = left[0..(i-1)].sub(/ +\z/, '')
+          left = left[i..-1].sub(/\A +/, '')
+          break
+        end
+      end
+      if line.nil? then
+        line = left[0..(width-1)]
+        left = left[width..-1]
+      end
+      result << line
+    end
+    result << left if left
+    return result.join("\n")
+  end
+
+end # Format
+
+end # Sequence
+
+end # Bio
+

data/lib/bio/sequence/generic.rb

@@ -0,0 +1,24 @@
+#
+# = bio/sequence/generic.rb - generic sequence class to store an intact string
+#
+# Copyright::   Copyright (C) 2006
+#               Toshiaki Katayama <k@bioruby.org>
+# License::     Ruby's
+#
+# $Id: generic.rb,v 1.3 2006/02/06 14:26:04 k Exp $
+#
+
+require 'bio/sequence/common'
+
+module Bio
+class Sequence
+
+class Generic < String
+
+  include Bio::Sequence::Common
+
+end # Generic
+
+end # Sequence
+end # Bio
+